From d0417ef19f3b891b1fae70d19d216d76d94adadd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9mie=20Lambert?= <jerelam51@gmail.com>
Date: Thu, 14 Sep 2023 11:09:51 +0200
Subject: [PATCH 1/3] Premier commit

---
 dxf_viewer/divers/acad2ogree.ipynb | 654 +++++++++++++++++++++++++++
 dxf_viewer/divers/main.py          | 210 +++++++++
 dxf_viewer/divers/requirements.txt |   3 +
 dxf_viewer/divers/tools.py         | 144 ++++++
 dxf_viewer/graphic/area.png        | Bin 0 -> 304 bytes
 dxf_viewer/graphic/axis.png        | Bin 0 -> 444 bytes
 dxf_viewer/graphic/file.png        | Bin 0 -> 215 bytes
 dxf_viewer/graphic/iso_xy.png      | Bin 0 -> 217 bytes
 dxf_viewer/graphic/json.png        | Bin 0 -> 619 bytes
 dxf_viewer/graphic/regle.png       | Bin 0 -> 166 bytes
 dxf_viewer/gui_mpl.py              | 698 +++++++++++++++++++++++++++++
 11 files changed, 1709 insertions(+)
 create mode 100644 dxf_viewer/divers/acad2ogree.ipynb
 create mode 100644 dxf_viewer/divers/main.py
 create mode 100644 dxf_viewer/divers/requirements.txt
 create mode 100644 dxf_viewer/divers/tools.py
 create mode 100644 dxf_viewer/graphic/area.png
 create mode 100644 dxf_viewer/graphic/axis.png
 create mode 100644 dxf_viewer/graphic/file.png
 create mode 100644 dxf_viewer/graphic/iso_xy.png
 create mode 100644 dxf_viewer/graphic/json.png
 create mode 100644 dxf_viewer/graphic/regle.png
 create mode 100644 dxf_viewer/gui_mpl.py

diff --git a/dxf_viewer/divers/acad2ogree.ipynb b/dxf_viewer/divers/acad2ogree.ipynb
new file mode 100644
index 0000000..0fdc2be
--- /dev/null
+++ b/dxf_viewer/divers/acad2ogree.ipynb
@@ -0,0 +1,654 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fdhER-gVSEDw",
+        "outputId": "6a63f9a9-ec7d-44d5-fe03-a0276bded533"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting ezdxf>=1.0.3 (from -r /content/requirements.txt (line 1))\n",
+            "  Downloading ezdxf-1.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n",
+            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/3.1 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/3.1 MB\u001b[0m \u001b[31m54.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m67.7 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m41.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hCollecting mixpeek>=1.7 (from -r /content/requirements.txt (line 2))\n",
+            "  Downloading mixpeek-1.7.tar.gz (4.4 kB)\n",
+            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "Collecting rdp>=0.8 (from -r /content/requirements.txt (line 3))\n",
+            "  Downloading rdp-0.8.tar.gz (4.4 kB)\n",
+            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: pyparsing>=2.0.1 in /usr/local/lib/python3.10/dist-packages (from ezdxf>=1.0.3->-r /content/requirements.txt (line 1)) (3.1.0)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from ezdxf>=1.0.3->-r /content/requirements.txt (line 1)) (4.6.3)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from mixpeek>=1.7->-r /content/requirements.txt (line 2)) (2.27.1)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from rdp>=0.8->-r /content/requirements.txt (line 3)) (1.22.4)\n",
+            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (1.26.16)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (2023.5.7)\n",
+            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (2.0.12)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (3.4)\n",
+            "Building wheels for collected packages: mixpeek, rdp\n",
+            "  Building wheel for mixpeek (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for mixpeek: filename=mixpeek-1.7-py3-none-any.whl size=2996 sha256=a28377dd05fa5d407bfa8bf86bf9043aa0bb571a2460238880512cc2bdc80465\n",
+            "  Stored in directory: /root/.cache/pip/wheels/87/58/46/2308be9b60f662a16b85069abd3e5bac1ab9b01e49ce4ea669\n",
+            "  Building wheel for rdp (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for rdp: filename=rdp-0.8-py3-none-any.whl size=4586 sha256=49546b7d9950739d79b7f2300c5f87ff3cc8cb3e4c0fdf1856933c2c72d7c015\n",
+            "  Stored in directory: /root/.cache/pip/wheels/5d/12/ec/0fc50553af000b9c3d2c74b9f77a01ae4bfe856e9917ac239c\n",
+            "Successfully built mixpeek rdp\n",
+            "Installing collected packages: rdp, ezdxf, mixpeek\n",
+            "Successfully installed ezdxf-1.0.3 mixpeek-1.7 rdp-0.8\n"
+          ]
+        }
+      ],
+      "source": [
+        "pip install -r \"/content/requirements.txt\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import ezdxf\n",
+        "import sys\n",
+        "import numpy as np\n",
+        "from rdp import rdp\n",
+        "import pprint as pp\n",
+        "from collections import defaultdict\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "np.set_printoptions(precision=3, suppress=True)\n",
+        "\n",
+        "def print_entity(e):\n",
+        "    print(\"LINE on layer: %s\\n\" % e.dxf.layer)\n",
+        "    print(\"start point: %s\\n\" % e.dxf.start)\n",
+        "    print(\"end point: %s\\n\" % e.dxf.end)\n",
+        "\n",
+        "def print_entity2(e):\n",
+        "    print(e.dxf.layer, e.dxf.start, e.dxf.end )\n",
+        "\n",
+        "def transform(vertices, new_center, axis1, axis2):\n",
+        "    mat = np.linalg.inv(np.array([axis1, axis2])) @ np.array([[1, 0], [0, 1]])\n",
+        "    transformed_vertices = (vertices - new_center) @ mat\n",
+        "    return transformed_vertices\n",
+        "\n",
+        "def transform_single_axis(vertices, new_center, axis1, direct):\n",
+        "    if direct:\n",
+        "        axis2 = np.array([-axis1[1], axis1[0]])\n",
+        "    else:\n",
+        "        axis2 = np.array([axis1[1]], -axis1[0])\n",
+        "    return transform(vertices, new_center, axis1, axis2)\n",
+        "\n",
+        "def plot(l, fig=True):\n",
+        "    if fig:\n",
+        "        plt.figure(figsize=(10,10))\n",
+        "    plt.plot(list(l[:, 0]) + [l[0, 0]], list(l[:, 1]) + [l[0, 1]])\n",
+        "    for i, vertice in enumerate(l):\n",
+        "        plt.annotate(str(i), vertice)\n",
+        "    plt.axis('equal')\n",
+        "\n",
+        "def perp(a) :\n",
+        "    b = np.empty_like(a)\n",
+        "    b[0] = -a[1]\n",
+        "    b[1] = a[0]\n",
+        "    return b\n",
+        "\n",
+        "def seg_intersect(a1, a2, b1, b2) :\n",
+        "    da = a2-a1\n",
+        "    db = b2-b1\n",
+        "    dp = a1-b1\n",
+        "    dap = perp(da)\n",
+        "    denom = np.dot( dap, db)\n",
+        "    num = np.dot( dap, dp )\n",
+        "    return (num / denom.astype(float))*db + b1\n",
+        "\n",
+        "def envelope(polygon, dist):\n",
+        "    shifted_segments = []\n",
+        "    for i in range(len(polygon)):\n",
+        "        a, b = polygon[i], polygon[(i+1)%len(polygon)]\n",
+        "        dx = b[0] - a[0]\n",
+        "        dy = b[1] - a[1]\n",
+        "        normal = np.array([dy, -dx])\n",
+        "        normal /= np.linalg.norm(normal)\n",
+        "        shifted_segments.append((a + dist*normal, b + dist*normal))\n",
+        "    new_polygon = []\n",
+        "    for i in range(len(shifted_segments)):\n",
+        "        seg1 = shifted_segments[(i-1)%len(shifted_segments)]\n",
+        "        seg2 = shifted_segments[i]\n",
+        "        new_polygon.append(seg_intersect(seg1[0], seg1[1], seg2[0], seg2[1]))\n",
+        "    return np.array(new_polygon)\n",
+        "\n",
+        "def get_circle(x, y, z):\n",
+        "    x, y, z = x[0]+x[1]*1j, y[0]+y[1]*1j, z[0]+z[1]*1j\n",
+        "    w = (z-x) / (y-x)\n",
+        "    c = (x-y)*(w-abs(w)**2)/2j/w.imag-x\n",
+        "    return -c.real, -c.imag, abs(c+x)\n",
+        "\n",
+        "def array2dict(lst):\n",
+        "    res_dict = {}\n",
+        "    for i in range(0, len(lst), 1):\n",
+        "        res_dict[i] = lst[i]\n",
+        "    return res_dict\n"
+      ],
+      "metadata": {
+        "id": "rbrKzV7iYuo6"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "doc = ezdxf.readfile(\"mgf.dxf\")\n",
+        "msp = doc.modelspace()\n",
+        "#\n",
+        "# LAYERS\n",
+        "#\n",
+        "for layer in doc.layers:\n",
+        "    print(layer.dxf.name)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "N7CSQRf8ZGRi",
+        "outputId": "35aeb1b1-81f4-42d5-b146-94a05f1c9408"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "0\n",
+            "05-Bâti_construction\n",
+            "05-Bâti_surplomb\n",
+            "06-Mur\n",
+            "06-Portail\n",
+            "07-Clôture\n",
+            "08-Escalier_marche\n",
+            "08-Escalier_flèche\n",
+            "09-Chaussée-avec-bordure\n",
+            "09-Bateau\n",
+            "09-Voirie_texte\n",
+            "11-Arbre\n",
+            "12-Mobilier-urbain\n",
+            "24-Réseau_Eau\n",
+            "20-Réseau_Assainissement\n",
+            "29-Réseau_Divers\n",
+            "99-Titre\n",
+            "99-Nord\n",
+            "99-Logo\n",
+            "14-Nature_sol\n",
+            "05-Bâti_contour-hachures\n",
+            "11-Arbustes\n",
+            "99-Texte\n",
+            "05-Bâti_contour\n",
+            "09-Allée-avec-bordurette\n",
+            "25-Réseau_Eclairage-privé\n",
+            "05-Bâti_hachures\n",
+            "09-Chaussée-sans-bordure\n",
+            "99-Légende\n",
+            "10-Signalisation_horizontale\n",
+            "91-Intérieur_cotation\n",
+            "91-Intérieur_sanitaires\n",
+            "99-Fenêtre-présentation\n",
+            "--FLF-Str-Esc-Flèche\n",
+            "--FLF-0-poubelle\n",
+            "--FLF-Cadre-100\n",
+            "--FLF-Cadre\n",
+            "FLF-BATI\n",
+            "Defpoints\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#\n",
+        "# LAYERS with ENTITIES by type\n",
+        "#\n",
+        "group = msp.groupby(dxfattrib=\"layer\")\n",
+        "a = defaultdict(lambda: defaultdict(lambda: 0))\n",
+        "for layer, entities in group.items():\n",
+        "    for entity in entities:\n",
+        "        a[layer][entity.dxftype()] += 1\n",
+        "a = {k: dict(a[k]) for k in a}\n",
+        "pp.pprint(a)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "JAPSSu36C94i",
+        "outputId": "8018dd3d-0587-41a0-d2e3-908bbeab87f8"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "{'--FLF-Str-Esc-Flèche': {'ARC': 1, 'LINE': 2, 'LWPOLYLINE': 5},\n",
+            " '0': {'ACAD_PROXY_ENTITY': 20, 'INSERT': 3, 'LINE': 2},\n",
+            " '05-Bâti_construction': {'CIRCLE': 1,\n",
+            "                          'INSERT': 1,\n",
+            "                          'LINE': 30,\n",
+            "                          'LWPOLYLINE': 8},\n",
+            " '05-Bâti_contour': {'LWPOLYLINE': 3},\n",
+            " '05-Bâti_contour-hachures': {'LWPOLYLINE': 2},\n",
+            " '05-Bâti_hachures': {'HATCH': 3},\n",
+            " '05-Bâti_surplomb': {'LINE': 5, 'LWPOLYLINE': 1},\n",
+            " '06-Mur': {'ARC': 9, 'CIRCLE': 3, 'LINE': 72, 'LWPOLYLINE': 13},\n",
+            " '06-Portail': {'INSERT': 3, 'LINE': 9, 'LWPOLYLINE': 3},\n",
+            " '07-Clôture': {'INSERT': 4, 'LINE': 33, 'LWPOLYLINE': 3},\n",
+            " '08-Escalier_flèche': {'ARC': 1, 'LWPOLYLINE': 1},\n",
+            " '08-Escalier_marche': {'LINE': 11, 'LWPOLYLINE': 2},\n",
+            " '09-Allée-avec-bordurette': {'LINE': 11, 'LWPOLYLINE': 2},\n",
+            " '09-Bateau': {'LWPOLYLINE': 1},\n",
+            " '09-Chaussée-avec-bordure': {'ARC': 8, 'LINE': 98, 'LWPOLYLINE': 44},\n",
+            " '09-Chaussée-sans-bordure': {'LINE': 9},\n",
+            " '09-Voirie_texte': {'TEXT': 14},\n",
+            " '10-Signalisation_horizontale': {'ARC': 1,\n",
+            "                                  'INSERT': 6,\n",
+            "                                  'LINE': 138,\n",
+            "                                  'LWPOLYLINE': 53},\n",
+            " '11-Arbre': {'INSERT': 1},\n",
+            " '11-Arbustes': {'CIRCLE': 4, 'INSERT': 14, 'LWPOLYLINE': 6},\n",
+            " '12-Mobilier-urbain': {'LWPOLYLINE': 2},\n",
+            " '14-Nature_sol': {'ARC': 3, 'LINE': 39, 'LWPOLYLINE': 12},\n",
+            " '20-Réseau_Assainissement': {'CIRCLE': 10, 'INSERT': 12, 'LINE': 69},\n",
+            " '24-Réseau_Eau': {'INSERT': 1, 'LINE': 1},\n",
+            " '25-Réseau_Eclairage-privé': {'INSERT': 12},\n",
+            " '29-Réseau_Divers': {'INSERT': 17, 'LINE': 32},\n",
+            " '91-Intérieur_cotation': {'INSERT': 1},\n",
+            " '91-Intérieur_sanitaires': {'INSERT': 1},\n",
+            " '99-Texte': {'LWPOLYLINE': 9, 'TEXT': 88}}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#\n",
+        "# LWPOLYLINES in LAYER\n",
+        "#\n",
+        "lines = []\n",
+        "all_vertices = []\n",
+        "layer='05-Bâti_contour'\n",
+        "\n",
+        "for polyline in msp.query(f'LWPOLYLINE[layer==\"{layer}\"]'):\n",
+        "  line = []\n",
+        "  for vertice in polyline:\n",
+        "    line.append([vertice[0], vertice[1]])\n",
+        "    all_vertices.append([vertice[0], vertice[1]])\n",
+        "  line = np.array(line)\n",
+        "  lines.append(line)"
+      ],
+      "metadata": {
+        "id": "NC3bQLUHZKeT"
+      },
+      "execution_count": 12,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Nouvelle section"
+      ],
+      "metadata": {
+        "id": "JgmcXaFRXkQW"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "\n",
+        "# DRAW 1st POLYLINE\n",
+        "plot(lines[0])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 830
+        },
+        "id": "A3DKnyOuV9d8",
+        "outputId": "4692dfc7-9b43-40f9-f5de-f4b4397487e2"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# NORMALIZE POLYLINE + new center + new axis\n",
+        "line = lines[0]\n",
+        "#new_center = (line[22] + line[31])/2\n",
+        "new_center = (line[9] + line[7])/2\n",
+        "new_center = seg_intersect(line[7],line[9], line[13],line[11])\n",
+        "\n",
+        "#axis1 = line[31] - line[22]\n",
+        "axis1 = line[7] - line[9]\n",
+        "axis1 /= np.linalg.norm(axis1)\n",
+        "new_line = transform_single_axis(line, new_center, axis1, True)\n",
+        "print(new_line)"
+      ],
+      "metadata": {
+        "id": "zGUF89MHwcCb",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "8d336f6c-8d94-40d3-ad20-b69e6dea28f6"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[[52.929 22.734]\n",
+            " [53.657 22.006]\n",
+            " [53.368 21.716]\n",
+            " [54.132 20.953]\n",
+            " [54.128 20.948]\n",
+            " [50.196 15.514]\n",
+            " [47.582 10.801]\n",
+            " [43.823  0.   ]\n",
+            " [21.921 -0.012]\n",
+            " [ 8.031  0.   ]\n",
+            " [ 8.042  8.086]\n",
+            " [-0.027  8.084]\n",
+            " [-0.066 13.793]\n",
+            " [-0.056 16.984]\n",
+            " [17.405 17.001]\n",
+            " [28.154 17.01 ]\n",
+            " [28.997 17.209]\n",
+            " [29.784 17.625]\n",
+            " [30.31  18.237]\n",
+            " [30.62  19.017]\n",
+            " [30.65  19.827]\n",
+            " [30.467 20.63 ]\n",
+            " [26.409 24.697]\n",
+            " [38.384 36.689]\n",
+            " [41.27  33.891]\n",
+            " [42.629 35.247]\n",
+            " [42.629 35.247]\n",
+            " [46.411 39.019]\n",
+            " [46.411 39.019]\n",
+            " [47.771 40.375]\n",
+            " [44.934 43.249]\n",
+            " [56.91  55.224]\n",
+            " [61.017 51.135]\n",
+            " [61.804 50.954]\n",
+            " [62.656 50.995]\n",
+            " [63.416 51.318]\n",
+            " [64.029 51.871]\n",
+            " [64.428 52.655]\n",
+            " [64.602 53.475]\n",
+            " [64.594 66.936]\n",
+            " [64.614 81.693]\n",
+            " [73.501 81.689]\n",
+            " [73.481 73.638]\n",
+            " [81.581 73.619]\n",
+            " [81.603 58.837]\n",
+            " [81.591 37.824]\n",
+            " [80.236 37.505]\n",
+            " [75.108 35.868]\n",
+            " [70.189 33.734]\n",
+            " [65.511 31.057]\n",
+            " [60.704 27.533]\n",
+            " [59.94  28.296]\n",
+            " [59.65  28.006]\n",
+            " [58.922 28.734]]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "new_line = np.array([        [   0 ,   0 ],\n",
+        "        [   0 , 110 ],\n",
+        "        [38.8 , 110 ],\n",
+        "        [38.8 ,  65 ],\n",
+        "        [  84 ,  65 ],\n",
+        "        [  84 , 150 ],\n",
+        "        [ 124 , 150 ],\n",
+        "        [ 124 ,  65 ],\n",
+        "        [ 167 ,  65 ],\n",
+        "        [ 167 , 115 ],\n",
+        "        [ 207 , 115 ],\n",
+        "        [ 207 ,  25 ],\n",
+        "        [ 177 ,  25 ],\n",
+        "        [ 177 ,   0 ],\n",
+        "        [ 142 ,   0 ],\n",
+        "        [ 142 ,  25 ],\n",
+        "        [ 112 ,  25 ],\n",
+        "        [ 112 ,   3 ],\n",
+        "        [  97 ,   3 ],\n",
+        "        [  97 ,  25 ],\n",
+        "        [  62 ,  25 ],\n",
+        "        [  62 ,   0 ]])"
+      ],
+      "metadata": {
+        "id": "GcAwpsw3-8sS"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot(new_line)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 830
+        },
+        "id": "uqSX8neGy-H_",
+        "outputId": "a96106bc-074f-4633-acaa-88b9bc1c028f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzYAAAMtCAYAAABNXuQZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACl00lEQVR4nOzdeVxU9f7H8ffAsMmmIoumuCtuWJopWmZqrplbm1lqmVY/NJfbonUrW6VNzTK3jOyWaVaatmi4kaYoopRp4r4L5gIoKNuc3x/EKIEpCgwzvJ6Px/x+OnNm+MxcrpcX55zvMRmGYQgAAAAA7JiTrQcAAAAAgOtF2AAAAACwe4QNAAAAALtH2AAAAACwe4QNAAAAALtH2AAAAACwe4QNAAAAALtntvUA/2SxWHTs2DF5e3vLZDLZehwAAAAANmIYhs6ePatq1arJyenf98mUubA5duyYatSoYesxAAAAAJQRhw8fVvXq1f91mzIXNt7e3pJyh/fx8bHxNAAAAABsJTU1VTVq1LA2wr8pc2GTd/iZj48PYQMAAADgqk5RYfEAAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAABg9wgbAAAAAHaPsAEAAHBgERERMplMGj16tPW+CxcuKDw8XH5+fvLy8lL//v2VlJRkuyHLmMI+s1mzZqlDhw7y8fGRyWRScnKyzeZD4QgbAAAABxUbG6uZM2cqNDQ03/1jxozR0qVLtXDhQkVHR+vYsWPq16+fjaYsWy73maWnp6tbt256/vnnbTQZroSwAQAAcEDnzp3TwIEDNXv2bFWqVMl6f0pKiubMmaNJkyapY8eOatmypSIjI7V+/XrFxMTYcGLbu9xnJkmjR4/WuHHj1KZNGxtNhyshbAAAABxQeHi4evbsqc6dO+e7Py4uTllZWfnuDwkJUXBwsDZs2FDaY5Ypl/vMYB/Mth4AAAAAxWv+/PnasmWLYmNjCzyWmJgoV1dXVaxYMd/9gYGBSkxMLKUJy55/+8xgHwgbAAAAB3L48GGNGjVKUVFRcnd3t/U4doHPzDFwKBoAAIADiYuL04kTJ9SiRQuZzWaZzWZFR0dr6tSpMpvNCgwMVGZmZoFVvZKSkhQUFGSboW3sSp9ZTk6OrUfEVWCPDQAAgIM4dCpdVRvdrG9XrM93/4v/CVftuvX16P+NVoVqN8js4qLIr5bozp69JUn79+7WoUOHFFC3mf44mmJ9nsl0dV/XpCtveNWvVcpfM8DbTZ06ddK2bdvy3f/II48oJCREzz33nJydna9uKNgUYQMAAOAAftx2XP/3xZZCH0s8naVD5gvaFnVa0mm5N+msZ555WlVWH5XJrYLORM2QW7UQvbA+Q1q/rnQHtzFXZyetevp2NW3aNN/9np6e8vPzs96fmJioxMRE7dmzR5K0bds2eXt7Kzg4WJUrVy71uVEQYQMAAOAA9pw4J0nycHFWxQou+R47bXaSp5tZVX1zzx8J6DNSB3+aoZPfTZSRnSXf+jer1t1PydU7//klhowrfl3jyptcxatc/Wtdzatd3etIZ9IzlZlj0cFT6apeqcK/bjtjxgy98sor1r+3b99ekhQZGakhQ4Zc3RdEiTIZxtX+R186UlNT5evrq5SUFPn4+Nh6HAAAALswdeVuTYrapQdbB+vNvs1sPY5d6Dr5FyUkndUXj7VWu3pVbD0OClGUNmDxAAAAAAdQtn5VbR/y9khd5Wk9KOMIGwAAAAB2j7ABAABwIOx9uHrWvVx8aA6BsAEAAHAAV3OiP/K72DWUjSMgbAAAAADYPcIGAADAgVztBS4h5S0OzGfmGAgbAAAAB8CqaCjvCBsAAACUS6wd4FgIGwAAAAfCifBF8HfZmDgWzSEUKWxycnL04osvqnbt2vLw8FDdunX12muvWY9PlHKPVXzppZdUtWpVeXh4qHPnztq9e3exDw4AAICLOBIN5V2Rwuatt97S9OnT9eGHH+rPP//UW2+9pbffflsffPCBdZu3335bU6dO1YwZM7Rx40Z5enqqa9euunDhQrEPDwAAAFwr66Fo7LBxCOaibLx+/Xr17t1bPXv2lCTVqlVLX375pTZt2iQpd2/NlClT9N///le9e/eWJH322WcKDAzU4sWL9cADDxR4zYyMDGVkZFj/npqaes1vBgAAoLzjh/SrZ10VzcZzoHgUaY9N27ZttXLlSu3atUuS9Ntvv2ndunXq3r27JGn//v1KTExU586drc/x9fVV69attWHDhkJfc+LEifL19bXeatSoca3vBQAAoPxiWTSUc0XaYzNu3DilpqYqJCREzs7OysnJ0RtvvKGBAwdKkhITEyVJgYGB+Z4XGBhofeyfxo8fr7Fjx1r/npqaStwAAACgxHEommMpUth89dVX+uKLLzRv3jw1adJE8fHxGj16tKpVq6bBgwdf0wBubm5yc3O7pucCAAAgP35GR3lVpLB55plnNG7cOOu5Ms2aNdPBgwc1ceJEDR48WEFBQZKkpKQkVa1a1fq8pKQk3XjjjcU3NQAAAPLhQLSiu3j0HjnoCIp0jk16erqcnPI/xdnZWRaLRZJUu3ZtBQUFaeXKldbHU1NTtXHjRoWFhRXDuAAAAEDxMP7OQQ5FcwxF2mPTq1cvvfHGGwoODlaTJk20detWTZo0SY8++qik3IsbjR49Wq+//rrq16+v2rVr68UXX1S1atXUp0+fkpgfAAAAl+BikyivihQ2H3zwgV588UX93//9n06cOKFq1arp8ccf10svvWTd5tlnn1VaWpqGDx+u5ORk3XrrrVq2bJnc3d2LfXgAAADkYlG0osv7zEhBx1CksPH29taUKVM0ZcqUy25jMpn06quv6tVXX73e2QAAAADgqhTpHBsAAACUTQbLBxSZdY8Nh+85BMIGAAAA5RpZ4xgIGwAAAAB2j7ABAABwABcPq7LtHPbEMFju2ZEQNgAAACiX8s5KMnEwmkMgbAAAAADYPcIGAADAAbD3oeg4fM+xEDYAAAAA7B5hAwAAgHKJa/84FsIGAADAAXBYVdHxmTkWwgYAAACA3SNsAAAAUC6x4IJjIWwAAAAcQN75IvyIjvKKsAEAAEC5xDk2joWwAQAAQDn1914uwsYhEDYAAACOgL0PKOcIGwAAAJRL1kPRODPJIRA2AAAAKNfYy+UYCBsAAAAHYF26mJ/Sr5px5U1gRwgbAAAAlEuGwRLZjoSwAQAAcCD8kI7yirABAABwAHl7H3D1Lh6+Z9MxUEwIGwAAAJRLF1uQsnEEhA0AAIAj4Wd0lFOEDQAAgAPgSLSisy4eQAw6BMIGAAAAgN0jbAAAAByIiWPRrpp18QCbToHiQtgAAAA4AI5EuwZ/f2hc1NQxEDYAAAAA7B5hAwAA4AAM694H285hTzgUzbEQNgAAAADsHmEDAACAconlnh0LYQMAAOAAjL8PrOJn9Kt38VA0PjVHQNgAAAAAsHuEDQAAAMolFlxwLIQNAACAA+CH9KIzuPqPQyFsAAAAANg9wgYAAADlEnu5HAthAwAA4EBY4ev6RUREyGQyafTo0ZKk06dPa+TIkWrYsKE8PDwUHBysp556SikpKbYdtJT983ORpMcff1x169aVh4eH/P391bt3b+3cudMm8xE2AAAAKJesyz1fsssmNjZWM2fOVGhoqPW+Y8eO6dixY3r33Xf1xx9/6NNPP9WyZcs0dOjQUp7Ydgr7XCSpZcuWioyM1J9//qnly5fLMAx16dJFOTk5pT4jYQMAAIDyKe9QtL//eu7cOQ0cOFCzZ89WpUqVrJs1bdpU33zzjXr16qW6deuqY8eOeuONN7R06VJlZ2eX/tyl7HKfiyQNHz5c7du3V61atdSiRQu9/vrrOnz4sA4cOFDqcxI2AAAADsD4+4QRzhe5duHh4erZs6c6d+58xW1TUlLk4+Mjs9lcCpPZ1tV+LmlpaYqMjFTt2rVVo0aNUpruIsf/TwIAAAAoRN5yzyaTNH/+fG3ZskWxsbFXfN7Jkyf12muvafjw4SU9os1dzefy0Ucf6dlnn1VaWpoaNmyoqKgoubq6luKUudhjAwAAgHLt6JEjGjVqlL744gu5u7v/67apqanq2bOnGjdurAkTJpTOgDZy+PDhq/pcBg4cqK1btyo6OloNGjTQfffdpwsXLpTipLnYYwMAAOAArCfC23QK+5K33PO2+K06ceKEWrRoYX0sJydHv/zyiz788ENlZGTI2dlZZ8+eVbdu3eTt7a1FixbJxcXFRpOXjri4uKv6XHx9feXr66v69eurTZs2qlSpkhYtWqQBAwaU6ryEDQAAAMqlvBhs3+EObdu2Ld9jjzzyiEJCQvTcc8/J2dlZqamp6tq1q9zc3LRkyZIr7tlxBJ06dbri5/JPhmHIMAxlZGSU1phWhA0AAADKtf/+sFduLk7WvV0mk0lHzlqUnpStKXHnlblutZa985SyMy/ozqfe0fCPf7Eu0uDhU1lOTs4ymS4u3GCSybrr7NLXvPjn/Pdbt7vk+aYCz794jaJLv5Yuve8y2+Ztdemy1vlmLeT5tzcI0K31q6hp06b5PitPT0/5+fmpadOm2rdvnxYsWKAuXbrI399fR44cUUREhDw8PNSjR4/Lft4lhbABAABwAMbFi7LYdA57UsXLVUmpGdqw71SBx86kZyrtdLrS/jyhC4d+11/7/pAkffVs33zb3fDEHJl9A0tl3tK0MO6I4l/q8q/buLu7a+3atZoyZYrOnDmjwMBAtW/fXuvXr1dAQEApTXoRYQMAAIByacHwMG0+eMa6VLZh/T+S0f+H3P9vSIaaSaMH/v1nw3r/xedcfL71/sLuu+T+PP98TeOS+3OfY+jSp1hfN99rFtzWuPiEfK9Z2PyXPj8tI1ufxxxSWkbh1+dZs2aN9c/VqlXTjz/+WOh2tkDYAAAAoFyqVcVTtap42nqMMiUx5YI+jzlk6zGuCcs9AwAAOADrNVlsPAccwz92LNkFwgYAAACA3SNsAAAAAEi6uPaEHe6wIWwAAAAcQd6hQyyKhvKKsAEAAAAgyb7P0SJsAAAAHIA9HjqEsuufy1LbA8IGAADAgZjs+nfuwLUjbAAAAADksuMuJmwAAAAcgB0eOYQyzB6/nQgbAAAAB8KqaCivCBsAAAAAkuz7HC3CBgAAwCHY48FDKKvs8dBGwgYAAMCB2O/v21EW2POhjIQNAAAAALtH2AAAADgAezx0CChOhA0AAIADsedDiWB79vztQ9gAAAAAKMCws92AhA0AAIADyPsZ1MQuG5RThA0AAAAASfYdxoQNAAAAgALs7Eg0wgYAAMARGFygE+UcYQMAAABAUv5V0ewtlQkbAAAAAHaPsAEAAHAAF1dFs+0csG/2/P1D2AAAAAAowKGvY1OrVi2ZTKYCt/DwcEnShQsXFB4eLj8/P3l5eal///5KSkoqkcEBAAAAIE+RwiY2NlbHjx+33qKioiRJ9957ryRpzJgxWrp0qRYuXKjo6GgdO3ZM/fr1K/6pAQAAkE/e79ZNsuNjiWBz9vz9Yy7Kxv7+/vn+HhERobp16+r2229XSkqK5syZo3nz5qljx46SpMjISDVq1EgxMTFq06ZN8U0NAAAAoETZ14Fo13GOTWZmpj7//HM9+uijMplMiouLU1ZWljp37mzdJiQkRMHBwdqwYcNlXycjI0Opqan5bgAAAABQFNccNosXL1ZycrKGDBkiSUpMTJSrq6sqVqyYb7vAwEAlJiZe9nUmTpwoX19f661GjRrXOhIAAEC5xapoKBZ2/P1zzWEzZ84cde/eXdWqVbuuAcaPH6+UlBTr7fDhw9f1egAAAACun50tila0c2zyHDx4UCtWrNC3335rvS8oKEiZmZlKTk7Ot9cmKSlJQUFBl30tNzc3ubm5XcsYAAAAAIqRPe/xu6Y9NpGRkQoICFDPnj2t97Vs2VIuLi5auXKl9b6EhAQdOnRIYWFh1z8pAAAALsv4+1RvO/65FGWMYWfLBxR5j43FYlFkZKQGDx4ss/ni0319fTV06FCNHTtWlStXlo+Pj0aOHKmwsDBWRAMAAABQooocNitWrNChQ4f06KOPFnhs8uTJcnJyUv/+/ZWRkaGuXbvqo48+KpZBAQAA8C/s65frKKPseY9fkcOmS5cuMi5zJpG7u7umTZumadOmXfdgAAAAKDp7PkcCZYu9LR5wzauiAQAAAEBZQdgAAAA4ADv75TrKKJMd7/IjbAAAAByIya7PkgCuHWEDAAAAQJJ9Lx5A2AAAADiAyy3uBFwre/uWImwAAAAciB2fIgFcF8IGAAAAgCT7DmPCBgAAwAHY2VFDsAOGnX1XETYAAAAA7B5hAwAAAECSfS8XTtgAAAA4gLwVrNYs/kKhoaHy8fGRj4+PwsLC9NNPP1m327t3r/r27St/f3/5+PjovvvuU1JSko2mRlnGqmgAAACwmUoBVRUREaG4uDht3rxZHTt2VO/evbV9+3alpaWpS5cuMplMWrVqlX799VdlZmaqV69eslgsth4dZYA9Lx5gtvUAAAAAKD43tuukHrfWtv79jTfe0PTp0xUTE6OjR4/qwIED2rp1q3x8fCRJc+fOVaVKlbRq1Sp17tzZVmMD1409NgAAAA6gsKOGcnJyNH/+fKWlpSksLEwZGRkymUxyc3OzbuPu7i4nJyetW7eu9IaFXbCzI9EIGwAAAEdikrRt2zZ5eXnJzc1NTzzxhBYtWqTGjRurTZs28vT01HPPPaf09HSlpaXp6aefVk5Ojo4fP27r0YHrQtgAAAA4mIYNGyo+Pl4bN27Uk08+qcGDB2vHjh3y9/fXwoULtXTpUnl5ecnX11fJyclq0aKFnJz4sRD5GXa2egDn2AAAADiAS38IdXV1Vb169SRJLVu2VGxsrN5//33NnDlTXbp00d69e3Xy5EmZzWZVrFhRQUFBqlOnjq1GB4oFYQMAAOBAClvVymKxKCMjI999VapUkSStWrVKJ06c0N13310a46GMY1U0AAAAlAlfz3hbdXMGKDg4WGfPntW8efO0Zs0aLV++XJIUGRmpRo0ayd/fXxs2bNCoUaM0ZswYNWzY0MaTo6yxrwPRCBsAAACHknrmlAYNGqTjx4/L19dXoaGhWr58ue68805JUkJCgsaPH6/Tp0+rVq1aeuGFFzRmzBgbTw1cP8IGAADAgTw6/i090q72ZR+PiIhQREREKU4Ee2KS/R6LxvIXAAAAAAqws0XRCBsAAAAAuex58QDCBgAAAEBB7LEBAAAAgNJF2AAAADgQezsvAmWLHR+JRtgAAAA4ApM9nxyBMsmws2PRCBsAAAAAdo+wAQAAACDJvvf8ETYAAAAACrC387UIGwAAAACSWDwAAAAAAGyKsAEAAHAAeb9pt7Ojh1CG2dv3EmEDAAAAQJJkx2sHEDYAAAAACjLsbPUAwgYAAACA3SNsAAAAAEjiOjYAAAAAHIx9HYhG2AAAADiEvF+029t5EUBxIWwAAAAA2D3CBgAAAEAB9rbzj7ABAAAAYGWv6wcQNgAAAAAKMOxs+QDCBgAAAIDdI2wAAAAcgJ0ePYQyyF6/lwgbAAAAAAXZ15FohA0AAACAi0x2unoAYQMAAADA7hE2AAAAAAqwsyPRCBsAAAAAF9nngWiEDQAAgEOw1/MigOJC2AAAADgQw96OH0KZZW/fS4QNAAAAACt73flH2AAAAAAowLCz5QMIGwAAAAB2j7ABAAAAYGWy03XRCBsAAAAHYJ8/iqIsY/EAAAAA2Iy9nReBMshOK5mwAQAAAGD3CBsAAAAABdjbvj/CBgAAAICVnR6JRtgAAAAAKMiws9UDCBsAAABHYK+/ZgeKCWEDAAAAwMpkp5FM2AAAADgQOzt6CGWYvX0vETYAAAAArEx2elwjYQMAAADA7hE2AAAAAOweYQMAAADAisUDAAAAYDP2el4EUFwIGwAAAAdiZwtZoQxjVTQAAAAAdste9/0RNgAAAAAKMOxs/x9hAwAAAMDKZKerBxA2AAAAAOxekcPm6NGjeuihh+Tn5ycPDw81a9ZMmzdvtj5uGIZeeuklVa1aVR4eHurcubN2795drEMDAAAgPzv9JTvKMIdePODMmTNq166dXFxc9NNPP2nHjh167733VKlSJes2b7/9tqZOnaoZM2Zo48aN8vT0VNeuXXXhwoViHx4AAABA8bLXRjYXZeO33npLNWrUUGRkpPW+2rVrW/9sGIamTJmi//73v+rdu7ck6bPPPlNgYKAWL16sBx54oJjGBgAAQGHs7bfsQHEp0h6bJUuW6Oabb9a9996rgIAA3XTTTZo9e7b18f379ysxMVGdO3e23ufr66vWrVtrw4YNhb5mRkaGUlNT890AAAAA2Ja9NXKRwmbfvn2aPn266tevr+XLl+vJJ5/UU089pblz50qSEhMTJUmBgYH5nhcYGGh97J8mTpwoX19f661GjRrX8j4AAAAAFAc7PRatSGFjsVjUokULvfnmm7rppps0fPhwDRs2TDNmzLjmAcaPH6+UlBTr7fDhw9f8WgAAAACKh/GP4xojIiJkMpk0evToQrft3r27TCaTFi9eXDoD/kORwqZq1apq3LhxvvsaNWqkQ4cOSZKCgoIkSUlJSfm2SUpKsj72T25ubvLx8cl3AwAAQNHY6S/ZUQYV9r0UGxurmTNnKjQ0tNDnTJkyxebXvylS2LRr104JCQn57tu1a5dq1qwpKXchgaCgIK1cudL6eGpqqjZu3KiwsLBiGBcAAABAaTp37pwGDhyo2bNn51sNOU98fLzee+89ffLJJzaY7qIihc2YMWMUExOjN998U3v27NG8efM0a9YshYeHS5J119Trr7+uJUuWaNu2bRo0aJCqVaumPn36lMT8AAAAuIRhd6d8o6zK+04KDw9Xz5498y0Qlic9PV0PPvigpk2bdtkjtEpLkZZ7btWqlRYtWqTx48fr1VdfVe3atTVlyhQNHDjQus2zzz6rtLQ0DR8+XMnJybr11lu1bNkyubu7F/vwAAAAAIrXpYeUzZ8/X1u2bFFsbGyh244ZM0Zt27a1XurFlooUNpJ011136a677rrs4yaTSa+++qpeffXV6xoMAAAAgO0cO3pEo0aNUlRUVKE7KZYsWaJVq1Zp69atNpiuoCIdigYAAACgfPgjfqtOnDihFi1ayGw2y2w2Kzo6WlOnTpXZbFZUVJT27t2rihUrWh+XpP79+6tDhw6lPm+R99gAAACg7LHxglRwIHnfS2HtO2jbtm35HnvkkUcUEhKi5557TlWqVNHjjz+e7/FmzZpp8uTJ6tWrV2mNa0XYAAAAACjAy8tb9epUzXefp6en/Pz81LRpU0kqdMGA4OBg1a5du1RmvBSHogEAAAAohH2tsMceGwAAAAdi2NfPoijTCh7fuGbNmn99hmHDb0D22AAAAACwe4QNAAAAALtH2AAAADgAUyGHDQHlCWEDAAAAwO4RNgAAAACs7HUBCsIGAAAAQAH2dtFXwgYAAACA3SNsAAAAANg9wgYAAMAB2NthQ0BxI2wAAAAA2D3CBgAAAIDdI2wAAAAAWBl2ut4zYQMAAOBA7PWHUpQ99nbaFmEDAAAAwO4RNgAAAA6AVdFQ3hE2AAAAAOweYQMAAADA7hE2AAAAAOweYQMAAOBAWBQN18tev4UIGwAAAAAFmOxsRQrCBgAAOITp06crNDRUPj4+8vHxUVhYmH766Sfr47NmzVKHDh3k4+Mjk8mk5ORk2w1bIuzrh1CguBE2AADAIVSvXl0RERGKi4vT5s2b1bFjR/Xu3Vvbt2+XJKWnp6tbt256/vnnbTwpgJJgtvUAAAAAxaFXr175/v7GG29o+vTpiomJUZMmTTR69GhJ0po1a0p/OAAljrABAAAOJycnRwsXLlRaWprCwsJsPQ6AUkDYAAAAh7Ft2zaFhYXpwoUL8vLy0qJFi9S4cWNbj1Wq7HVFK5QhdvpNxDk2AADAYTRs2FDx8fHauHGjnnzySQ0ePFg7duyw9VgASgF7bAAAgMNwdXVVvXr1JEktW7ZUbGys3n//fc2cOdPGk5U8O1uZF3bA3r6l2GMDAAAclsViUUZGhq3HAFAK2GMDAADsVlaORW/88KeSUi/IPX6B+t59l4KDg3X27FnNmzdPa9as0fLlyyVJiYmJSkxM1J49eyTlno/j7e2t4OBgVa5c2ZZvA0AxIGwAAIBdysqxaOS8rVq2PVGSlLNuu75Z+JWSEo/L19dXoaGhWr58ue68805J0owZM/TKK69Yn9++fXtJUmRkpIYMGVLq8wMoXoQNAACwO5dGjauzk7zdzTrV4f/UqKqP4h9rrcqergWeM2HCBE2YMKH0hwVQKjjHBgAA2JV/Rs3MQS214PE2quLlpj+Pp+rB2TE6nZZp6zFtxrDTpXpRdtjrtxBhAwAA7EZhUXNHwwDVC/DW/OFt5O/tpp2JZ8tl3NjbClZAcSNsAACAXbhc1OSpF+ClL4flj5tT51gRDbhW9raEOGEDAADKvCtFTZ56AV6aP7yNAqxxs1EniRugXCBsAABAmXa1UZOnrn9u3AT6uCkhKXfPTXmLm+nTpys0NFQ+Pj7y8fFRWFiYfvrpJ+vjiYmJevjhhxUUFCRPT0+1aNFC33zzjQ0nBq4fYQMAAMqsokZNnjr+Xpo/PEyBPm7alXSu3MVN9erVFRERobi4OG3evFkdO3ZU7969tX37dknSoEGDlJCQoCVLlmjbtm3q16+f7rvvPm3dutXGkwPXjrABAABl0rVGTZ7aVTw1f3iYgnzctSvpnAbMitFfZx0/bgwZ6tWrl3r06KH69eurQYMGeuONN+Tl5aWYmBhJ0vr16zVy5EjdcsstqlOnjv773/+qYsWKiouLs/H0wLUjbAAAQJlzvVGTJzdu2ijIx127T5zTgNkxOnH2QglMXHbl5ORo/vz5SktLU1hYmCSpbdu2WrBggU6fPi2LxaL58+frwoUL6tChg22HRZlg2Oma4YQNAAAoU4oravLU+jtuqvq6a8+J3D03jhg3/1zBatu2bfLy8pKbm5ueeOIJLVq0SI0bN5YkffXVV8rKypKfn5/c3Nz0+OOPa9GiRapXr54NJgeKB2EDAADKjOKOmjx5cVPN1117/0rLjZtUx4ubSzVs2FDx8fHauHGjnnzySQ0ePFg7duyQJL344otKTk7WihUrtHnzZo0dO1b33Xeftm3bZuOpUZaY7OzqSIQNAAAoE0oqavLU9Ms95yYvbh6Y7dhx4+rqqnr16qlly5aaOHGimjdvrvfff1979+7Vhx9+qE8++USdOnVS8+bN9fLLL+vmm2/WtGnTbD02cM0IGwAAYHMlHTV5gv0qaP7wMN1Q0UP7/krTA7NilORAcXN26496e3ivQpd5Tk9P16xZs6yHmzVt2lQmk0kmk0kLFy6Us7OzLBaLLccHrgthAwAAbKq0oiZPbty0yY2bk7mHpTlK3Dh7++muoU9rwIABmj59ulq0aKG7775bjz32mGJiYjR//nwdOnRItWvXVuvWrTVs2DBVqFBBu3fvVlRUlPr06WPrtwBcM8IGAADYTGlHTZ4alfPHzQOzYpSYYt9xcyY9SxXqtVaLWzsqOztbL7zwgj7++GPl5ORo/fr1Wr58ue6//37VqFFDy5cv1w033KDIyEhlZmZqwYIFmjt3rnr06GHrt4EywD7XRCNsAACAjdgqavLkxU31Sh7afzJND8zaoOMp50vt6xe3348kS5Ka3eCrOXPmaO/evZo7d65cXFz09ddf684777RuW79+fT3//PPKzs5WdHS0fvvtNz388MM2mhwoHoQNAAAodbaOmjyXxs2BU+l6YFaMXcbNqXMZOnw6d26n5EOXXeb5UnPmzFGjRo3Utm3b0h4XKBGEDQAAKFVlJWryVK+UGzc1Knvo4N9xcyzZvuLmt7/31tT191TL0KaXXeY5z/nz5zVv3jwNHTrUBtPCXvzz2khlHWEDAABKTVmLmjy5cRNmt3ETfzhFknRjjUqXXeb5Ul9//bXS09M1aNAgW4wLlAjCBgAAlIqyGjV5bqjoofnDwxRcuYIOnc6Nm6N2EDfTp0/Xa4/21KHJ9+qjR27Nt8SzJFksFh05ckQdO3aUp6enfHx8NHLkSPXs2VP+/v42nBwoXoQNAAAocWU9avLkxk2bS+Jmg46cSbf1WP/qhhtuUMX2g1V18BT17Ntf9erV0913361FixZp/PjxWrNmjdasWaMuXbpo06ZN+vrrr5WamqpHH33U1qMDxYqwAQAAJcpeoiZPtYoeWvB4G9X0q6DDp8/rgVkxZTpuvBu0kVHjJvkGBcvbxUlr165Vdna2Bg8erNjYWDVs2FBjx47VuHHj1KRJE61Zs0bVq1dXz549bT06yijDTtd7JmwAAECJsbeoyVPVN3fPTS2/CjpyJjduDp8ue3FjGIYmRe2SJD3cpqY+/ni2IiIi5OrqqpiYGM2bN087d+5UQECA2rZtq8DAQP3666+aN2+enJz4MRCOhe9oAABQIuw1avLkxk1YmY6bqB1J2nY0RU5nDumN+1oVWOJ53759kqQJEyZo2LBhWrZsmVq0aKFOnTpp9+7dNp4eKF6EDQAAKHb2HjV5gnzdNX94mGpX8dTRZNvGzfTp0xUaGiofHx/5+PgoLCxMz0/9nyTpsbvaqUmTJsrJyVFKSop69uwpk8mkiIgISdLjjz+uRx55RDfddJMmT56shg0b6pNPPrHJ+wBKCmEDAACKlaNETZ4gX3d9OayN6lwSN4dOXTluCguRvNXKTp8+rZEjR6phw4by8PBQcHCwnnrqKaWkpFz29apXr66IiAjFxcVp8+bNCm56i+I+fl7mlCP6v04h8vDw0LBhw3T8+HHddttteuihh/Tqq69KUoELdDZq1EiHDh26jk8FKHvMth4AAAA4DkeLmjxBvu76cngbDZgVo30n0/TArA25S0P7Vbjsc/JCpH79+jIMQ3PnzlXv3r21detWGYahY8eO6d1331Xjxo118OBBPfHEEzp27Jg6deqk6dOn68CBA5KkJk2a6KWXXlKvXr2sr51jMXQqpK+kado74wmt6RooSapQoYKCgoJkNpvl7OysZs2aqVq1akpISMg3265du9S9e/di/5wAW2KPDQAAKBaOGjV5An3cNX94G9Xx99SxlAt6YNYGHTyVdtnte/XqpR49eqh+/fpq0KCB3njjDXl5eWnixIl68MEHFRUVpYEDB+qhhx5SRkaG3njjDS1dulSLFi3SX3/9pYyMDJnNZp06dUq9e/fW9u3bra/96bq9iol8VbJYJEnbt2/XhQsXNHfuXHl4eGj16tW6cOGCzp8/r2eeeUZTp07V119/rT179ujFF1/Uzp07NXTo0BL/zIDSRNgAAIDr5uhRkyfAx13zh7VRXWvcxOjAycvHTZ6cnBzNnz9faWlpCgsLy3dIWceOHdW7d2/t2LFDPj4+uueee7RgwQIlJCRoxYoVCgkJUU5OjtavX6/ff/9dbh6eeqxDQ6VtX6PBz78rSXr//fcVFxcnwzDUvHlzPffcc1q3bp0eeughjR49WuPHj9eYMWPUvHlzrVy5UlFRUapbt25Jf1ywU4bsc71nk2GUrZWqU1NT5evrq5SUFPn4+Nh6HAAAcAXlJWoudeLsBQ2YFaO9f6Up6O89ObWqeBbYbtu2bQoLC9OFCxfk5eWlefPmqUePHgW2q1SpkpycnPTEE0/ojTfesN6fk5Ojd999V+PGjdMPP/6o9WlBmvPjrzr57etq2DRUSQlbdfLkSS1atEh9+vTJ95qrVq1Sp06dtGfPHiIGRRLy4k+6kGXR2mfvUI3Klz/csjQUpQ3YYwMAAK5ZeYwaSQrwzj3npl6AlxJTc/fc7C9kz03Dhg0VHx+vjRs36sknn9TgwYO1Y8cO6+M5OTn65JNPlJKSosaNG2vChAmScoPIy8tLbm5ueumllxQQGKglJyrr883HdG7LDwq79Xb9se5nNW/e/LIztm7dWpK0Z8+e4n3zQBnF4gEAAOCalNeoyRPgnbta2oOzY7T7xDnrggK1L9lz4+rqqnr16kmSWrZsqdjYWL3//vsaMWKEdU+OJIWGhioqKkouLi6SpNWrV8tisSgnJ0c+Pj5KPpuuJWu3SCnH5X16p35ct02SZPn7HJvCxMfHS5KqVq1aEm8f5YDJZOsJioY9NgAAoMjKe9Tk8fd207xhbVQ/wEtJqRm6f+YG7fvr3GW3t1gsysjIUMOGDbV27Vo1atRI1apV09GjR60X05SkwYMHK2rdRj35zv9kCWiorOxsnV76jhqejdfxwwfk6+srJycnrV69WpLUr18/1a5dW3FxcTpw4ICWLFmiQYMGqX379goNDS3xzwEoCwgbAABQJFk5Fo2Yt6XcR00ef283fTm8jRoEeunE2Qw9MCtG8zcd0hNP/UfR0dE6cOCAtm3bpvHjx2vNmjUaOHCgLly4oCeffFImk0mrV69Wo0aNNHHiRB0/flzrd5/Q+O/3aNDXh/XjyUry7fWcjKwMeRlp2rN9q1xcXFSxYkXdcsstmjlzpiTp5ZdfVkBAgLp06aKQkBD95z//Uf/+/bV06VIbfzpA6WHxAAAAcNXyomb59iSi5h9OnsvQwNkblZB0NvfvP76vzMO/K+fcaVXw8lajxk31wvPjdFuHTlqxcpXu7134dWS8buohz0btZfbxVxN/V3kfXq9vPp2up59+Wu+8806B7U0mU6GLBwDXquF/f1JGtkXrnrtD1SvZz+IBnGMDAACuClHz76p4uWn+8DaK/HW/Yvaf1m93j1FG9sVzYE5IGrXWojOvD5RHnZt1wxNzZMk8r7Qda5Qa840C7ntV5kpVdWpJhM4d2KTMcylK8/SU2WyWt7e3nnnmGdu9OcAOEDYAAOCKiJqrU8nTVWO7NJQkZWZbtP1YiuIOntHmA2e0+eAZnTyXoZy0FJ36YZJyzp2R2d1T3tXqqt2ISapzU1s1rZitqP119Xv8VmVK8vLyUvv27XNXRgso/PMuYwffADZD2AAAgH9F1FwbV7OTbgqupJuCK+mx23IDJC0zR+5vdJfZ+fKnOT/bb1kpTgk4DsIGAABcFlFTfEwmk7zc+NEL9sNkZ+s9syoaAAAoFFEDwJ4UKWwmTJggk8mU7xYSEmJ9/MKFCwoPD5efn5+8vLzUv39/JSUlFfvQAACgZBE1AOxNkffYNGnSRMePH7fe1q1bZ31szJgxWrp0qRYuXKjo6GgdO3ZM/fr1K9aBAQBAySJqgPLNXpejKPKBnmazWUFBQQXuT0lJ0Zw5czRv3jx17NhRkhQZGalGjRopJiZGbdq0uf5pAQBAiSJqANirIu+x2b17t6pVq6Y6depo4MCBOnTokCQpLi5OWVlZ6ty5s3XbkJAQBQcHa8OGDZd9vYyMDKWmpua7AQCA0kfUALBnRQqb1q1b69NPP9WyZcs0ffp07d+/X7fddpvOnj2rxMREubq6qmLFivmeExgYqMTExMu+5sSJE+Xr62u91ahR45reCAAAuHZEDQB7V6RD0bp37279c2hoqFq3bq2aNWvqq6++koeHxzUNMH78eI0dO9b699TUVOIGAIBSRNQAKIx9LfZ8ncs9V6xYUQ0aNNCePXsUFBSkzMxMJScn59smKSmp0HNy8ri5ucnHxyffDQAAlA6iBoCjuK6wOXfunPbu3auqVauqZcuWcnFx0cqVK62PJyQk6NChQwoLC7vuQQEAQPEiagA4kiIdivb000+rV69eqlmzpo4dO6aXX35Zzs7OGjBggHx9fTV06FCNHTtWlStXlo+Pj0aOHKmwsDBWRAMAoIwhagBclp2u91yksDly5IgGDBigU6dOyd/fX7feeqtiYmLk7+8vSZo8ebKcnJzUv39/ZWRkqGvXrvroo49KZHAAAHBtiBoAjshkGEaZarLU1FT5+voqJSWF820AAChmRA2AK2nwwk/KzLFo/biOqlbx2hYIKy5FaYMiX6ATAADYp3xRY3bSzIeJGgCOg7ABAKAc+GfUzHq4pToQNQD+hcnO1nu+rlXRAABA2UfUACgPCBsAABwYUQOgqAw7XRaNsAEAwEERNQDKE8IGAAAHRNQAKG8IGwAAHAxRA6A8ImwAAHAgRA2A8oqwAQDAQRA1AIqTSfa13jNhAwCAAyBqAJR3hA0AAHaOqAFQnAz7XO2ZsAEAwJ4RNQCQi7ABAMBOETUAcBFhAwCAHSJqACA/wgYAADtD1ABAQYQNAAB2hKgBUFpM9rXaM2EDAIC9yMwmagDgcggbAADsQGa2RSO/JGoAlDw7Xe2ZsAEAoKwjagDgyggbAADKMKIGAK4OYQMAQBlF1ADA1SNsAAAog4gaACgawgYAgDKGqAFQFtjZas+EDQAAZQlRA8DWDMM+10UjbAAAKCOIGgC4doQNAABlAFEDANeHsAEAwMaIGgC4foQNAAA2RNQAQPEgbAAAsBGiBgCKD2EDAIANEDUAyjw7W++ZsAEAoJQRNQDKMvtc7JmwAQCgVBE1AFAyCBsAAEoJUQMAJYewAQCgFBA1AFCyCBsAAEoYUQMAJY+wAQCgBBE1AFA6CBsAAEoIUQPAnpnsbL1nwgYAgBJA1ACwV4adrvdM2AAAUMyIGgAofYQNAADFiKgBANsgbAAAKCZEDQDYDmEDAEAxIGoAwLYIGwAAimD69OkKDQ2Vj4+PfHx8FBYWpiXf/2CNGrOy1Xj/QvVv20heXl7q37+/kpKSbD02ADg8wgYAgCKoXr26IiIiFBcXp82bN+v2Dneob58+Wrpmk1zNTmpycJG2rF2hhQsXKjo6WseOHVO/fv1sPTYAFJnJvlZ7ltnWAwAAYE969epl/XNmtkVnGveTXD5QTtIuTXqyi/q1nad58+apY8eOkqTIyEg1atRIMTExatOmja3GBgCHxx4bAACuQWa2ReFfxOrbhV/JyLqgt57srwqph5SVlaXOnTtbtwsJCVFwcLA2bNhgw2kBwPGxxwYAgCLasvU3tQ4LU3ZmhpxcPfTmR3M1pOdtmjdvnlxdXVWxYsV82wcGBioxMdE2wwJAOUHYAABQBJnZFn0Un66Awe/LOfu8bnPeo/deGKW7b73R1qMBQLnGoWgAAFylvCWdVySclqd/dX327AP6YtZUNW/eXO+//76CgoKUmZmp5OTkfM9LSkpSUFCQbYYGgHKCsAEA4Cr823VqLBaLMjIy1LJlS7m4uGjlypXW5yUkJOjQoUMKCwuz1egAUC5wKBoAAFdgsRjWqEldO1cvPzlQtdzStW3bNs2bN09r1qzR8uXL5evrq6FDh2rs2LGqXLmyfHx8NHLkSIWFhbEiGgC7YBiG9c92ttozYQMAwJXsO3lOy7fnXmSzvrdFk/87Ss8ePy5fX1+FhoZq+fLluvPOOyVJkydPlpOTk/r376+MjAx17dpVH330kS3HB4BygbABAOAK6vp7qVuTIC3bnqgzNw/VZ1Onq30D/0K3dXd317Rp0zRt2rRSnhIAyjfOsQEA4ApMJpOmDrhJdzYOVGa2RcM+26xf95y09VgAgEsQNgAAXAVXs5OmPdhCnRsFKCPboqFzY7V+L3EDAGUFYQMAwFVyNTtp2sAWuqOhvy5kWTT0082K2XfK1mMBAETYAABQJG5mZ01/qKVub+Cv81k5evTTWMUeOG3rsQCg3CNsAAAoIncXZ818uKVuq19F6Zk5GvLJJsUdJG4A2L9LVnuWyWRfCz4TNgAAXAN3F2fNHnSz2tb1U1pmjgZ/Eqsth87YeiwAKLcIGwAArpG7i7PmDG6lNnUq61xGtgbP2aT4w8m2HgsAyiXCBgCA6+Dh6qxPhrTSLbUr62xGth6es1HbjqTYeiwAKHcIGwAArlMFV7Mih7TSzTUr6eyFbD00Z6P+OErcAEBpImwAACgGnm5mffroLWoRXFEp57P00JyN2nEs1dZjAUC5QdgAAFBMvNzMmvvoLbqxRkUlp2dp4Mcx2plI3ABAaSBsAAAoRt7uLvps6C1qXt1XZ9KzNHD2Ru1KOmvrsQDgqlyy2rPsa7FnwgYAgGLn4+6iz4a2VrMbfHUqLVMPzo7RbuIGAEoUYQMAQAnw9XDR/4beosZVfXTyXKYGzN6oPSfO2XosAHBYhA0AACWkYgVXffFYazWq6qOT5zL04OwY7fvr3+Nm4sSJatWqlby9vRUQEKA+ffooISEh3zZ79+5V37595e/vLx8fH913331KSkoqybcCAGUeYQMAQAmq5JkbNyFB3jpxNkMDZsfowMm0y24fHR2t8PBwxcTEKCoqSllZWerSpYvS0nKfk5aWpi5dushkMmnVqlX69ddflZmZqV69eslisZTW2wKAMsdkGIZx5c1KT2pqqnx9fZWSkiIfHx9bjwMAQLE4eS5DA2bFaPeJc6rq6675w9uopp/nFZ/3119/KSAgQNHR0Wrfvr1+/vlnde/eXWfOnLH+72RKSooqVaqkn3/+WZ07dy7ptwLAgeVYDNV9/kdJ0tYX71QlT1ebzlOUNmCPDQAApaCKl5vmDWujegFeOp5yQQNmxejw6fQrPi8lJfdCn5UrV5YkZWRkyGQyyc3NzbqNu7u7nJyctG7dupIZHkC5Ucb2eRQJYQMAQCnx93bTvGGtVcffU8dSLuiBWTE6cubycWOxWDR69Gi1a9dOTZs2lSS1adNGnp6eeu6555Senq60tDQ9/fTTysnJ0fHjx0vrrQAoB0x2tt4zYQMAQCkK8HbXl8PaqHYVTx1NPq8Bs2N0NPl8oduGh4frjz/+0Pz58633+fv7a+HChVq6dKm8vLzk6+ur5ORktWjRQk5O/M86gPKLfwEBAChlgT65cVPTr4IOnz6vAbNidDwlf9yMGDFC33//vVavXq3q1avne6xLly7au3evTpw4oZMnT+p///ufjh49qjp16pTm2wCAMoWwAQDABoJ8c+MmuHIFHTqdrgGzYpSUekGGYWjEiBFatGiRVq1apdq1a1/2NapUqaKKFStq1apVOnHihO6+++5SfAcAULaYbT0AAADlVbWKHvpyeBvdP3ODDpzKjZt6uxfoqwVf6rvvvpO3t7cSExMlSb6+vvLw8JAkRUZGqlGjRvL399eGDRs0atQojRkzRg0bNrTl2wEAm7quPTYREREymUwaPXq09b4LFy4oPDxcfn5+8vLyUv/+/bloGAAAl3FDRQ/1ufEGSdK+k2maPWuGUlJS1KFDB1WtWtV6W7BggfU5CQkJ6tOnjxo1aqRXX31VL7zwgt59911bvQUAKBOuOWxiY2M1c+ZMhYaG5rt/zJgxWrp0qRYuXKjo6GgdO3ZM/fr1u+5BAQBwRB+v3acPV++RJI3sWE+GYRR6GzJkiPU5ERERSkxMVGZmpnbt2qWxY8fKZG/LFwEok+x3sedrDJtz585p4MCBmj17tipVqmS9PyUlRXPmzNGkSZPUsWNHtWzZUpGRkVq/fr1iYmKKbWgAABzBx2v36fUf/pQkPdWpvsbe2cDGEwHARSbZ1y9MrilswsPD1bNnzwJXN46Li1NWVla++0NCQhQcHKwNGzYU+loZGRlKTU3NdwMAwJF07dpVnp6eMplMcnJyUtWqVTXqnUhr1DzUxEP/6dJQTk5OMplM+W4LFy608fQAYB+KHDbz58/Xli1bNHHixAKPJSYmytXVVRUrVsx3f2BgoPXkx3+aOHGifH19rbcaNWoUdSQAAMq0uLg4DRgwQIsXL9b8+fN17kKmpj73mLLTkjWqU3298uDtat++vW688Ub9+OOPiomJUceOHSVJ1apVs/H0AGAfirQq2uHDhzVq1ChFRUXJ3d29WAYYP368xo4da/17amoqcQMAcCgnT560/nnWL3vlfc8bOvfxk7olZ6fG3DlQUm78TJ8+Xd27d5cknT59Wm5ubvrzzz/Vrl07m8wNAPakSHts4uLidOLECbVo0UJms1lms1nR0dGaOnWqzGazAgMDlZmZqeTk5HzPS0pKUlBQUKGv6ebmJh8fn3w3AAAc0czovXrzx53KOXtKkvTwnS2sj7Vt21YLFizQ6dOnFRsbq/j4eJlMJnXo0MFG0wKAfSlS2HTq1Enbtm1TfHy89XbzzTdr4MCB1j+7uLho5cqV1uckJCTo0KFDCgsLK/bhAQCwFzOj92riTztlsWQrffkkeXt7q2/fvtbHv/rqK2VlZcnPz09t2rSRk5OTvvvuO9WrV8+GUwOA/SjSoWje3t5q2rRpvvs8PT3l5+dnvX/o0KEaO3asKleuLB8fH40cOVJhYWFq06ZN8U0NAIAdmRG9VxE/7ZQkZX71tM6fTSmwqM6LL76o5ORk/fDDD7r//vvVtm1b3XfffVq7dq2aNWtmi7EBlEOGHa/3fF0X6CzM5MmTddddd6l///5q3769goKC9O233xb3lwEAwC5MX3NJ1CwYq5NH9mvVqlVq1aqVdZu9e/fqww8/1CeffKJTp04pIyNDn3/+uW6++WZNmzbNVqMDKO/sa7Xnou2xKcyaNWvy/d3d3V3Tpk3jH2IAQLk3fc1evbVspywWi7IXPq2kQ3u0bNkytW/fPt926enpkiQnJyfNmTNHd999t/z9/eXs7CyLxWKL0QHA7lx32AAAgILyokaSsr76jxIP7taUKVMUGBio33//XZJUvXp1Va5cWSEhIapXr54GDRqkzZs3a86cOXrvvfcUFRWl77//3pZvAwDsRrEfigYAQHk3bfUea9T8584GSjy4W5I0evRoNW/e3Hp79tlnJUkuLi768ccfdfbsWTk5OWnkyJH67LPPNHfuXPXo0cNm7wMA7AlhAwBAMZq2eo/eWZ4gKTdqRnaqL8MwCr19/PHH1ufVr19fO3fuVE5OjtLS0vTbb7/p4YcfttXbAIACIiIiZDKZNHr0aOt9HTp0kMlkynd74oknbDIfh6IBAFBMLo2ap7s00IiO9W08EQAUjaHCl0WLjY3VzJkzFRoaWuCxYcOG6dVXX7X+vUKFCiU2379hjw0AAMXgw1W7rVHzTNeGRA0Ah3Hu3DkNHDhQs2fPVqVKlQo8XqFCBQUFBVlvPj4+NpiSsAEA4Lp9uGq33v15l6TcqAm/g4tqAij7Cju0TJIyjv6pxC+fV7UqFeXj46O6deuqa9eu6ty5c6Gv88UXX6hKlSpq2rSpxo8fb13psbRxKBoAANfhg5W79V4UUQPAvlzu0LKYDRuU9NXL8g27V8sWzdWva1ZpypQpev311wt9nQcffFA1a9ZUtWrV9Pvvv+u5555TQkKCTa5jSdgAAHCNpq7crUl/R82z3Rrq/zoQNQDKvksPLftnsDz79H/k07KXfNvcK29vH7311luKioqSr69voa81fPhw65+bNWumqlWrqlOnTtq7d6/q1q1bou/jnzgUDQCAa0DUALBX4eHh6tmzZ4FDy06cOKFNmzbJybOiEv/3tMJatdCJEyd00003yWw2y2w2Kzo6WlOnTpXZbFZOTk6B127durUkac+ePaXyXi5F2AAAUETvr7gYNc91CyFqANiN+fPna8uWLZo4cWKBx/bt2ydJSlk3T17Nu+qrbxfroYcekrOzs7777jvFx8fr5ptv1sCBAxUfHy9nZ+cCrxEfHy9Jqlq1aom+j8JwKBoAAEUwZcUuTVmRe8HN57qF6MkOpXuoBQBcq8OHD2vUqFGKioqSu7t7vsdyLIb2nTgrSfK6sZu8Qu9UWNt26tqxg3777TetW7dOPXv2lKenp/z8/NS0aVPt3btX8+bNU48ePeTn56fff/9dY8aMUfv27QtdFrqkETYAAFylS6NmXPcQPXE7UQPAfsTFxenEiRNq0aKF9b6cnBxF//KL3p/6gaoNmylJcqkSLE9XZ7mbc/fINGrUSIcOHSrweq6urlqxYoWmTJmitLQ01ahRQ/3799d///vf0nlD/0DYAACKzcSJE/Xtt99q586d8vDwUNu2bfXWW2+pYcOG1m0ef/xxrVixQseOHZOXl5d1m5CQEBtOfmWTo3bp/ZW5UTO+e4geJ2oA2JHk9Ew53dBMT330nbYfS9XuxLPKslh06sf35eJXXT6t+8s34Aadqeivlr7n9WF4O7mac89a2bVrl7p37y5JWrNmjfU1a9SooejoaFu8nUIRNgCAYhMdHa3w8HC1atVK2dnZev7559WlSxft2LFDnp6ekqSWLVtq4MCBCg4O1unTpzVhwgR16dJF+/fvL/R47bKAqAFgj/afTNOyPxK1fHui4g8n/32vs6RKMvlV0g3ebjJV9FHjxjU1+dWHFBLkrQ/9ntfLL7+s3/rcIdONN2ru3LnauXOnvv76axu+k6tjMgzDsPUQl0pNTZWvr69SUlJsdtVSAEDx+OuvvxQQEKDo6Gi1b9++0G1+//13NW/eXHv27Cn1pUGvxqVR83yPEA1vX/ZmBABJMgxDO46navn2JC3/I1EJSWfzPV7X31OtalW23mpU9tAdd9yhG2+8UVOmTLFuFxERoWnTpun06dNq3ry53n77bd16662l/G5yFaUN2GMDACgxKSkpkqTKlSsX+nhaWpoiIyNVu3Zt1ahRozRHuyLDMDR5xW5N/TtqXujRSMPa17HxVACQn8ViaOvhM1r2R6KWbU/U4dPnrY+ZnUwKq+unbk2DdGejQAX4uBd4/qWHluUZN26cxo0bV5JjlwjCBgBQIiwWi0aPHq127dqpadOm+R776KOP9OyzzyotLU0NGzZUVFSUXF1dbTRpQYZhaHLULk1dlXsdBqIGQFmSlWNRzL5TWvZHon7ekaS/zmZYH3N3cdLtDfzVtUmQOoUEyreCiw0nLV0cigYAKBFPPvmkfvrpJ61bt07Vq1fP91hKSopOnDih48eP691339XRo0f166+/Flh+1BYMw9CkqF364O+o+W/PRnrsNqIGgG2dz8zRL7v/0vI/ErXizySlXsi2PubtblankAB1axqk9g38VcHVcfZdcCgaAMCmRowYoe+//16//PJLgaiRJF9fX/n6+qp+/fpq06aNKlWqpEWLFmnAgAE2mPYiogZAWZJyPkurd57Q8u2JWpPwl85n5Vgfq+LlqjsbB6lb0yCF1fGzrmBWnhE2AIBiYxiGRo4cqUWLFmnNmjWqXbv2VT3HMAxlZGRccduSZBiG3vt5lz5cTdQAuDYREREaP368Ro0apSlTpujAgQOX/Xfwq6++0r333lvg/r/OZihqR5KWb0/U+r0nlZVz8eCqGyp6qFvT3JhpEVxJzk6mEnsv9oiwAQBcF4vF0Js//qnoXX+p4ta5ilr6rb777jt5e3srMTFRUu4eGg8PD+3bt08LFixQly5d5O/vryNHjigiIkIeHh7q0aOHzd6DYRh69+cETVu9VxJRA6DoYmNjNXPmTIWGhlrvq1Gjho4fP55vu1mzZumdd96xXhdGko6cSbeuZBZ78LQuPVGkfoCXujUNUtcmQWpSzUcmEzFzOYQNAOCaWSyGxn+7TQs2H5YkHfw8UpLUoUOHfNtFRkZqyJAhcnd319q1azVlyhSdOXNGgYGBat++vdavX6+AgIDSHl9Swah58a7GGnrrlfc0AUCec+fOaeDAgZo9e7Zef/116/3Ozs4KCgrKt+2iRYt03333KTHd0LJNu7Vse6L+OJqab5vm1X3VpUluzNQL8CqV9+AICBsAwDW5NGqcTFLDIB/pue/l7uKkjwe10q31qxR4TrVq1fTjjz/aYNrCGYahd5Yn6KM1uVHz0l2N9ShRA6CIwsPD1bNnT3Xu3Dlf2FzKMAwt+Cla8fHxcr51qDpP+sX6mJNJalWrsro1DVKXJkG6oaJHaY3uUAgbAECRWSyGnl90MWom33+jujYJ0pOfx2l1wl96dG6sZj7UUneE2GYvzNUwDENvL0/QdKIGwHWYP3++tmzZotjY2AKP5VgMxR44reXbE7X8j0RtWzhJLn41dNKztlydndSuXu41Zjo3CpSfl5sNpncsLPcMACiSvKiZH3sxanrfeIMkKSM7RyPnbdXPO5Lk4mzShw+2UNcmQVd4xZLVtWtXrVu3Tunp6TKZTAoMDNQnn3yi3021rVHjvvw1JcRvzPe8oKAg7du3Tx4e/OYUQOEOHz6sm2++WVFRUdZza9rffrv8azVU/btHKGpHkk6lZUqSLFkZOjptkNr0H6bnnn1GdzT0l7d7+bnGzLUqShsQNgCAq/ZvUZMnK8ei0Qvi9cPvx+XsZNKU+29Ur+bVbDSxVKVKFfXp00e9evVSRkaGRowYoZOnTqva/82V2bOiJvRqrPdH9NP27dv1zDPPqEuXLnJ2dtaePXs0YMAAubnxW1QAhVu8eLH69u0rZ2dnGZIMQzIsOZJMksmk4KcXqaKnuzo3CpR531pNfmmsjh49Kn9/f1uPbjcIGwBAsbNYDL2weJu+3JQbNZPuu1F9brqh0G2zcyx69uvf9e3Wo3IySe/c01z9Wxa8nk1pMwxDY2b/oPcf76VKnYdr0oRxGtKutnx8fNSoUSNt3Ljxyi8CAJKS0zO1dPM+LVobry0HzygzxyJJOvXj+/IODFb/R8I1qOdtuqV2Zbk4O6lDhw6qUqWKvv76axtPbl+4QCcAoFgVJWokyezspHfvbS5Xs5Pmxx7W01//pswciwbcElyKU+dnGIYilu3Ul6t+kyQ91LGFhrSrrRMnTujs2bPavn27XFxcZBiGqlWrpk8++USdO3e22bwAyh7DMPTL7pOau/6Aonf9pRyLIclbquyt+n4V1K1JkL7Z8aXa3dJE74/qa33enj179Msvv5SpxVMcEWEDAPhX/4ya9+5r/q9Rk8fJyaQ3+zaTm9lJczcc1Phvtykz26LBbWuV/ND/YBiGIn7aqelrdunk0nfkXsFLU8c/Lknat2/f3/M66aWXXpKTk5MmTpyorl27aufOnapfv36pzwugbEnPzNY3W47q01/3a+9fadb7Q4K8rdeYCQnylslk0vK3zQWuNfPJJ5+oevXq6tKlS2mPXq5wKBoA4LJyo+YPfbnpkDVq+t5UtEPKDCP3Ap6z1+6XJL3Qo5GGtS+9i18ahqGJP+3UrF/26ejHT8py5phiYjaoVatWkqT169erXbt2Gj9+vN58801J0qpVq9SpUyc9/vjjmjFjRqnNCqBsOXImXZ9tOKj5mw4p9UK2JMnLzax7WlbXw2E1Vdefa8yUNA5FAwBct+KIGkkymUx6vkcjuZmd9eHqPXrjxz+VkZ2jER1Lfk/IpVFz7JNwWc4c1erVq61RI0lVq1aVJDVu3Nh6X+vWrSVJu3btKvEZAZQthmEo9sAZRf66X8u3J8ry9y6Amn4VNDislu69uTqrmZVRhA0AoACLxdB/v8uNGtN1RE0ek8mkp7s2lJvZSe9F7dK7P+9SRrZFY+9sUOCQjeKSt6doZvReJX46UtmnDmv5smVq3759vu1q1aqlatWqKSEhwXpffHy8JKlOndLbswTAtjKyc7T0t+OK/HW/th9Ltd7frp6fHmlbW3eEBMjZqWT+vULxIGwAAPnkRc28jblRM+k6o+ZSIzvVl6vZSRN/2qkPVu1RZrZF47qHFHvcXHr42/HIEco+eUhTpkxRYGCgfv/9d0lS9erVVblyZe3bt0+hoaGaPHmyqlatKmdnZ40bN05OTk4aP358sc4FoOw5cfaCPo85pHkbD+rkudxrzriZndSvxQ0a0ra2GgZ523hCXC3CBgBgVZJRk+fx2+vKzeykCUt3aOYv+5SRbdHLvRoXW9wYhqE3fvhTH6/LPacn++QhSdLo0aPzbTd06FB9/PHHcnV1VXp6uiwWi8LDw2UymVS1alXNnz9fdevWLZaZAJQ9vx9JVuSvB/T978eUlZN7vFmQj7seDqupAbcEq7Knq40nRFGxeAAAQFJu1Lz43R/64u+oee/e5urXouSuPTNv4yG9sHibDEMacEuw3ujTVE7XeZiHYRh6/Yc/NefvqHm9T1M91KZmcYwLwAFk51i0bHuiIn89oLiDZ6z3twiuqEfa1Va3pkFycXay4YT4JxYPAAAUSWlHjSQ92DpYrmYnPfv1b/py0yFlZlv09j2h13wM+z+j5o2+TTWwNVEDIPdiml9uOqz/bTigYykXJEkuzib1bFZVj7SrreY1Ktp2QBQLwgYAyjmLxdBLSy5Gzbv3lHzU5LmnZXW5mp00ZkG8vtlyRJk5Fk26r/m//sZ04sSJ+vbbb7Vz5055eHiobdu2ioiI0Fe7Lfrk1/xRYxiGevTooWXLlmnRokXq06dPqbwvAGXDrqSzivz1gBZtPaILWRZJkp+nqwa2DtZDbWoqwMfdxhOiOLGvDQDKsbyo+TzmYtT0b1k6UZPn7ubVNO3BFnJxNmnpb8c0Yt4WZWZbLrt9dHS0wsPDFRMTo6ioKGVlZalN+476ePWfkqQ3+zaz7qmZMmVKia26BqB0REREyGQy5TtPLjExUQ8//LCCgoLk6empFi1a6JtvvpGU++/ayj+TNPDjGHWZ/Iu+3HRIF7IsalzVR+/cE6pfx3XU2C4NiRoHxB4bACinDMP2UZOnW9MgzXy4pZ74fIuWb0/SE5/H6aOBLeTu4lxg22XLlln/bBiGmgwYpx9/bC/3pD2a9NQAPdg6WFLuks3vvfeeNm/ebL1WDQD7Ehsbq5kzZyo0NDTf/YMGDVJycrKWLFmiKlWqaN68ebrvvvv04sffac1JTx04lS5JcjJJdzYO1KPtauuW2pX5RYeDY48NAJRDhpF7Tk1e1Lxjw6jJ0zEkUB8PulnuLk5atfOEhn22Weczcy67vWEYevX7Hfpi7U5J0ti7WlijJj09XQ8++KCmTZumoKCgUpkfQPE6d+6cBg4cqNmzZ6tSpUr5Hlu/fr1GjhypW265Rc6+gcpp3lcmN0998NXPOnAqXd7uZg27rbain7lDMx++Wa3r+BE15QB7bACgnCksau6xcdTkad/AX5FDbtHQubFau/ukhkRu0idDWsnTLf//XOVFzSfr9unMytlqEHqznh1wp/XxMWPGqG3bturdu3dpvwUAxSQ8PFw9e/ZU586d9frrr+d7rG3btprxyf/0c2pVrT18Xmk71sqSnan6N7ZW+N1N1K9F9QL/bsDx8Z84AJQjZTlq8oTV9dP/ht6iIZ/EauP+0xr0ySZFPtJKPu4uknLfwytLd+jT9Qd0+ufp8kw/rpVrNlifv2TJEq1atUpbt2611VsAcJ3mz5+vLVu2KDY2Nt/9F7JytGjrUWV3GKUts1/U+hF3Sk7OcnFz11vTP9N/Hrn3upeNh/3iUDQAKCcMw9BL3223Rs3b/UPLXNTkaVmzsj5/rLV83M2KO3hGD328UcnpmfmjJmq6XI/Fa9Ovv6h69YvvY9WqVdq7d68qVqwos9ksszn3d3j9+/dXhw4dbPSOAFytw4cPa9SoUfriiy/k7p57gn9mtkWbD5xWm4krNf7bbdr8zQwpM10DX5mtJSvW6oXnntEb/xmu7dv/sPH0sCUu0AkA5UBe1Pwv5qA1au69uYatx7qi7cdS9NDHG3UmPUuNqvroxhoVNW/jQZ1ZMUPmw5u18de1ql+/fr7nJCYm6uTJk/nua9asmd5//3316tVLtWvXLs23AKCIFi9erL59+8rZOXfxEIshGZYcSSbJZFKLp+dqyzsPa8PmrWrT8kbr8zp37qx69eppxowZthkcJYILdAIArAzD0MtL7C9qJKlJNV8teDxMD87eqD+Pp+rP46k6EzVdObvXaen3S+Tt7a3ExERJkq+vrzw8PBQUFFToggHBwcFEDWAHbrv9Dk35aoUWbz2qhKSzkqRTP76vqjXraNxz49SmTmXd9I7kW8Et3/OcnZ1lsVx+qXg4PsIGABxYXtR8tiE3at6yo6jJ0yDQW1893kYPzt6opLMXdHbrj5JU4LCyyMhIDRkypPQHBFAszl7I0qe/HtD/Yg7qxNkMSX7yquqv3s2rac2fX6rdLSF6om8HZWVlqV69enr88cf17rvvys/PT4sXL1ZUVJS+//57W78N2BBhAwAOqrCouc/OoiZPHX8vrfzP7TqdlqkaE4t+BHUZO+oawCVyLIa+jjusd5bv0slzGZIkf283DWpTUwNaB6uKl5s6TLv4I6uLi4t+/PFHjRs3Tr169dK5c+dUr149zZ07Vz169LDV20AZwDk2AOCADMPQhCXbNTcvavqF6r5W9hk1ABzXxn2n9Or3O7T9WKokqXYVT43qVF89mlWVq5k1rsA5NgBQrhE1AMq6w6fTNfGnP/Xjttxz5LzdzRrVqb4GhdUiaHDNCBsAcCB5yyETNQDKonMZ2Zq2eo/mrN2vzByLnEzSgFuCNfbOBvLzcrvyCwD/grABAAdx6TVeiBoAZYnFYujruCN6e3mC9TyadvX89OJdjRUSxKkHKB6EDQA4AKIGQFm1af9pvfr9dv1xNPc8mlp+FfRCz8bq3ChAJpPJxtPBkRA2AGDnLo0aiagBUDYcPp2uiJ926odtxyVJ3m5mPdWpvga1rSk3s7ONp4MjImwAwI4ViJr+zYgaADaVlpGtj9bs0ey1+5WZnXsezQN/n0dThfNoUIIIGwCwU4Zh6NXv80fN/a2CbTsUgHLLYjH0zZbc82j+Opt7Hk1YHT+91KuxGlXlPBqUPMIGAOxQXtRE/npAkhTRj6gBYDuxB07r1aU7tO1oiiSppl8FPd+jkbo0DuQ8GpQawgYA7ExhUfPALUQNgNJ35Ey6Jv60Uz/8nnsejZebWSM71tOQdrU4jwaljrABADtiGIZe+/5PogaATaVlZGtG9F7N+mWfMrItMpmkB1rV0Ng7G8rfm/NoYBuEDQDYibyo+eTX/ZKkiUQNgFJmsRhatPWo3l6+U0mpuefRtKlTWS/e1VhNqvnaeDqUd4QNANiBwqJmAFEDoBRtPnBar36/Q78fyT2PJrhy7nk0XZtwHg3KBidbDwAA+HeGYej1H4gaACUjIiJCJpNJo0ePtt63d+9e9e3bV/7+/vL28VH9Nl3U970f9fuRFHm5mTWue4iixrZXt6ZBRA3KDMIGAMqwvKiZsy43at7sS9QAKD6xsbGaOXOmQkNDrfelpaWpS5cushjSkNfnyO+BCB09fVYnvnlV97e8Qauf7qAnbq/L4gAocwgbACijDMPQG/+ImgdbEzUAise5c+c0cOBAzZ49W5UqVbLev3btOh04cEBHQ4do4X5nqXJNdf2/V5WVuEd3VjrJ4gAoswgbACiD8qLm47+j5o2+TYkaAMUqPDxcPXv2VOfOna33xR08o5cXx8tiSH+lG6pR2UPTB7bQl0/cJicnJ61bt86GEwP/jsUDAKCMKSxqBrauaeOpADiS+fPna8uWLYqNjZUkZWZbFJ1wQounr1eOaw05ubqr7oHF+vrFD+RmdtIzzzyjnJwcHT9+3MaTA5fHHhsAKEMMw9CbPxI1AErO4cOHNWrUKH3xxReyOJk1KWqX4g8na+9faTKZpAfbN9WX8xfo4Na1qlLJV76+vkpOTlaLFi3k5MSPjii72GMDAGVEXtTMXpsbNa/3IWoAFL+4uDidOHFCN7VoIYthSIYkwyId/kPp8T/ozYwMOTuH6r4+d+nkyZMym82qWLGigoKCVKdOHVuPD1wWYQMAZYBhGJr40858UfNQG6IGQPHza9BCdzz/mXYmpkqSAn3clRb1gVrf1EzPPfecnJ0vrnZWpUoVSdKqVat04sQJ3X333TaZGbgahA0A2Fhe1Mz6ZZ8kogZAyUhKvaCJP/6pxfHHJFVWpRv89X931NPQW2ur253/k5+fn5o2bSpJioyMVKNGjeTv768NGzZo1KhRGjNmjBo2bGjbNwH8C8IGAGzon1HzGlEDoARE7UjSM1//puT0LJlM0j0tquuZrg0V4ONe6PYJCQkaP368Tp8+rVq1aumFF17QmDFjSnlqoGhMhmEYth7iUqmpqfL19VVKSop8fHxsPQ4AlBjDMBTx007NvCRqHiZqABSjjOwcTfxxpz5df0CS1PQGH03sG6pm1X1tOxhwlYrSBuyxAQAbKBA1vZsQNQCK1b6/zmnkl1u1/VjuuTRDb62tZ7s1lJvZ+QrPBOwTYQMApazQqAmrZduhADiUb+KO6MXv/lB6Zo4qe7rq3XtD1TEk0NZjASWKsAGAUmQYhiKWETUASsa5jGy9uPgPLdp6VJLUpk5lTbn/JgX5Fn4uDeBICBsAKCXWqInOjZpXiRoAxeiPoykaMW+LDpxKl5NJGtO5gf7vjnpydjLZejSgVBTp8rHTp09XaGiofHx85OPjo7CwMP3000/Wxy9cuKDw8HD5+fnJy8tL/fv3V1JSUrEPDQD2xjAMvbUsIV/UDCJqABQDwzD0ybr96vvRrzpwKl1Vfd01f3iYRnaqT9SgXClS2FSvXl0RERGKi4vT5s2b1bFjR/Xu3Vvbt2+XJI0ZM0ZLly7VwoULFR0drWPHjqlfv34lMjgA2Iu8qJkRvVcSUQOg+JxOy9Rjczfr1e93KCvH0J2NA/XTqNt0S+3Kth4NKHXXvdxz5cqV9c477+iee+6Rv7+/5s2bp3vuuUeStHPnTjVq1EgbNmxQmzZtrur1WO4ZgCMhagCUlJh9pzRq/lYlpWbI1eyk//ZspIfb1JTJxF4aOI5SWe45JydHCxcuVFpamsLCwhQXF6esrCx17tzZuk1ISIiCg4P/NWwyMjKUkZGRb3gAcASGYejt5UQNgOKVnWPR1FV79OGq3bIYUh1/T304oIUaV+MXwijfihw227ZtU1hYmC5cuCAvLy8tWrRIjRs3Vnx8vFxdXVWxYsV82wcGBioxMfGyrzdx4kS98sorRR4cAMqyvKiZviY3al65m6gBcP2OJZ/X6Pnx2nTgtCTp3pbV9UrvJqrgynpQQJHOsZGkhg0bKj4+Xhs3btSTTz6pwYMHa8eOHdc8wPjx45WSkmK9HT58+JpfCwDKAsMw9M4/omZw21q2HQrAVZswYYJMJlO+W0hIiPXxxx9/XHXr1pWHh4f8/f3Vu3dv7dy5s8TnitqRpB5T12rTgdPydHXWlPtv1Dv3NidqgL8V+b8Jrq6uqlevniSpZcuWio2N1fvvv6/7779fmZmZSk5OzrfXJikpSUFBQZd9PTc3N7m5uRV9cgAog/Ki5iOiBrBrTZo00YoVK6x/N5sv/sjUsmVLDRw4UMHBwTp9+rQmTJigLl26aP/+/XJ2di72WS5k5Sjip536dP0BSVKzG3z1wYCbVKuKZ7F/LcCeXXfiWywWZWRkqGXLlnJxcdHKlSvVv39/SVJCQoIOHTqksLCw6x4UAMq6f0bNhF6NiRrATpnN5sv+Ynb48OHWP9eqVUuvv/66mjdvrgMHDqhu3brFOsfev85p5Lyt2nE89xzkx26trWe7hcjVXOSDbgCHV6SwGT9+vLp3767g4GCdPXtW8+bN05o1a7R8+XL5+vpq6NChGjt2rCpXriwfHx+NHDlSYWFhV70iGgDYK8Mw9O7P+aNmSLvaNp4KwLXavXu3qlWrJnd3d4WFhWnixIkKDg4usF1aWpoiIyNVu3Zt1ahRo9i+vmEY+mbLUb303R9Kz8xRZU9XvXdvc90RElBsXwNwNEUKmxMnTmjQoEE6fvy4fH19FRoaquXLl+vOO++UJE2ePFlOTk7q37+/MjIy1LVrV3300UclMjgAlBV5UTNtNVEDOILWrVvr008/VcOGDXX8+HG98soruu222/THH3/I29tbEyZMKLDwUe3ateXq6ipJmjVrlubNm6ctW7bo7NmzOnPmTIHFlf7NuYxsvbj4Dy3aelSSFFbHT1MeuFGBPu7F9h4BR3Td17EpblzHBoA9+WfUvNyrsR4hagCHkpycrJo1a2rSpEkaOnSoJkyYoAULFmjOnDlKSkrSjBkzlJiYqI0bN8rd3V1TpkzRhQsXJOUe7VKUsNl2JEUjv9yiA6fS5WSSxnRuoP+7o56cnbg2DcqnUrmODQCUd4Zh6L2fdxE1gIOrWLGiGjRooD179ljvc3NzU9u2bSVJPXv2VKVKlbRo0SINGDBAo0ePliStWbPmqr+GYRj65NcDivjpT2XlGKrm6673B9ykVrUqF+dbARwaYQMA1yAvaj5cnfuDzkt3ETWAozp37pz27t2rKlWqyGS6uOfEZDLJxcVF/fr1k8Vi0Zw5czRhwgQdOnRI/v7+uvnmm6/q9U+nZeqZhb9p5c4TkqQujQP19j2hqljBtUTeD+CoCBsAKCLDMDQpKn/UPHorUQPYs8xsi7YdTdGNNSrquWefUa9evVSzZk0dO3ZML7/8spydndW0aVPt3btXN910k+rXr68mTZpoz549mjx5sjIyMmQ2m/Xuu++qcePGOnjwoAYPHnzFr7th7ymNXrBVSakZcjU76b89G+nhNjXzBRSAq0PYAEAR5EXNB6uIGsBRpGVk65HIWG06cFp3Ng5UyuHDGjBggE6dOiV/f3/deuutiomJ0f/+9z+5uLjo7Nmzmj17ts6cOaPAwEB16tRJP/30k+6991716tVLklS3bl0NHTpUr7zyirKzswt8zewci6au3K0PVu+RYUh1/D314YAWalyN84uBa0XYAMBV+mfUvEjUAHbv0qiRpKgdSbqz5zM68MWXhV4r5sCBAzpz5ow8PT3VuXNn6zLQrVq1yncOjpS7FLSU/+KeknQs+bxGzd+q2ANnJEn33VxdE+5uogqu/FgGXA+u7gQAV8EwDE3+R9QMJWoAu3Zp1Hi7m/Xfno3kanZS1I4khc/bosxsS77t85aBXrZsmaZPn679+/frtttu0/Hjx7V3715VrVpVEyZMkMlkkslk0rvvvitJatWqlfU1vt9yQKFd7te3Y7rp8KR7VDV2mv5zWxBRAxQDwgYAriAvaqYSNYDD+GfU/G9oaz12Wx19POhma9z83xf54+aGZmE6X72VIj/9VO7u7poxY4ZOnTqlTp06ydnZWQMGDJCUexhaSEiIGjZsKEmaNGmSNsbG6dnPf9WAof+n5J0xuuWx17T4pygp/Yz69etnk88AcDT8egAA/oVhGJq8Yrc1av7bsxFRA9i5tIxsPfJp/qi5sUZFSVL7Bv76eNDNGvbZZq34MzduPhrYQhv2ndKwzzYrM9sip1//0IL583Xq1CnlXQ4wJiZG/v7+ysjI0KFDh5SVlWX9enfffbckqfKdT+rc71F64Nm3Nfe1kXI1O6n+DZFq1KiRYmJi1KZNm1L/LABHQtgAwGVYo2blbkm5UfPYbXVsPBWA62GNmv2n5e2WP2rytG/gr9mXxM3Aj2P025EU694byx2j1KNRgN7q3UD169TWE088obp16yo1NVWff/65cnJyFBQUJA8PD93QoLkSG/ZVloefXJK267QlW9Ofe8R6/k5ISIiCg4O1YcMGwga4ThyKBgCXQdQAjqVA1DxWMGry5MWNm9lJsQfOKDPbIp/fvtToxllyOveXvo+KVuitXayHoKWmpqpLly4ym82aMmWKPo6cq4Y9h2lT/B/aF/kftbrBXWNvDZCrq6sqVsz/NQMDA5WYmFjyHwDg4NhjAwCFmBy1i6gBHEhRoiZP+wb++njwzRqzIF7t6lXR8f1Zenvc/+nkyVMy3L3lekNj9Xx2lnwqVdaGdWu1ceNGSdJTTz2V73VcPSqoi/t+eXpUKKm3B0CEDQAUMDlql94nagCHkZ5Z9KjJc1t9f8W+0Dn3gpkPLLDev273SQ2dG6tNpywK/2KLpg28TRaLRXPW7ddby3YqK8dQNV93TR1wk568t6v27durO++8U5mZmUpOTs631yYpKUlBQUHF/K6B8odD0QDgEpdGzQs9iBrA3qVnZmtI5LVFTR6TyVTgvlvrV9Gcwa3kZnbSij9P6MnPt2jo3M16/Yc/lZVjqGuTQP046jaFVHG1LgXdsmVLubi4aOXKldbXSUhI0KFDhxQWFna9bxUo9wgbAPjbP6NmWHuiBrBn/4yaz4beUuSo+TeXxs2qnSe0aucJpaz5RAODz2rcrX7aEb9Zffv2tZ6H4+vrq6FDh2rs2LFavXq14uLi9MgjjygsLIyFA4BiQNgAgKQpK4gawJEUFjU3BVcq9q+TFzdebmbVD/BSWKAU+fpYhYSE6L777pOfn591KWhJmjx5su666y71799f7du3V1BQkL799ttinwsoj0xG3gLsZURqaqp8fX2VkpIiHx8fW48DoByYsmKXpqzIjZrne4RoePu6Np4IwPVIz8y9+ObGEo6aS13IypGb2anQw9YAXLuitAGLBwAo14gawLH8M2rmlkLUSJK7i3OJfw0A/45D0QCUW++v2E3UAA6ksKhpUQpRA6BsIGwAlEvvr9itySt2SZLGdydqAHuXnpmtRz/NjRovogYolwgbAOXO1JX5o+bx24kawJ7lRU3Mvtyo+YyoAcolwgZAuTJ15W5NisqNmnFEDWD3iBoAeQgbAOXGP6PmCaIGsGtEDYBLETYAyoUPiBrAoaRnZmvop5uJGgBWhA0Ah/fByt167++oea4bUQPYu7yo2bDvVO5CAY8SNQAIGwAO7sNV+aPmyQ5EDWDPCoualjWJGgCEDQAH9uGq3Xr3Z6IGcBTnM3OIGgCXRdgAcEiXRs2z3RoSNYCdO5+Zo0c/jb0kaloRNQDyIWwAOJxpq/fki5r/61DPxhMBuB6FR01lW48FoIwhbAA4lGmr9+id5QmSpGe6EjWAvSNqAFwtwgaA3Zk4caJatWolb29vBQQEqE+fPkpISLBGTc75s6qZsEBTn+gpDw8PBQcH66mnnlJKSoqtRwdQBJdGjaerM1ED4F8RNgDsTnR0tMLDwxUTE6OoqChlZWUprH1HvbX0N0nSoOY+quKUpnfffVd//PGHPv30Uy1btkxDhw618eQArtb5zBwNnXsxaj4begtRA+BfmQzDMGw9xKVSU1Pl6+urlJQU+fj42HocAHYgYtFGje/XRoEPRujFx/or/I6Ch58tXLhQDz30kNLS0mQ2m20wJYCrlRc16/cSNUB5V5Q2YI8NALv20Zo9+mDZ75KkoZ2aFRo1kqz/IBI1QNlG1AC4VoQNALv10Zo9euunP3Vm5WzVadpSbzzao9DtTp48qddee03Dhw8v5QkBFMX5zBw99tnFqMm9Tg1RA+Dq8KtLAHbpozV79PayBJ3+ebo8zh1T9JqYQrdLTU1Vz5491bhxY02YMKF0hwRw1fKi5tc9F6Pm5lpEDYCrR9gAsDvT1+zNjZqo6TIf3arNG9erevXqBbY7e/asunXrJm9vby1atEguLi42mBbAlRA1AIoDYQPArkxfs1cRP/2pMytmyOlgrDZtWKfatWsX2C41NVVdu3aVm5ublixZInd3dxtMC+BKiBoAxYWwAWA3Zv+yT28t26nTUdOVs2utfvphqby9vZWYmChJ8vX1lYeHh1JTU9WlSxelp6fr888/V2pqqlJTUyVJ/v7+cnZ2tuXbAPC385k5GvbZZmvUfErUALgOhA0Au5CdY9F7UQmSpHNbf5QkdejQId82kZGRGjJkiLZs2aKNGzdKkurVy79K2v79+1WrVq0SnxfAv8uLmnV7TlqjphVRA+A6sCoaALtgdnbS4La1JEk1n/te8zYelGEY+W5DhgyRlBs8/3ws70bUALZ3adRUIGoAFBPCBoDdGNctRI+2yz2fZvy32/TlpkM2nghAUV3Iyh81c4kaAMWEsAFgN0wmk168q5EeaVdLUm7czCduALtxIStHj80lagCUDMIGgF0xmUx66a7G1rgZR9wAdoGoAVDSCBsAdqewuFkQS9wAZRVRA6A0EDYA7FJe3Az5e0GB574hboCy6J9R8+kjRA2AkkHYALBbJpNJL/e6GDfjvt2mr2IP23YoAFb/XCjg00du0S21iRoAJYOwAWDXLo0bw5Ce+/Z34gawkWnTpqlWrVpyd3dXq1tuUd8Jc7V2N1EDoHQQNgDsHnED2N6CBQs0duxYvfzyy9qwMVbJHtX083tPyTXrrCKHtCJqAJQ4wgaAQ8iLm8FhNS/GzWbiBigtkyZN0rBhwzTgoUGatDldmW2GysnVXXc671DrOn62Hg9AOUDYAHAYJpNJE+5ucjFuviFugNKQmZmpuLg4te/QUcM+26y1u0/K081FXTp31pGE32w9HoBygrAB4FDy4mbQJXGzkLgBStTJkyeVk5OjT7actp5TEzmklZrUC1ZiYqKtxwNQThA2AByOyWTSK5fEzbPEDVCiLmTlSJJ+O5wsD5fcqOHwMwCljbAB4JDy4ubhNhfj5uu4I7YeC3A4F7Jy9OLyQ5LJSc4Zqfr0kYtRk5SUJBcXF/Xq1UvVqlWTyWTS4sWLbTswAIdF2ABwWCaTSa/2vhg3z3z9G3EDFKMLWTka/r84/bovWe5V6yvM/bg1aiwWi1auXKn69eurefPmmjZtmo2nBeDozLYeAABKUl7cGDL0ecwhPfN17onM97SsbuPJAPuWcj5LzV/5WZLk4eKsF557Wq8/O0JzO92qW265RVOmTFFaWpoiIiIUGBho42kBlAeEDQCHZzKZ9FrvppJkjRuTpP7EDXDN2kWssv75kXa19Gy3bqrodEEvvfSSjh49Knd3dxmGoWbNmqlt27Z66623bDgtgPKAQ9EAlAsmk0mv3t1UD7UJlmFIT3/9m77hsDTgmm16oZP1zx+v2681CSc0YsQIHTx4UJ07d9aHH36oTZs2KSoqSllZWerSpYsNpwVQHpgMwzBsPcSlUlNT5evrq5SUFPn4+Nh6HAAOxmIx9OJ3f+iLjYdkMknv3dtc/Vqw5wa4FpnZFo38couWb0+Sq9lJsx5uqQ4NAwps99dffykgIPf+RYsWqU+fPqU8KQB7VZQ2YI8NgHLFySn3sLSBrXP33Pxn4W/6dgt7boBr4Wp20ocPtlDXJoHKzLZo+P/itCbhRIHtUlJSbDAdgPKGsAFQ7uTFzYOXxM2ircQNcC1cnP89biwWi0aPHq127drZcEoA5QFhA6BccnIy6fVL4mbsV8QNcK3+LW6GDx+uLVu26MUXX5Qk7d+/X/Hx8Tp06JAtRwbggDjHBkC5ZrEYemHxH/py0yE5maT37muuvjdxzg1wLbJyLBoSuUm/7jklb3ezbvtrib5euFB//fVXgW0HDx6sTz/9tPSHBGBXOMcGAK6Sk5NJb/RpqgG3BMtiSP/56jct3nrU1mMBdum3w8mKP5QswzCUs3aOvlu8WL/++qsMw5BhGProo4/UrFkzeXt769tvv1VwcLBMJpNGjx5t69EBOACuYwOg3MuLG8nQl5sOa+xX8ZKkPjfdYNO5AHuyO+msBn+ySWmZOXLbFKljW1fqu+++k7e3txITEyVJ/v7+ioiIUP369fXbb7/psccekySdOnXKlqMDcBDssQEA5cVNMw24pYYshjT2q3h9F3/lPTcTJ05Uq1at5O3trYCAAPXp00cJCQn5tpk1a5Y6dOggHx8fmUwmJScnl9C7AGxn6+FkpWXmSJJ2r/lWKSkp6tChg6pWrWq9nTt3Tj169FDVqlX1/PPP6+uvv5bZbLaGDwBcD8IGAP6WFzcPtMqNmzELrhw30dHRCg8PV0xMTL4LEaalpVm3SU9PV7du3fT888+X9FsAbKbvTTeoW5MgSVL953/Uqp1J1kPQ8m5DhgyRJIWHh6t79+46efKkcnJyFBQUZMPJATgKFg8AgH+wWAw9v2ib5scelpNJmnz/jep949UdlpZ3IcLo6Gi1b98+32Nr1qzRHXfcoTNnzqhixYolMDlgW1k5Fo2ct1XLtifK1dlJMwe11B3/uGDn22+/rXHjxslkMsnb21vBwcHq2LGjpkyZYpuhAZRpLB4AANfBycmkN/sWbc9NnrwLEVauXLkkRwTKJBdnJ33w4E3q1iRImTkWPf5ZnFbvvHhNm8OHD+u9997TkiVLtGnTJj355JP6888/OccGQLFgjw0AXIbFYmj8t9u0YPPV7bmxWCy6++67lZycrHXr1hV4nD02KC8K7Ll5uKXuCAnQ4sWL1bdvXzk7O1u3zcnJPS/H2dlZGRkZ+R4DAPbYAEAxcHIyaWK/Zrr/5ot7bpb8duyy24eHh+uPP/7Q/PnzS3FKoOwpsOfmf7l7bjp16qRt27YpPj7eevP29ladOnUUHx9P1AC4LoQNAPyLf8bN6PlbC42bESNG6Pvvv9fq1atVvToX+ATy4ua2+lWUmWPRk1/E6eVXX9Pp06fl5eUlwzD0xRdf6OzZs2revLmaNm1q65EB2DnCBgCuIC9u7ru5ujVulv4dN4ZhaMSIEfrf//6nihUrKjQ09LLLPmdmZkqSateuLS8vL/Xv319JSUml/n6A0uLi7KSKFVwlSX6ebjpz6qQGDRqkhg0bqlOnToqNjVVoaKiCg4NtPCkAR8AFOgHgKjg5mRTRL1SS9NXmIxo1f6sk6aeZr2vevHlq2LChBg4cqBtvvFHZ2dl655131KVLF+3YsUNnz55VYmKi3nzzTUnSyy+/rICAAE2ePFn9+vXTr7/+arP3BZSkRVuPaOlvx+Rkkt5/4EbdXKujrUcC4MBYPAAAisBiMfTcN79rYdwRebg4a+fr3QvdburUqXrqqacUHR2tVatW6ZVXXimwzZtvvqnnn39eGzZsUJs2bUp6dKBUHTyVph7vr1VaZo7GdG6gUZ3r23okAHaIxQMAoIQ4OZn0Vv9QBfq46XxWjjbsPVngIoSGYah799zgqVy5siZMmKCVK1dKks6cOWPdZvz48QoODtaGDRts+ZaAYpeVY9FT8+OVlpmjW2pV1oiO9Ww9EoByoEhhM3HiRLVq1Ure3t6XPYb8woULCg8Pl5+fH8eQA3BITk4m3Vwz9zo1cQfPFHjcYrFo9OjRateunfWE6MTERLm6uhZY5jkwMFCJiYklPjNQmiZF7dJvh5Pl6+GiyQ/cKGcnk61HAlAOFClsoqOjFR4erpiYGEVFRSkrK0tdunRRWlqadZsxY8Zo6dKlWrhwoaKjo3Xs2DH169ev2AcHAFtqUbOSJGlLIWHDss8oz37dc1IzovdKkt7q30w3VPSw8UQAyosiLR6wbNmyfH//9NNPFRAQoLi4OLVv314pKSmaM2eO5s2bp44dc08QjIyMVKNGjRQTE8Mx5AAcRsu/wybuUO6hZSZT7m+k85Z9/uWXX/It+xwUFKTMzEwlJyfn22uTlJSkoKCgUp0dKCmnzmVozIJ4GYY04JZgdWta1dYjAShHruscm5SUFEm5x5BLUlxcnLKystS5c2frNiEhIf96DHlGRoZSU1Pz3QCgrGtc1UduZiclp2dp38k0RUdHq1atWpo+fbqOHDmi3377Ld/2NWrUkJOTk2rXrq0KFSqoW7duWr58uQ4dOqSwsDAbvQug+BhG7sIaJ85mqF6Al166q7GtRwJQzlxz2BTXMeQTJ06Ur6+v9VajRo1rHQkASo2r2UnNq1eUlHuezTvvvKPExETr6mdnzpxRYmKizp8/L8MwNGjQIAUEBMjd3V3Tp09XhQoVdPfdd6t169bszYZD+GzDQa3484RcnZ009YGb5OHqbOuRAJQz1xw2xXUM+fjx45WSkmK9HT58+LpeDwBKS/MavpKkHcdS9cMPPygjI0MvvviiJOnRRx9V1apVtWDBAu3evVsxMTH64Ycf1K9fP40ZM0bLly+XJN177702mx8oLn8eT9UbP/4pSXq+R4gaV+NyDQBK3zWFTd4x5KtXr77sMeSX+rdjyN3c3OTj45PvBgD2wOyc+0+oyaR8Sz1L0qJFi2QYhoYMGaKMjAxJkq+vr6ZNm6bTp08rLS1NAQEB2rZtm83mB4rD+cwcjfxyqzKzLeoUEqDBbWvZeiQA5VSRwsYwDI0YMUKLFi3SqlWrVLt27XyPt2zZUi4uLtbrNUhSQkICx5ADcEgXsnIkSe4u/37ITd65huPHj9eZM2eUmZmpt956S0eOHNHx48dLY1SgxLz2ww7tOXFOAd5uevueUOtCGgBQ2oq0Klp4eLjmzZun7777Tt7e3tbzZnx9feXh4SFfX18NHTpUY8eOVeXKleXj46ORI0cqLCyMY8gBOJwLWRZJkscVwsbFxUXffvuthg4dqsqVK8vZ2VmdO3dW9+7drXt4AHu07I/jmrfxkEwmadJ9N8rPy83WIwEox4oUNtOnT5ckdejQId/9kZGRGjJkiCRp8uTJcnJyUv/+/ZWRkaGuXbvqo48+KpZhAaAsubjH5so7v1u2bKn4+HilpKQoMzNT/v7+at26tW6++eaSHhMoEceSz+u5b3IPpXy8fV3dWr+KjScCUN4V+VC0wm55USNJ7u7u+Y4h//bbb7lGAwCHtG9brE58/Yqe699WJpNJixcvzvf4uXPnNGLECFWvXl0eHh5q3LixvvzyS/n7+2v37t3avHmzevfubZvhgeuQYzE0ekG8Us5nqXl1X/2nSwNbjwQARdtjAwC4KD0tTS4BdTT08WF679nh2r9/v+Lj4yVJ+/fv1+DBg7V582Z9/vnn2r59u/bt26fw8HAdPnxYX3zxhfr06aMuXbrY9k0A12Da6j3atP+0PF2dNXXATXJxvq7L4gFAseBfIgC4BoZhyCm4hSq1f1gdu90lSRo7dqxuuukm65+//fZbVa5cWR06dFBOTo6++uorGYahDz/8UA8//LC+/PJLW74F4JpsPnBa76/cLUl6rU9T1fTztPFEAJCLsAGAa7DtaIoSks7K1eyksDp+ki4u8Zx3GzZsmMxms44ePaqRI0fqs88+k6enp5YuXarXXntNrq6uNn4XQNGknM/SqPnxyrEY6nNjNfVrUf3KTwKAUsKhaABwDb7cdEiS1KNpkCp5Fh4oH3zwgYYPH67q1avLbDbLyclJs2fPVvv27UtzVKBYGIah5xdt09Hk8wquXEGv9Wlq65EAIB/22ADAVfrll1/Uq1cvVa1WTRH9myt91wYNuCXY+njfvn1lMpmsN3d3d3322WcaMmSI4uLi9N577yk8PFwrVqyw4bsArs3CzUf0w+/HZXYyaeqAm+Tt7mLrkQAgH8IGAK5SWlqamjdvrgdGTZAkBfq665bala2Pf/LJJzp+/LiOHz+uffv2ydk59/o2L774okJDQzVixAjdf//9evfdd20xPnDN9v51Ti8v2S5JGtulgW6sUdG2AwFAITgUDQCuUvfu3dW9e3f1+mCdJKl9/Sr5rrJeqVIl6/L2qampysnJUfPmzVWnTh3rNs7OzrJYLKU7OHAdMrJzNHLeVp3PylHbun56on1dW48EAIUibACgCLYeOqNtR1MkSTdW87Qu7yzJutxz5cqV5eaWewX2U6dOac2aNapZs6aio6P12WefadKkSbYYHbgmby9L0I7jqapUwUWT779RTk6mKz8JAGyAsAGAS/zyyy965513FBcXp+PHj2vRokXq06ePJOmvsxka+eVWZZ08LEka8fhjyszMtD537NixkqTBgwercePG8vX11R133KGBAwfq9OnTqlmzpt544w098cQTpf6+gGuxJuGE5qzbL0l6557mCvRxt/FEAHB5hA0AXCLvPJpHH31U/fr1s95/IStHwz7brP379unEl89JkiZOnKjevXtr+/btatOmjQICAqzbh4SE6OGHH9YHH3xQ6u8BKA5/nc3Q0wt/kyQNDqupzo0DbTwRAPw7Fg+4SnmrIVWrVk0mk0mLFy/O9/iECRMUEhIiT09PVapUSZ07d9bGjRttMyzsypW+ty71xBNPyGQyacqUKaU2nyP6t8+8e/fuOnLkiDVq8lY6a9DyNsUfTlbar5+rZ48ekqQ6deqobt26uvvuu/NFzdq1a5WQkKDHHnusVN8XUFwsFkP/WfibTp7LVEiQt8b3aGTrkQDgigibq5T3W9xp06YV+niDBg304Ycfatu2bVq3bp1q1aqlLl266K+//irlSWFvrvS9lWfRokWKiYlRtWrVSmkyx3U1n3m3bt0k5a509vznv8joOEpmJ0NZBzarZWhjSbmHnLVu3bpAjM6ZM0ctW7ZU8+bNS+w9ACVpzrr9+mXXX3IzO+mDATfJ3cXZ1iMBwBVxKNpVylsN6XIefPDBfH+fNGmS5syZo99//12dOnUq6fFgx670vSXJeuX65cuXq2fPnqU0meO6ms887+T/LYmZWpqSKmd3L41p7asRaWl68803JUnDhg1TZmam+vbtqzVr1uj2229XamqqFi5cqPfee6/E3wdQErYdSdHby3dKkl7q1Vj1A71tPBEAXB3CpgRkZmZq1qxZ8vX15Te2uG4Wi0UPP/ywnnnmGTVp0sTW45QbK1etliR99ObzqlCvtZ7778sKzMpdNODChQuSZI2X6tWra8aMGbr99ts1f/58GYahAQMG2GZw4DqkZWTrqflblZVjqFuTID14yQVoAaCs41C0YvT999/Ly8tL7u7umjx5sqKiolSlShVbjwU799Zbb8lsNuupp56y9SjlQvzhZO12rSuPO0dJkiqFdpLn6V1a8tZI9ezZU2azWa+99poMw7DeHnzwQR06dEiSNHz4cKWnp8vX19eWbwO4JhOWbNf+k2mq6uuuiP7N8l2nCQDKOvbYFKM77rhD8fHxOnnypGbPnq377rtPGzduzHdSMVAUcXFxev/997VlyxZ+wChhu5PO6t2fE7R8e5JUuYUq+jvpL0nvjbhXt7WOUN26dbV+/Xq1atVKCQkJ+Z67a9cu1axZ0zaDA8VkyW/HtDDuiEwmafL9N6piBVdbjwQARcIem2Lk6empevXqqU2bNpozZ47MZrPmzJlj67Fgx9auXasTJ04oODhYZrNZZrNZBw8e1H/+8x/VqlXL1uPZtXMZ2fplV+7iHu/+vFNdp/ySGzVZ53Vb5XOa2qWiJOl04hGlpqaqUqVK2rNnj5555hktWLBAs2fP1p49e/Thhx9q6dKl+r//+z8bvhvg+hw+na4Xvt0mSRpxRz21qeNn44kAoOjYY1OCLBaLMjIySu3rGYbxj79f8ucrbVvg8X/8XZd/7YJzFO251zVbKX6tf772Ff56zZ/hqbQMHU0+L0nqfPc9+rlVu3yPP3Rvb/W7d4Due/BhHT6dXviLXOHrFHgvl92usNcr5LlX+XUvt/XVf+3CtrvK1zOkg6fStOnAaW0+cEbbj6XI8vd2uxLPqYKP1LVJoG7zPKGH+/fU538/L++im5JUtWpV3X333ZoxY4YmTpyop556Sg0bNtQ333yjW2+9tZCJgbIvO8eiUfO36mxGtlr8f3t3Hh1lffd9/DOZrASSkABZgEDYkSWglDTA7VIiNEUEt4o3t6byWE8tPoJUEVtRFBWh1gep3KBWgRYVbauouEJAEEVWI1JZAkRAIAkoyYSELMz8nj8gA4EwkGQmVyZ5v87JOc51XTPz5ed1MvnMb0uM0oShXa0uCQBqhWDjQc7RYt3+ynodPV4mV/kJlf90yP0H091zP9SEZT8oIKyF7GER+umLJQrv9nMFhreUs8Shws3LVLTvgF49FKvX/vShJC//QY9Gw1V+QiePHXY/fvDVFZq6Il8BYc0VGHH+MMajxU4t2VakD985KOlgPVbaeFS2eZuIEO2TNDwxQLcOa6m+XdooOrqHHnjgAd10002Ki4vTnj17NHnyZBUVFWn48OGSpHHjxmncuHHW/iMAL3k+M1tb9heoRWignh/TX4F2BnMA8E8EGw825PyoH46d+ua89MBO5b3xR/e5IyteliSF9x6qmOHjVXr0gBxbV8h5wiF7WISC47oqduxMBUQnqsJJIvFn505tsVU5Z7vgueqfe/6LlRzco8OLp7gPHVv5N0lSRN80xY2cdN7r2GxSoN2msGr2lbjQNJzqDlc3Z6fap1dz8JJfzwf1VP+al/beMeHB+lnHaIUe3aFHfnufKuPk4uena/Hz05WRkaF58+Zp69atWrRokQoKCpSQkKBhw4Zp+vTp7iWggcZi3Z4f9cKq3ZKkp2/oo/bRzSyuCABqz2aqG1diIYfDocjISBUWFioiIsLSWpZs2K8pb3+rwV1iNPOmvlXO1eUPWk9/KFd34Nw/hn39h/aFrj//ter2Xp7mwtf0uZ5qu2hdTMoH0AQdKy5X+vOfK9dRqluuaKc/38L2BAAanppkA3psPKhMfGFBgWrXkm+xAACNgzFGD/17q3IdperUKlzTrmePLAD+j4G0HlT2ZfGFPgDAn02bNk02m839ExAQoAX336Agu01zbuuv8BC+5wTg//hNdgnINQAAf9erVy+tWLFCu/OPK+PV9Sp32fTQL3uod1s2kwXQONBj40F1y8gCAOCPAgMDFRXTWtMzD8kZGqVr+nXRuMFJVpcFAF5Dj40HDEUDADQW2dnZah0br1JXgCI6XKb773hRAQF8wAFoPOix8aCyv+a8lcMAAPAjKSkpmvTkbLUY/aiih/1e8QFFGp2epqKiIqtLAwCvIdh4crrLhh4bAIA/6z/oGr1f1EHBbZL0f++4WWtXLVdBQYHeeustq0sDAK9hKBoAAI2Y02V0/5tZKiipUK+ECD34y+4KCbSrW7du2r17t9XlAYDX0GPjgXsoGj02AAA/NX/1Hq3b+6PCguyac1t/hQTadfz4ce3Zs0fx8fFWlwcAXkOw8cC9eABzbAAAfmjL/mN6bvkuHVv5im5tVyR78VF9+eWXuuGGG2S323XbbbdZXSIAeA3BxgNzJtkAAOBXKpwuPfDWN3K6jNrYi/XS4xPUvXt3/frXv1ZMTIy++uortW7d2uoyAcBrmGPjAbvYAAD81evr92vv0WK1ah6szJXLFBkWZHVJAOBT9NhcAjpsAAD+xFFaodkrdkmSJqZ1I9QAaBIINh6c2aCTaAMA8B//u2qPjpVUqHPrcI35WXurywGAekGw8eDMBp0AAPiHH46V6NUvciRJf/xVTwXa+agH0DTw284D9+IBAAD4iWc/2anyky6ldorRL3q0sbocAKg3BJtLYLNJa9as0ciRI5WQkCCbzaalS5e6z1dUVOihhx5Snz59FB4eroSEBN1xxx06dOiQdUUDAJqcrT8UaGnWqc+eP43oyVBqAE0KweYS2CQVFxcrOTlZc+fOPe98SUmJtmzZoqlTp2rLli16++23tXPnTl1//fX1XywAoEkyxuipD7ZLkm7s31a920ZaXBEA1C+We/bg7MUD0tPTlZ6eXu11kZGRWr58eZVjL7zwggYOHKj9+/crMTHR16UCAJq4FdvztT7nJ4UEBugPw7tbXQ4A1Dt6bDwwp5cPqE1HfmFhoWw2m6KiorxaEwAA56pwujTjo1O9Nf9nSJLaRoVZXBEA1D+CjQe1XTugtLRUDz30kG677TZFRER4tygAAM6xZMN+7T1SrJjwYN1zdWerywEASxBsPHDnmhp02VRUVOjXv/61jDGaN2+eL8oCAMDNUVqh/7ciW5I0Ma2rWoSyGSeApok5NpfAdonJpjLU7Nu3TytXrqS3BgDgc/M/26OfisvVqXW4xgxkTieApotg48GZxQMufm1lqMnOztaqVasUExPj2+IAAE3ewYITemXtqc04H07vqSA24wTQhBFsPDBnBqPp+PHj2r17t/txTk6OsrKyFB0drfj4eN18883asmWLli1bJqfTqdzcXElSdHS0goOD6712AEDj95dPdqrspEspSdFK68lmnACaNoLNJbBJ2rRpk6655hr3sUmTJkmSMjIyNG3aNL333nuSpH79+lV57qpVq3T11VfXU6UAgKZi28FCvf31QUlsxgkAEsHGo8q5NUbS1VdfLeNhmTRP5wAA8CZjjJ784DtJ0uh+CerbLsraggCgAWAwrgcBp7/8chFaAAANyMod+fpq708KDgzQA2zGCQCSCDYeVfbqk2sAAA3FSadLT394ajPOcYOT1K5lM4srAoCGgWDjQcDpZMMwMwBAQ7Fk4wHtOVKsls2C9Ptr2IwTACoRbDyonIjpItcAABqAotIKzV6xS5I0Ma2bItiMEwDcCDYeMMcGANCQvLh6r44eL1dSq3D9dwqbcQLA2Qg2HlQunEmuAQBY7XDhCb38+V5J0pT0HmzGCQDn4LeiBwEBlcs9k2wAANZ69pNdKjvp0sCO0Rp2WazV5QBAg0Ow8cA9x8ZlcSEAgCbt1GacP0iS/shmnABQLYKNB8yxAQBYzRijpz/cLmOk65MT1K99lNUlAUCDRLDxwCZWRQMAWOuznUf05Z4fFWwP0INsxgkAF0Sw8SDA3dNPsgEA1L+zN+O8c3BHtY9mM04AuBCCjQcB7GMDALDQW5t+UHb+cUU1C9Lvr+lidTkA0KARbDywMccGAGCR4rKTem75qc04JwztqsgwNuMEAE8INh7Y6LEBAFjkxTV7dfR4mTrGNNPYlA5WlwMADR7BxoPKOTaGHhsAQD3KLSzVS2v2SDq1GWdwIB/XAHAxgVYX0JBVzrEh1wAA6svBgwd17W13K3vj55KzTA9+0E2tFizQgAEDrC4NABo0go0HzLEBANSnY8eOaeDPB8nRspva3DJNL9/9CwWX5Ktly5ZWlwYADR7BxoMzc2wINgAA35s5c6Yqwloq5lcTdV3feF03pJ/VJQGA32DQrgdn5thYWwcAoGlY8q93VBrZUT+++4yWTBiu/v376+WXX7a6LADwCwQbD5hjAwCoL06X0YF936vo6w91eZ+eWv7pp7rnnnt03333adGiRVaXBwANHkPRPAhgjg0AoJ78a/MBuVwuNUvoqvcWzlVksyD1799f27Zt0/z585WRkWF1iQDQoNFj4xFzbAAAvldcdlJ/+XSX7M1b6vLkPopsdmYzzp49e2r//v0WVgcA/oFg44F7jo21ZQAAGrmXP9+r/KIyRXfqI1NwqMq5Xbt2qUMHNugEgIsh2HgQ4F4VzeJCAACNVr6jVC+u3itJ+uPkB7R+/Vd6+umntXv3br3++ut66aWXNH78eIurBICGjzk2HgScjn2GoWgAAB9ZvH6/TlQ41T8xShPGDFKXFu/o4Ycf1hNPPKGkpCTNnj1bY8eOtbpMAGjwCDYe2MSqaAAA3zHG6P1vTg09y0jtKJvNpuuuu07XXXedxZUBgP9hKJoHNlZFAwD40LaDDuUcLVZoUICuvSzW6nIAwK8RbDxgjg0AwJfezTooSRraM1bhIQyiAIC6qHGwWbNmjUaOHKmEhATZbDYtXbq0ynljjB599FHFx8crLCxMaWlpys7O9la99erMBp0kGwCAd7lcRsu2HpYkXZ+cYHE1AOD/ahxsiouLlZycrLlz51Z7ftasWZozZ47mz5+v9evXKzw8XMOHD1dpaWmdi61vlUPRyDUAAG/b8P1PynWUqkVooK7u3trqcgDA79W43zs9PV3p6enVnjPGaPbs2XrkkUc0atQoSdLf//53xcbGaunSpRozZsx5zykrK1NZWZn7scPhqGlJPsMcGwCAr7x3etGAX/aKU0ig3eJqAMD/eXWOTU5OjnJzc5WWluY+FhkZqZSUFK1bt67a58yYMUORkZHun/bt23uzpDo5M8eGYAMA8J4Kp0sffXtqGNqofm0trgYAGgevBpvc3FxJUmxs1ZVdYmNj3efO9fDDD6uwsND9c+DAAW+WVCdn5thYXAgAoFFZm31Ux0oq1Kp5iFI7x1hdDgA0CpYvwRISEqKQkBCry6iWe46NtWUAABqZymFo1/WNlz3AZnE1ANA4eLXHJi4uTpKUl5dX5XheXp77nD8JYI4NAMDLTpQ79el/To1iGMlqaADgNV4NNklJSYqLi1NmZqb7mMPh0Pr165WamurNt6oXNubYAAC8bOWOfBWXO9WuZZguT4yyuhwAaDRqPBTt+PHj2r17t/txTk6OsrKyFB0drcTERE2cOFFPPvmkunbtqqSkJE2dOlUJCQkaPXq0N+uuF+7FA1wWFwIAaDQqN+UcmZzg/gINAFB3NQ42mzZt0jXXXON+PGnSJElSRkaGFi5cqMmTJ6u4uFh33323CgoKNGTIEH388ccKDQ31XtX1hI8bAIA3FZ6o0Gc7j0hiU04A8LYaB5urr75axsPQLJvNpieeeEJPPPFEnQprCFjuGQDgTZ/8J1flTpe6tmmuHnEtrC4HABoVr86xaWzO3qBzzZo1GjlypBISTg0dWLp0aZVr3377bQ0bNkwxMTGy2WzKysqq93qtcLF2Mcbo0UcfVXx8vMLCwpSWlqbs7GxrigUAi71/ejW06xmGBgBeR7Dx4EyPjVRcXKzk5GTNnTu32muLi4s1ZMgQzZw5sz5LtNzF2mXWrFmaM2eO5s+fr/Xr1ys8PFzDhw9XaWlpPVcKANY6UlSmL3YflSRd349haADgbZbvY9OQufexMVJ6errS09MveO3tt98uSfr+++/robKGw1O7GGM0e/ZsPfLIIxo1apQk6e9//7tiY2O1dOlSjRkzpj5LBQBLffjtYbmMlNw+Sh1iwq0uBwAaHXpsPKjssfE0pwgXlpOTo9zcXKWlpbmPRUZGKiUlRevWrbOwMgCof++dNQwNAOB9BBsP2KCzbnJzT21AFxsbW+V4bGys+xwANAU/HCvR5n3HZLNJ1/WNt7ocAGiUCDYenFk8wNo6AAD+7f1vDkuSfp4Uo9gI/9v+AAD8AcHGAxtD0eokLi5OkpSXl1fleF5envscADQFlZtysmgAAPgOiwd4UDnH5qTL6D+HCquc2/9T8XnHJOlgnkOStCe/SEHnnG8o+cgbdTQLsatz6+Yer0lKSlJcXJwyMzPVr18/SZLD4dD69et1zz331L0IAPAD2XlF2pFbpCC7Tem9+VIHAHyFYOOB/XSwKSl3Kv3Z5Tp57LD73LTXPtMzn/+kgLDmCoxoI+eJIjkdR+Q8/qMk6XdzlykoOkv28JayN29pSf2+9uTo3hrdO0a7d+92H8vJyVFWVpaio6OVmJioiRMn6sknn1TXrl2VlJSkqVOnKiEhQaNHj7aucACoR5WLBlzZtbWimgVbXA0ANF4EGw/atQzT0B5ttO1QoRx7d2jHwgfc546t/JskqVX/a9X25sk6svsz/fDvZ93nj743S5KU8IvblTD0DkmSTXXfjM0b+7nV9SUcpSd1vOyk9h4p1qZNObrmmmvc5yZNmiRJysjI0MKFCzV58mQVFxfr7rvvVkFBgYYMGaKPP/5YoaGMMQfQ+BljzqyGxjA0APApm2lgE0gcDociIyNVWFioiIgIq8tBNWZ+vEPzPtujcYOT9OjIy6wuBwAarG8OFGjU3C8UFmTXpkfSFB7C94kAUBM1yQYsHgAAgI9U9takXRZLqAEAHyPYoMYq+/i8MSwOABorp8to2VY25QSA+kKwAQDABzbk/KQ8R5kiQgN1ZbdWVpcDAI0ewQYAAB+oHIaW3jteIYF2i6sBgMaPYIMaMzo1Fo2RaABQvfKTLn347aktAlgNDQDqB8EGAAAv+zz7iApPVKh1ixD9vFOM1eUAQJNAsAEAwMsqh6GN6BMvewD92wBQHwg2qDlWRQOACzpR7tTy7/IkSaMYhgYA9YZgAwCAF63YnqeScqcSo5upX/soq8sBgCaDYAMAgBdVDkMbmRwvG13bAFBvCDaosdMj0fjABoBzFJ6o0OqdRyRJ1ye3tbgaAGhaCDYAAHjJJ9tyVe50qXtsC3WPa2F1OQDQpBBsAADwksphaOxdAwD1j2CDGjOGDToB4Fz5RaX6cs9RSdLIvgQbAKhvBBsAALzgg62H5TJSv/ZRSoxpZnU5ANDkEGwAAPAC9zC0ZHprAMAKBBvUmHEvi2ZpGQDQYBz4qURf7y9QgE26rm+81eUAQJNEsAEAoI4qe2tSO8eoTUSoxdUAQNNEsEGNnemwocsGACTpfYahAYDlCDYAANTBrrwi7cgtUpDdpl/2YhgaAFiFYAMAQB28l3Wqt+aqbm0U2SzI4moAoOki2KDGKhcPsDESDUATZ4xhU04AaCAINgAA1FLWgQLt/6lEYUF2pfVsY3U5ANCkEWwAAKilyt6aay+LVbPgQIurAYCmjWCDGjOn10VjJBqApszpMlq29bAkVkMDgIaAYAMAQC2s3/ujjhSVKTIsSFd2a211OQDQ5BFsAACohcphaL/qE6fgQD5OAcBq/CZGjbEqGoCmrvykSx9ty5UkjWQYGgA0CAQbAABqaM2uIyo8UaE2LUKUkhRjdTkAABFsAACoscphaNf1TZA9gO5rAGgICDaoNRvrogFogkrKT2r5d3mS2JQTABoSgg0AADWw/Ls8nahwqkNMMyW3i7S6HADAaQQbAABq4P3Tw9BG9k2QjVVUAKDBINigxszpZdH4PAfQ1BSUlGv1riOSGIYGAA0NwQYAgEv08bZcVTiNesS1ULfYFlaXAwA4C8EGAIBLVLkaGr01ANDwEGxQY6f352RNNABNSr6jVOv2/ijp1PwaAEDDQrABAOASLNt6WMZIlydGqX10M6vLAQCcg2CDGjPuLhv6bAA0He5haMn01gBAQ0SwAQDgIvb/WKKsAwUKsEkjGIYGAA0SwQYAgIt4f+up3ppBnVupdYsQi6sBAFSHYIMaM6eXD2AgGoCm4t2sg5IYhgYADRnBBgAAD3bkOrQr77iC7QEa3jvO6nIAABdAsAEAwIP3sk4NQ7u6e2tFhgVZXA0A4EIINqixylXRWBQNQGNnjHHPr2FTTgBo2Ag2AABcwNcHCnTgpxMKD7ZraI9Yq8sBAHhAsAEA4AIqh6Fde1mswoLtFlcDAPCEYIMac+/PybpoABoxp8vog28PS2IYGgD4A4INAADV+GrvjzpSVKaoZkEa0qW11eUAAC6CYAMAQDUqh6Gl945XcCAflwDQ0PGbGjXGqmgAGruyk059uO30MDQ25QQAv0CwAQDgHKt3HlFR6UnFRYRqYFK01eUAAC4BwQYAgHO8982pYWjX9Y2XPYDuaQDwBwQb1MKpsWh81ANojIrLTmrF9jxJrIYGAP6EYAMAwFlWbM9TaYVLHWOaqU/bSKvLAQBcIoINAABnqVwN7frkBNlYJQUA/AbBBjXGqmgAGquCknKtyT4iiWFoAOBvCDYAAJz20bZcVTiNesZHqEubFlaXAwCoAYINas1ms6moqEgTJ05Uhw4dFBYWpkGDBmnjxo1WlwYvcDqdmjp1qpKSkhQWFqbOnTtr+vTpMpVddkAj07FjR/13Sgftm3mdPp54pWw2m2w2m8aPH291aQCASxBodQHwP2f/XXvXXXdp27Zt+sc//qGEhAQtXrxYaWlp+u6779S2bVvrikSdzZw5U/PmzdOiRYvUq1cvbdq0SXfeeaciIyN13333WV0e4HXLMj9X+uzVkpHevXeQfvphr6699lrdcsstVpcGALgE9Nig1srLSvXvf/9bs2bN0pVXXqkuXbpo2rRp6tKli+bNm2d1eaijL7/8UqNGjdKIESPUsWNH3XzzzRo2bJg2bNhgdWmAT3x1qEL28JZK6dVJl/fopGXLlqlz58666qqrrC4NAHAJCDaoMXN6HxuX86ScTqdCQ0OrnA8LC9PatWutKA1eNGjQIGVmZmrXrl2SpG+++UZr165Venq6xZUBvvH+6U05r++XoPLyci1evFjjxo1jZTQA8BMMRUOthTZrrtTUVE2fPl09e/ZUbGys3njjDa1bt05dunSxujzU0ZQpU+RwONSjRw/Z7XY5nU499dRTGjt2rNWlAV73/dFiffNDoewBNv2qT7yWLl2qgoIC/eY3v7G6NADAJaLHBnXyj3/8Q8YYtW3bViEhIZozZ45uu+02BQRwa/m7t956S6+99ppef/11bdmyRYsWLdKzzz6rRYsWWV0a4HWVvTWDOseoVfMQvfLKK0pPT1dCAks+A4C/8Nlfn3PnzlXHjh0VGhqqlJQUxuU3ImfvY9O5c2etXr1ax48f14EDB7RhwwZVVFSoU6dO1haJOnvwwQc1ZcoUjRkzRn369NHtt9+u+++/XzNmzLC6NMCrjDF675szm3Lu27dPK1as0F133WVxZQCAmvBJsHnzzTc1adIkPfbYY9qyZYuSk5M1fPhw5efn++Lt0ACEh4crPj5ex44d0yeffKJRo0ZZXRLqqKSk5LyeN7vdLpfLZVFFgG/syC1Sdv5xBQcGaHjvOC1YsEBt2rTRiBEjrC4NAFADPplj89xzz+m3v/2t7rzzTknS/Pnz9cEHH+jVV1/VlClTfPGWsMCm74/p/r8skmQU276T8g9+r3/97zOKaZskdbtar67NkXSqZ+ds1U3DPXdy7qU859yLqn/dc1/H8/tU9zrVX+O5wEv6N1Z7zUUeV/OsS5nXfLH3ru41+g0ZqqnTnlCuM1yJnbtr745teuHPzypt1Bj3sJ1zedrhprb733h6mvHwjh6fd4Fzta3f47/MF/V7ert6fj9PT6x1nb54TQ/PW7fnR0nSNd1bq3mwXQsWLFBGRoYCA5mGCgD+xOu/tcvLy7V582Y9/PDD7mMBAQFKS0vTunXrzru+rKxMZWVl7scOh8PbJcHLQoJOfYu/cke+irdvV8GaRTpZdFT20BZq1n2Qoq68Q09/nG1xlagrV6dbVH6wTE/96QG5Sgplbx6tZj2v1aZW12rzG19bXR7gddcnt9WKFSu0f/9+jRs3zupyAAA15PVgc/ToUTmdTsXGxlY5Hhsbqx07dpx3/YwZM/T44497uwz40J2Dk1Rx0qj0pFPqd6t0263VflN67qHqvoU970i1r1P14LkvU/17e35O9fWdf825V5333tU945yLqr+m5q9TbXXnvc4l/Lsv8pzKa2y2aKln9T2s1fUcuc956EHyeK6Wr+mJp2V6Pb2k5zrr9/08PbP2dXp6Xv3+v63lKa+3dduoMP2yd5zsfeNr3bsIALCW5f3sDz/8sCZNmuR+7HA41L59ewsrwsV0bt1cM2/ua3UZAAAAgJvXg02rVq1kt9uVl5dX5XheXp7i4uLOuz4kJEQhISHeLgMAAABAE+L1VdGCg4N1xRVXKDMz033M5XIpMzNTqamp3n47AAAAAPDNULRJkyYpIyNDAwYM0MCBAzV79mwVFxe7V0kDAAAAAG/ySbC59dZbdeTIET366KPKzc1Vv3799PHHH5+3oAAAAAAAeIPNNLDlXxwOhyIjI1VYWKiIiAirywEAAABgkZpkA6/PsQEAAACA+kawAQAAAOD3CDYAAAAA/B7BBgAAAIDfI9gAAAAA8HsEGwAAAAB+j2ADAAAAwO8RbAAAAAD4PYINAAAAAL9HsAEAAADg9wg2AAAAAPwewQYAAACA3yPYAAAAAPB7BBsAAAAAfo9gAwAAAMDvEWwAAAAA+D2CDQAAAAC/R7ABAAAA4PcINgAAAAD8HsEGAAAAgN8j2AAAAADwewQbAAAAAH6PYAMAAADA7xFsAAAAAPi9QKsLOJcxRpLkcDgsrgQAAACAlSozQWVG8KTBBZuioiJJUvv27S2uBAAAAEBDUFRUpMjISI/X2MylxJ965HK5dOjQIbVo0UI2m83qcuRwONS+fXsdOHBAERERVpfTaNCuvkPb+gbt6hu0q2/Qrr5D2/oG7eobjaFdjTEqKipSQkKCAgI8z6JpcD02AQEBateundVlnCciIsJvb4iGjHb1HdrWN2hX36BdfYN29R3a1jdoV9/w93a9WE9NJRYPAAAAAOD3CDYAAAAA/B7B5iJCQkL02GOPKSQkxOpSGhXa1XdoW9+gXX2DdvUN2tV3aFvfoF19o6m1a4NbPAAAAAAAaooeGwAAAAB+j2ADAAAAwO8RbAAAAAD4PYINAAAAAL9HsAEAAADg9wg2FzF37lx17NhRoaGhSklJ0YYNG6wuya+sWbNGI0eOVEJCgmw2m5YuXVrlvDFGjz76qOLj4xUWFqa0tDRlZ2dbU6wfmTFjhn72s5+pRYsWatOmjUaPHq2dO3dWuaa0tFTjx49XTEyMmjdvrptuukl5eXkWVewf5s2bp759+7p3aE5NTdVHH33kPk+besczzzwjm82miRMnuo/RtrUzbdo02Wy2Kj89evRwn6dda+/gwYP6n//5H8XExCgsLEx9+vTRpk2b3Of5/Kq5jh07nne/2mw2jR8/XhL3a205nU5NnTpVSUlJCgsLU+fOnTV9+nSdvfBxU7lfCTYevPnmm5o0aZIee+wxbdmyRcnJyRo+fLjy8/OtLs1vFBcXKzk5WXPnzq32/KxZszRnzhzNnz9f69evV3h4uIYPH67S0tJ6rtS/rF69WuPHj9dXX32l5cuXq6KiQsOGDVNxcbH7mvvvv1/vv/++/vnPf2r16tU6dOiQbrzxRgurbvjatWunZ555Rps3b9amTZv0i1/8QqNGjdJ//vMfSbSpN2zcuFEvvvii+vbtW+U4bVt7vXr10uHDh90/a9eudZ+jXWvn2LFjGjx4sIKCgvTRRx/pu+++01/+8he1bNnSfQ2fXzW3cePGKvfq8uXLJUm33HKLJO7X2po5c6bmzZunF154Qdu3b9fMmTM1a9Ys/fWvf3Vf02TuV4MLGjhwoBk/frz7sdPpNAkJCWbGjBkWVuW/JJl33nnH/djlcpm4uDjz5z//2X2soKDAhISEmDfeeMOCCv1Xfn6+kWRWr15tjDnVjkFBQeaf//yn+5rt27cbSWbdunVWlemXWrZsaf72t7/Rpl5QVFRkunbtapYvX26uuuoqM2HCBGMM92tdPPbYYyY5Obnac7Rr7T300ENmyJAhFzzP55d3TJgwwXTu3Nm4XC7u1zoYMWKEGTduXJVjN954oxk7dqwxpmndr/TYXEB5ebk2b96stLQ097GAgAClpaVp3bp1FlbWeOTk5Cg3N7dKG0dGRiolJYU2rqHCwkJJUnR0tCRp8+bNqqioqNK2PXr0UGJiIm17iZxOp5YsWaLi4mKlpqbSpl4wfvx4jRgxokobStyvdZWdna2EhAR16tRJY8eO1f79+yXRrnXx3nvvacCAAbrlllvUpk0b9e/fXy+//LL7PJ9fdVdeXq7Fixdr3Lhxstls3K91MGjQIGVmZmrXrl2SpG+++UZr165Venq6pKZ1vwZaXUBDdfToUTmdTsXGxlY5Hhsbqx07dlhUVeOSm5srSdW2ceU5XJzL5dLEiRM1ePBg9e7dW9Kptg0ODlZUVFSVa2nbi/v222+Vmpqq0tJSNW/eXO+8844uu+wyZWVl0aZ1sGTJEm3ZskUbN2487xz3a+2lpKRo4cKF6t69uw4fPqzHH39c//Vf/6Vt27bRrnWwd+9ezZs3T5MmTdIf//hHbdy4Uffdd5+Cg4OVkZHB55cXLF26VAUFBfrNb34jid8DdTFlyhQ5HA716NFDdrtdTqdTTz31lMaOHSupaf29RbAB/Nz48eO1bdu2KuPqUXvdu3dXVlaWCgsL9a9//UsZGRlavXq11WX5tQMHDmjChAlavny5QkNDrS6nUan8RlaS+vbtq5SUFHXo0EFvvfWWwsLCLKzMv7lcLg0YMEBPP/20JKl///7atm2b5s+fr4yMDIuraxxeeeUVpaenKyEhwepS/N5bb72l1157Ta+//rp69eqlrKwsTZw4UQkJCU3ufmUo2gW0atVKdrv9vNU48vLyFBcXZ1FVjUtlO9LGtXfvvfdq2bJlWrVqldq1a+c+HhcXp/LychUUFFS5nra9uODgYHXp0kVXXHGFZsyYoeTkZD3//PO0aR1s3rxZ+fn5uvzyyxUYGKjAwECtXr1ac+bMUWBgoGJjY2lbL4mKilK3bt20e/du7tk6iI+P12WXXVblWM+ePd3D/Pj8qpt9+/ZpxYoVuuuuu9zHuF9r78EHH9SUKVM0ZswY9enTR7fffrvuv/9+zZgxQ1LTul8JNhcQHBysK664QpmZme5jLpdLmZmZSk1NtbCyxiMpKUlxcXFV2tjhcGj9+vW08UUYY3TvvffqnXfe0cqVK5WUlFTl/BVXXKGgoKAqbbtz507t37+ftq0hl8ulsrIy2rQOhg4dqm+//VZZWVnunwEDBmjs2LHu/6ZtveP48ePas2eP4uPjuWfrYPDgwectob9r1y516NBBEp9fdbVgwQK1adNGI0aMcB/jfq29kpISBQRU/ZPebrfL5XJJamL3q9WrFzRkS5YsMSEhIWbhwoXmu+++M3fffbeJiooyubm5VpfmN4qKiszXX39tvv76ayPJPPfcc+brr782+/btM8YY88wzz5ioqCjz7rvvmq1bt5pRo0aZpKQkc+LECYsrb9juueceExkZaT777DNz+PBh909JSYn7mt/97ncmMTHRrFy50mzatMmkpqaa1NRUC6tu+KZMmWJWr15tcnJyzNatW82UKVOMzWYzn376qTGGNvWms1dFM4a2ra0//OEP5rPPPjM5OTnmiy++MGlpaaZVq1YmPz/fGEO71taGDRtMYGCgeeqpp0x2drZ57bXXTLNmzczixYvd1/D5VTtOp9MkJiaahx566Lxz3K+1k5GRYdq2bWuWLVtmcnJyzNtvv21atWplJk+e7L6mqdyvBJuL+Otf/2oSExNNcHCwGThwoPnqq6+sLsmvrFq1ykg67ycjI8MYc2oJwqlTp5rY2FgTEhJihg4danbu3Glt0X6gujaVZBYsWOC+5sSJE+b3v/+9admypWnWrJm54YYbzOHDh60r2g+MGzfOdOjQwQQHB5vWrVuboUOHukONMbSpN50bbGjb2rn11ltNfHy8CQ4ONm3btjW33nqr2b17t/s87Vp777//vundu7cJCQkxPXr0MC+99FKV83x+1c4nn3xiJFXbVtyvteNwOMyECRNMYmKiCQ0NNZ06dTJ/+tOfTFlZmfuapnK/2ow5a1tSAAAAAPBDzLEBAAAA4PcINgAAAAD8HsEGAAAAgN8j2AAAAADwewQbAAAAAH6PYAMAAADA7xFsAAAAAPg9gg0AAAAAv0ewAQAAAOD3CDYAAAAA/B7BBgAAAIDf+//tXdVUCwXWewAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#\n",
+        "# Reduce Points\n",
+        "#\n",
+        "simple_line = rdp(new_line, epsilon=0.2)\n",
+        "print(len(new_line), len(simple_line))\n",
+        "plot(simple_line)\n",
+        "\n",
+        "# convert Array into Dict\n",
+        "dict_line = array2dict(simple_line)\n",
+        "pp.pprint(dict_line)"
+      ],
+      "metadata": {
+        "id": "GDmsfTmIn0xK",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "outputId": "69845adb-3e5c-4273-e874-129511cad2d8"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "54 37\n",
+            "{0: array([52.929, 22.734]),\n",
+            " 1: array([53.657, 22.006]),\n",
+            " 2: array([53.368, 21.716]),\n",
+            " 3: array([54.132, 20.953]),\n",
+            " 4: array([50.196, 15.514]),\n",
+            " 5: array([47.582, 10.801]),\n",
+            " 6: array([43.823,  0.   ]),\n",
+            " 7: array([8.031, 0.   ]),\n",
+            " 8: array([8.042, 8.086]),\n",
+            " 9: array([-0.027,  8.084]),\n",
+            " 10: array([-0.056, 16.984]),\n",
+            " 11: array([28.154, 17.01 ]),\n",
+            " 12: array([29.784, 17.625]),\n",
+            " 13: array([30.62 , 19.017]),\n",
+            " 14: array([30.467, 20.63 ]),\n",
+            " 15: array([26.409, 24.697]),\n",
+            " 16: array([38.384, 36.689]),\n",
+            " 17: array([41.27 , 33.891]),\n",
+            " 18: array([47.771, 40.375]),\n",
+            " 19: array([44.934, 43.249]),\n",
+            " 20: array([56.91 , 55.224]),\n",
+            " 21: array([61.017, 51.135]),\n",
+            " 22: array([62.656, 50.995]),\n",
+            " 23: array([64.029, 51.871]),\n",
+            " 24: array([64.602, 53.475]),\n",
+            " 25: array([64.614, 81.693]),\n",
+            " 26: array([73.501, 81.689]),\n",
+            " 27: array([73.481, 73.638]),\n",
+            " 28: array([81.581, 73.619]),\n",
+            " 29: array([81.591, 37.824]),\n",
+            " 30: array([75.108, 35.868]),\n",
+            " 31: array([70.189, 33.734]),\n",
+            " 32: array([65.511, 31.057]),\n",
+            " 33: array([60.704, 27.533]),\n",
+            " 34: array([59.94 , 28.296]),\n",
+            " 35: array([59.65 , 28.006]),\n",
+            " 36: array([58.922, 28.734])}\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "int_line = envelope(simple_line, 2.)\n",
+        "plt.figure(figsize=(10,10))\n",
+        "plot(simple_line, False)\n",
+        "#plot(int_line, False)\n",
+        "lengths = []\n",
+        "for i in range(len(simple_line)):\n",
+        "    a, b = simple_line[i], simple_line[(i+1)%len(simple_line)]\n",
+        "    dx, dy = b[0]-a[0], b[1]-a[1]\n",
+        "    normal = np.array([dy, -dx])\n",
+        "    normal /= np.linalg.norm(normal)\n",
+        "    length = np.linalg.norm(a - b)\n",
+        "    lengths.append(length)\n",
+        "    if length > 5:\n",
+        "        plt.annotate(\"%.2f\" % length, (a+b)/2 - 3.*normal - 1., color='red')\n",
+        "print(np.array(lengths))\n"
+      ],
+      "metadata": {
+        "id": "W6DMPdufi2Eu",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 902
+        },
+        "outputId": "e04abfeb-6167-4c42-9024-d43d6cd3f2eb"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[ 1.03   0.41   1.08   6.714  5.389 11.437 35.791  8.086  8.069  8.899\n",
+            " 28.21   1.741  1.624  1.62   5.745 16.948  4.02   9.181  4.038 16.936\n",
+            "  5.796  1.644  1.629  1.703 28.218  8.887  8.051  8.1   35.795  6.771\n",
+            "  5.362  5.389  5.961  1.08   0.41   1.03   8.48 ]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#centerx, centery, radius = get_circle(new_line[7], new_line[50], new_line[45])\n",
+        "centerx, centery, radius = get_circle(new_line[16], new_line[18], new_line[21])\n",
+        "print(centerx, centery, radius)"
+      ],
+      "metadata": {
+        "id": "wAzQl2sdLZMD",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "9c0f2f10-e71e-4b0d-84d1-541a0945f76d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "28.201591063209122 19.577485930188082 2.4983033721166876\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/dxf_viewer/divers/main.py b/dxf_viewer/divers/main.py
new file mode 100644
index 0000000..9aa1a0e
--- /dev/null
+++ b/dxf_viewer/divers/main.py
@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+import os
+import ezdxf
+import sys
+import numpy as np
+from rdp import rdp
+import pprint as pp
+from collections import defaultdict
+import matplotlib.pyplot as plt
+from matplotlib.widgets import Button
+import mplcursors
+
+np.set_printoptions(precision=3, suppress=True)
+
+def print_entity(e):
+    print("LINE on layer: %s\n" % e.dxf.layer)
+    print("start point: %s\n" % e.dxf.start)
+    print("end point: %s\n" % e.dxf.end)
+
+def print_entity2(e):
+    print(e.dxf.layer, e.dxf.start, e.dxf.end )
+
+def transform(vertices, new_center, axis1, axis2):
+    mat = np.linalg.inv(np.array([axis1, axis2])) @ np.array([[1, 0], [0, 1]])
+    transformed_vertices = (vertices - new_center) @ mat
+    return transformed_vertices
+
+def transform_single_axis(vertices, new_center, axis1, direct):
+    if direct:
+        axis2 = np.array([-axis1[1], axis1[0]])
+    else:
+        axis2 = np.array([axis1[1]], -axis1[0])
+    return transform(vertices, new_center, axis1, axis2)
+    
+point1 = None
+point2 = None
+def on_click(event):
+    global point1, point2
+
+    if event.button == 1:  # Clic gauche
+        if point1 is None:
+            point1 = (event.xdata, event.ydata)
+            print("Point 1 sélectionné :", point1)
+        elif point2 is None:
+            point2 = (event.xdata, event.ydata)
+            print("Point 2 sélectionné :", point2)
+            compute_distance()
+            # Réinitialiser les points sélectionnés pour permettre de mesurer une nouvelle distance
+            point1 = None
+            point2 = None
+
+
+def compute_distance():
+    global point1, point2
+
+    if point1 is not None and point2 is not None:
+        distance = ((point2[0] - point1[0]) ** 2 + (point2[1] - point1[1]) ** 2) ** 0.5
+        print("Distance entre les deux points :", distance)
+
+
+
+def plot(l, fig=True):
+    
+
+    if fig:
+        fig, ax = plt.subplots()
+
+    mplcursors.cursor(hover=True)
+    cid = fig.canvas.mpl_connect('button_press_event', on_click)
+    ax.plot(list(l[:, 0]) + [l[0, 0]], list(l[:, 1]) + [l[0, 1]])
+    for i, vertice in enumerate(l):
+        ax.annotate(str(i), vertice)
+    plt.axis('equal')
+
+def perp(a) :
+    b = np.empty_like(a)
+    b[0] = -a[1]
+    b[1] = a[0]
+    return b
+
+def seg_intersect(a1, a2, b1, b2) :
+    da = a2-a1
+    db = b2-b1
+    dp = a1-b1
+    dap = perp(da)
+    denom = np.dot( dap, db)
+    num = np.dot( dap, dp )
+    return (num / denom.astype(float))*db + b1
+
+def envelope(polygon, dist):
+    shifted_segments = []
+    for i in range(len(polygon)):
+        a, b = polygon[i], polygon[(i+1)%len(polygon)]
+        dx = b[0] - a[0]
+        dy = b[1] - a[1]
+        normal = np.array([dy, -dx])
+        normal /= np.linalg.norm(normal)
+        shifted_segments.append((a + dist*normal, b + dist*normal))
+    new_polygon = []
+    for i in range(len(shifted_segments)):
+        seg1 = shifted_segments[(i-1)%len(shifted_segments)]
+        seg2 = shifted_segments[i]
+        new_polygon.append(seg_intersect(seg1[0], seg1[1], seg2[0], seg2[1]))
+    return np.array(new_polygon)
+
+def get_circle(x, y, z):
+    x, y, z = x[0]+x[1]*1j, y[0]+y[1]*1j, z[0]+z[1]*1j
+    w = (z-x) / (y-x)
+    c = (x-y)*(w-abs(w)**2)/2j/w.imag-x
+    return -c.real, -c.imag, abs(c+x)
+
+def array2dict(lst):
+    res_dict = {}
+    for i in range(0, len(lst), 1):
+        res_dict[i] = lst[i]
+    return res_dict
+
+doc = ezdxf.readfile("../mgf.dxf")
+msp = doc.modelspace()
+
+object_type = set()
+
+group = msp.groupby(dxfattrib="layer")
+a = defaultdict(lambda: defaultdict(lambda: 0))
+
+for layer, entities in group.items():
+    for entity in entities:
+        object_type.add(entity.dxftype())
+        a[layer][entity.dxftype()] += 1
+a = {k: dict(a[k]) for k in a}
+# pp.pprint(a)
+
+# print(object_type)
+
+lines = []
+all_vertices = []
+layer='05-Bâti_contour'
+
+
+
+for polyline in msp.query(f'LWPOLYLINE[layer=="{layer}"]'):
+  line = []
+  for vertice in polyline:
+    line.append([vertice[0], vertice[1]])
+    all_vertices.append([vertice[0], vertice[1]])
+  
+  line = np.array(line)
+
+
+  lines.append(line)
+
+
+
+
+
+
+plot(lines[0])
+
+# # NORMALIZE POLYLINE + new center + new axis
+# line = lines[0]
+# #new_center = (line[22] + line[31])/2
+# new_center = (line[9] + line[7])/2
+# new_center = seg_intersect(line[7],line[9], line[13],line[11])
+
+# #axis1 = line[31] - line[22]
+# axis1 = line[7] - line[9]
+# axis1 /= np.linalg.norm(axis1)
+# new_line = transform_single_axis(line, new_center, axis1, True)
+# print(new_line)
+
+
+# plot(new_line)
+
+# #
+# # Reduce Points
+# #
+# simple_line = rdp(new_line, epsilon=0.2)
+# print(len(new_line), len(simple_line))
+
+
+# plot(simple_line)
+
+# # convert Array into Dict
+# dict_line = array2dict(simple_line)
+# pp.pprint(dict_line)
+
+# int_line = envelope(simple_line, 2.)
+
+
+# plot(simple_line, False)
+
+# #plot(int_line, False)
+# lengths = []
+# for i in range(len(simple_line)):
+#     a, b = simple_line[i], simple_line[(i+1)%len(simple_line)]
+#     dx, dy = b[0]-a[0], b[1]-a[1]
+#     normal = np.array([dy, -dx])
+#     normal /= np.linalg.norm(normal)
+#     length = np.linalg.norm(a - b)
+#     lengths.append(length)
+#     if length > 5:
+#         plt.annotate("%.2f" % length, (a+b)/2 - 3.*normal - 1., color='red')
+# print(np.array(lengths))
+
+# #centerx, centery, radius = get_circle(new_line[7], new_line[50], new_line[45])
+# centerx, centery, radius = get_circle(new_line[16], new_line[18], new_line[21])
+# print(centerx, centery, radius)
+
+plt.show()
+
diff --git a/dxf_viewer/divers/requirements.txt b/dxf_viewer/divers/requirements.txt
new file mode 100644
index 0000000..f28833d
--- /dev/null
+++ b/dxf_viewer/divers/requirements.txt
@@ -0,0 +1,3 @@
+ezdxf >= 1.0.3
+mixpeek >= 1.7
+rdp >= 0.8
\ No newline at end of file
diff --git a/dxf_viewer/divers/tools.py b/dxf_viewer/divers/tools.py
new file mode 100644
index 0000000..c316e25
--- /dev/null
+++ b/dxf_viewer/divers/tools.py
@@ -0,0 +1,144 @@
+import numpy as np
+import time
+from tkinter import *
+
+def transform(vertices, new_center, axis1, axis2):
+    mat = np.linalg.inv(np.array([axis1, axis2])) @ np.array([[1, 0], [0, 1]])
+    transformed_vertices = (vertices - new_center) @ mat
+    return transformed_vertices
+
+def transform_single_axis(vertices, new_center, axis1, direct):
+    if direct:
+        axis2 = np.array([-axis1[1], axis1[0]])
+    else:
+        axis2 = np.array([axis1[1]], -axis1[0])
+    return transform(vertices, new_center, -axis1, axis2)
+
+
+class ZoomPan:
+    def __init__(self):
+        self.press = None
+        self.cur_xlim = None
+        self.cur_ylim = None
+        self.x0 = None
+        self.y0 = None
+        self.x1 = None
+        self.y1 = None
+        self.xpress = None
+        self.ypress = None
+
+    def zoom_factory(self, ax, base_scale=1.25):
+        def zoom(event):
+            cur_xlim = ax.get_xlim()
+            cur_ylim = ax.get_ylim()
+            xdata = event.xdata
+            ydata = event.ydata
+            if event.button == 'up':
+                scale_factor = 1 / base_scale
+            elif event.button == 'down':
+                scale_factor = base_scale
+            else:
+                scale_factor = 1
+            try:
+                new_width = (cur_xlim[1] - cur_xlim[0]) * scale_factor
+                new_height = (cur_ylim[1] - cur_ylim[0]) * scale_factor
+                relx = (cur_xlim[1] - xdata) / (cur_xlim[1] - cur_xlim[0])
+                rely = (cur_ylim[1] - ydata) / (cur_ylim[1] - cur_ylim[0])
+                ax.set_xlim([xdata - new_width * (1 - relx), xdata + new_width * relx])
+                ax.set_ylim([ydata - new_height * (1 - rely), ydata + new_height * rely])
+                ax.figure.canvas.draw()
+            except :
+                pass
+
+        def pan(event):
+            if event.button == 2:
+                if self.press is None:
+                    self.press = event.x, event.y, ax.get_xlim(), ax.get_ylim()
+                else:
+                    dx = event.x - self.press[0]
+                    dy = event.y - self.press[1]
+                    ax.set_xlim([self.press[2][0] - dx, self.press[2][1] - dx])
+                    ax.set_ylim([self.press[3][0] - dy, self.press[3][1] - dy])
+                    ax.figure.canvas.draw()
+
+        def release(event):
+            if event.button == 2:
+                self.press = None
+                
+        fig = ax.get_figure()
+        fig.canvas.mpl_connect('scroll_event', zoom)
+        fig.canvas.mpl_connect('button_press_event', pan)
+        fig.canvas.mpl_connect('button_release_event', release)
+
+        return zoom, pan, release
+
+
+
+def cap_frequency(max_calls_per_second):
+    min_interval = 1.0 / max_calls_per_second
+    last_call_time = 0.0
+
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            nonlocal last_call_time
+            current_time = time.time()
+            elapsed_time = current_time - last_call_time
+            if elapsed_time >= min_interval:
+                result = func(*args, **kwargs)
+                last_call_time = current_time
+                return result
+        return wrapper
+
+    return decorator
+
+
+class ToolTip(object):
+
+    def __init__(self, widget):
+        self.widget = widget
+        self.tipwindow = None
+        self.id = None
+        self.x = self.y = 0
+
+    def showtip(self, text):
+        "Display text in tooltip window"
+        self.text = text
+        if self.tipwindow or not self.text:
+            return
+        x, y, cx, cy = self.widget.bbox("insert")
+        x = x + self.widget.winfo_rootx() + 30
+        y = y + cy + self.widget.winfo_rooty() + 30
+        self.tipwindow = tw = Toplevel(self.widget)
+        tw.wm_overrideredirect(1)
+        tw.wm_geometry("+%d+%d" % (x, y))
+        label = Label(tw, text=self.text, justify=LEFT,
+                      background="#ffffe0", relief=SOLID, borderwidth=1,
+                      font=("tahoma", "8", "normal"))
+        label.pack(ipadx=1)
+
+    def hidetip(self):
+        tw = self.tipwindow
+        self.tipwindow = None
+        if tw:
+            tw.destroy()
+
+def CreateToolTip(widget, text):
+    toolTip = ToolTip(widget)
+    def enter(event):
+        toolTip.showtip(text)
+    def leave(event):
+        toolTip.hidetip()
+    widget.bind('<Enter>', enter)
+    widget.bind('<Leave>', leave)
+
+def generate_json(name,points):
+    points = list(points[0])
+    json_response = {"points":[]}
+    for i in points:
+        json_response["points"].append(list(i))
+    return str(json_response)
+
+def get_file_name(file_path):
+    file_path_components = file_path.split('/')
+    file_name_and_extension = file_path_components[-1].rsplit('.', 1)
+    return file_name_and_extension[0]
\ No newline at end of file
diff --git a/dxf_viewer/graphic/area.png b/dxf_viewer/graphic/area.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd3540f7422b5aae0626959c0734e57222c3149a
GIT binary patch
literal 304
zcmV-00nh%4P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800009a7bBm000XU
z000XU0RWnu7ytkO;z>k7RCt{2mO%=GFc3v^r#VABr)SVJm~D(l(4EAcF6EaWD7N4t
zwZTA}fq{@2@*n;|Mj>;k0)S!xfWGgcwT6h?lGJj}9Yd(K4iI+*wW_K*07T^SW7b-1
z+lH>|FpgtLp4W8^LTB|?P4z7RMJQm536D?H6wbV3?W~>@pss7o^BmR7uRxHb0N#7-
z`ySOxTbM}!+P1~AEK$8rOOgUKO%n~kflLnIKd^wq$o#D#w158}xEjeUxEcjOiUm@J
zQ1Y#0*4p=#%sCe>?pjKzH4MW6kTX<Pbrb;Px8MPQE$B?)G66II0000<MNUMnLSTYw
Czk2cj

literal 0
HcmV?d00001

diff --git a/dxf_viewer/graphic/axis.png b/dxf_viewer/graphic/axis.png
new file mode 100644
index 0000000000000000000000000000000000000000..b777e0d599468c10710dd6cb498d22e92bd5faca
GIT binary patch
literal 444
zcmV;t0Ym<YP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800009a7bBm000XU
z000XU0RWnu7ytkPZb?KzRCt{2l|RdZP!z_mi3ojyaBb45FVouC*5cCQ2MAYjanhi<
z@EbT~Q{b43;O5{aVnff%y-<YFn^%j5d_cT^<ecAg&Xr5>Wsx2LeG58>5W=2LG0+2a
zP~QUb6Nk{YZEUw&Zh-ZA4aaf10mN|(S(YIP0-`8t46xtt+4^ueM4G1U0WOydEX#tf
z>ujE78FstfQ-IB8gFMgKc(GW(b=`lHzXYgjI-RnFrfEI^7>2>dv)PO%B)9-*HAbTm
zk|cQmIGs*V6a}8=eGY)CEKBwd!|(<`$5d5Sfmfsrz;d~SD2g|L!C-*-e2$_hJ_`_r
zAyidmNhtsYxrd>9*J`{KpscypG!2Kt;kJJ~9x<6rT2+IzaeX}p_lNL&K4Z07L6Ri4
zHXe@=1VMX%@`dX<K-+2%Ue`^;Qw_rFnnz8lLGCBM?{m3savRo7(Hu_!sOZN{e<hyl
mn8u{BA7bFkB0T_py#;@biL?K6om|fV0000<MNUMnLSTZU$iGPd

literal 0
HcmV?d00001

diff --git a/dxf_viewer/graphic/file.png b/dxf_viewer/graphic/file.png
new file mode 100644
index 0000000000000000000000000000000000000000..6e13b11c31acabc585383c60befc9cdc15db8ce8
GIT binary patch
literal 215
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz&H|6fVg?3oVGw3ym^DWNDA?)g
z;uumf=j|15t^*1@t`~R9u<!aW%ekvlL|yjlV#OI+wE}aFHuJm8Im|y{_wvSvoQfXj
zZt^!U9h6>BJyEF9RN+{~yrolqHbkvnGG$jhQ?|ot4yNn_SGQQjFxtF1$hF|^;UESp
z`^B}4v)-^C*v+&DLH}Wxww_^eB)@^S&+eD28<?An)chAF_?ZD6#o+1c=d#Wzp$P!Q
C97{p~

literal 0
HcmV?d00001

diff --git a/dxf_viewer/graphic/iso_xy.png b/dxf_viewer/graphic/iso_xy.png
new file mode 100644
index 0000000000000000000000000000000000000000..ab76479fe1e52118665bf513e71209b5c881e958
GIT binary patch
literal 217
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz&H|6fVg?3oVGw3ym^DWNDA?`k
z;uumf=j~NTt^*1@EC*`)*#G{Ye56Kc>GYtY4J$it3yC*<Njl~x;KgU=u-}Y{;cgf6
zhEDc|ObPx3VSa{h90%BL9AR#-W!k`K7UGco_T$tqR|FhfwoEz1cw%j(muL3cegA(I
zXox$gnaZ<0nX~@u9_GEg_v>~uyqHrX$uRk~e8bg)pZcT|oa7HOIx|ib2~Tp`0(2IG
Mr>mdKI;Vst02oqB)Bpeg

literal 0
HcmV?d00001

diff --git a/dxf_viewer/graphic/json.png b/dxf_viewer/graphic/json.png
new file mode 100644
index 0000000000000000000000000000000000000000..a01df0882c6e8bb6c8342bebf07fb39012d3d71c
GIT binary patch
literal 619
zcmV-x0+juUP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800009a7bBm000XU
z000XU0RWnu7ytkQ9Z5t%RCt{2m(NQTQ545NJ{PtSa#Pu&zz{`R7;0d-3Cu-^q{b{l
z`bn*nHsV(54+z3lL}f;$4Y*QVrVzLkOu-~v3AIYGf{F^`!gt^@+&44tP70D=IJ~*<
zo^$5Qx#!0n*hexNfL<VQ$VrF(d7z4afC4ZEY$wQ9=|yPQ|4YE(yacYv*#<BPgbo>s
z*#s83+$2Wj=vE0fHi6tELOBUM2+Zo`xk!XL2pHQ#z&ov1fTO!X;DT%xWY-UT_l-p8
zLEs?pF`;T6?KA;{8sI^!TIQ{z*>M7Cxse&+e@)=JI-sldo{`Qy;7>}cj?0ERY%0Db
z^!`@q-1Q(3`AEgKBtiwyqGwafJwUUyUkP*o$1VM{dOjv``OQq=BJfjV_LH@LMICQV
z>mNWD(5>j416~3z@)8KNZqo0dhE$buVI8Ojo&n32z9BYaC0}j=1>hC%OY0lJQ@zCC
zCh*15|Ex%O6F3d5YBZbVsRf<`mo;D>i-ZaN9Sxspi$Gtj{7NQJ3A_QefC1nL@D}*3
z@SXz7fe~O6m{TH}1bi=FuYvo%1cDOek_bj<bm(Lz@WG?LjZDe@fU3r&V~#WxCxAs6
z%on*2#$^KNw0sOZrs1Nd<=z-ZqaK&iVz@0|rerhYs*E<RYxy|Pru~78M>8oOQRmEz
zf)xc@9%?`7>gAFrKp7sWw?55!bni2$%UGVh^05z!;V&-*Az#)=BRl{A002ovPDHLk
FV1nPc4y6D9

literal 0
HcmV?d00001

diff --git a/dxf_viewer/graphic/regle.png b/dxf_viewer/graphic/regle.png
new file mode 100644
index 0000000000000000000000000000000000000000..c9e196da8d0e9a9ee967135fe0f0d5d689136881
GIT binary patch
literal 166
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz&H|6fVg?3oVGw3ym^DWNC>Y`C
z;uumf=j~K$E(b*(mgoPb-@DGnUHKqgv|ORJ^XLTKrZWPJs!YZ%3=?)*I4`*LEp2~x
zKSzNxi|*pjzuGxIB*$vMaNE$#Q4qtjqhD~{BuS+OE(vYVS?yk}lAUFg|IrX=2ZN`p
KpUXO@geCxEIyBJ$

literal 0
HcmV?d00001

diff --git a/dxf_viewer/gui_mpl.py b/dxf_viewer/gui_mpl.py
new file mode 100644
index 0000000..bbe5983
--- /dev/null
+++ b/dxf_viewer/gui_mpl.py
@@ -0,0 +1,698 @@
+import tkinter as tk
+from tkinter import filedialog
+import os
+import ezdxf
+import sys
+import numpy as np
+from rdp import rdp
+import pprint as pp
+from collections import defaultdict
+import matplotlib.pyplot as plt
+import sys
+import re
+import matplotlib
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg,NavigationToolbar2Tk
+from matplotlib.patches import Polygon
+from matplotlib.lines import Line2D
+from matplotlib.patches import Rectangle
+from matplotlib.widgets import Cursor
+sys.path.append("./divers")
+from tools import *
+import mplcursors
+from pprint import pprint
+matplotlib.use('TkAgg')
+from tkinter.filedialog import asksaveasfile
+
+class App(tk.Tk):
+    def __init__(self):
+        
+        super().__init__() # create CTk window like you do with the Tk window
+        
+        self.initial_width = 1600
+        self.initial_height = 900
+        self.geometry(f"{self.initial_width}x{self.initial_height}")
+        self.configure(bg="#d9d9d9")
+        self.resizable(False,False)
+        self.x_ratio = self.initial_width/1280
+        self.y_ratio = self.initial_height/720
+        self.cur_file = ''
+        self.protocol("WM_DELETE_WINDOW", lambda:self.on_closing_window())
+
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+        self.grid_rowconfigure(1, weight=70)
+        self.grid_columnconfigure(1, weight=70)
+
+        #Lieux de dessin   
+        
+        self.cadre = tk.Frame(self,bg="white")
+        self.canvas_width = self.initial_width * 0.7
+        self.canvas_height = self.initial_height * 0.9
+        self.cadre.place(relx=0.025, rely=0.05, width=self.canvas_width, height=self.canvas_height) 
+        
+        self.fig, self.ax = plt.subplots(figsize=(26*self.x_ratio,6*self.y_ratio), dpi=100)
+        self.horizontal_line = self.ax.axhline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.vertical_line = self.ax.axvline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.fig.canvas.mpl_connect('motion_notify_event', self.cursor_hover)
+        self.fig.canvas.mpl_connect('axes_leave_event', self.cursor_leave)
+        self.fig.canvas.mpl_connect('motion_notify_event', self.closest_pt)
+
+
+        self.canvas = FigureCanvasTkAgg(self.fig, master=self.cadre)
+        self.canvas.get_tk_widget().pack()
+        self.toolbar = NavigationToolbar2Tk(self.canvas, self.cadre)
+        self.toolbar.update()
+        zoom_pan = ZoomPan()
+        zoom_func, pan_func, release_func = zoom_pan.zoom_factory(self.ax)
+        self.canvas.get_tk_widget().pack(fill=tk.BOTH)
+        self.lines_to_draw = []
+
+
+        #Menu
+        self.buton_size = 33
+        #bouton fichier
+        self.file_border = tk.Frame(self, bg="#d9d9d9")
+        self.file_border.place(relx=0.85, rely=0.05, width=self.buton_size+4, height=self.buton_size+4) 
+        self.fichier_icone = tk.PhotoImage(file="graphic/file.png") 
+        self.file_bouton = tk.Button(self.file_border, image=self.fichier_icone,command=self.file_func,bg="white")
+        self.file_bouton.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
+        CreateToolTip(self.file_bouton, text = 'Open a file')
+
+        #bouton axes
+        self.axis_border = tk.Frame(self, bg="#d9d9d9")
+        self.axis_border.place(relx=0.88, rely=0.05, width=self.buton_size+4, height=self.buton_size+4) 
+        self.axis_icone = tk.PhotoImage(file="graphic/axis.png")
+        self.axis_bouton = tk.Button(self.axis_border, image=self.axis_icone,command=self.redefine_axis,bg="white")
+        self.axis_bouton.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
+        self.rect = False
+        CreateToolTip(self.axis_bouton, text = 'Redefine axes')
+
+        #bouton mesure
+        self.mesure_border = tk.Frame(self, bg="#d9d9d9")
+        self.mesure_border.place(relx=0.91, rely=0.05, width=self.buton_size+4, height=self.buton_size+4)  
+        self.mesure_icone = tk.PhotoImage(file="graphic/regle.png")
+        self.mesure_bouton = tk.Button(self.mesure_border, image=self.mesure_icone,command=self.mesurer,bg="white")
+        self.mesure_bouton.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
+        self.mesure = False
+        CreateToolTip(self.mesure_bouton, text = "Measure distance between\n" + \
+                                                 "two points")
+
+        #bouton iso_xy
+        self.xy_border = tk.Frame(self, bg="#d9d9d9")
+        self.xy_border.place(relx=0.94, rely=0.05, width=self.buton_size+4, height=self.buton_size+4)  
+        self.iso_xy_icone = tk.PhotoImage(file="graphic/iso_xy.png")
+        self.iso_xy = tk.Button(self.xy_border, image=self.iso_xy_icone,command=self.equalize_xy,bg="white")
+        self.iso_xy.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
+        self.are_equals = True
+        CreateToolTip(self.iso_xy, text = "Normalize X/Y axis\n" + \
+                                          "Keep real ratio X/Y")
+
+
+        #bouton select_point
+        self.button_border = tk.Frame(self, bg="#d9d9d9")
+        self.button_border.place(relx=0.85, rely=0.10, width=self.buton_size+4, height=self.buton_size+4)   
+        self.aera_icone = tk.PhotoImage(file="graphic/area.png")
+        self.area_button = tk.Button(self.button_border, image=self.aera_icone,command=self.on_choose_press,bg="white")
+        self.area_button.place(x=2,y=2,width=self.buton_size, height=self.buton_size)
+        self.choose = False
+        self.area = None
+        self.selection = []
+        self.selected = []
+        CreateToolTip(self.area_button, text = "Select points within an area\n" + \
+                                               "too export too Json file")
+
+        #bouton json export
+        self.json_border = tk.Frame(self, bg="#d9d9d9")
+        self.json_border.place(relx=0.88, rely=0.10, width=self.buton_size+4, height=self.buton_size+4)  
+        self.json_icone = tk.PhotoImage(file="graphic/json.png")
+        self.json = tk.Button(self.json_border, image=self.json_icone,command=self.export_to_json,bg="white")
+        self.json.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
+        self.are_equals = True
+        CreateToolTip(self.json, text = "Export selected points\n" + \
+                                        "to Json")
+        
+
+        #Choix des couches 
+        self.liste_couches = tk.Listbox(self, selectmode=tk.SINGLE)
+        self.liste_couches.place(relx=0.750,rely=0.15, width = 250*self.x_ratio, height = 200*self.y_ratio)
+
+        #Choix des objets a dessiner 
+        self.liste_objets = tk.Listbox(self, selectmode=tk.MULTIPLE,activestyle="none")
+        self.liste_objets.place(relx=0.750,rely=0.45, width = 250*self.x_ratio, height = 200*self.y_ratio)
+    
+        self.bind('<Button-1>', self.on_click)
+
+        self.highlight = None
+        self.close = None
+        
+        #Lance l'app
+        self.mainloop()
+
+
+    def export_to_json(self):
+        if not self.selection:
+            self.warning("First select some points to export")
+
+        else:
+            extensions = [('Json file', '*.json')]
+            default_name = get_file_name(self.cur_file) #vire le path et l'extension
+            file = asksaveasfile(filetypes = extensions, defaultextension = extensions,initialfile = f"{default_name}")
+            if file:
+                file.write(generate_json("lol",self.selection))
+                file.close()
+
+
+    def on_choose_press(self):
+        # Lorsque on clique sur le bouton pour choisir des points
+        # On vérifie qu'il n'y en a pas de séléction déja en cours et sinon on lance la sélection
+        for i in self.selected:
+            i.remove()
+        self.canvas.draw()
+        self.selected = []
+        self.selection = []
+        if not self.choose:
+            self.button_border["bg"] = 'black'
+            self.choose_curs = self.ax.figure.canvas.mpl_connect('button_press_event', self.choose_area) # evenemnt sélection
+            self.choose = True
+        else:
+            self.button_border["bg"] = '#d9d9d9'
+            self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
+            self.choose = False
+    
+    
+    def choose_area(self,event):
+        # debut de la sélection, evennement desisn de rctangele
+        start_x = event.xdata
+        start_y = event.ydata
+        if start_x and start_y:           
+            self.drop = self.fig.canvas.mpl_connect('button_release_event', lambda event : self.choosed_area(event,start_x,start_y))
+            self.drag = self.fig.canvas.mpl_connect('motion_notify_event', lambda event : self.in_select(event,start_x,start_y))
+
+
+    @cap_frequency(24)
+    def in_select(self,event,x_start,y_start):
+        x = event.xdata
+        y = event.ydata
+        
+        if self.area:
+            self.area.remove()
+            self.canvas.draw_idle()
+            self.area = None
+        
+        if x and y :
+            # dessin du rectangle
+            self.area = Rectangle((x_start,y_start),-x_start+x,-y_start+y,fill=False,linestyle='--',lw=1.5)
+            self.ax.add_patch(self.area)
+            self.canvas.draw_idle()
+
+                
+    def choosed_area(self,event,x_start,y_start):
+        x = event.xdata
+        y = event.ydata
+        # Fin du dessin
+        if self.area:
+            self.area.remove()
+        self.canvas.draw_idle()
+        self.area = None
+        self.choose = False
+        self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
+        self.choose = False
+        self.ax.figure.canvas.mpl_disconnect(self.drag)
+        self.ax.figure.canvas.mpl_disconnect(self.drop)
+        self.selected = []
+        self.button_border["bg"] = '#d9d9d9'
+        if x and y :
+            for i in self.lines_to_draw:
+                    self.selection.append(i[(i[:,0]>min(x_start,x))*(i[:,0]<max(x_start,x))*\
+                                  (i[:,1]>min(y_start,y))*(i[:,1]<max(y_start,y)),:])
+            for i in self.selection:
+                self.selected.append(self.ax.scatter(i[:,0],i[:,1],c="blue",s=80))
+            self.canvas.draw_idle()
+
+        
+    def equalize_xy(self):
+        if self.are_equals:
+            self.ax.set_aspect('auto')
+            self.are_equals=False
+        else:
+            self.ax.set_aspect('equal')
+            self.are_equals=True
+
+        self.horizontal_line = self.ax.axhline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.vertical_line = self.ax.axvline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.fig.canvas.mpl_connect('motion_notify_event', self.cursor_hover)
+        self.fig.canvas.mpl_connect('axes_leave_event', self.cursor_leave)
+        self.canvas.draw_idle()
+
+
+    @cap_frequency(24)
+    def cursor_hover(self,event):
+        if event.inaxes == self.ax:
+            # Récupérer les coordonnées du curseur
+            x = event.xdata
+            y = event.ydata
+
+            # Mettre à jour les positions des lignes
+            self.horizontal_line.set_ydata(y)
+            self.vertical_line.set_xdata(x)
+
+            # Afficher les lignes
+            self.horizontal_line.set_visible(True)
+            self.vertical_line.set_visible(True)
+
+            # Actualiser le graphique
+            self.canvas.draw_idle()
+        
+
+    def on_closing_window(self):
+        self.destroy()
+        sys.exit()
+
+
+    def cursor_leave(self,event):
+        # Cacher les lignes lorsque le curseur quitte le graphique
+        self.horizontal_line.set_visible(False)
+        self.vertical_line.set_visible(False)
+
+        # Actualiser le graphique
+        self.fig.canvas.draw()
+
+
+    def on_click(self,event):
+        widget_under_cursor = event.widget.winfo_containing(event.x_root, event.y_root)
+        if widget_under_cursor == self.liste_couches:
+            self.afficher_selection()
+        elif widget_under_cursor == self.liste_objets:
+            self.dessiner_selection()
+
+        
+    def file_func(self):
+        # option pour la selection du fichier dxf
+        options = {'defaultextension': '.dxf',
+        'filetypes': [('Fichiers dxf', '.dxf')],
+        'initialdir': os.getcwd()}
+
+        fichier = filedialog.askopenfilename(**options)
+
+        self.cur_file = fichier
+        if self.cur_file != '':
+            #ouvre le fichier avec ezdxf
+            self.doc = ezdxf.readfile(f"{self.cur_file}")
+            self.msp = self.doc.modelspace()
+            group = self.msp.groupby(dxfattrib="layer")
+
+            #Charge les layers dans le dico et leurs objets associés
+            a = defaultdict(lambda: defaultdict(lambda: 0))
+            for layer, entities in group.items():
+                for entity in entities:
+                    a[layer][entity.dxftype()] += 1
+            self.layers = {k: dict(a[k]) for k in a}
+            self.liste_couches.delete(0, tk.END)
+            # On ajoute les layers dans la fenetre adaptée 
+            for layer in self.layers:
+                self.liste_couches.insert(tk.END, f"{layer}")
+
+            # On trie les layers par ordre alphabetique
+            elements = list(self.liste_couches.get(0, tk.END))
+            elements.sort()
+            self.liste_couches.delete(0, tk.END)
+            for element in elements:
+                self.liste_couches.insert(tk.END, element)
+
+
+    def afficher_selection(self):
+        
+        # Récupérer et afficher les différents objets de la couche séléctionée
+        #On recupére la layer séléctionée
+        
+        indices_selectionnes = self.liste_couches.curselection()
+        self.current_layer = self.liste_couches.get(indices_selectionnes)
+        
+        self.liste_objets.delete(0, tk.END)
+        
+        #On affiche les différents objets de la layer
+        for i in self.layers[self.current_layer] :
+            self.liste_objets.insert(tk.END,f"--- {i} ---")
+            for k in range (0,self.layers[self.current_layer][i]):
+                self.liste_objets.insert(tk.END,f"{i} {k}")
+
+        #On bloque les titres (types d'objet ex: ---LWPOLYLINE---, ---LINE---, etc...)
+        for index in range(self.liste_objets.size()):
+            item = self.liste_objets.get(index)
+            if item.startswith("---"):
+                self.liste_objets.itemconfigure(index, selectbackground=self.liste_objets.cget("background"), \
+                    selectforeground=self.liste_objets.cget("foreground"))
+
+            
+    def dessiner_selection(self):
+
+        # On doit récupérer les différents objets a dessiner sous forme de liste de points à dessiner
+
+        indices_objet_selectionnes = self.liste_objets.curselection()
+        objects_to_draw = []
+        for i in indices_objet_selectionnes:
+            objects_to_draw.append(self.liste_objets.get(i))
+            
+
+        self.lines_to_draw = []
+
+        for i in objects_to_draw:
+            type_dessin = re.match(r'^(?!-{3})\S+', i)
+            if type_dessin:
+                type_dessin = type_dessin.group()
+                number = int(re.search(r'(\S+)\s*$', i).group())
+
+                if type_dessin == 'LWPOLYLINE': #Gestion des polylines
+                    polyline = self.msp.query(f'LWPOLYLINE[layer=="{self.current_layer}"]').entities[number]
+                    line = []
+                    for vertice in polyline:
+                        line.append([vertice[0], vertice[1]])
+                    line.append(line[0])
+                    line = np.array(line)
+                    self.lines_to_draw.append(line)
+
+                if type_dessin == 'LINE': #Gestion des lines
+                    line = self.msp.query(f'LINE[layer=="{self.current_layer}"]').entities[number]
+                    x_start = line.dxf.start[0]
+                    y_start = line.dxf.start[1]
+                    x_end = line.dxf.end[0]
+                    y_end = line.dxf.end[1]
+                    self.lines_to_draw.append(np.array([[x_start,y_start],[x_end,y_end]]))
+
+                if type_dessin == 'CIRCLE': #Gestion des lines
+                    circle = self.msp.query(f'CIRCLE[layer=="{self.current_layer}"]').entities[number]
+                    
+                    center = circle.dxf.center
+                    radius = circle.dxf.radius
+                    
+                    points = np.linspace(0,2*np.pi,25)
+                    points = np.array([center[0]+radius*np.cos(points) ,\
+                                       center[1]+radius*np.sin(points)]).T
+                    points_to_draw = []
+                    self.lines_to_draw.append(points)
+                
+                if type_dessin == 'INSERT':
+                    insert = self.msp.query(f'INSERT[layer=="{self.current_layer}"]').entities[number]
+                    block_name = insert.dxf.name
+                    
+                    x = insert.dxf.insert.x
+                    y = insert.dxf.insert.y
+                    x_scale = insert.dxf.xscale
+                    y_scale = insert.dxf.yscale
+                    rotation = insert.dxf.rotation
+
+                    # Récupérer le bloc de définition correspondant
+                    block = self.doc.blocks.get(block_name)
+
+                    if block is not None:
+                        # Parcourir les entités du bloc de définition
+                        for entity in block:
+                            # Vérifier le type d'entité)
+                            if entity.dxftype() == 'LWPOLYLINE':
+                                # Récupérer les points de la POLYLINE
+                                points = entity.get_points()
+                                
+                                # Appliquer les transformations d'insertion
+                                transformed_points = []
+                                for point in points:
+                                    tx = point[0] * x_scale
+                                    ty = point[1] * y_scale
+                                    transformed_point = (tx, ty)
+                                    transformed_points.append(transformed_point)
+                                poly = Polygon(transformed_points, closed=True, fill=None, edgecolor='black')
+                                points = poly.xy
+                                rotation = np.deg2rad(rotation)
+                                points = points@np.array([[np.cos(rotation) , -np.sin(rotation)],\
+                                                          [np.sin(rotation) ,  np.cos(rotation)]])
+                                points[:,0] += x
+                                points[:,1] += y
+                                self.lines_to_draw.append(points)
+
+                if type_dessin == 'HATCH':
+                    hatch = self.msp.query(f'HATCH[layer=="{self.current_layer}"]').entities[number]
+                    # Récupérer les boucles du HATCH
+                    loops = hatch.paths
+                    for loop in loops:
+                        # Récupérer les segments de chaque boucle
+                        segments = loop.edges
+
+                        for i in loop.edges:
+                            if isinstance(i,ezdxf.entities.boundary_paths.LineEdge):
+                                start = i.start
+                                end = i.end
+                                self.lines_to_draw.append(np.array([[start[0],start[1]],[end[0],end[1]]]))
+                            else:
+                                center = (i.center[0],i.center[1])
+                                radius = i.radius
+                                start_angle = np.deg2rad(i.start_angle)
+                                end_angle = np.deg2rad(i.end_angle)
+                                points = np.linspace(start_angle,end_angle,25)
+                                points = np.array([center[0]+radius*np.cos(points) ,\
+                                                   center[1]+radius*np.sin(points)]).T
+                                self.lines_to_draw.append(points)
+
+                if type_dessin == 'ARC':
+                    circle = self.msp.query(f'ARC[layer=="{self.current_layer}"]').entities[number]
+                    
+                    center = circle.dxf.center
+                    radius = circle.dxf.radius
+                    start_angle = np.deg2rad(circle.dxf.start_angle)
+                    end_angle = np.deg2rad(circle.dxf.end_angle)
+                    points = np.linspace(start_angle,end_angle,25)
+                    points = np.array([center[0]+radius*np.cos(points) ,\
+                                       center[1]+radius*np.sin(points)]).T
+                    points_to_draw = []
+                    self.lines_to_draw.append(points)
+        
+        if self.lines_to_draw != []:
+            new_lines_to_draw = []
+            for ligne in self.lines_to_draw:
+                self.x_min = 1e99
+                self.y_min = 1e99
+                if np.min(ligne[:,0]) < self.x_min : self.x_min = np.min(ligne[:,0])
+                if np.min(ligne[:,1]) < self.y_min : self.y_min = np.min(ligne[:,1])
+            for ligne in self.lines_to_draw:
+                line = rdp(ligne, epsilon=0.2)-[self.x_min,self.y_min]
+                new_lines_to_draw.append(line)
+            self.lines_to_draw = new_lines_to_draw
+            self.plot_on_canvas(self.lines_to_draw)
+
+
+    def redefine_axis(self):
+        if  self.lines_to_draw == []:
+            self.warning("Tracez d'abord quelque chose")
+
+        else:    
+            self.point1 = []
+            self.point2 = []
+            self.point3 = []
+            # Créer un canvas supplémentaire pour le rectangle
+            if not self.rect :
+                self.axis_border["bg"] = 'black'
+                self.mesure_bouton.configure(state='disabled')
+                self.rect=True
+                self.label = tk.Label(self.cadre, text=f"Séléctionez 2 points dans ce cadre pour servir de nouvel axe x \n puis un pour le centre",\
+                                      background = "white",font = ("Arial", 14))
+                self.label.place(relx=0.22,rely=0.00)
+                self.cursor = self.canvas.mpl_connect('button_press_event', self.on_click_curseur)
+
+                
+            else:
+                self.canvas.mpl_disconnect(self.cursor)
+                self.rect=False
+                self.label.destroy()
+                self.axis_border["bg"] = '#d9d9d9'
+                self.mesure_bouton.configure(state='normal')
+
+                
+    def on_click_curseur(self,event):
+        if self.point1 == []:
+            if self.close: self.point1 = self.close
+            else: self.point1 = [event.xdata, event.ydata]
+        elif self.point2 == []:
+            if self.close: self.point2 = self.close
+            else:self.point2 = [event.xdata, event.ydata]
+        elif self.point3 == []:
+            if self.close: self.point3 = self.close
+            else:self.point3 = [event.xdata, event.ydata]
+            self.canvas.mpl_disconnect(self.cursor)
+            self.rect=False
+            self.label.destroy()
+
+            if None in self.point1 or None in self.point2 or None in self.point3 :
+                self.warning("L'un des points n'est pas dans le plan !")
+                self.point1 = []
+                self.point2 = []
+                self.point3 = []
+
+            else:
+                self.point1 = np.array(self.point1)
+                self.point2 = np.array(self.point2)
+                self.point3 = np.array(self.point3)
+                axis1 = -self.point1 + self.point2
+                axis1 /= np.linalg.norm(axis1)
+                new_lines_to_draw = []
+                for i in self.lines_to_draw:
+                    new_lines_to_draw.append(transform_single_axis(i,self.point3,axis1,True))
+                self.lines_to_draw = new_lines_to_draw
+                self.point1 = []
+                self.point2 = []
+                self.point3 = []
+                self.plot_on_canvas(self.lines_to_draw)
+            self.axis_border["bg"] = '#d9d9d9'
+            self.mesure_bouton.configure(state='normal')
+
+
+    def mesurer(self):
+        self.point1 = []
+        self.point2 = []
+
+        if not self.mesure:
+            self.mesure_border["bg"] = 'black'
+            self.label = tk.Label(self.cadre, text=f"Séléctionez 2 points entre lesquels mesurer",background = "white",font = ("Arial", 14))
+            self.label.place(relx=0.22,rely=0.0)
+            self.mesure = True
+            self.cursor = self.canvas.mpl_connect('button_press_event', self.on_click_mesure)
+            self.axis_bouton.configure(state='disabled')
+            
+        else:
+            self.mesure_border["bg"] = '#d9d9d9'
+            self.canvas.mpl_disconnect(self.cursor)
+            self.mesure=False
+            self.label.destroy()
+            self.canvas.draw_idle()
+            self.axis_bouton.configure(state='normal')
+
+
+    def on_click_mesure(self,event):
+
+        if self.point1 == []:
+            if self.close: self.point1 = self.close
+            else: self.point1 = [event.xdata, event.ydata]
+
+        elif self.point2 == []:
+            if self.close: self.point2 = self.close
+            else:self.point2 = [event.xdata, event.ydata]
+            self.canvas.mpl_disconnect(self.cursor)
+            self.mesure=False
+            self.label.destroy()
+            if None in self.point1 or None in self.point2:
+                self.warning("L'un des points n'est pas dans le plan !")
+                self.point1 = []
+                self.point2 = []
+                self.axis_bouton.configure(state='normal')
+
+    
+            else:
+                self.point1 = np.array(self.point1)
+                self.point2 = np.array(self.point2)
+                distance = np.linalg.norm(self.point1-self.point2)
+                x1 = self.point1[0]
+                x2 = self.point2[0]
+                y1 = self.point1[1]
+                y2 = self.point2[1]
+            
+                self.ax.plot([x1,x2],[y1,y2],c='b')
+                x_text = (self.point1[0] + self.point2[0]) / 2
+                y_text = (self.point1[1] + self.point2[1]) / 2
+                self.ax.text(x_text, y_text, f'Distance: {distance:.2f}')
+                self.canvas.draw()
+            self.mesure_border["bg"] = '#d9d9d9'
+            self.axis_bouton.configure(state='normal')
+
+
+    def plot_on_canvas(self,lignes):
+        self.ax.clear()
+        nb_point = 1
+        for ligne in lignes:
+            self.ax.plot(ligne[:,0], ligne[:,1], c="black")
+            self.ax.scatter(ligne[:,0],ligne[:,1], color="b", s=9)
+            for i,vertice in enumerate(ligne):
+                if i > 0 and list(vertice) == list(ligne[0,:]):
+                    continue
+                self.ax.annotate(str(i+nb_point), vertice)
+            nb_point += len(ligne[:,0])
+        self.ax.set_aspect('equal')
+        self.horizontal_line = self.ax.axhline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.vertical_line = self.ax.axvline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.fig.canvas.mpl_connect('motion_notify_event', self.cursor_hover)
+        self.fig.canvas.mpl_connect('axes_leave_event', self.cursor_leave)
+        self.fig.canvas.mpl_connect('axes_notify_event', self.closest_pt)
+        self.canvas.draw()
+
+
+    def warning(self,message):
+        # Créer une fenêtre pop-up
+        window = tk.Toplevel()
+        window.title("Avertissement")
+
+        screen_width = self.winfo_screenwidth()
+        screen_height = self.winfo_screenheight()
+
+        # Calculer les coordonnées pour centrer la fenêtre pop-up
+        window_width = 300  # Largeur de la fenêtre pop-up
+        window_height = 150  # Hauteur de la fenêtre pop-up
+        x = (screen_width // 2) - (window_width // 2)
+        y = (screen_height // 2) - (window_height // 2)
+
+        # Définir les coordonnées de la fenêtre pop-up
+        window.geometry(f"{window_width}x{window_height}+{x}+{y}")
+
+        # Créer un label pour afficher le message d'avertissement
+        label = tk.Label(window, text=message)
+        label.pack(padx=10, pady=10)
+
+        # Fonction pour fermer la fenêtre
+        def close_window():
+            window.destroy()
+
+        # Créer un bouton "OK" pour fermer la fenêtre
+        button_ok = tk.Button(window, text="OK", command=close_window)
+        button_ok.pack(pady=10)
+
+        # Définir la fenêtre comme une fenêtre modale
+        window.transient(window.master)
+        window.grab_set()
+        window.focus_set()
+        window.wait_window()
+
+
+    @cap_frequency(20)
+    def closest_pt(self,event):
+        if self.lines_to_draw != []:
+            compte_pt=0
+            pt = -1
+            d_min = 99999
+            x = event.xdata
+            y = event.ydata
+
+            if x and y:
+                for line in self.lines_to_draw:
+                    distance = np.sqrt((line[:,0]-x)**2+(line[:,1]-y)**2)                
+                    d = np.min(distance)
+                    compte_pt = np.shape(d)
+                    if d<d_min:
+                        d_min = d 
+                        point_actuel = line[np.argmin(distance),:]
+                        pt = np.argmin(distance)
+                    compte_pt += np.shape(d)
+            
+            delta = 0.01 * (self.ax.get_xlim()[1]-self.ax.get_xlim()[0])  
+
+            if d_min < delta:
+                self.close = list(point_actuel)
+                if not self.highlight:
+                    self.highlight = self.ax.scatter(point_actuel[0],point_actuel[1],c="blue",s=80)
+                    
+            elif d_min > delta :
+                if self.highlight:
+                    self.highlight.remove()
+                    self.highlight = None
+                    self.close = None
+            self.canvas.draw_idle()
+
+
+
+
+if __name__ == "__main__":
+    app = App()
\ No newline at end of file

From 98ccdb400c88e5b5f906c69cd2e4a7145a43ab7a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9mie=20Lambert?= <jerelam51@gmail.com>
Date: Mon, 25 Sep 2023 17:37:33 +0200
Subject: [PATCH 2/3] deuxieme comit

---
 dxf_viewer/{gui_mpl.py => app.py}  | 847 ++++++++++++++++++-----------
 dxf_viewer/divers/acad2ogree.ipynb | 654 ----------------------
 dxf_viewer/divers/main.py          | 210 -------
 dxf_viewer/divers/requirements.txt |   3 -
 dxf_viewer/divers/tools.py         |  37 +-
 dxf_viewer/graphic/plus.png        | Bin 0 -> 463 bytes
 dxf_viewer/graphic/polyline.png    | Bin 0 -> 743 bytes
 dxf_viewer/graphic/sel_point.png   | Bin 0 -> 568 bytes
 dxf_viewer/requirements.txt        | Bin 0 -> 6590 bytes
 9 files changed, 569 insertions(+), 1182 deletions(-)
 rename dxf_viewer/{gui_mpl.py => app.py} (65%)
 delete mode 100644 dxf_viewer/divers/acad2ogree.ipynb
 delete mode 100644 dxf_viewer/divers/main.py
 delete mode 100644 dxf_viewer/divers/requirements.txt
 create mode 100644 dxf_viewer/graphic/plus.png
 create mode 100644 dxf_viewer/graphic/polyline.png
 create mode 100644 dxf_viewer/graphic/sel_point.png
 create mode 100644 dxf_viewer/requirements.txt

diff --git a/dxf_viewer/gui_mpl.py b/dxf_viewer/app.py
similarity index 65%
rename from dxf_viewer/gui_mpl.py
rename to dxf_viewer/app.py
index bbe5983..eb1ca43 100644
--- a/dxf_viewer/gui_mpl.py
+++ b/dxf_viewer/app.py
@@ -1,3 +1,4 @@
+
 import tkinter as tk
 from tkinter import filedialog
 import os
@@ -23,6 +24,20 @@
 matplotlib.use('TkAgg')
 from tkinter.filedialog import asksaveasfile
 
+"""
+In this verson, the lower left btton ( supposed to let u add points manually doesnt work ), its to add
+also, the export to json func is not working properly i think
+The new feature is the lowest box where selected points appaears, 
+you can select a first bunch of points with the area selection and then add points
+one by one with the selector (hand icon)
+In the box you can order the points as you want by drag and drop them
+The polyline button removes all the non selected point and draw a polyline
+between remaining points in the order they are in the box 
+the line appears not to be close atm
+to be fix and can be fix quickly
+"""
+
+
 class App(tk.Tk):
     def __init__(self):
         
@@ -66,13 +81,13 @@ def __init__(self):
         zoom_func, pan_func, release_func = zoom_pan.zoom_factory(self.ax)
         self.canvas.get_tk_widget().pack(fill=tk.BOTH)
         self.lines_to_draw = []
-
+        self.point_id = []
 
         #Menu
         self.buton_size = 33
         #bouton fichier
         self.file_border = tk.Frame(self, bg="#d9d9d9")
-        self.file_border.place(relx=0.85, rely=0.05, width=self.buton_size+4, height=self.buton_size+4) 
+        self.file_border.place(relx=0.75, rely=0.05, width=self.buton_size+4, height=self.buton_size+4) 
         self.fichier_icone = tk.PhotoImage(file="graphic/file.png") 
         self.file_bouton = tk.Button(self.file_border, image=self.fichier_icone,command=self.file_func,bg="white")
         self.file_bouton.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
@@ -80,7 +95,7 @@ def __init__(self):
 
         #bouton axes
         self.axis_border = tk.Frame(self, bg="#d9d9d9")
-        self.axis_border.place(relx=0.88, rely=0.05, width=self.buton_size+4, height=self.buton_size+4) 
+        self.axis_border.place(relx=0.775, rely=0.05, width=self.buton_size+4, height=self.buton_size+4) 
         self.axis_icone = tk.PhotoImage(file="graphic/axis.png")
         self.axis_bouton = tk.Button(self.axis_border, image=self.axis_icone,command=self.redefine_axis,bg="white")
         self.axis_bouton.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
@@ -89,7 +104,7 @@ def __init__(self):
 
         #bouton mesure
         self.mesure_border = tk.Frame(self, bg="#d9d9d9")
-        self.mesure_border.place(relx=0.91, rely=0.05, width=self.buton_size+4, height=self.buton_size+4)  
+        self.mesure_border.place(relx=0.8, rely=0.05, width=self.buton_size+4, height=self.buton_size+4)  
         self.mesure_icone = tk.PhotoImage(file="graphic/regle.png")
         self.mesure_bouton = tk.Button(self.mesure_border, image=self.mesure_icone,command=self.mesurer,bg="white")
         self.mesure_bouton.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
@@ -99,7 +114,7 @@ def __init__(self):
 
         #bouton iso_xy
         self.xy_border = tk.Frame(self, bg="#d9d9d9")
-        self.xy_border.place(relx=0.94, rely=0.05, width=self.buton_size+4, height=self.buton_size+4)  
+        self.xy_border.place(relx=0.825, rely=0.05, width=self.buton_size+4, height=self.buton_size+4)  
         self.iso_xy_icone = tk.PhotoImage(file="graphic/iso_xy.png")
         self.iso_xy = tk.Button(self.xy_border, image=self.iso_xy_icone,command=self.equalize_xy,bg="white")
         self.iso_xy.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
@@ -107,70 +122,306 @@ def __init__(self):
         CreateToolTip(self.iso_xy, text = "Normalize X/Y axis\n" + \
                                           "Keep real ratio X/Y")
 
+        #bouton json export
+        self.json_border = tk.Frame(self, bg="#d9d9d9")
+        self.json_border.place(relx=0.85, rely=0.05, width=self.buton_size+4, height=self.buton_size+4)  
+        self.json_icone = tk.PhotoImage(file="graphic/json.png")
+        self.json = tk.Button(self.json_border, image=self.json_icone,command=self.export_to_json,bg="white")
+        self.json.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
+        self.are_equals = True
+        CreateToolTip(self.json, text = "Export selected points\n" + \
+                                        "to Json")
+       
+
+        #bouton add_points
+        self.add_point_border = tk.Frame(self, bg="#d9d9d9")
+        self.add_point_border.place(relx=0.75, rely=0.63, width=self.buton_size+4, height=self.buton_size+4)   
+        self.add_point_icone = tk.PhotoImage(file="graphic/plus.png")
+        self.add_point_button = tk.Button(self.add_point_border, image=self.add_point_icone,command=self.add_point,bg="white")
+        self.add_point_button.place(x=2,y=2,width=self.buton_size, height=self.buton_size)
+        CreateToolTip(self.add_point_button, text = "Add a Point")
 
-        #bouton select_point
+
+        #bouton select_point with area
         self.button_border = tk.Frame(self, bg="#d9d9d9")
-        self.button_border.place(relx=0.85, rely=0.10, width=self.buton_size+4, height=self.buton_size+4)   
+        self.button_border.place(relx=0.775, rely=0.63, width=self.buton_size+4, height=self.buton_size+4)   
         self.aera_icone = tk.PhotoImage(file="graphic/area.png")
         self.area_button = tk.Button(self.button_border, image=self.aera_icone,command=self.on_choose_press,bg="white")
         self.area_button.place(x=2,y=2,width=self.buton_size, height=self.buton_size)
         self.choose = False
         self.area = None
         self.selection = []
-        self.selected = []
+        self.selected = None
         CreateToolTip(self.area_button, text = "Select points within an area\n" + \
                                                "too export too Json file")
+        
+        #bouton select_point
+        self.plus_border = tk.Frame(self, bg="#d9d9d9")
+        self.plus_border.place(relx=0.8, rely=0.63, width=self.buton_size+4, height=self.buton_size+4)   
+        self.plus_icone = tk.PhotoImage(file="graphic/sel_point.png")
+        self.plus_button = tk.Button(self.plus_border, image=self.plus_icone,command=self.selection_points,bg="white")
+        self.plus_button.place(x=2,y=2,width=self.buton_size, height=self.buton_size)
+        CreateToolTip(self.plus_button, text = "Select points by "+\
+                                                "click")
+        self.adding_points = False
+        self.selected_points = {}
 
-        #bouton json export
-        self.json_border = tk.Frame(self, bg="#d9d9d9")
-        self.json_border.place(relx=0.88, rely=0.10, width=self.buton_size+4, height=self.buton_size+4)  
-        self.json_icone = tk.PhotoImage(file="graphic/json.png")
-        self.json = tk.Button(self.json_border, image=self.json_icone,command=self.export_to_json,bg="white")
-        self.json.place(x=2, y=2, width=self.buton_size, height=self.buton_size)
-        self.are_equals = True
-        CreateToolTip(self.json, text = "Export selected points\n" + \
-                                        "to Json")
         
+        #bouton polyline
+        self.polyline_border = tk.Frame(self, bg="#d9d9d9")
+        self.polyline_border.place(relx=0.825, rely=0.63, width=self.buton_size+4, height=self.buton_size+4)   
+        self.polyline_icone = tk.PhotoImage(file="graphic/polyline.png")
+        self.polyline_button = tk.Button(self.polyline_border, image=self.polyline_icone,command=self.extract_points,bg="white")
+        self.polyline_button.place(x=2,y=2,width=self.buton_size, height=self.buton_size)
+        CreateToolTip(self.polyline_button, text = "Create new polyline between selected points\n"+\
+                                                   "remove the other and reindex")
+
+
+
 
         #Choix des couches 
         self.liste_couches = tk.Listbox(self, selectmode=tk.SINGLE)
-        self.liste_couches.place(relx=0.750,rely=0.15, width = 250*self.x_ratio, height = 200*self.y_ratio)
+        self.liste_couches.place(relx=0.750,rely=0.1, width = 200*self.x_ratio, height = 175*self.y_ratio)
+
+        self.vertical_scrollbar_couches = tk.Scrollbar(self.liste_couches, orient= 'vertical')
+        self.vertical_scrollbar_couches.pack(side= tk.RIGHT, fill= tk.BOTH)
+        self.liste_couches.config(yscrollcommand= self.vertical_scrollbar_couches.set)
+        self.vertical_scrollbar_couches.config(command= self.liste_couches.yview)
+
+        self.horizontal_scrollbar_couches= tk.Scrollbar(self.liste_couches, orient= 'horizontal')
+        self.horizontal_scrollbar_couches.pack(side= tk.BOTTOM, fill= tk.BOTH)
+        self.liste_couches.config(xscrollcommand= self.horizontal_scrollbar_couches.set)
+        self.horizontal_scrollbar_couches.config(command= self.liste_couches.xview)
+
+
 
         #Choix des objets a dessiner 
         self.liste_objets = tk.Listbox(self, selectmode=tk.MULTIPLE,activestyle="none")
-        self.liste_objets.place(relx=0.750,rely=0.45, width = 250*self.x_ratio, height = 200*self.y_ratio)
+        self.liste_objets.place(relx=0.750,rely=0.35, width = 200*self.x_ratio, height = 175*self.y_ratio)
+        
+        self.vertical_scrollbar_objets = tk.Scrollbar(self.liste_objets, orient= 'vertical')
+        self.vertical_scrollbar_objets.pack(side= tk.RIGHT, fill= tk.BOTH)
+        self.liste_objets.config(yscrollcommand= self.vertical_scrollbar_objets.set)
+        self.vertical_scrollbar_objets.config(command= self.liste_objets.yview)
+
+        self.horizontal_scrollbar_objets= tk.Scrollbar(self.liste_objets, orient= 'horizontal')
+        self.horizontal_scrollbar_objets.pack(side= tk.BOTTOM, fill= tk.BOTH)
+        self.liste_objets.config(xscrollcommand= self.horizontal_scrollbar_objets.set)
+        self.horizontal_scrollbar_objets.config(command= self.liste_objets.xview)
+
+
+        #Box pour séléction de points
+        self.box_points = DragDropListbox(self,activestyle="none")
+        self.box_points.place(relx=0.750,rely=0.68, width = 200*self.x_ratio, height = 175*self.y_ratio)
+        
+        self.vertical_scrollbar_points = tk.Scrollbar(self.box_points, orient= 'vertical')
+        self.vertical_scrollbar_points.pack(side= tk.RIGHT, fill= tk.BOTH)
+        self.box_points.config(yscrollcommand= self.vertical_scrollbar_points.set)
+        self.vertical_scrollbar_points.config(command= self.box_points.yview)
+
+
     
+
         self.bind('<Button-1>', self.on_click)
 
+        self.id_selected = []
         self.highlight = None
         self.close = None
-        
+        self.id_close = None
+        self.bind('<Escape>',self.escape)
+
         #Lance l'app
         self.mainloop()
 
 
-    def export_to_json(self):
-        if not self.selection:
-            self.warning("First select some points to export")
+    
+    
+########Fonctions liées au boutons################
+
+#Bouton fichier
+    def file_func(self):
+            # option pour la selection du fichier dxf
+            options = {'defaultextension': '.dxf',
+            'filetypes': [('Fichiers dxf', '.dxf')],
+            'initialdir': os.getcwd()}
+
+            fichier = filedialog.askopenfilename(**options)
+
+            self.cur_file = fichier
+            if self.cur_file != '':
+                #ouvre le fichier avec ezdxf
+                self.doc = ezdxf.readfile(f"{self.cur_file}")
+                self.msp = self.doc.modelspace()
+                group = self.msp.groupby(dxfattrib="layer")
+
+                #Charge les layers dans le dico et leurs objets associés
+                a = defaultdict(lambda: defaultdict(lambda: 0))
+                for layer, entities in group.items():
+                    for entity in entities:
+                        a[layer][entity.dxftype()] += 1
+                self.layers = {k: dict(a[k]) for k in a}
+                self.liste_couches.delete(0, tk.END)
+                # On ajoute les layers dans la fenetre adaptée 
+                for layer in self.layers:
+                    self.liste_couches.insert(tk.END, f"{layer}")
+
+                # On trie les layers par ordre alphabetique
+                elements = list(self.liste_couches.get(0, tk.END))
+                elements.sort()
+                self.liste_couches.delete(0, tk.END)
+                for element in elements:
+                    self.liste_couches.insert(tk.END, element)
+                self.liste_couches.insert(tk.END, "")
+                self.liste_couches.itemconfigure(len(elements), selectbackground=self.liste_objets.cget("background"), \
+                        selectforeground=self.liste_objets.cget("foreground"))
+
+#Bouton axes
+    def redefine_axis(self):
+        self.escape(None)
+        if  self.lines_to_draw == []:
+            self.warning("Tracez d'abord quelque chose")
+
+        else:    
+            self.point1 = []
+            self.point2 = []
+            self.point3 = []
+            # Créer un canvas supplémentaire pour le rectangle
+            if not self.rect :
+                self.axis_border["bg"] = 'black'
+                self.mesure_bouton.configure(state='disabled')
+                self.rect=True
+                self.label = tk.Label(self.cadre, text=f"Séléctionez 2 points dans ce cadre pour servir de nouvel axe x \n puis un pour le centre",\
+                                      background = "white",font = ("Arial", 14))
+                self.label.place(relx=0.22,rely=0.00)
+                self.cursor = self.canvas.mpl_connect('button_press_event', self.on_click_curseur)
+
+                
+            else:
+                self.canvas.mpl_disconnect(self.cursor)
+                self.rect=False
+                self.label.destroy()
+                self.axis_border["bg"] = '#d9d9d9'
+                self.mesure_bouton.configure(state='normal')
+
+#Fonction axes
+    def on_click_curseur(self,event):
+        if self.point1 == []:
+            if self.close: self.point1 = self.close
+            else: self.point1 = [event.xdata, event.ydata]
+        elif self.point2 == []:
+            if self.close: self.point2 = self.close
+            else:self.point2 = [event.xdata, event.ydata]
+        elif self.point3 == []:
+            if self.close: self.point3 = self.close
+            else:self.point3 = [event.xdata, event.ydata]
+            self.canvas.mpl_disconnect(self.cursor)
+            self.rect=False
+            self.label.destroy()
+
+            if None in self.point1 or None in self.point2 or None in self.point3 :
+                self.warning("L'un des points n'est pas dans le plan !")
+                self.point1 = []
+                self.point2 = []
+                self.point3 = []
+
+            else:
+                self.point1 = np.array(self.point1)
+                self.point2 = np.array(self.point2)
+                self.point3 = np.array(self.point3)
+                axis1 = -self.point1 + self.point2
+                axis1 /= np.linalg.norm(axis1)
+                new_lines_to_draw = []
+                for i in self.lines_to_draw:
+                    new_lines_to_draw.append(transform_single_axis(i,self.point3,axis1,True))
+                self.lines_to_draw = new_lines_to_draw
+                self.point1 = []
+                self.point2 = []
+                self.point3 = []
+                self.plot_on_canvas(self.lines_to_draw)
+            self.axis_border["bg"] = '#d9d9d9'
+            self.mesure_bouton.configure(state='normal')
+
+#Bouton mesurer
+    def mesurer(self):
+        self.escape(None)
+        self.point1 = []
+        self.point2 = []
 
+        if not self.mesure:
+            self.mesure_border["bg"] = 'black'
+            self.label = tk.Label(self.cadre, text=f"Séléctionez 2 points entre lesquels mesurer",background = "white",font = ("Arial", 14))
+            self.label.place(relx=0.22,rely=0.0)
+            self.mesure = True
+            self.cursor = self.canvas.mpl_connect('button_press_event', self.on_click_mesure)
+            self.axis_bouton.configure(state='disabled')
+            
         else:
-            extensions = [('Json file', '*.json')]
-            default_name = get_file_name(self.cur_file) #vire le path et l'extension
-            file = asksaveasfile(filetypes = extensions, defaultextension = extensions,initialfile = f"{default_name}")
-            if file:
-                file.write(generate_json("lol",self.selection))
-                file.close()
+            self.mesure_border["bg"] = '#d9d9d9'
+            self.canvas.mpl_disconnect(self.cursor)
+            self.mesure=False
+            self.label.destroy()
+            self.canvas.draw_idle()
+            self.axis_bouton.configure(state='normal')
+    
+#Mesure 
+    def on_click_mesure(self,event):
+
+        if self.point1 == []:
+            if self.close: self.point1 = self.close
+            else: self.point1 = [event.xdata, event.ydata]
+
+        elif self.point2 == []:
+            if self.close: self.point2 = self.close
+            else:self.point2 = [event.xdata, event.ydata]
+            self.canvas.mpl_disconnect(self.cursor)
+            self.mesure=False
+            self.label.destroy()
+            if None in self.point1 or None in self.point2:
+                self.warning("L'un des points n'est pas dans le plan !")
+                self.point1 = []
+                self.point2 = []
+                self.axis_bouton.configure(state='normal')
+
+    
+            else:
+                self.point1 = np.array(self.point1)
+                self.point2 = np.array(self.point2)
+                distance = np.linalg.norm(self.point1-self.point2)
+                x1 = self.point1[0]
+                x2 = self.point2[0]
+                y1 = self.point1[1]
+                y2 = self.point2[1]
+            
+                self.ax.plot([x1,x2],[y1,y2],c='b')
+                x_text = (self.point1[0] + self.point2[0]) / 2
+                y_text = (self.point1[1] + self.point2[1]) / 2
+                self.ax.text(x_text, y_text, f'Distance: {distance:.2f}')
+                self.canvas.draw_idle()
+            self.mesure_border["bg"] = '#d9d9d9'
+            self.axis_bouton.configure(state='normal')
+
+#Bouton isométrie
+    def equalize_xy(self):
+        if self.are_equals:
+            self.ax.set_aspect('auto')
+            self.are_equals=False
+        else:
+            self.ax.set_aspect('equal')
+            self.are_equals=True
 
+        self.horizontal_line = self.ax.axhline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.vertical_line = self.ax.axvline(0, color='red', linestyle='--', visible=False, lw=1)
+        self.fig.canvas.mpl_connect('motion_notify_event', self.cursor_hover)
+        self.fig.canvas.mpl_connect('axes_leave_event', self.cursor_leave)
+        self.canvas.draw_idle()
 
+#Bouton séléction de points par aire 
     def on_choose_press(self):
         # Lorsque on clique sur le bouton pour choisir des points
         # On vérifie qu'il n'y en a pas de séléction déja en cours et sinon on lance la sélection
-        for i in self.selected:
-            i.remove()
-        self.canvas.draw()
-        self.selected = []
-        self.selection = []
+
         if not self.choose:
+            self.escape(None)
             self.button_border["bg"] = 'black'
             self.choose_curs = self.ax.figure.canvas.mpl_connect('button_press_event', self.choose_area) # evenemnt sélection
             self.choose = True
@@ -179,7 +430,7 @@ def on_choose_press(self):
             self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
             self.choose = False
     
-    
+#Vérifie que le point de départ pour faire le triangle est valide est si oui lance le dessin   
     def choose_area(self,event):
         # debut de la sélection, evennement desisn de rctangele
         start_x = event.xdata
@@ -188,7 +439,7 @@ def choose_area(self,event):
             self.drop = self.fig.canvas.mpl_connect('button_release_event', lambda event : self.choosed_area(event,start_x,start_y))
             self.drag = self.fig.canvas.mpl_connect('motion_notify_event', lambda event : self.in_select(event,start_x,start_y))
 
-
+#dessine le rectangle
     @cap_frequency(24)
     def in_select(self,event,x_start,y_start):
         x = event.xdata
@@ -205,8 +456,16 @@ def in_select(self,event,x_start,y_start):
             self.ax.add_patch(self.area)
             self.canvas.draw_idle()
 
-                
+# détérmine la liste des points séléctionés               
     def choosed_area(self,event,x_start,y_start):
+        if self.selected:
+            self.selected.remove()
+            self.selected = None
+        self.box_points.delete(0, tk.END)
+        self.selected_points = {}
+        self.id_selected = []
+        self.selection = []
+        self.id_selected = []
         x = event.xdata
         y = event.ydata
         # Fin du dessin
@@ -216,35 +475,104 @@ def choosed_area(self,event,x_start,y_start):
         self.area = None
         self.choose = False
         self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
-        self.choose = False
         self.ax.figure.canvas.mpl_disconnect(self.drag)
         self.ax.figure.canvas.mpl_disconnect(self.drop)
-        self.selected = []
         self.button_border["bg"] = '#d9d9d9'
         if x and y :
-            for i in self.lines_to_draw:
-                    self.selection.append(i[(i[:,0]>min(x_start,x))*(i[:,0]<max(x_start,x))*\
-                                  (i[:,1]>min(y_start,y))*(i[:,1]<max(y_start,y)),:])
-            for i in self.selection:
-                self.selected.append(self.ax.scatter(i[:,0],i[:,1],c="blue",s=80))
-            self.canvas.draw_idle()
-
+            for c,i in enumerate(self.lines_to_draw):
+                ids_points = self.point_id[c]
+                if not False in np.equal(i[0,:],i[-1,:]):
+                    i = i[:-1,:]
+                    ids_points = self.point_id[c][:-1]
+
+                self.selection += list(i[(i[:,0]>min(x_start,x))*(i[:,0]<max(x_start,x))*\
+                              (i[:,1]>min(y_start,y))*(i[:,1]<max(y_start,y)),:])
+                self.id_selected += list(ids_points[(i[:,0]>min(x_start,x))*(i[:,0]<max(x_start,x))*\
+                              (i[:,1]>min(y_start,y))*(i[:,1]<max(y_start,y))])
+
+            self.selection = [list(i) for i in self.selection]
+            self.highlight_selected(self.selection)
         
-    def equalize_xy(self):
-        if self.are_equals:
-            self.ax.set_aspect('auto')
-            self.are_equals=False
+            for number,value in zip(self.id_selected,self.selection):
+                label = f"point n°{number}"
+                self.box_points.insert(tk.END, label)
+                self.selected_points[label] = value
+
+#Bouton Json
+    def export_to_json(self):
+        if not self.selection:
+            self.warning("First select some points to export")
+
         else:
-            self.ax.set_aspect('equal')
-            self.are_equals=True
+            extensions = [('Json file', '*.json')]
+            default_name = get_file_name(self.cur_file) #vire le path et l'extension
+            file = asksaveasfile(filetypes = extensions, defaultextension = extensions,initialfile = f"{default_name}")
+            if file:
+                file.write(generate_json("lol",self.selection))
+                file.close()       
+    
+#Bouton séléction de points
+    def selection_points(self):
+        if not self.adding_points:
+            self.escape(None)
+            self.adding_points = True
+            self.config(cursor="hand2")
+            self.plus_border["bg"] = 'black'
+            self.choose_curs = self.ax.figure.canvas.mpl_connect('button_press_event', self.choose_point)
+        else:
+            self.adding_points = False
+            self.config(cursor="arrow")
+            self.plus_border["bg"] = '#d9d9d9'
+            self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
+    
+#Séléction des points
+    def choose_point(self,event):
+        if self.close:
+            x = self.close[0]
+            y = self.close[1]
+            label = f"point n°{self.id_close}"
+            if not self.id_close in self.id_selected:
+                self.id_selected.append(self.id_close)
+                self.box_points.insert(tk.END, label)
+                self.selection.append([x,y])
+                self.selected_points[label] = [x,y]
+            else:
+                idx = self.box_points.get(0, tk.END).index(label) 
+                self.box_points.delete(idx)
+                self.id_selected.remove(self.id_close)
+                self.selection.remove([x,y])
+                del self.selected_points[label]
+            self.highlight_selected(self.selection)
+
+#Draw polyline
+    #Extrait les coordonées des points séléctionés dans l'ordre
+    def extract_points(self):
+        if len(self.selection) != 0:
+            line = []
+            for i in range(self.box_points.size()):
+                item = self.box_points.get(i)
+                line.append(self.selected_points[item])
+            self.lines_to_draw = np.array([line])
+            self.redefine_origin()
+            if self.selected:
+                self.selected.remove()
+                self.selected = None
+            self.box_points.delete(0, tk.END)
+            self.selected_points = {}
+            self.id_selected = []
+            self.selection = []
+            self.id_selected = []
+        
+#Add point
+    def add_point(self):
+        pass     
+
+####################################################
 
-        self.horizontal_line = self.ax.axhline(0, color='red', linestyle='--', visible=False, lw=1)
-        self.vertical_line = self.ax.axvline(0, color='red', linestyle='--', visible=False, lw=1)
-        self.fig.canvas.mpl_connect('motion_notify_event', self.cursor_hover)
-        self.fig.canvas.mpl_connect('axes_leave_event', self.cursor_leave)
-        self.canvas.draw_idle()
 
+####### Fonctions de dessin ########################
 
+# Dessine les axes sous le curseur
     @cap_frequency(24)
     def cursor_hover(self,event):
         if event.inaxes == self.ax:
@@ -262,99 +590,28 @@ def cursor_hover(self,event):
 
             # Actualiser le graphique
             self.canvas.draw_idle()
-        
-
-    def on_closing_window(self):
-        self.destroy()
-        sys.exit()
-
-
+     
+#Cache les axes quand le cursueur n'est pas sur le canva 
     def cursor_leave(self,event):
         # Cacher les lignes lorsque le curseur quitte le graphique
         self.horizontal_line.set_visible(False)
         self.vertical_line.set_visible(False)
 
         # Actualiser le graphique
-        self.fig.canvas.draw()
-
+        self.fig.canvas.draw()   
 
-    def on_click(self,event):
-        widget_under_cursor = event.widget.winfo_containing(event.x_root, event.y_root)
-        if widget_under_cursor == self.liste_couches:
-            self.afficher_selection()
-        elif widget_under_cursor == self.liste_objets:
-            self.dessiner_selection()
+#Charge les points de n'importe quel objet contenu dans une couche
+    def dessiner_selection(self):
 
-        
-    def file_func(self):
-        # option pour la selection du fichier dxf
-        options = {'defaultextension': '.dxf',
-        'filetypes': [('Fichiers dxf', '.dxf')],
-        'initialdir': os.getcwd()}
-
-        fichier = filedialog.askopenfilename(**options)
-
-        self.cur_file = fichier
-        if self.cur_file != '':
-            #ouvre le fichier avec ezdxf
-            self.doc = ezdxf.readfile(f"{self.cur_file}")
-            self.msp = self.doc.modelspace()
-            group = self.msp.groupby(dxfattrib="layer")
-
-            #Charge les layers dans le dico et leurs objets associés
-            a = defaultdict(lambda: defaultdict(lambda: 0))
-            for layer, entities in group.items():
-                for entity in entities:
-                    a[layer][entity.dxftype()] += 1
-            self.layers = {k: dict(a[k]) for k in a}
-            self.liste_couches.delete(0, tk.END)
-            # On ajoute les layers dans la fenetre adaptée 
-            for layer in self.layers:
-                self.liste_couches.insert(tk.END, f"{layer}")
-
-            # On trie les layers par ordre alphabetique
-            elements = list(self.liste_couches.get(0, tk.END))
-            elements.sort()
-            self.liste_couches.delete(0, tk.END)
-            for element in elements:
-                self.liste_couches.insert(tk.END, element)
+        # On doit récupérer les différents objets a dessiner sous forme de liste de points à dessiner
 
+        indices_objet_selectionnes = self.liste_objets.curselection()
+        objects_to_draw = []
+        for i in indices_objet_selectionnes:
+            objects_to_draw.append(self.liste_objets.get(i))
+            
 
-    def afficher_selection(self):
-        
-        # Récupérer et afficher les différents objets de la couche séléctionée
-        #On recupére la layer séléctionée
-        
-        indices_selectionnes = self.liste_couches.curselection()
-        self.current_layer = self.liste_couches.get(indices_selectionnes)
-        
-        self.liste_objets.delete(0, tk.END)
-        
-        #On affiche les différents objets de la layer
-        for i in self.layers[self.current_layer] :
-            self.liste_objets.insert(tk.END,f"--- {i} ---")
-            for k in range (0,self.layers[self.current_layer][i]):
-                self.liste_objets.insert(tk.END,f"{i} {k}")
-
-        #On bloque les titres (types d'objet ex: ---LWPOLYLINE---, ---LINE---, etc...)
-        for index in range(self.liste_objets.size()):
-            item = self.liste_objets.get(index)
-            if item.startswith("---"):
-                self.liste_objets.itemconfigure(index, selectbackground=self.liste_objets.cget("background"), \
-                    selectforeground=self.liste_objets.cget("foreground"))
-
-            
-    def dessiner_selection(self):
-
-        # On doit récupérer les différents objets a dessiner sous forme de liste de points à dessiner
-
-        indices_objet_selectionnes = self.liste_objets.curselection()
-        objects_to_draw = []
-        for i in indices_objet_selectionnes:
-            objects_to_draw.append(self.liste_objets.get(i))
-            
-
-        self.lines_to_draw = []
+        self.lines_to_draw = []
 
         for i in objects_to_draw:
             type_dessin = re.match(r'^(?!-{3})\S+', i)
@@ -371,6 +628,7 @@ def dessiner_selection(self):
                     line = np.array(line)
                     self.lines_to_draw.append(line)
 
+
                 if type_dessin == 'LINE': #Gestion des lines
                     line = self.msp.query(f'LINE[layer=="{self.current_layer}"]').entities[number]
                     x_start = line.dxf.start[0]
@@ -464,147 +722,18 @@ def dessiner_selection(self):
                     points_to_draw = []
                     self.lines_to_draw.append(points)
         
-        if self.lines_to_draw != []:
-            new_lines_to_draw = []
-            for ligne in self.lines_to_draw:
-                self.x_min = 1e99
-                self.y_min = 1e99
-                if np.min(ligne[:,0]) < self.x_min : self.x_min = np.min(ligne[:,0])
-                if np.min(ligne[:,1]) < self.y_min : self.y_min = np.min(ligne[:,1])
-            for ligne in self.lines_to_draw:
-                line = rdp(ligne, epsilon=0.2)-[self.x_min,self.y_min]
-                new_lines_to_draw.append(line)
-            self.lines_to_draw = new_lines_to_draw
-            self.plot_on_canvas(self.lines_to_draw)
-
-
-    def redefine_axis(self):
-        if  self.lines_to_draw == []:
-            self.warning("Tracez d'abord quelque chose")
-
-        else:    
-            self.point1 = []
-            self.point2 = []
-            self.point3 = []
-            # Créer un canvas supplémentaire pour le rectangle
-            if not self.rect :
-                self.axis_border["bg"] = 'black'
-                self.mesure_bouton.configure(state='disabled')
-                self.rect=True
-                self.label = tk.Label(self.cadre, text=f"Séléctionez 2 points dans ce cadre pour servir de nouvel axe x \n puis un pour le centre",\
-                                      background = "white",font = ("Arial", 14))
-                self.label.place(relx=0.22,rely=0.00)
-                self.cursor = self.canvas.mpl_connect('button_press_event', self.on_click_curseur)
-
-                
-            else:
-                self.canvas.mpl_disconnect(self.cursor)
-                self.rect=False
-                self.label.destroy()
-                self.axis_border["bg"] = '#d9d9d9'
-                self.mesure_bouton.configure(state='normal')
-
-                
-    def on_click_curseur(self,event):
-        if self.point1 == []:
-            if self.close: self.point1 = self.close
-            else: self.point1 = [event.xdata, event.ydata]
-        elif self.point2 == []:
-            if self.close: self.point2 = self.close
-            else:self.point2 = [event.xdata, event.ydata]
-        elif self.point3 == []:
-            if self.close: self.point3 = self.close
-            else:self.point3 = [event.xdata, event.ydata]
-            self.canvas.mpl_disconnect(self.cursor)
-            self.rect=False
-            self.label.destroy()
-
-            if None in self.point1 or None in self.point2 or None in self.point3 :
-                self.warning("L'un des points n'est pas dans le plan !")
-                self.point1 = []
-                self.point2 = []
-                self.point3 = []
-
-            else:
-                self.point1 = np.array(self.point1)
-                self.point2 = np.array(self.point2)
-                self.point3 = np.array(self.point3)
-                axis1 = -self.point1 + self.point2
-                axis1 /= np.linalg.norm(axis1)
-                new_lines_to_draw = []
-                for i in self.lines_to_draw:
-                    new_lines_to_draw.append(transform_single_axis(i,self.point3,axis1,True))
-                self.lines_to_draw = new_lines_to_draw
-                self.point1 = []
-                self.point2 = []
-                self.point3 = []
-                self.plot_on_canvas(self.lines_to_draw)
-            self.axis_border["bg"] = '#d9d9d9'
-            self.mesure_bouton.configure(state='normal')
-
-
-    def mesurer(self):
-        self.point1 = []
-        self.point2 = []
-
-        if not self.mesure:
-            self.mesure_border["bg"] = 'black'
-            self.label = tk.Label(self.cadre, text=f"Séléctionez 2 points entre lesquels mesurer",background = "white",font = ("Arial", 14))
-            self.label.place(relx=0.22,rely=0.0)
-            self.mesure = True
-            self.cursor = self.canvas.mpl_connect('button_press_event', self.on_click_mesure)
-            self.axis_bouton.configure(state='disabled')
-            
-        else:
-            self.mesure_border["bg"] = '#d9d9d9'
-            self.canvas.mpl_disconnect(self.cursor)
-            self.mesure=False
-            self.label.destroy()
-            self.canvas.draw_idle()
-            self.axis_bouton.configure(state='normal')
-
-
-    def on_click_mesure(self,event):
-
-        if self.point1 == []:
-            if self.close: self.point1 = self.close
-            else: self.point1 = [event.xdata, event.ydata]
-
-        elif self.point2 == []:
-            if self.close: self.point2 = self.close
-            else:self.point2 = [event.xdata, event.ydata]
-            self.canvas.mpl_disconnect(self.cursor)
-            self.mesure=False
-            self.label.destroy()
-            if None in self.point1 or None in self.point2:
-                self.warning("L'un des points n'est pas dans le plan !")
-                self.point1 = []
-                self.point2 = []
-                self.axis_bouton.configure(state='normal')
-
-    
-            else:
-                self.point1 = np.array(self.point1)
-                self.point2 = np.array(self.point2)
-                distance = np.linalg.norm(self.point1-self.point2)
-                x1 = self.point1[0]
-                x2 = self.point2[0]
-                y1 = self.point1[1]
-                y2 = self.point2[1]
-            
-                self.ax.plot([x1,x2],[y1,y2],c='b')
-                x_text = (self.point1[0] + self.point2[0]) / 2
-                y_text = (self.point1[1] + self.point2[1]) / 2
-                self.ax.text(x_text, y_text, f'Distance: {distance:.2f}')
-                self.canvas.draw()
-            self.mesure_border["bg"] = '#d9d9d9'
-            self.axis_bouton.configure(state='normal')
-
+        #Remet les points dans un référentiel local et supprime les points superflus
+        self.redefine_origin()
 
+#Dessine les points chargés sur le dessin
     def plot_on_canvas(self,lignes):
         self.ax.clear()
         nb_point = 1
+        self.point_id = []
+        id_last=1
         for ligne in lignes:
+            self.point_id.append(np.arange(ligne.shape[0])+id_last)
+            id_last += ligne.shape[0]
             self.ax.plot(ligne[:,0], ligne[:,1], c="black")
             self.ax.scatter(ligne[:,0],ligne[:,1], color="b", s=9)
             for i,vertice in enumerate(ligne):
@@ -620,7 +749,96 @@ def plot_on_canvas(self,lignes):
         self.fig.canvas.mpl_connect('axes_notify_event', self.closest_pt)
         self.canvas.draw()
 
+#Met en surbrillance le point le plus proche
+    @cap_frequency(20)
+    def closest_pt(self,event):
+        if self.lines_to_draw != []:
+            compte_pt=0
+            pt = -1
+            d_min = 99999
+            x = event.xdata
+            y = event.ydata
+
+            if x and y:
+                for c,line in enumerate(self.lines_to_draw):
+                    distance = np.sqrt((line[:,0]-x)**2+(line[:,1]-y)**2)                
+                    d = np.min(distance)
+                    compte_pt = np.shape(d)
+                    if d<d_min:
+                        d_min = d 
+                        point_actuel = line[np.argmin(distance),:]
+                        id_actuel = self.point_id[c][np.argmin(distance)]
+                        pt = np.argmin(distance)
+                    compte_pt += np.shape(d)
+            
+            delta = 0.01 * (self.ax.get_xlim()[1]-self.ax.get_xlim()[0])  
+
+            if d_min < delta:
+                self.close = list(point_actuel)
+                self.id_close = id_actuel
+                if not self.highlight:
+                    self.highlight = self.ax.scatter(point_actuel[0],point_actuel[1],c="blue",s=80)
+                    
+            elif d_min > delta :
+                if self.highlight:
+                    self.highlight.remove()
+                    self.highlight = None
+                    self.close = None
+                    self.i_close = None
+            self.canvas.draw_idle()
+
+#Met en surbrillance les points séléctionés
+    def highlight_selected(self,list_selected):
+        if self.selected:
+            self.selected.remove()
+        list_selected = np.array(list_selected)
+        self.selected = None
+        self.selected = self.ax.scatter(list_selected[:,0],list_selected[:,1],c="blue",s=80)
+        self.canvas.draw()
+
+####################################################
+
 
+########### Divers #################################
+
+#Permet quand on clique sur une couche d'en charger les objets et quand on clique sur un objet de le dessiner
+    def on_click(self,event):
+        widget_under_cursor = event.widget.winfo_containing(event.x_root, event.y_root)
+        if widget_under_cursor == self.liste_couches:
+            self.afficher_selection()
+        elif widget_under_cursor == self.liste_objets:
+            self.dessiner_selection()
+
+#Affiche les objets d'une couche 
+    def afficher_selection(self):
+        
+        # Récupérer et afficher les différents objets de la couche séléctionée
+        #On recupére la layer séléctionée
+        
+        indices_selectionnes = self.liste_couches.curselection()
+        self.current_layer = self.liste_couches.get(indices_selectionnes)
+        
+        self.liste_objets.delete(0, tk.END)
+        
+        #On affiche les différents objets de la layer
+        try:
+            for i in self.layers[self.current_layer] :
+                self.liste_objets.insert(tk.END,f"--- {i} ---")
+
+                for k in range (0,self.layers[self.current_layer][i]):
+                    self.liste_objets.insert(tk.END,f"{i} {k}")
+        except :
+            pass
+        
+        self.liste_objets.insert(tk.END,"")
+        #On bloque les titres (types d'objet ex: ---LWPOLYLINE---, ---LINE---, etc...)
+        for index in range(self.liste_objets.size()):
+            item = self.liste_objets.get(index)
+            if item.startswith("---") or item == "":
+                self.liste_objets.itemconfigure(index, selectbackground=self.liste_objets.cget("background"), \
+                    selectforeground=self.liste_objets.cget("foreground"))
+
+#fenetre d'avertissement
     def warning(self,message):
         # Créer une fenêtre pop-up
         window = tk.Toplevel()
@@ -656,43 +874,54 @@ def close_window():
         window.focus_set()
         window.wait_window()
 
+#Permet que le kernel python s'arrete proprement quand fermeture de la fenetre 
+    def on_closing_window(self):
+        self.destroy()
+        sys.exit()
 
-    @cap_frequency(20)
-    def closest_pt(self,event):
-        if self.lines_to_draw != []:
-            compte_pt=0
-            pt = -1
-            d_min = 99999
-            x = event.xdata
-            y = event.ydata
-
-            if x and y:
-                for line in self.lines_to_draw:
-                    distance = np.sqrt((line[:,0]-x)**2+(line[:,1]-y)**2)                
-                    d = np.min(distance)
-                    compte_pt = np.shape(d)
-                    if d<d_min:
-                        d_min = d 
-                        point_actuel = line[np.argmin(distance),:]
-                        pt = np.argmin(distance)
-                    compte_pt += np.shape(d)
-            
-            delta = 0.01 * (self.ax.get_xlim()[1]-self.ax.get_xlim()[0])  
-
-            if d_min < delta:
-                self.close = list(point_actuel)
-                if not self.highlight:
-                    self.highlight = self.ax.scatter(point_actuel[0],point_actuel[1],c="blue",s=80)
-                    
-            elif d_min > delta :
-                if self.highlight:
-                    self.highlight.remove()
-                    self.highlight = None
-                    self.close = None
+#Escape from any selection or menu
+    def escape(self,event):
+        if self.rect :
+            self.canvas.mpl_disconnect(self.cursor)
+            self.rect=False
+            self.label.destroy()
+            self.axis_border["bg"] = '#d9d9d9'
+            self.mesure_bouton.configure(state='normal')
+        
+        if self.mesure:
+            self.mesure_border["bg"] = '#d9d9d9'
+            self.canvas.mpl_disconnect(self.cursor)
+            self.mesure=False
+            self.label.destroy()
             self.canvas.draw_idle()
+            self.axis_bouton.configure(state='normal')
+        
+        if self.adding_points:
+            self.adding_points = False
+            self.config(cursor="arrow")
+            self.plus_border["bg"] = '#d9d9d9'
 
+        if self.choose:
+            self.button_border["bg"] = '#d9d9d9'
+            self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
+            self.choose = False
+            self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
 
+#Place the leftest point to 0 and the lower one too
+    def redefine_origin(self):
+        if len(self.lines_to_draw) != 0:
+            new_lines_to_draw = []
+            for ligne in self.lines_to_draw:
+                self.x_min = 1e99
+                self.y_min = 1e99
+                if np.min(ligne[:,0]) < self.x_min : self.x_min = np.min(ligne[:,0])
+                if np.min(ligne[:,1]) < self.y_min : self.y_min = np.min(ligne[:,1])
+            for ligne in self.lines_to_draw:
+                line = rdp(ligne, epsilon=0.2)-[self.x_min,self.y_min]
+                new_lines_to_draw.append(line)
+            self.lines_to_draw = new_lines_to_draw
+            self.plot_on_canvas(self.lines_to_draw)
 
-
+###################################################
 if __name__ == "__main__":
     app = App()
\ No newline at end of file
diff --git a/dxf_viewer/divers/acad2ogree.ipynb b/dxf_viewer/divers/acad2ogree.ipynb
deleted file mode 100644
index 0fdc2be..0000000
--- a/dxf_viewer/divers/acad2ogree.ipynb
+++ /dev/null
@@ -1,654 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": []
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
-  "cells": [
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "fdhER-gVSEDw",
-        "outputId": "6a63f9a9-ec7d-44d5-fe03-a0276bded533"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Collecting ezdxf>=1.0.3 (from -r /content/requirements.txt (line 1))\n",
-            "  Downloading ezdxf-1.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n",
-            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/3.1 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/3.1 MB\u001b[0m \u001b[31m54.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m67.7 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m41.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hCollecting mixpeek>=1.7 (from -r /content/requirements.txt (line 2))\n",
-            "  Downloading mixpeek-1.7.tar.gz (4.4 kB)\n",
-            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
-            "Collecting rdp>=0.8 (from -r /content/requirements.txt (line 3))\n",
-            "  Downloading rdp-0.8.tar.gz (4.4 kB)\n",
-            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
-            "Requirement already satisfied: pyparsing>=2.0.1 in /usr/local/lib/python3.10/dist-packages (from ezdxf>=1.0.3->-r /content/requirements.txt (line 1)) (3.1.0)\n",
-            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from ezdxf>=1.0.3->-r /content/requirements.txt (line 1)) (4.6.3)\n",
-            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from mixpeek>=1.7->-r /content/requirements.txt (line 2)) (2.27.1)\n",
-            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from rdp>=0.8->-r /content/requirements.txt (line 3)) (1.22.4)\n",
-            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (1.26.16)\n",
-            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (2023.5.7)\n",
-            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (2.0.12)\n",
-            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->mixpeek>=1.7->-r /content/requirements.txt (line 2)) (3.4)\n",
-            "Building wheels for collected packages: mixpeek, rdp\n",
-            "  Building wheel for mixpeek (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
-            "  Created wheel for mixpeek: filename=mixpeek-1.7-py3-none-any.whl size=2996 sha256=a28377dd05fa5d407bfa8bf86bf9043aa0bb571a2460238880512cc2bdc80465\n",
-            "  Stored in directory: /root/.cache/pip/wheels/87/58/46/2308be9b60f662a16b85069abd3e5bac1ab9b01e49ce4ea669\n",
-            "  Building wheel for rdp (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
-            "  Created wheel for rdp: filename=rdp-0.8-py3-none-any.whl size=4586 sha256=49546b7d9950739d79b7f2300c5f87ff3cc8cb3e4c0fdf1856933c2c72d7c015\n",
-            "  Stored in directory: /root/.cache/pip/wheels/5d/12/ec/0fc50553af000b9c3d2c74b9f77a01ae4bfe856e9917ac239c\n",
-            "Successfully built mixpeek rdp\n",
-            "Installing collected packages: rdp, ezdxf, mixpeek\n",
-            "Successfully installed ezdxf-1.0.3 mixpeek-1.7 rdp-0.8\n"
-          ]
-        }
-      ],
-      "source": [
-        "pip install -r \"/content/requirements.txt\""
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "import ezdxf\n",
-        "import sys\n",
-        "import numpy as np\n",
-        "from rdp import rdp\n",
-        "import pprint as pp\n",
-        "from collections import defaultdict\n",
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "np.set_printoptions(precision=3, suppress=True)\n",
-        "\n",
-        "def print_entity(e):\n",
-        "    print(\"LINE on layer: %s\\n\" % e.dxf.layer)\n",
-        "    print(\"start point: %s\\n\" % e.dxf.start)\n",
-        "    print(\"end point: %s\\n\" % e.dxf.end)\n",
-        "\n",
-        "def print_entity2(e):\n",
-        "    print(e.dxf.layer, e.dxf.start, e.dxf.end )\n",
-        "\n",
-        "def transform(vertices, new_center, axis1, axis2):\n",
-        "    mat = np.linalg.inv(np.array([axis1, axis2])) @ np.array([[1, 0], [0, 1]])\n",
-        "    transformed_vertices = (vertices - new_center) @ mat\n",
-        "    return transformed_vertices\n",
-        "\n",
-        "def transform_single_axis(vertices, new_center, axis1, direct):\n",
-        "    if direct:\n",
-        "        axis2 = np.array([-axis1[1], axis1[0]])\n",
-        "    else:\n",
-        "        axis2 = np.array([axis1[1]], -axis1[0])\n",
-        "    return transform(vertices, new_center, axis1, axis2)\n",
-        "\n",
-        "def plot(l, fig=True):\n",
-        "    if fig:\n",
-        "        plt.figure(figsize=(10,10))\n",
-        "    plt.plot(list(l[:, 0]) + [l[0, 0]], list(l[:, 1]) + [l[0, 1]])\n",
-        "    for i, vertice in enumerate(l):\n",
-        "        plt.annotate(str(i), vertice)\n",
-        "    plt.axis('equal')\n",
-        "\n",
-        "def perp(a) :\n",
-        "    b = np.empty_like(a)\n",
-        "    b[0] = -a[1]\n",
-        "    b[1] = a[0]\n",
-        "    return b\n",
-        "\n",
-        "def seg_intersect(a1, a2, b1, b2) :\n",
-        "    da = a2-a1\n",
-        "    db = b2-b1\n",
-        "    dp = a1-b1\n",
-        "    dap = perp(da)\n",
-        "    denom = np.dot( dap, db)\n",
-        "    num = np.dot( dap, dp )\n",
-        "    return (num / denom.astype(float))*db + b1\n",
-        "\n",
-        "def envelope(polygon, dist):\n",
-        "    shifted_segments = []\n",
-        "    for i in range(len(polygon)):\n",
-        "        a, b = polygon[i], polygon[(i+1)%len(polygon)]\n",
-        "        dx = b[0] - a[0]\n",
-        "        dy = b[1] - a[1]\n",
-        "        normal = np.array([dy, -dx])\n",
-        "        normal /= np.linalg.norm(normal)\n",
-        "        shifted_segments.append((a + dist*normal, b + dist*normal))\n",
-        "    new_polygon = []\n",
-        "    for i in range(len(shifted_segments)):\n",
-        "        seg1 = shifted_segments[(i-1)%len(shifted_segments)]\n",
-        "        seg2 = shifted_segments[i]\n",
-        "        new_polygon.append(seg_intersect(seg1[0], seg1[1], seg2[0], seg2[1]))\n",
-        "    return np.array(new_polygon)\n",
-        "\n",
-        "def get_circle(x, y, z):\n",
-        "    x, y, z = x[0]+x[1]*1j, y[0]+y[1]*1j, z[0]+z[1]*1j\n",
-        "    w = (z-x) / (y-x)\n",
-        "    c = (x-y)*(w-abs(w)**2)/2j/w.imag-x\n",
-        "    return -c.real, -c.imag, abs(c+x)\n",
-        "\n",
-        "def array2dict(lst):\n",
-        "    res_dict = {}\n",
-        "    for i in range(0, len(lst), 1):\n",
-        "        res_dict[i] = lst[i]\n",
-        "    return res_dict\n"
-      ],
-      "metadata": {
-        "id": "rbrKzV7iYuo6"
-      },
-      "execution_count": 2,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "doc = ezdxf.readfile(\"mgf.dxf\")\n",
-        "msp = doc.modelspace()\n",
-        "#\n",
-        "# LAYERS\n",
-        "#\n",
-        "for layer in doc.layers:\n",
-        "    print(layer.dxf.name)"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "N7CSQRf8ZGRi",
-        "outputId": "35aeb1b1-81f4-42d5-b146-94a05f1c9408"
-      },
-      "execution_count": 10,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "0\n",
-            "05-Bâti_construction\n",
-            "05-Bâti_surplomb\n",
-            "06-Mur\n",
-            "06-Portail\n",
-            "07-Clôture\n",
-            "08-Escalier_marche\n",
-            "08-Escalier_flèche\n",
-            "09-Chaussée-avec-bordure\n",
-            "09-Bateau\n",
-            "09-Voirie_texte\n",
-            "11-Arbre\n",
-            "12-Mobilier-urbain\n",
-            "24-Réseau_Eau\n",
-            "20-Réseau_Assainissement\n",
-            "29-Réseau_Divers\n",
-            "99-Titre\n",
-            "99-Nord\n",
-            "99-Logo\n",
-            "14-Nature_sol\n",
-            "05-Bâti_contour-hachures\n",
-            "11-Arbustes\n",
-            "99-Texte\n",
-            "05-Bâti_contour\n",
-            "09-Allée-avec-bordurette\n",
-            "25-Réseau_Eclairage-privé\n",
-            "05-Bâti_hachures\n",
-            "09-Chaussée-sans-bordure\n",
-            "99-Légende\n",
-            "10-Signalisation_horizontale\n",
-            "91-Intérieur_cotation\n",
-            "91-Intérieur_sanitaires\n",
-            "99-Fenêtre-présentation\n",
-            "--FLF-Str-Esc-Flèche\n",
-            "--FLF-0-poubelle\n",
-            "--FLF-Cadre-100\n",
-            "--FLF-Cadre\n",
-            "FLF-BATI\n",
-            "Defpoints\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#\n",
-        "# LAYERS with ENTITIES by type\n",
-        "#\n",
-        "group = msp.groupby(dxfattrib=\"layer\")\n",
-        "a = defaultdict(lambda: defaultdict(lambda: 0))\n",
-        "for layer, entities in group.items():\n",
-        "    for entity in entities:\n",
-        "        a[layer][entity.dxftype()] += 1\n",
-        "a = {k: dict(a[k]) for k in a}\n",
-        "pp.pprint(a)\n"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "JAPSSu36C94i",
-        "outputId": "8018dd3d-0587-41a0-d2e3-908bbeab87f8"
-      },
-      "execution_count": 11,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "{'--FLF-Str-Esc-Flèche': {'ARC': 1, 'LINE': 2, 'LWPOLYLINE': 5},\n",
-            " '0': {'ACAD_PROXY_ENTITY': 20, 'INSERT': 3, 'LINE': 2},\n",
-            " '05-Bâti_construction': {'CIRCLE': 1,\n",
-            "                          'INSERT': 1,\n",
-            "                          'LINE': 30,\n",
-            "                          'LWPOLYLINE': 8},\n",
-            " '05-Bâti_contour': {'LWPOLYLINE': 3},\n",
-            " '05-Bâti_contour-hachures': {'LWPOLYLINE': 2},\n",
-            " '05-Bâti_hachures': {'HATCH': 3},\n",
-            " '05-Bâti_surplomb': {'LINE': 5, 'LWPOLYLINE': 1},\n",
-            " '06-Mur': {'ARC': 9, 'CIRCLE': 3, 'LINE': 72, 'LWPOLYLINE': 13},\n",
-            " '06-Portail': {'INSERT': 3, 'LINE': 9, 'LWPOLYLINE': 3},\n",
-            " '07-Clôture': {'INSERT': 4, 'LINE': 33, 'LWPOLYLINE': 3},\n",
-            " '08-Escalier_flèche': {'ARC': 1, 'LWPOLYLINE': 1},\n",
-            " '08-Escalier_marche': {'LINE': 11, 'LWPOLYLINE': 2},\n",
-            " '09-Allée-avec-bordurette': {'LINE': 11, 'LWPOLYLINE': 2},\n",
-            " '09-Bateau': {'LWPOLYLINE': 1},\n",
-            " '09-Chaussée-avec-bordure': {'ARC': 8, 'LINE': 98, 'LWPOLYLINE': 44},\n",
-            " '09-Chaussée-sans-bordure': {'LINE': 9},\n",
-            " '09-Voirie_texte': {'TEXT': 14},\n",
-            " '10-Signalisation_horizontale': {'ARC': 1,\n",
-            "                                  'INSERT': 6,\n",
-            "                                  'LINE': 138,\n",
-            "                                  'LWPOLYLINE': 53},\n",
-            " '11-Arbre': {'INSERT': 1},\n",
-            " '11-Arbustes': {'CIRCLE': 4, 'INSERT': 14, 'LWPOLYLINE': 6},\n",
-            " '12-Mobilier-urbain': {'LWPOLYLINE': 2},\n",
-            " '14-Nature_sol': {'ARC': 3, 'LINE': 39, 'LWPOLYLINE': 12},\n",
-            " '20-Réseau_Assainissement': {'CIRCLE': 10, 'INSERT': 12, 'LINE': 69},\n",
-            " '24-Réseau_Eau': {'INSERT': 1, 'LINE': 1},\n",
-            " '25-Réseau_Eclairage-privé': {'INSERT': 12},\n",
-            " '29-Réseau_Divers': {'INSERT': 17, 'LINE': 32},\n",
-            " '91-Intérieur_cotation': {'INSERT': 1},\n",
-            " '91-Intérieur_sanitaires': {'INSERT': 1},\n",
-            " '99-Texte': {'LWPOLYLINE': 9, 'TEXT': 88}}\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#\n",
-        "# LWPOLYLINES in LAYER\n",
-        "#\n",
-        "lines = []\n",
-        "all_vertices = []\n",
-        "layer='05-Bâti_contour'\n",
-        "\n",
-        "for polyline in msp.query(f'LWPOLYLINE[layer==\"{layer}\"]'):\n",
-        "  line = []\n",
-        "  for vertice in polyline:\n",
-        "    line.append([vertice[0], vertice[1]])\n",
-        "    all_vertices.append([vertice[0], vertice[1]])\n",
-        "  line = np.array(line)\n",
-        "  lines.append(line)"
-      ],
-      "metadata": {
-        "id": "NC3bQLUHZKeT"
-      },
-      "execution_count": 12,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "# Nouvelle section"
-      ],
-      "metadata": {
-        "id": "JgmcXaFRXkQW"
-      }
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "\n",
-        "\n",
-        "# DRAW 1st POLYLINE\n",
-        "plot(lines[0])"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 830
-        },
-        "id": "A3DKnyOuV9d8",
-        "outputId": "4692dfc7-9b43-40f9-f5de-f4b4397487e2"
-      },
-      "execution_count": 14,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x1000 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# NORMALIZE POLYLINE + new center + new axis\n",
-        "line = lines[0]\n",
-        "#new_center = (line[22] + line[31])/2\n",
-        "new_center = (line[9] + line[7])/2\n",
-        "new_center = seg_intersect(line[7],line[9], line[13],line[11])\n",
-        "\n",
-        "#axis1 = line[31] - line[22]\n",
-        "axis1 = line[7] - line[9]\n",
-        "axis1 /= np.linalg.norm(axis1)\n",
-        "new_line = transform_single_axis(line, new_center, axis1, True)\n",
-        "print(new_line)"
-      ],
-      "metadata": {
-        "id": "zGUF89MHwcCb",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "8d336f6c-8d94-40d3-ad20-b69e6dea28f6"
-      },
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "[[52.929 22.734]\n",
-            " [53.657 22.006]\n",
-            " [53.368 21.716]\n",
-            " [54.132 20.953]\n",
-            " [54.128 20.948]\n",
-            " [50.196 15.514]\n",
-            " [47.582 10.801]\n",
-            " [43.823  0.   ]\n",
-            " [21.921 -0.012]\n",
-            " [ 8.031  0.   ]\n",
-            " [ 8.042  8.086]\n",
-            " [-0.027  8.084]\n",
-            " [-0.066 13.793]\n",
-            " [-0.056 16.984]\n",
-            " [17.405 17.001]\n",
-            " [28.154 17.01 ]\n",
-            " [28.997 17.209]\n",
-            " [29.784 17.625]\n",
-            " [30.31  18.237]\n",
-            " [30.62  19.017]\n",
-            " [30.65  19.827]\n",
-            " [30.467 20.63 ]\n",
-            " [26.409 24.697]\n",
-            " [38.384 36.689]\n",
-            " [41.27  33.891]\n",
-            " [42.629 35.247]\n",
-            " [42.629 35.247]\n",
-            " [46.411 39.019]\n",
-            " [46.411 39.019]\n",
-            " [47.771 40.375]\n",
-            " [44.934 43.249]\n",
-            " [56.91  55.224]\n",
-            " [61.017 51.135]\n",
-            " [61.804 50.954]\n",
-            " [62.656 50.995]\n",
-            " [63.416 51.318]\n",
-            " [64.029 51.871]\n",
-            " [64.428 52.655]\n",
-            " [64.602 53.475]\n",
-            " [64.594 66.936]\n",
-            " [64.614 81.693]\n",
-            " [73.501 81.689]\n",
-            " [73.481 73.638]\n",
-            " [81.581 73.619]\n",
-            " [81.603 58.837]\n",
-            " [81.591 37.824]\n",
-            " [80.236 37.505]\n",
-            " [75.108 35.868]\n",
-            " [70.189 33.734]\n",
-            " [65.511 31.057]\n",
-            " [60.704 27.533]\n",
-            " [59.94  28.296]\n",
-            " [59.65  28.006]\n",
-            " [58.922 28.734]]\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "new_line = np.array([        [   0 ,   0 ],\n",
-        "        [   0 , 110 ],\n",
-        "        [38.8 , 110 ],\n",
-        "        [38.8 ,  65 ],\n",
-        "        [  84 ,  65 ],\n",
-        "        [  84 , 150 ],\n",
-        "        [ 124 , 150 ],\n",
-        "        [ 124 ,  65 ],\n",
-        "        [ 167 ,  65 ],\n",
-        "        [ 167 , 115 ],\n",
-        "        [ 207 , 115 ],\n",
-        "        [ 207 ,  25 ],\n",
-        "        [ 177 ,  25 ],\n",
-        "        [ 177 ,   0 ],\n",
-        "        [ 142 ,   0 ],\n",
-        "        [ 142 ,  25 ],\n",
-        "        [ 112 ,  25 ],\n",
-        "        [ 112 ,   3 ],\n",
-        "        [  97 ,   3 ],\n",
-        "        [  97 ,  25 ],\n",
-        "        [  62 ,  25 ],\n",
-        "        [  62 ,   0 ]])"
-      ],
-      "metadata": {
-        "id": "GcAwpsw3-8sS"
-      },
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "plot(new_line)"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 830
-        },
-        "id": "uqSX8neGy-H_",
-        "outputId": "a96106bc-074f-4633-acaa-88b9bc1c028f"
-      },
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x1000 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#\n",
-        "# Reduce Points\n",
-        "#\n",
-        "simple_line = rdp(new_line, epsilon=0.2)\n",
-        "print(len(new_line), len(simple_line))\n",
-        "plot(simple_line)\n",
-        "\n",
-        "# convert Array into Dict\n",
-        "dict_line = array2dict(simple_line)\n",
-        "pp.pprint(dict_line)"
-      ],
-      "metadata": {
-        "id": "GDmsfTmIn0xK",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 1000
-        },
-        "outputId": "69845adb-3e5c-4273-e874-129511cad2d8"
-      },
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "54 37\n",
-            "{0: array([52.929, 22.734]),\n",
-            " 1: array([53.657, 22.006]),\n",
-            " 2: array([53.368, 21.716]),\n",
-            " 3: array([54.132, 20.953]),\n",
-            " 4: array([50.196, 15.514]),\n",
-            " 5: array([47.582, 10.801]),\n",
-            " 6: array([43.823,  0.   ]),\n",
-            " 7: array([8.031, 0.   ]),\n",
-            " 8: array([8.042, 8.086]),\n",
-            " 9: array([-0.027,  8.084]),\n",
-            " 10: array([-0.056, 16.984]),\n",
-            " 11: array([28.154, 17.01 ]),\n",
-            " 12: array([29.784, 17.625]),\n",
-            " 13: array([30.62 , 19.017]),\n",
-            " 14: array([30.467, 20.63 ]),\n",
-            " 15: array([26.409, 24.697]),\n",
-            " 16: array([38.384, 36.689]),\n",
-            " 17: array([41.27 , 33.891]),\n",
-            " 18: array([47.771, 40.375]),\n",
-            " 19: array([44.934, 43.249]),\n",
-            " 20: array([56.91 , 55.224]),\n",
-            " 21: array([61.017, 51.135]),\n",
-            " 22: array([62.656, 50.995]),\n",
-            " 23: array([64.029, 51.871]),\n",
-            " 24: array([64.602, 53.475]),\n",
-            " 25: array([64.614, 81.693]),\n",
-            " 26: array([73.501, 81.689]),\n",
-            " 27: array([73.481, 73.638]),\n",
-            " 28: array([81.581, 73.619]),\n",
-            " 29: array([81.591, 37.824]),\n",
-            " 30: array([75.108, 35.868]),\n",
-            " 31: array([70.189, 33.734]),\n",
-            " 32: array([65.511, 31.057]),\n",
-            " 33: array([60.704, 27.533]),\n",
-            " 34: array([59.94 , 28.296]),\n",
-            " 35: array([59.65 , 28.006]),\n",
-            " 36: array([58.922, 28.734])}\n"
-          ]
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x1000 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "int_line = envelope(simple_line, 2.)\n",
-        "plt.figure(figsize=(10,10))\n",
-        "plot(simple_line, False)\n",
-        "#plot(int_line, False)\n",
-        "lengths = []\n",
-        "for i in range(len(simple_line)):\n",
-        "    a, b = simple_line[i], simple_line[(i+1)%len(simple_line)]\n",
-        "    dx, dy = b[0]-a[0], b[1]-a[1]\n",
-        "    normal = np.array([dy, -dx])\n",
-        "    normal /= np.linalg.norm(normal)\n",
-        "    length = np.linalg.norm(a - b)\n",
-        "    lengths.append(length)\n",
-        "    if length > 5:\n",
-        "        plt.annotate(\"%.2f\" % length, (a+b)/2 - 3.*normal - 1., color='red')\n",
-        "print(np.array(lengths))\n"
-      ],
-      "metadata": {
-        "id": "W6DMPdufi2Eu",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 902
-        },
-        "outputId": "e04abfeb-6167-4c42-9024-d43d6cd3f2eb"
-      },
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "[ 1.03   0.41   1.08   6.714  5.389 11.437 35.791  8.086  8.069  8.899\n",
-            " 28.21   1.741  1.624  1.62   5.745 16.948  4.02   9.181  4.038 16.936\n",
-            "  5.796  1.644  1.629  1.703 28.218  8.887  8.051  8.1   35.795  6.771\n",
-            "  5.362  5.389  5.961  1.08   0.41   1.03   8.48 ]\n"
-          ]
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x1000 with 1 Axes>"
-            ],
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0sAAAMtCAYAAABO6eoxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC/50lEQVR4nOzde3zO9f/H8ee189hB0w7kfJwzSYxCzodE9C1SDokOU+GXskrpIOmAkhQJJSkxKUXOh5hYVoQ5m8M2h9hs7GDX9fvjYyeuYXNt1w6P++123bbr83l/Ptfrs2/f2nPvk8lisVgEAAAAAMjGwd4FAAAAAEBhRFgCAAAAACsISwAAAABgBWEJAAAAAKwgLAEAAACAFYQlAAAAALCCsAQAAAAAVjjZu4Crmc1mnTx5Up6enjKZTPYuBwAAAICdWCwWXbhwQeXLl5eDQ8H38xS6sHTy5ElVrFjR3mUAAAAAKCSOHTumChUqFPjnFrqw5OnpKcn4gXh5edm5GgAAAAD2Eh8fr4oVK2ZkhIJW6MJS+tA7Ly8vwhIAAAAAu03PYYEHAAAAALCCsAQAAAAAVhCWAAAAAMAKwhIAAABuXVqaNHasVLWq5O4uVa8uvf22ZLFc/7pvv5UaNZJKlZLKlZOeeEI6ezbzfGqq9NZbxv3c3Iy2y5fn77MAVxCWAAAAcOsmTpSmT5c+/VTas8d4//770tSpOV/zxx/SgAHSkCHSv/9KCxdKf/4pDR2a2ea116QvvjDus3u39PTT0oMPSjt25P8zocQzWSw3ivsFKz4+Xt7e3oqLi2M1PAAAgKLi/vslf39p1qzMY336GL1M8+ZZv+bDD42AdfBg5rGpU42gdfy48b58eenVV6Xg4Ju/L4oNe2cDepYAAABw61q2lFavlvbtM97//be0aZPUtWvO1wQFSceOSb/+agzXi42VfvxR6tYts01ysjH8Lit3d+PeQD4rdPssAQAAoAgaM0aKj5cCAyVHR2MO0/jxUv/+OV/TqpUxZ+mRR6SkJOnyZalHD2natMw2nTtLkyZJrVsb85ZWr5YWLzbuD+QzepYAAABw6374wQg+8+dLf/0lzZ1rDLObOzfna3bvll54QXr9dSk83Fi44cgRY15Suo8/lmrWNEKYi4s0fLg0eLDkwK+xyH/MWQIAAMCtq1jR6F3KOrfonXeMeUV791q/5vHHjR6lhQszj23aJN17r3TypLE6XrqkJGOVvPLljc/55RdjUQgUa/bOBkRyAAAA3LqLF6/t7XF0lMzm3F8jXbvkuJubdMcdxlC9RYuknj1vvWbgBpizBAAAgFvXo4cxR6lSJalePWNp70mTjH2T0oWESCdOSF9/nXnN0KHGinidO0vR0dKIEdLddxs9SJK0datxTePGxtdx44wA9tJLBfyAKIkISwAAALh1U6cam9I++6x06pQRdp56ypiPlC46WoqKynw/aJB04YKxN9P//Z9UpozUrp2xdHi6pCRjr6VDhyQPD2OlvG++MdoC+Yw5SwAAAAAKJXtnA+YsAQAAAIAVhCUAAAAAsIKwBAAAAABWEJYAAAAAwArCEgAAAABYQVgCAAAAACsISwAAAABgBWEJAACgmJkwYYKaNWsmT09P+fn5qVevXoqMjMzWpm3btjKZTNleTz/9tJ0qtq+b+XlJ0pYtW9SuXTuVLl1aXl5eat26tS5dumSHilFQCEsAAADFzPr16xUcHKywsDCtXLlSqamp6tSpkxITE7O1Gzp0qKKjozNe77//vp0qtq+b+Xlt2bJFXbp0UadOnfTnn39q27ZtGj58uBwc+HW6ODNZLBaLvYvIyt679AIAABQ3p0+flp+fn9avX6/WrVtLMnqWGjdurClTpti3uELI2s+rRYsW6tixo95++207V1ey2DsbEIUBAACKubi4OEmSj49PtuPffvutbr/9dtWvX18hISG6ePGiPcordK7+eZ06dUpbt26Vn5+fWrZsKX9/f7Vp00abNm2yZ5koAE72LgAAAAD5x2w2a8SIEWrVqpXq16+fcfzRRx9V5cqVVb58ef3zzz96+eWXFRkZqcWLF9uxWvuz9vM6dOiQJGncuHH68MMP1bhxY3399ddq3769du3apZo1a9qzZOQjwhIAAEAxFhwcrF27dl3TCzJs2LCM7xs0aKBy5cqpffv2OnjwoKpXr17QZRYa1n5eZrNZkvTUU09p8ODBkqQmTZpo9erV+uqrrzRhwgS71Ir8xzA8AACAYmr48OH65ZdftHbtWlWoUOG6bZs3by5JOnDgQEGUVijl9PMqV66cJKlu3brZ2tepU0dRUVEFWiMKFj1LAAAAxcSBUxf0X2KqLBaLPhz3stb/vkyfzV+q0/LW6cP/ZWtrMmW/9u/tWyVJZ82ltO2I0faqJjm6+l45tLLhvW7ubqabuJmvp6vKe7vpueeeU2hoqNatW6eqVatma1OlShWVL1/+muXE9+3bp65du95cwSiSCEsAAADFwLrIUxo0e5sk6ezvnylx93r59X5NIxdHSjJ+yTe5lpKDs6tSz0Urcfc6uVdvJkd3T6WcOqJza2bKtWJ9vbI+Xlq/xY5PUvDuPrlYvy9dpJ9++kmenp6KiYmRJHl7e8vd3V0mk0mjR4/WG2+8oUaNGqlx48aaO3eu9u7dqx9//NHO1SM/EZYAAACKgaNnjZXsSrs46uiOXyVJsd+FZGsT+PDLKtesi5KcvLT75E6d+etnpaVcklsZP5Vr1EaVOzwuJ7fS19w7NzvN5GZPmpu9rSUXd83NpjinLiQr5bJZC7/5SpKxnHpWs2fP1qBBgyRJI0aMUFJSkkaOHKn//vtPjRo10sqVK0v0/K6SgLAEAABQjLQN9NO/N5MY3nk4/4sp5B6dGabNB89qyY7j6tn4jhu2HzNmjMaMGVMAlaGwYIEHAAAAlEjpmfJm5jahZCIsAQAAAIAVhCUAAACUSOlzoehXQk4ISwAAACiRMofh2bcOFF6EJQAAAACwgrAEAACAEil9zUATA/GQA8ISAAAASjSG4SEnhCUAAIBiIDcbx+IKfmS4AcISAAAASiRWw8ON5CospaWlaezYsapatarc3d1VvXp1vf3229n+kmGxWPT666+rXLlycnd3V4cOHbR//36bFw4AAIBr8Ys/YDu5CksTJ07U9OnT9emnn2rPnj2aOHGi3n//fU2dOjWjzfvvv69PPvlEn3/+ubZu3arSpUurc+fOSkpKsnnxAAAAQF6xdDhuxCk3jTdv3qyePXuqe/fukqQqVarou+++059//inJ6FWaMmWKXnvtNfXs2VOS9PXXX8vf319LlixR3759r7lncnKykpOTM97Hx8fn+WEAAACAm5U5Noq0BOty1bPUsmVLrV69Wvv27ZMk/f3339q0aZO6du0qSTp8+LBiYmLUoUOHjGu8vb3VvHlzbdmyxeo9J0yYIG9v74xXxYoV8/osAAAAAGAzuepZGjNmjOLj4xUYGChHR0elpaVp/Pjx6t+/vyQpJiZGkuTv75/tOn9//4xzVwsJCdGoUaMy3sfHxxOYAAAAkO/S590zDA85yVVY+uGHH/Ttt99q/vz5qlevniIiIjRixAiVL19eAwcOzFMBrq6ucnV1zdO1AAAAAJBfchWWRo8erTFjxmTMPWrQoIGOHj2qCRMmaODAgQoICJAkxcbGqly5chnXxcbGqnHjxrarGgAAALhF6XOW6FhCTnI1Z+nixYtycMh+iaOjo8xmsySpatWqCggI0OrVqzPOx8fHa+vWrQoKCrJBuQAAALCG/VVzL3M1POISrMtVz1KPHj00fvx4VapUSfXq1dOOHTs0adIkPfHEE5KMf9BGjBihd955RzVr1lTVqlU1duxYlS9fXr169cqP+gEAAAAgX+QqLE2dOlVjx47Vs88+q1OnTql8+fJ66qmn9Prrr2e0eemll5SYmKhhw4bp/Pnzuueee7R8+XK5ubnZvHgAAAAgrxiGhxvJVVjy9PTUlClTNGXKlBzbmEwmvfXWW3rrrbdutTYAAADkEkPKANvJ1ZwlAAAAoNhg6XDcAGEJAAAAJVLGMDzCEnJAWAIAAAAAKwhLAAAAKJEylg5niQfkgLAEAACAEsmijLQEWEVYAgAAKAYs7EoL2BxhCQAAACWShY4l3ABhCQAAAACsICwBAAAUI/SS3LyMniXWDkcOCEsAAAAokTL2WbJrFSjMCEsAAAAAYAVhCQAAACWS5co4PEbhISeEJQAAAOBWpaVJY8dKVatK7u5S9erS22/feE33deukO++UXF2lGjWkOXOynx83zkhzWV+Bgfn0ELiak70LAAAAAOzJZItZSxMnStOnS3PnSvXqSdu3S4MHS97e0vPPW7/m8GGpe3fp6aelb7+VVq+WnnxSKldO6tw5s129etKqVZnvnfgVvqDwkwYAAECJlLkang1utnmz1LOnEX4kqUoV6bvvpD//zPmazz83eqI++sh4X6eOtGmTNHly9rDk5CQFBNigSOQWw/AAAACKgRsM9kJ+a9nS6Bnat894//ffRvDp2jXna7ZskTp0yH6sc2fjeFb790vly0vVqkn9+0tRUbatHTmiZwkAAAAlkuVKxLTJ+g5jxkjx8cZ8IkdHYw7T+PFGuMlJTIzk75/9mL+/cZ9Ll4y5T82bG/OYateWoqOlN9+U7r1X2rVL8vS0ReW4DsISAAAASiSLLTda+uEHY97R/PnGHKOICGnECKNHaODAvN83a89Uw4ZGeKpc2fi8IUNutWrcAGEJAACgGGEZbDsZPdroXerb13jfoIF09Kg0YULOYSkgQIqNzX4sNlby8jJ6lawpU0aqVUs6cMBmpSNnzFkCAABAiZTZsWSDhHnxouRw1a/Wjo6S2ZzzNUFBxjynrFauNI7nJCFBOnjQWDEP+Y6wBAAAANyqHj2MOUrLlklHjkihodKkSdKDD2a2CQmRBgzIfP/009KhQ9JLL0l790qffWYMrxs5MrPNiy9K69cb99y82bifo6PUr19BPVmJRlgCAABAiWS5MmnJJkMXp06VHnpIevZZYwnwF1+UnnrK2Jg2XXS0MTQvffPaunWNYXXffGPMR/roI+nLL7MvG378uPTww8Ymt61bG/st3X+/5Ot7bQ0LFxoLTLi5GcMAf/3VBg9WshGWAAAAUCLZcn0HeXpKU6YYYejSJWOo3DvvSC4umW3mzDGC0PTp0qefSnv2SB9/bAyt+/BD45pBg7Lfd8ECaetWafhw6auvpMaNjY1ur7Z5s9HbNGSItGOH1KuX8dq1yxZPV2IRlgAAAICCknXz2ipVjN6oTp2uv3ltlSpGqBowwHpQkozzXboYC03UqWP0aN15pxHKkGeEJQAAgGLAYmFb2ly78iMzFeQSgnnZvPZm3OwGt8gVlg4HAAAACkpeNq+9GTltcBsTc2v3LeEISwAAACiRMuYsFeTeVPm1eS3yBWEJAAAAJVLGangF+aF52bz2ZuS0wW1AQN7vCeYsAQAAFCcF+os/ci8vm9fejLxscIsbomcJAAAAJZJdhuGlb15bqZIxDG/HDmPz2ieeyGwTEiKdOCF9/XXmsYgI42tCgnT6tPHexcXYq0mSXnhBatPG2Kupe3djyfHt26UZMwrqyYolwhIAAABKuAJMS1OnGpvSPvusdOqUMVfpqaek11/PbBMdLUVFZb+uSZPM78PDjTlPlStLR44Yx1q2NI699pr0yitSzZrSkiVS/fr5/UTFGmEJAAAAJZJdVltP37x2ypSc28yZc+2xmyn2f/8zXrAZ5iwBAACgRLJcGYhXoMPwUKQQlgAAAADACsISAAAASqT0kW10LCEnhCUAAACUSBlhiXF4yAFhCQAAAACsICwBAACgRKNfCTkhLAEAABQjDCnLvVmfTlKzZs3k6ekpPz8/9erVS5GRkRnnjxw5IpPJZPW1cOFCO1aevyZMmHDdn4skxcTE6PHHH1dAQIBKly6tO++8U4sWLbJTxbZHWAIAAECJZLkyaSl862YFBwcrLCxMK1euVGpqqjp16qTExERJUsWKFRUdHZ3t9eabb8rDw0Ndu3a15yPkq/Xr11/35yJJAwYMUGRkpJYuXaqdO3eqd+/eevjhh7Vjxw47Vm47bEoLAACAEil9m9fP5y1SgwreGcfnzJkjPz8/hYeHq3Xr1nJ0dFRAQEC2a0NDQ/Xwww/Lw8OjACsuWMuXL8/2/uqfiyRt3rxZ06dP19133y1Jeu211zR58mSFh4erSZMmBV6zrdGzBAAAAGQRFxcnSfLx8bF6Pjw8XBERERoyZEhBlmV31n4uLVu21Pfff6///vtPZrNZCxYsUFJSktq2bWunKm2LniUAAACUSJlLh2ceM5vNGjFihFq1aqX69etbvW7WrFmqU6eOWrZsWQBVFg45/Vx++OEHPfLIIypbtqycnJxUqlQphYaGqkaNGnas1nYISwAAAMVA+i/+uDXBwcHatWuXNm3aZPX8pUuXNH/+fI0dO7aAK7OvnH4uY8eO1fnz57Vq1SrdfvvtWrJkiR5++GFt3LhRDRo0sFO1tkNYAgAAQIlkUfaEOXz4cP3yyy/asGGDKlSoYPWaH3/8URcvXtSAAQMKosRCIaefy8GDB/Xpp59q165dqlevniSpUaNG2rhxo6ZNm6bPP//cXiXbDGEJAAAAJVJmb5xFw4cPV2hoqNatW6eqVavmeM2sWbP0wAMPyNfXt0BqtCeLxaLnnnsux5/LxYsXJUkODtmXQXB0dJTZbC6wOvMTYQkAAAAlWo9+g3Vi+yq1Hf6+Qn7eL2m/TCaTnN1Ly9nFTZIxr+lC7DGt37BBHUdO0ZA52zKOG0wZ36cfMpkk05V3JpOynM9smNnWlO269Puk75tlynLjbPfM4bMyv1pvm34fa58lSU0r36bfvnhH8+fP108//SRPT0/FxMRIkry9veXu7q7AwEDVqFFDTz31lD788EOVLVtWS5Ys0cqVK/XLL79c92deVBCWAAAAihG2pL15fl6uOnUhWUc2LpEkrfzg2Wzny3YbIY8GHTLen1v/vRw9blekU1Xt23uqIEstcN+EHdWh6dMl6ZqV7WbPnq1BgwbJ2dlZv/76q8aMGaMePXooISFBNWrU0Ny5c9WtWzc7VG17hCUAAACUSLMGNtPWw//J0ve4JGNYXvo8pvQhesaxK98/9JGyjNy78sWS2TbrdVnuk3lN5iypzPtnP5b5feZ8KksOn5VTzVmvz35PK8+X5U16/Z+uPaA0s0VnLiSprIfr1T+2bGrWrKlFixZdt01RRlgCAABAieTv5aYHGpW3dxmFzqdrD9i7hEKDTWkBAAAAwArCEgAAAABYQVgCAAAoBq7eMwjArSMsAQAAAIAVhCUAAAAAsIKwBAAAAABWEJYAAAAAwArCEgAAQHFisncBQPFBWAIAAAAAKwhLAAAAAGAFYQkAAAAArCAsAQAAAIAVhCUAAIBiwGKxdwUobvhHirAEAAAAAFYRlgAAAADACsISAAAAAFhBWAIAAAAAKwhLAAAAxYhJJnuXABQbhCUAAAAAsIKwBAAAAABWEJYAAAAAwArCEgAAQDHABqKA7RGWAAAAAMAKwhIAAAAAWEFYAgAAAAArchWWqlSpIpPJdM0rODhYkpSUlKTg4GCVLVtWHh4e6tOnj2JjY/OlcAAAAADIT7kKS9u2bVN0dHTGa+XKlZKk//3vf5KkkSNH6ueff9bChQu1fv16nTx5Ur1797Z91QAAALDKxJ60gM045aaxr69vtvfvvfeeqlevrjZt2iguLk6zZs3S/Pnz1a5dO0nS7NmzVadOHYWFhalFixa2qxoAAAAA8lme5yylpKRo3rx5euKJJ2QymRQeHq7U1FR16NAho01gYKAqVaqkLVu25Hif5ORkxcfHZ3sBAAAAsC8L69HnPSwtWbJE58+f16BBgyRJMTExcnFxUZkyZbK18/f3V0xMTI73mTBhgry9vTNeFStWzGtJAAAAAGAzeQ5Ls2bNUteuXVW+fPlbKiAkJERxcXEZr2PHjt3S/QAAAEoiegFgK8x7y5SrOUvpjh49qlWrVmnx4sUZxwICApSSkqLz589n612KjY1VQEBAjvdydXWVq6trXsoAAAAAgHyTp56l2bNny8/PT927d8841rRpUzk7O2v16tUZxyIjIxUVFaWgoKBbrxQAAAAAClCue5bMZrNmz56tgQMHyskp83Jvb28NGTJEo0aNko+Pj7y8vPTcc88pKCiIlfAAAAAAFDm5DkurVq1SVFSUnnjiiWvOTZ48WQ4ODurTp4+Sk5PVuXNnffbZZzYpFAAAAAAKUq7DUqdOnWTJYQahm5ubpk2bpmnTpt1yYQAAAABgT3leDQ8AAACFDwuZAbZDWAIAAAAAKwhLAAAAAGAFYQkAAAAArCAsAQAAFAMWWV+AC0DeEZYAAAAAwArCEgAAAABYQVgCAAAAcA2GdhKWAAAAAMAqwhIAAACADGxsnImwBAAAUIyY+E0XsBnCEgAAAABYQVgCAAAAACsISwAAALYwYYLUrJnk6Sn5+Um9ekmRkdnbxMRIjz8uBQRIpUtLd94pLVp0a/f97z/puefU7/FO2vtRb4U83UV6/nkpLs7WTwiUOIQlAAAAW1i/XgoOlsLCpJUrpdRUqVMnKTExs82AAUbQWbpU2rlT6t1bevhhaceOvN/35Enp5EltfvpldXpimn4IfktavlwaMiR/nxcoAZzsXQAAAECxsHx59vdz5hg9QeHhUuvWxrHNm6Xp06W77zbev/aaNHmy0aZJk7zdt359adEiHVl7QFEXInWwQQWp/njpsceky5clJ37dA/KKniUAAID8kD4Mzscn81jLltL33xtD58xmacECKSlJatv21u5rrY2XF0EJuEX8PwgAAMDWzGZpxAipVSuj5yfdDz9IjzwilS1rBJlSpaTQUKlGjVu7bxal4s9Jb78tDRt2y48BlHSEJQAAAFsLDpZ27ZI2bcp+fOxY6fx5adUq6fbbpSVLjDlLGzdKDRrk/b5XeCRf1BMTxkh160rjxt3qUwAlHmEJAADAloYPl375RdqwQapQIfP4wYPSp58aYadePeNYo0ZGUJo2Tfr887zd9wrniwma+8PrSi7rbfRWOTvb8KGAkok5SwAAALZgsRiBJjRUWrNGqlo1+/mLF42vDlf9+uXoaAyvy+t9JSk+Xg+8NFipjk6a+/LHkpvbrT0LAEmEJQAAANsIDpbmzZPmzzf2RIqJMV6XLhnnAwONuUlPPSX9+afR0/TRR8Zy4L16Zd6nfXujB+pm7xsfL3XqJKekS3qp6wtyvZiY2SYtrcAeHyiOGIYHAABgC9OnG1+vXtlu9mxp0CBjWNyvv0pjxkg9ekgJCUZ4mjtX6tYts/3Bg9KZMzd/37/+krZu1e2SNswYKs3I0ubwYalKFRs8HFAyEZYAAABswWK5cZuaNaVFi67f5siR3N23bVvJYtG0tQf0wYpIPXJXRU18qOGNawFu5Cb+kS7uGIYHAAAAIIPJZLJ3CYUGYQkAAAAArCAsAQAAAIAVhCUAAAAAsIKwBAAAAABWEJYAAACKEebmA7ZDWAIAAAAAKwhLAAAAAGAFYQkAAKAYsNzMprgAcoWwBAAAAABWEJYAAAAAwArCEgAAAABYQVgCAAAAACsISwAAAABgBWEJAAAAwDVYX5GwBAAAUKyYTPauACg+CEsAAAAAMpC3MxGWAAAAigH2pAVsj7AEAAAAAFYQlgAAAADACsISAAAAAFhBWAIAAAAAKwhLAAAAAGAFYQkAAAAArCAsAQAAAIAVhCUAAIBihS1FAVshLAEAABQD7EkL2B5hCQAAAACsICwBAAAAgBWEJQAAAACwgrAEAAAA4BoWJsIRlgAAAABkMrGgYgbCEgAAAABYQVgCAAAAACsISwAAAMUIQ6gA2yEsAQAAAIAVhCUAAIBigJXLANsjLAEAAACAFYQlAAAAALCCsAQAAAAAVhCWAAAAAMAKwhIAAAAAWEFYAgAAAAArCEsAAAAAYAVhCQAAoBgx2bsAoBghLAEAABQDFrErLWyLf6YISwAAAACyMNE/mYGwBAAAAABWEJYAAAAAwArCEgAAAABYQVgCAAAAACtyHZZOnDihxx57TGXLlpW7u7saNGig7du3Z5y3WCx6/fXXVa5cObm7u6tDhw7av3+/TYsGAAAAgPyWq7B07tw5tWrVSs7Ozvrtt9+0e/duffTRR7rtttsy2rz//vv65JNP9Pnnn2vr1q0qXbq0OnfurKSkJJsXDwAAAAD5xSk3jSdOnKiKFStq9uzZGceqVq2a8b3FYtGUKVP02muvqWfPnpKkr7/+Wv7+/lqyZIn69u1ro7IBAAAAIH/lqmdp6dKluuuuu/S///1Pfn5+atKkiWbOnJlx/vDhw4qJiVGHDh0yjnl7e6t58+basmWL1XsmJycrPj4+2wsAAAC5Y7myf6iJLXIAm8lVWDp06JCmT5+umjVrasWKFXrmmWf0/PPPa+7cuZKkmJgYSZK/v3+26/z9/TPOXW3ChAny9vbOeFWsWDEvzwEAAAAANpWrsGQ2m3XnnXfq3XffVZMmTTRs2DANHTpUn3/+eZ4LCAkJUVxcXMbr2LFjeb4XAAAAANhKrsJSuXLlVLdu3WzH6tSpo6ioKElSQECAJCk2NjZbm9jY2IxzV3N1dZWXl1e2FwAAAADYW67CUqtWrRQZGZnt2L59+1S5cmVJxmIPAQEBWr16dcb5+Ph4bd26VUFBQTYoFwAAAAAKRq5Wwxs5cqRatmypd999Vw8//LD+/PNPzZgxQzNmzJAkmUwmjRgxQu+8845q1qypqlWrauzYsSpfvrx69eqVH/UDAAAAQL7IVVhq1qyZQkNDFRISorfeektVq1bVlClT1L9//4w2L730khITEzVs2DCdP39e99xzj5YvXy43NzebFw8AAAAA+SVXYUmS7r//ft1///05njeZTHrrrbf01ltv3VJhAAAAAOwnfTn6kixXc5YAAAAAFHPs1ZWBsAQAAFCMmPhNF7AZwhIAAEAxwIgpwPYISwAAAABgBWEJAAAAAKwgLAEAAACAFYQlAAAAALCCsAQAAAAAVhCWAAAAAMAKwhIAAAAAWEFYAgAAAAArCEsAAADFgcXYltZksnMdQDFCWAIAAAAAKwhLAAAAAGAFYQkAAADANSz2LqAQICwBAAAAyMC0t0yEJQAAAACwgrAEAAAAAFYQlgAAAADACsISAAAAAFhBWAIAAAAAKwhLAAAAxUD6Ms+sZAbYDmEJAAAAAKwgLAEAAACAFYQlAAAAALCCsAQAAIqFCRMmqFmzZvL09JSfn5969eqlyMjIbG2SkpIUHByssmXLysPDQ3369FFsbKydKgZQ2BGWAABAsbB+/XoFBwcrLCxMK1euVGpqqjp16qTExMSMNiNHjtTPP/+shQsXav369Tp58qR69+5tx6oBFGZO9i4AAADAFpYvX57t/Zw5c+Tn56fw8HC1bt1acXFxmjVrlubPn6927dpJkmbPnq06deooLCxMLVq0sEfZAAoxepYAAECxFBcXJ0ny8fGRJIWHhys1NVUdOnTIaBMYGKhKlSppy5YtdqkRQOFGWAIAAMWO2WzWiBEj1KpVK9WvX1+SFBMTIxcXF5UpUyZbW39/f8XExNihSqBws1gsN250I9OnSw0bSl5exisoSPrtt8zzbdtKJlP219NPX/+eV7dPf33wQWabv/6SOnaUypSRypaVhg2TEhJyXT5hCQAAFDvBwcHatWuXFixYYO9SCkz677UmE9vSohCpUEF67z0pPFzavl1q107q2VP699/MNkOHStHRma/337/+PbO2jY6WvvrKCEt9+hjnT56UOnSQatSQtm6Vli83Pm/QoFyXz5wlAABQrAwfPly//PKLNmzYoAoVKmQcDwgIUEpKis6fP5+tdyk2NlYBAQF2qBQonGyat3v0yP5+/HijtyksTKpXzzhWqpSUm/8PXt32p5+k++6TqlUz3v/yi+TsLE2bJjlc6Rv6/HOjh+vAASNE3SR6lgAAQLFgsVg0fPhwhYaGas2aNapatWq2802bNpWzs7NWr16dcSwyMlJRUVEKCgoq6HKBkictTVqwQEpMNIbjpfv2W+n226X69aWQEOnixZu/Z2ystGyZNGRI5rHkZMnFJTMoSZK7u/F106ZclUxYAgAARZbZbNH7y/fqmXnhGjLsac2bN0/z58+Xp6enYmJiFBMTo0uXLkmSvL29NWTIEI0aNUpr165VeHi4Bg8erKCgoLythDdu3LVzJgIDr3/NlClS7drGL24VK0ojR0pJSdnbTJsmVakiublJzZtLf/6Z+9qAwmTnTsnDQ3J1NeYjhYZKdesa5x59VJo3T1q71ghK33wjPfbYzd977lzJ01PKugVAu3ZSTIwxhyklRTp3ThozxjgXHZ2r0hmGBwAAiiSz2aKXF/2jheHHJUlHv5whSWrbtm22drNnz9agK3MVJk+eLAcHB/Xp00fJycnq3LmzPvvss7wXUa+etGpV5nun6/xqNX++8QvbV19JLVtK+/YZcyhMJmnSJKPN999Lo0YZQ4aaNzfCVefOUmSk5OeX9zoBe6pdW4qIkOLipB9/lAYOlNavNwLTsGGZ7Ro0kMqVk9q3lw4elKpXv/G9v/pK6t/f+ONCunr1jBA1apQRwBwdpeefl/z9s/c23QTCEgAAKHKyBiVHB5PKuDtLL/+imn4emj+0hXw9Xa1e5+bmpmnTpmnatGm2KcTJ6ebnWmzeLLVqZfwlXTJ6j/r1Myagp5s0yZjsPniw8f7zz40hRl99lfmXcaCocXHJnCfUtKm0bZv08cfSF19c27Z5c+PrgQM3DksbNxp/SPj++2vPPfqo8YqNlUqXzvyjRPq8ppvEMDwAAFCkXB2UpjzSWD8+01IBXm7afypBj84M0+kLyQVTzP79Uvnyxi9g/ftLUVE5t23Z0lgRLH1Y3aFD0q+/St26Ge9TUozzWfaBkoOD8Z59oFCcmM3GvCJrIiKMr+XK3fg+s2YZ4atRo5zb+PsbQwC//97oferYMVelEpYAAECRYS0o9WhUXlVvL60Fw1pkBKZ+M8N06kLSjW94K5o3l+bMMZYlnj5dOnxYuvde6cIF6+0ffVR66y3pnnuMlbqqVzf2mHnlFeP8mTPGBHh//+zX+fsb8y+AoigkRNqwQTpyxJi7FBIirVtn/HHh4EHp7beNPxIcOSItXSoNGCC1bm2sXHfFHklOP/+c/b7x8dLChdKTT1r/3E8/NfZa2rfPmAc4fLg0YYKx71IuEJYAAECRkFNQSlflSmAq5+2mA6cS1G9GPgemrl2l//3P+KWuc2ejl+j8eemHH6y3X7dOevdd6bPPjF/iFi82hti9/Xb+1QjY26lTRgCqXduYi7Rtm7RihdHD4+JizPnr1MlYHOX//s/YK+mqYBQoyRQfn/2+CxYYm4v162f9c//80/iMBg2kGTOMIX/PP5/r8pmzBAAACr0bBaV06YGp34wwHTydqH4zwvTd0Bby83KzclcbK1NGqlXLmGthzdix0uOPZ/4lvEEDYwnlYcOkV181lk52dDTmWGQVG3tT86Isstxa/UB+mDUr53MVKxoLPdyASVJc//5yz3pw2LDsi0Nc7euvb7bC66JnCQAAFGo3G5TSVS5bWguGBam8t5sOnk5U35lhOhWfz0PyJCkhwRhWlNNci4sXr12Jy9HR+GqxGH9lb9pUyrIPlMxm430u94GaMGGCmjVrJk9PT/n5+alXr16KjIy02tZisahr164ymUxasmRJrj4HKO4ISwAAoNDKbVBKV6lsKS0YFqQ7yrjr0OlE9Z0RplhbB6YXXzT+Kn7kiLHS3YMPGuEnfVjQgAHG/Ix0PXoYc5sWLDDmN61cafQ29eiRGZpGjZJmzjSWPd6zR3rmGaP3KX11vJu0fv16BQcHKywsTCtXrlRqaqo6deqkxMTEa9pOmTJFJpMpjz8EoHhjGB4AACiU8hqU0hmBqYX6zgjToTNXhuQNayF/Ww3JO37cCEZnz0q+vsbCDWFhxveSsTJe1p6k114zli9+7TXpxAmjXY8e0vjxmW0eeUQ6fVp6/XVjUYfGjY0FJK5e9OEGli9fnu39nDlz5Ofnp/DwcLVu3TrjeEREhD766CNt375d5W5m9TGghCEsAQCAQudWg1K6ij7ZA1PfK3OYArxtEJgWLLj++XXrsr93cpLeeMN4Xc/w4cbLhuLi4iRJPj4+GccuXryoRx99VNOmTVPAze4VBZQwDMMDAACFiq2CUrr0wHRHGXcdPpOofjPDFBNXAHOYCgmz2awRI0aoVatWql+/fsbxkSNHqmXLlurZs6cdqwMKN8ISAAAoNGwdlNJV9Cml759qoQq3GYGp74wtio67ZIOKC7/g4GDt2rVLC7L0hC1dulRr1qzRlClT7FcYCj0LCywSlgAAQOGQX0EpXYXbjB6mij7uOnL2ovrOCNPJ88U7MA0fPly//PKL1q5dqwoVKmQcX7NmjQ4ePKgyZcrIyclJTk7GzIw+ffqobdu2dqoWhYVJLPiRjrAEAADsLr+DUjojMAWpoo+7jhbjwGSxWDR8+HCFhoZqzZo1qlq1arbzY8aM0T///KOIiIiMlyRNnjxZs2fPtkPFQOHEAg8AAMCuCioopbujjLsWDAtSvxlhivrPCEzfXZnTVFwEBwdr/vz5+umnn+Tp6amYmBhJkre3t9zd3RUQEGB1UYdKlSpdE6yAkoyeJQAAYDcFHZTSGYGphSr5lLoSmLboRBHvYTpy9qIkycPVSdOnT1dcXJzatm2rcuXKZby+//57O1cJFC2EJQAAYBf2Ckrpyl8JTJXLltKx/y6p74wtOn7uYoF9vi1dSErVqt2xkqRO9fxlsVisvgYNGpTjPSwWi3r16lUwBQNFBGEJAAAUOHsHpXTpgalKRmAK07H/il5gWvFvrJIvm1XNt7Qa3OFt73KAYoOwBAAAClRhCUrpynkbc5iqlC2l4+eKZmBasuOEJKlX4ztkMrGSGWArhCUAAFBgCltQShfg7aYFw4JU9fbSOnG+aAWm2PgkbT54RpIRlgDYDmEJAAAUiMIalNIFeLvpu6Etilxgemb0WJ2YM1InpvxPd9Wpol69eikyMjJbm6eeekrVq1eXu7u7fH191bNnT+3du9dOFQNFB2EJAADku8IelNIZPUwtVC1LYIo6W7gD06YNG+R5Z3e9NWuJVq5cqdTUVHXq1EmJiYkZbZo2barZs2drz549WrFihSwWizp16qS0tDQ7Vg4UfiaLxWKxdxFZxcfHy9vbW3FxcfLy8rJ3OQAA4BYVlaCU1an4JPWdGaZDpxNV3ttN3w1rocplS9u7rGscOHVBHSZtkJODSX++2kE+pV10+vRp+fn5af369WrdurXV6/755x81atRIBw4cUPXq1Qu4ahR2dcYu16XUNG186T5V9Cll11rsnQ3oWQIAAPmmKAYlSfLzctOCoS1U3be0TsYlqe+MMB09m3jjCwvYkh0nJUltavnKp7SLJCkuLk6S5OPjY/WaxMREzZ49W1WrVlXFihULplCgiCIsAQCAfFFUg1I6Py+jR6m6b2lFXwlMR84UnsBksVi0JMJYBa9nE2NhB7PZrBEjRqhVq1aqX79+tvafffaZPDw85OHhod9++00rV66Ui4tLgdcNFCWEJQAAYHNFPSil8/M0AlMNP49CF5jCj57T8XOXVNrFUR3r+EuSgoODtWvXLi1YsOCa9v3799eOHTu0fv161apVSw8//LCSkpIKumygSCEsAQAAmyouQSmdn6exSl5NPw/FxBuB6fBNBKYJEyaoWbNm8vT0lJ+fn9VV6mbMmKG2bdvKy8tLJpNJ58+fv+m6Qq/srdS5foDcXRw1fPhw/fLLL1q7dq0qVKhwTXtvb2/VrFlTrVu31o8//qi9e/cqNDT0pj8PKIkISwAAwGaKW1BK5+vpqvnZAtMWHTqdcN1r1q9fr+DgYIWFheW4St3FixfVpUsXvfLKKxnHbhSy/vvvPz0bPFwfDe2mqI96a94L3dWwYUMtXrxYa9asUdWqVW/4PBaLRRaLRcnJyXn4aaC4Y1/jTE72LgAAABQPxTUopfP1dNV3w1ro0Zlh2heboL4zwoxlxn09rLZfvnx5tvdz5syRn5+fwsPDM1apGzFihCRp3bp1Ge3SQ1azZs10+fJlvfLKK+rUqZN2796t0qVL6/jxE9q8c7+82g6Wf6UaqnLgR/26bJnuueceeXp6KiYmRpLRk+Tu7q5Dhw7p+++/V6dOneTr66vjx4/rvffek7u7u7p162b7HxRQjNCzBAAAbllxD0rpbvcwephq+3vq1IVk9Z0RpoM36GFKd6NV6tItX75cgwYNUr169dSoUSPNmTNHUVFRCg8P14FTF/TWHxd0vuXzKlWjuZ7o2kK//PyzzGazNmzYoHLlymW8vv/+e0mSm5ubNm7cqG7duqlGjRp65JFH5Onpqc2bN8vPz+/WfiBAMUfPEgAAuCUlJSilMwJTcz06c6siYy+o34ywK6vmWe9hkq6/St2NpIesZZHxCl2xSSlpZpVycdTozrU1IKiKRlos+vLLLxUSEqLTp09fc3358uX166+/5u4hAUiiZwkAANyCkhaU0pW9EpgCAzJ7mA6cyrmH6Xqr1F2P2WzW4KeC5V2lvr4/aFJKmlntAv20clQbDW5VVY4OJp05c0Zvv/22hg0bdquPBeAqhCUAAJAnJTUopSvr4apvnzQC0+mMwHThmnY3WqUuJxeSUtWsWz9t2R4hj64v6nYPF03t10SzBt6lO8q4S5Li4+PVvXt31a1bV+PGjbPVowG4grAEAEBhs2GD1KOHVL68sSzVkiXXttmzR3rgAcnbWypdWmrWTIqKyvmeqanSW29J1atLbm5So0bSVQsQZPPee8ZnX1mA4GolPSilK3tlDlOdcl46k5CsvjO2an+sEZgsFouGDx+u0NDQm16lLt3K3bGq2fZ/+nvzGvn3e1f97musVaPaqEej8jJdWarswoUL6tKlizw9PRUaGipnZ+d8eUagJGPOEgAAhU1iohFmnnhC6t372vMHD0r33CMNGSK9+abk5SX9+68RgnLy2mvSvHnSzJlSYKC0YoX04IPS5s1SkybZ227bJn3xhdSwodVbEZSy8yntovlPNtejX27Vnuh49ZsZpkEtq+inz97Slt+XatLMb3U+1VEHjx5XKRdHlSlTRu7uRs9QTEyMYmJidODAAUnShq3b9c32WP32w9dKOrRddz4zRZOHdVWrGrdn+8z4+Hh17txZrq6uWrp0qdyu9789gDwzWSwWi72LyCo+Pl7e3t6Ki4uTl5eXvcsBAMC+TCYpNFTq1SvzWN++krOz9M03N3+f8uWlV1+VgoMzj/XpI7m7GyEqXUKCdOed0mefSe+8IzVuLE2ZknGaoJSzc4kp6v/lVu2OjpckHZ14v9V2NR4arTptHlDZ0i6K/PUrbfnxi2vamJxc9OT4mQrp217uLo6SMpcCj4+PV6dOnXTx4kWFhoaqdOnSGdf5+vrK0dExH54OJUnd15frYkqaNr50nyr6lLJrLfbOBvQsAQBQlJjN0rJl0ksvSZ07Szt2SFWrSiEh2QPV1ZKTr+15cneXNm3Kfiw4WOreXerQwQhL2T6aoHQ9t5V20XdDW+ibsCOK+u+izs7+U2cSU3Q2IVlnE1J0KTVNkpQq6Z/jxgp3qt5DlV/uke0+RyfeL8vlFM18eaBmvpx5fPbs2Ro0aJD++usvbd26VZJUo0aNbNcePnxYVapUya9HBEocwhIAAEXJqVNG78977xlhZuJEY+5R797S2rVSmzbWr+vcWZo0SWrd2pi3tHq1tHixlJaW2WbBAumvv4xheFchKN0c71LOGt6uptVzF1Mu62xCis5mCVBnEo2vZxOSdf5SqlrX9NWA8Wlycsx5Wnnbtm1VyAYGAcUWYQkAgKLEbDa+9uwpjRxpfN+4sTH36PPPcw5LH38sDR1qzFcymYzANHiw9NVXxvljx6QXXpBWrrymB4qgZBulXJxUysfJ7sOaANw8VsMDAKAouf12yclJqls3+/E6da6/Gp6vr7GqXmKidPSotHev5OEhVatmnA8PN3qt7rzTuL+Tk7R+vSyffCKLs7MWbTtKUAJQ4tCzBABAUeLiYiwTHhmZ/fi+fVLlyje+3s1NuuMOYynxRYukhx82jrdvL+3cma2pZfBg/eXur5CaXWVyciIoAShxCEsAABQ2CQnSlaWkJUmHD0sREZKPj1SpkjR6tPTII8b8o/vuM+Ys/fyztG5d5jUDBhihaMIE4/3WrdKJE8aQvRMnpHHjjCF9L71knPf0lOrXz7jcbLbo8EWL/rY46qB/VYISgBIpV8Pwxo0bJ5PJlO0VGBiYcT4pKUnBwcEqW7asPDw81KdPH8XGxtq8aAAAirXt2429j9L3Pxo1yvj+9deN9w8+aMxPev99qUED6csvjV6ie+7JvEdUlBQdnfk+KcnYa6luXeP6O+4wVsIrU+aaj0+fo3T6QrJMJobeASUV64jkoWepXr16WrVqVeYNnDJvMXLkSC1btkwLFy6Ut7e3hg8frt69e+uPP/6wTbUAAJQEbdve+LeUJ54wXjnJ2sskGQs/7N59w4/OupjD4scmEpSAEshk7wIKkVyHJScnJwUEBFxzPC4uTrNmzdL8+fPVrl07ScZ+AHXq1FFYWJhatGhh9X7JyclKTk7OeB8fH5/bkgAAgA2w6h0AZJfr1fD279+v8uXLq1q1aurfv7+irqy8Ex4ertTUVHXo0CGjbWBgoCpVqqQtW7bkeL8JEybI29s741WxYsU8PAYAALgVBCUAuFauwlLz5s01Z84cLV++XNOnT9fhw4d177336sKFC4qJiZGLi4vKXDX22d/fXzExMTneMyQkRHFxcRmvY8eO5elBAABA3hCUAMC6XA3D69q1a8b3DRs2VPPmzVW5cmX98MMPcnd3z1MBrq6ucnV1zdO1AADg1hCUACBnt7QpbZkyZVSrVi0dOHBAAQEBSklJ0fnz57O1iY2NtTrHCQAA2BdBCQCu75bCUkJCgg4ePKhy5cqpadOmcnZ21urVqzPOR0ZGKioqSkFBQbdcKAAAsB2CEgDcWK6G4b344ovq0aOHKleurJMnT+qNN96Qo6Oj+vXrJ29vbw0ZMkSjRo2Sj4+PvLy89NxzzykoKCjHlfAAAEDBIygBwM3JVVg6fvy4+vXrp7Nnz8rX11f33HOPwsLC5OvrK0maPHmyHBwc1KdPHyUnJ6tz58767LPP8qVwAACQewQlALh5JoulcO3NGx8fL29vb8XFxcnLy8ve5QAAUGxcHZQ+7ttY9zckKAHIrt7ry5WYkqYNo+9TpbKl7FqLvbPBLc1ZAgAARQNBCQByj7AEAEAxR1ACgLwhLAEAUIwRlAAg7whLAAAUUwQlALg1hCUAAIohghKAW2VRoVoHzi4ISwAAFDMEJQC3wmQy2buEQoOwBABAMUJQAgDbISwBAFBMEJQAwLYISwAAFAMEJQCwPcISAABFHEEJAPIHYQkAgCKMoAQA+YewBABAEUVQAoD8RVgCAKAIIigBQP4jLAEAUMQQlACgYBCWAAAoQghKAFBwCEsAABQRBCUAKFiEJQAAigCCEgAUPMISAACFHEEJAOyDsAQAQCFGUAIA+yEsAQBQSBGUAMC+CEsAABRCBCUA9mK68tVisWsZhQJhCQCAQoagBACFA2EJAIBChKAEAIUHYQkAgEKCoAQAhQthCQCAQoCgBACFD2EJAAA7IygBQOFEWAIAwI4ISgBQeBGWAACwE4ISABRuhCUAAOyAoAQAhR9hCQCAAkZQAoCigbAEAEABIigBQNFBWAIAoIAQlACgaCEsAQBQAAhKAFD0EJYAAMhnBCUAKJoISwAA5COCEgAUXYQlAADyCUEJQFFmsXcBhQBhCQCAfEBQAlBkmexdQOFBWAIAwMYISgBQPBCWAACwIYISABQfhCUAAGyEoAQAxQthCQAAGyAoAUDxQ1gCACAXNmzYoB49eqh8+fIymUxasmRJtqBkuXReVf6do2Fd7lKpUqXUpUsX7d+/395lAwDygLAEAEAuJCYmqlGjRpo2bZqk7D1KDibJfd0kpZ6L0U8//aQdO3aocuXK6tChgxITE+1cOQAgt5zsXQAAAEVJ165d1bVr14z3X285oghHFzk6mPRSC089/d5fWrRrl+rVqydJmj59ugICAvTdd9/pySeftFfZAIA8oGcJAIA8MJuN7Ro3HzybMUepZdUykiQ3N7eMdg4ODnJ1ddWmTZvsUSYA4BYQlgAAyKX0oXeS5JBlMYfAwEBVqlRJISEhOnfunFJSUjRx4kQdP35c0dHRdq4aAJBbhCUAAHIh6xwlSRpyT9WMVe+cnZ21ePFi7du3Tz4+PipVqpTWrl2rrl27ysGB/+QCQFHDnCUAAG7S1cuDS1KzKj7Z2jRt2lQRERGKi4tTSkqKfH191bx5c9111132KBkAcAv4MxcAADfB2j5K1+Pt7S1fX1/t379f27dvV8+ePQumUACAzdCzBADADVgsmUHJdDlJL9ztqQrmU5Kkw4cPKyIiQj4+PqpUqZIWLlwoX19fVapUSTt37tQLL7ygXr16qVOnTnZ+CgBAbhGWAAC4gaNnL2bMUerkl6gXHnko49yoUaMkSQMHDtScOXMUHR2tUaNGKTY2VuXKldOAAQM0duxYu9QNALg1hCUAAG6gctlSah/op9V7T2n9BV/9ceC0Wla/3Wrb559/Xs8//3wBVwgAtmO68tVisdi1jsKAOUsAANyAyWTSZ4/dqba1fZWUataQOdu19dBZe5cFAMhnhCUAAG6Cq5OjPn+sqVrX8tWl1DQNnrNN2478Z++yAAD5iLAEAMBNcnN21IzHm+qeGrfrYkqaBn31p8KPEpgAoLgiLAEAkAtuzo6aOeAutaxeVokpaRr41TbtiDpn77IAAPmAsAQAQC65uzjqy4F3qUU1HyUkX9aAWX/q72Pn7V0WAMDGCEsAAORBKRcnfTWome6u4qMLyZf1+Kyt2nk8zt5lAQBsiLAEAEAelXJx0leDm+muyrcpPumyHpu1VbtOEJgAoLggLAEAcAs8XJ00e3Az3VmpjOIupeqxWVu1+2S8vcsCANgAYQkAgFvk6easOU/crUYVy+j8xVT1/zJMe2MITABQ1BGWAACwAS83Z339xN1qWMFb5y6mqv/MrdoXe8HeZQEAbgFhCQAAG/F2d9Y3TzRX/Tu8dDYxRY/ODNOBUwQmACiqCEsAANiQdylnzRvSXHXLeelMQor6zdyqg6cT7F0WACAPCEsAANhYmVIu+vbJ5goM8NTpC8nqNyNMh88k2rssAEAuEZYAAMgHt5U2AlNtf0+duhKYjhCYAKBIISwBAJBPynq46tuhzVXTz0Mx8UnqNzNMUWcv3vC6DRs2qEePHipfvrxMJpOWLFmS7XxCQoKGDx+uChUqyN3dXXXr1tXnn3+eT08BoKQxmUySJIud6ygMCEsAAOSj2z1cNX9oC1X3La3oOCMwHfvv+oEpMTFRjRo10rRp06yeHzVqlJYvX6558+Zpz549GjFihIYPH66lS5fmxyMAQIlFWAIAIJ/5errqu6EtVO320jpx/pL6zQzT8XM5B6auXbvqnXfe0YMPPmj1/ObNmzVw4EC1bdtWVapU0bBhw9SoUSP9+eef+fUIAFAiEZYAACgAfl5u+m5YC1W9vbSOnzMC08nzl/J0r5YtW2rp0qU6ceKELBaL1q5dq3379qlTp042rhoASjbCEgAABcTfy03fDW2hymVL6dh/RmCKjst9YJo6darq1q2rChUqyMXFRV26dNG0adPUunXrfKgaAEouwhIAAAUowNsITBV93HX07EU9OnOrYuOTcnWPqVOnKiwsTEuXLlV4eLg++ugjBQcHa9WqVflUNQCUTIQlAAAKWPky7vpuaAtVuM1dh88kqt/MMJ26ycB06dIlvfLKK5o0aZJ69Oihhg0bavjw4XrkkUf04Ycf5nPlAFCyEJYAALCDCreV0ndDW+iOMu46dNoITKcvJN/wutTUVKWmpsrBIft/wh0dHWU2m/OrXAAokQhLAADYSUUfIzCV93bTwdOJenRmmC6lpCkhIUERERGKiIiQJB0+fFgRERGKioqSl5eX2rRpo9GjR2vdunU6fPiw5syZo6+//jrH1fMAAHlzS2Hpvffek8lk0ogRIzKOJSUlKTg4WGXLlpWHh4f69Omj2NjYW60TAIBiqVLZUnosqLIkaf+pBO2LvaDt27erSZMmatKkiSRjX6UmTZro9ddflyQtWLBAzZo1U//+/VW3bl299957Gj9+vJ5++mm7PQcAFEdOeb1w27Zt+uKLL9SwYcNsx0eOHKlly5Zp4cKF8vb21vDhw9W7d2/98ccft1wsAADFzY/hx/XBikhJ0mMtKqlhBW+ZKraVxWLJ8ZqAgADNnj27oEoEgBIrTz1LCQkJ6t+/v2bOnKnbbrst43hcXJxmzZqlSZMmqV27dmratKlmz56tzZs3KywszGZFAwBQHPwYflyjf/xbFosRlN7uWV8mk8neZQEArshTWAoODlb37t3VoUOHbMfDw8OVmpqa7XhgYKAqVaqkLVu2WL1XcnKy4uPjs70AACjuFm4/RlACgEIu18PwFixYoL/++kvbtm275lxMTIxcXFxUpkyZbMf9/f0VExNj9X4TJkzQm2++mdsyAAAosn7YfkwvL/pHFov0eIvKeqtnPYISABRCuepZOnbsmF544QV9++23cnNzs0kBISEhiouLy3gdO3bMJvcFAKAwyhqUBgQRlACgMMtVWAoPD9epU6d05513ysnJSU5OTlq/fr0++eQTOTk5yd/fXykpKTp//ny262JjYxUQEGD1nq6urvLy8sr2AgCgOPphW/ag9OYDBCUAhdd11pkpMXI1DK99+/bauXNntmODBw9WYGCgXn75ZVWsWFHOzs5avXq1+vTpI0mKjIxUVFSUgoKCbFc1AABFzA/bjunlxUZQGhhUWeMISgAKKf7VlClXYcnT01P169fPdqx06dIqW7ZsxvEhQ4Zo1KhR8vHxkZeXl5577jkFBQWpRYsWtqsaAIAiJGtQGtSyit7oUZegBABFwC1tSmvN5MmTdf/996tPnz5q3bq1AgICtHjxYlt/DACgpLtwQRoxQqpcWXJ3l1q2lKwsPpQhOlp69FGpVi3JwcG41popU6TatY17VqwojRwpJSXluczvt0XppUUEJQAoivK8KW26devWZXvv5uamadOmadq0abd6awAAcvbkk9KuXdI330jly0vz5kkdOki7d0t33HFt++RkyddXeu01afJk6/ecP18aM0b66isjfO3bJw0aZIxJmTQp1yUu+DNKYxYbw9cJSgBQ9Ni8ZwkAgHx36ZK0aJH0/vtS69ZSjRrSuHHG1+nTrV9TpYr08cfSgAGSt7f1Nps3S61aGT1QVapInTpJ/fpJf/6Z6xKzBqXBrQhKAFAUEZYAAEXP5ctSWpp09TYW7u7Spk15v2/LllJ4eGY4OnRI+vVXqVu3XN3mu6uC0uv3E5QAoCgiLAEAih5PTykoSHr7benkSSM4zZsnbdlizE3Kq0cfld56S7rnHsnZWapeXWrbVnrllZu+xfytUQq5EpSeaFWVoASgyPr84w/VrFkzeXp6ys/PT7169VJkZGS2NgcPHtSDDz4oX19feXl56eGHH1ZsbKydKrY9whIAoGj65htjE5A77pBcXaVPPjGGzDncwn/a1q2T3n1X+uwz6a+/pMWLpWXLjFB2E+ZvjdIroZlBaez9dQhKAIqsP7f8oeDgYIWFhWnlypVKTU1Vp06dlJiYKElKTExUp06dZDKZtGbNGv3xxx9KSUlRjx49ZDab7Vy9bdzyAg8AANhF9erS+vVSYqIUHy+VKyc98ohUrVre7zl2rPT448biEZLUoIFx/2HDpFdfvW4Q+3brUb0aukuSNOSeqnqtO0EJQNH21YJQ1fDzyHg/Z84c+fn5KTw8XK1bt9Yff/yhI0eOaMeOHfLy8pIkzZ07V7fddpvWrFmjDh062Kt0m6FnCQBQtJUubQSlc+ekFSuknj3zfq+LF68NRI6OxtfrbGU/LywzKD1JUAJQTMXFxUmSfHx8JEnJyckymUxydXXNaOPm5iYHBwdtupX5o4UIYQkAUDStWCEtXy4dPiytXCndd58UGCgNHmycDwkxVr7LKiLCeCUkSKdPG9/v3p15vkcPYzW9BQsy7zt2rHE8PTRdZV7YUb22JDMovUpQAlAMmc1mjRgxQq1atVL9+vUlSS1atFDp0qX18ssv6+LFi0pMTNSLL76otLQ0Rd/K/NFChGF4AICiKS7OCETHj0s+PlKfPtL48cbCDJKx0ENUVPZrmjTJ/D483NhXqXJl6cgR49hrrxl7Kr32mnTihLEvU48exn2t+CbsqMZeCUpD762qV7oRlAAUT8HBwdq1a1e2HiNfX18tXLhQzzzzjD755BM5ODioX79+uvPOO+VwK/NHCxHCEgCgaHr4YeOVkzlzrj12naF0kiQnJ+mNN4zXDWQNSsNaV1NI10CCEoBiafjw4frll1+0YcMGVahQIdu5Tp066eDBgzpz5oycnJxUpkwZBQQEqNqtzB8tRAhLAADk0jdbjmjsT/9KIigBKL4sFouGDx+u0NBQrVu3TlWrVs2x7e233y5JWrNmjU6dOqUHHnigoMrMV4QlAABy4estR/T6laD0VOtqGkNQAlBMXE4zK/zoOSWnGst+jxszSstCF+qnn36Sp6enYmJiJEne3t5yd3eXJM2ePVt16tSRr6+vtmzZohdeeEEjR45U7dq17fYctkRYAgDgJmULSm2qaUwXghKAoi0+KVXrI09r9Z5YrY08rbhLqRnn5s/5UpLUtm3bbNfMnj1bgwYNkiRFRkYqJCRE//33n6pUqaJXX31VI0eOLKjy853JYrnRAO6CFR8fL29vb8XFxWWs1w4AKDo2bNigDz74QOHh4YqOjlZoaKh69eqVrc2ePXv08ssva/369bp8+bLq1q2rRYsWqVKlSvYp+iYQlAAUF1FnL2rVnlit3hurrYf+02VzZhwoU8pZ99X2U+8779C9NX3tWKXB3tmAniUAgE0lJiaqUaNGeuKJJ9S7d+9rzh88eFD33HOPhgwZojfffFNeXl76999/5ebmZodqb87czUf0xlIjKD3dprpe7lKboASgyEgzWxRx7JxW7Tml1XtitS82Idv5ar6l1aGOvzrU8dedlcrIybF4rGRnC/QsAQDyjclkuqZnqW/fvnJ2dtY333xjv8JyIWtQeqZtdb3UmaAEoPBLTL6sjftPa9WeU1q795TOJqZknHN0MOmuyrepY11/ta/jr6q3l7Zjpddn72xAzxIAoMCYzWYtW7ZML730kjp37qwdO3aoatWqCgkJuWaoXmEw54/DGvezsWktQQlAYXfi/CWt2ROrlXtOKezgWaWkmTPOebo5qW1tP3Wo46c2tXxVppSLHSstOghLAIACc+rUKSUkJOi9997TO++8o4kTJ2r58uXq3bu31q5dqzZt2ti7xAyz/zisN68EpWfbVtdoghKAQsZstmjniTit2hOrVXtOaU90fLbzlcuWUvtAf3Wo46dmVX3kzPC6XCMsAQAKjNls/JWzZ8+eGaslNW7cWJs3b9bnn39eaMISQQlAYXUpJU2bDpzR6j2xWr33lE5fSM4452CS7qx0m9rXMQJSDT8P/t11iwhLAIACc/vtt8vJyUl169bNdrxOnTratGmTnarK7qtNh/XWL0ZQCr6vul7sRFACYF+x8UlafWVxhk0Hzij5cubwutIujmpdy1cd6vjrvkA/+ZRmeJ0tEZYAAAXGxcVFzZo1U2RkZLbj+/btU+XKle1UVaZZmw7r7StBafh9NfR/nWoRlADkaPr06Zo+fbqOHDkiSapXr55ef/11de3aVZKUlJSk//u//9OCBQuUnJyszp0767PPPpO/v/9172uxWPTvyXgjIO2N1T/H47Kdv6OMuzrU8VP7Ov5qXs1Hrk6O+fJ8ICwBAG6RxWLR1DUHtC7ylN7uVV+VvRx14MCBjPOHDx9WRESEfHx8VKlSJY0ePVqPPPKIWrdurfvuu0/Lly/Xzz//rHXr1tnvIURQApB7FSpU0HvvvaeaNWvKYrFo7ty56tmzp3bs2KF69epp5MiRWrZsmRYuXChvb28NHz5cvXv31h9//HHNvZJS07Tl0FljeN2eU4qOS8p2vnHFMhkBKTDAk38/FRCWDgcA5JnFYtG7v+7RzI2HJUne7s56rk6Khj7S45q2AwcO1Jw5cyRJX331lSZMmKDjx4+rdu3aevPNN9WzZ8+CLD2bLzce0jvL9kiSnmtXQ6M6EpQA5I2Pj48++OADPfTQQ/L19dX8+fP10EMPSZL27t2rOnXqaMuWLWrRooXOJCRrzd5TWrXbGF53MSUt4z7uzo66p+bt6lDHT/cF+snPs/DuRZef7J0NCEsAgDy5OihVKVtKR85elKerk2YPbqa7qvjYucKbkzUoPd+uhkYSlADkQVpamhYuXKiBAwdqx44diomJUfv27XXu3DmVKVNGkvHvzQoVK6vFA4/LXL+bIo6dV9bfxAO83NSujp861vFXUPWycnNmeJ29swHD8AAAuXZ1UHq7V3092OQODZmzTVsP/6cBX/2pWQObKah6WTtXen0EJQC3aufOnQoKClJSUpI8PDwUGhqqunXrKiIiQi4uLirl4aWN+09r9Z5TWrUnVmfMblr1V6Ru82opSap/h5c61PFXhzr+qlfei38HFTKEJQBArlgsFk34bW+2oPR4C2NxhjmD79awb7Zr4/4zGjT7T80ccJda1/K1Z7k5mrnhkMb/eiUota+pkR1q8ksKgFyrXbu2IiIiFBcXpx9//FEDBw7U0t9Wadvhs7pstujOt1cqIflyRnuTTKrkU0pjHqyv9oH+CvAumcPrigp2pgIA3LT0oDRjwyFJ2YOSJLm7OGrmgLt0X21fJV8268m527V6T6y9ys3RjA0HM4LSC+1rMkcJQJ65uLioevXq8q5YW1W6PCmHslXUeegYzd91QebLqYqPO6/bPVz1yF0VNePxpvJzTtITHZuof/PKBKUigJ4lAMBNsVgsei9rUOpZL1tQSufm7KgvHr9Lz333l1b8G6un54Vrar8m6lK/XEGXbNWMDQf17q97JRlBaWTHWnauCEBRlJpm1vYj57RqT6xW74nVkbMXJUlxl1Lk5Jyq+g0ba/2Pznq+TrJGDW0vBweTIiMjdSwqSkFBQXauHjeLBR4AADeUHpS+yBqUgqpc95rUNLNGfh+hX/6JlqODSZMfaawHGpUvgGpz9sX6g5rwG0EJQN5FxlzQnM2HteyfaB1d8aXcq90lJy9fOVxOkteJrdq9/BvN+/EnPdq7h5555hn9+uuvmjNnjry8vPTcc89JkjZv3mznpyg67J0N6FkCAFzX1UHprZsISpLk7Oigj/s2kYuTgxb/dUIjFuxQymWzHmpaIZ8rtu7z9Qf13pWgNKJDTY3oQFACcHPSzBat2XtKs/84rM0Hz2Ycd0q5oEsrP9bF82dVpoy3ajVsqMkrVqhjx46SpMmTJ8vBwUF9+vTJtiktig56lgAAObJYLHpv+V59sT4zKA24iaCUldls0SuhO7Vg2zGZTNL4Xg30aPNK+VBtzghKAPLiQlKqfth+XHM3H1HUf8YwOweT1KV+gB5vUUV3V/WRowPzHfOTvbMBPUsAAKtsEZQkycHBpHcfbCBXJwfN3XJUr4TuVMrlNA1qVdXGFVs3fd1BTVxuBKWRHWrphQ41C+RzARRdR84kas7mI1q4/ZgSr2wU6+3urL53V9SAoCq6o4y7nStEQSEsAQCuYbFYNHF55C0HpXQODiaNe6CeXJ0dNWPDIY37ebeSL5v1VJvqNqrYus/WHdD7yyMlEZQAXJ/FYtEfB85q9h+HtSbyVMZmsTX8PDS4VRU92OQOlXLhV+eShv/FAQDZpAelz9cflHTrQSmdyWRSSNdAuTo5aOqaA5rw214lXzbr+fb5E2CyBqVRHWvl2+cAKNoupaQpdMcJzdl8WPtiEzKOtwv00+BWVXRPjdvZWqAEIywBADLkV1BKZzKZ9H+dasvF0UEfrdynSSv3KeWyWf/Xybb7HE1be0AfrDCC0v91rKXnCEoArnLy/CV9veWoFmyL0vmLqZKk0i6OeqhpBQ1sWUXVfD3sXCEKA8ISAECSEZTeX5EZlN58wLZBKavn2teUq7OD3v11rz5de0DJl9P0Src6NglMBCUAObFYLAo/ek6z/zii5f/GKM1sjLWr6OOugUFV9HCzivJyc7ZzlShMCEsAgIygNH1dZlAa2LJKvn7msNbV5erkqDeW/quZGw8r+bJZ43rUk8MtrCyVNSi92KmWhrcjKAGQki+nadk/0Zr9xxHtPBGXcTyoWlkNblVF7ev4s6odrGLpcAAo4SwWiz5YEanPCjAoZTV/a5ReXbJTFovUt1lFvftggxsGpg0bNuiDDz5QeHi4oqOjFRoaquNe9fTh7/skSUcn3m/1uvfff1+jR4+2+TMAKJxOX0jWt1uPal5YlM4kJEuSXJwc9GDjOzSoVRXVKcfvmoWdvbOBQ4F/IgCg0Lg6KI3rUbdAg5IkPdq8kj54qJEcTNKCbcf04sK/dTnNfN1rEhMT1ahRI02bNk2StOyfkxlBaXTn2oqOjs72+uqrr2QymdSnT598fx4At2769Olq2LChvLy85OXlpaCgIP32228Z52fMmKG2bdvKy8tLJpNJ58+fz3b9rhNxGvVDhFq9t0ZTVu3XmYRk+Xu5anTn2goLaa+JDzUkKOGm0LMEACWUtaBUUHsfWbP075Ma+X2E0swW3d+wnCY/0ljOjjf+m57JZJLvg6+qVK0gje5cW8H31bimTa9evXThwgWtXr06P0oHYGM///yzHB0dVbNmTVksFs2dO1cffPCBduzYoXr16mnKlClKSkqSJIWEhOjcuXPy8PTSyt2xmv3HEf155L+MezWpVEaDW1VV1/oBN/XvFBQu9s4GzFkCgBLIYrHow98zg9Ibdg5KkvRAo/JycXTQc9/9pV/+iVbKZbOmPtpErk6OOV7zyer9Gd+/1KW2nm17bVCKjY3VsmXLNHfu3HypG4Dt9ejRI9v78ePHa/r06QoLC1O9evU0YsQISdK6deskSbM3HdaPu87pxPlLkiQnB5O6Nyynwa2qqnHFMgVYOYob4jUAlDDpQWna2sygNNjOQSldl/oB+uLxpnJxctDvu2P19DfhSkpNs9r241X7NWmlMfTuwTvvsBqUJGnu3Lny9PRU7969861uAPknLS1NCxYsUGJiooKCgjKOHzh1QV9uNDbOnrxqn06cvySf0i56rl0N/TGmnT7u24SghFtGzxIAlCCFOSilaxfor1kD79LQr7drbeRpPTl3u2YMaKpSLpn/yfp41X5NXrUv433X+uVyvN9XX32l/v37y83NLV/rBmBbO3fuVFBQkJKSkuTh4aHQ0FAFBtbR2r2n9NUfh7Vx/xklRcVKkmr6e+ipDg31QOPycnPOuTcayC16lgCghLBYLPro930ZQen1+wtfUEp3b01fzRl8t0q5OGrTgTMaNHubEpIvS5KmrNqXEZTGdA287n02btyoyMhIPfnkk/leMwDbql27tiIiIrR161YNGfqU+vZ/XEEvz9XgOdu0cf8ZmUzSXZV9JEk/Pt1SDzerSFCCzRGWAKAESA9Kn649IMkISk/cUziDUroW1crqmyF3y9PVSX8e/k+Pz9qq95fv1ZRVxjylMV0D9XSb6te9x6xZs9S0aVM1atSoIEoGYEMuLi5yua28fo121++l2inVu6J2r/xenm5OevKeqtow+j692Lm2JNlkQ2vAGsISABRzFotFk1YWraCUrmllH307tLm83Z21I+p8xoIUI9tUVAvvC4qIiJAkHT58WBEREYqKisq4Nj4+XgsXLqRXCShiLBaLNh88o6Ffb1ebD9dq1qbDupB8WW5ODmp8R2mFhbTXa/fXVUWfUvYuteCdOCE99phUtqzk7i41aCBt355z+0GDJJPp2le9epltqlSx3iY4OL+fpkhgzhIAFGPpQWnqGiMojS1CQSldwwplNH9ocz0+60/9l5iikK6Bqm05piZN7stoM2rUKEnSwIEDNWfOHEnSggULZLFY1K9fP3uUDSCXLqeZtXjHCX216bC2fD9V7tXukpOXr5qUc5Pn8TAtOBSh16dPVGlXJ8XExCgmJkYHDhj/btu5c6c8PT1VqVIl+fj42PlJ8sm5c1KrVtJ990m//Sb5+kr790u33ZbzNR9/LL33Xub7y5elRo2k//0v89i2bVJaloV0du2SOnbM3qYEY58lACimrAWlIUUsKGV1JiFZMXFJqn+Ht71LAWBjG/ad1tu/7Nb+UwmSpPPLP5FO7tLFuDMq4+2thg0b6uWXX1bHjh0lSePGjdObb755zX1mz56tQYMGFWTpBWfMGOmPP6SNG/N+jyVLpN69pcOHpcqVrbcZMUL65RcjiBWC4Y32zgaEJQAohiwWiyav3KdPrgSl17rX0ZP3VrNzVQCQ3cHTCXp32R6t3ntKknRbKWc93aa6+jarJO9SznaurpCpW1fq3Fk6flxav1664w7p2WeloUNv/h49ekjJydLvv1s/n5IilS8vjRolvfKKbeq+RfbOBgzDA4BihqAEoLCLu5iqT9bs19zNR3TZbJGTg0kDW1bR8+1qEpJycuiQNH16ZpDZtk16/nnJxUUaOPDG1588aQzfmz8/5zZLlkjnzxtznSCJsAQAxYrFYtHkVfsJSgAKpctpZn237Zgm/R6pcxdTJUntAv30avc6qu7rYefqCjmzWbrrLundd433TZoY84s+//zmwtLcuVKZMlKvXjm3mTVL6trV6F2CJMISABQbGUFptbG0NkEJQGGyaf8Zvf3LbkXGXpAk1fTz0Gv311WbWr52rqyIKFfOGIqXVZ060qJFN77WYpG++kp6/HGjJ8qao0elVaukxYtvvdZihLAEAMUEQQlAYXT4TKLGL9utVXuMeUllSjlrVMdaevTuSnJyZBebm9aqlRQZmf3Yvn05L9SQ1fr10oED0pAhObeZPVvy85O6d7+1OosZwhIAFAOTV+4jKAEoVOIupWrq6v2au+WIUtOMeUmPB1XWC+1rqkypHHo3kLORI6WWLY1heA8/LP35pzRjhvFKFxJi7MX09dfZr501S2reXKpf3/q9zWYjLA0cKDkRD7LipwEARdzklfv08ZWg9Go3ghIA+7qcZtaCbcc0aeU+/ZeYIkm6r7avXu1eVzX8mJeUZ82aSaGhRiB66y2palVpyhSpf//MNtHRUpbNuSVJcXHGUL2PP8753qtWGdc98US+lF6UsXQ4AFizYYP0wQdSeLjxH5/Q0Gsnxe7ZI738sjG84fJlYyz5okVSpUrW75maKk2YYEyyPXFCql1bmjhR6tIls824cdLVe4fUri3t3Wv1llcHpaGtCUoA7OePA8a8pL0xxrykGn4eeq17HbWt7WfnylBU2Tsb0LMEANYkJhq7nD/xhLGB39UOHpTuuccY//3mm5KXl/Tvv5KbW873fO01ad48aeZMKTBQWrFCevBBafNmY1WjdPXqGX/lS5fDkIisQemVboEEJQB2Y8xL2qNVe2IlSd7uzhrZoab6t6gsZ+YloQgjLAGANV27Gq+cvPqq1K2b9P77mceqV7/+Pb/5JvM6SXrmGSMUffSREaLSOTlJAQHXvdWUVdmD0rDWN/hsAMgH8Ump+nTNAc3+47BS0yxydDDp8RaVNaID85JQPBD1ASC3zGZp2TKpVi1jN3U/P2Pi7JIl178uOfnanid3d2nTpuzH9u839rioVs0Yi37V+PMpq/ZpyiqCEgD7STNbNH9rlO77YJ1mbDik1DSL2tTy1YoR92rcA/UISig2CEsAkFunTkkJCdJ77xnzjX7/3RhO17u3MX8pJ507S5MmGWHIbJZWrjT2s4iOzmzTvLk0Z460fLmxU/vhw9K990oXjPH/WYNSSFeCEoCCt/nAGXX/ZKNeCd2ps4kpqu5bWrMHN9PcJ+5WDT9Pe5cH2BTD8AAgt8xm42vPnsZSrpLUuLEx9+jzz6U2baxf9/HH0tChxnwlk8kYtjd4sLFRYLqsQ/8aNjTCU+XK0g8/6OPKrbMFpafaEJQAFJyjZ415Sb/vNuYlebk5aWTHWnqMeUkoxvgnGwBy6/bbjXlF1nZSv3rJ1qx8fY2heomJxk7pe/dKHh7GcLuclCkj1aqlbav+1ORV+yQRlADcmunTp6thw4by8vKSl5eXgoKC9Ntvv0mS/vvvPz333HOqXbu23N3dValSJT397HC9sfBPdZy0Qb/vjpWjg0kDgypr/ej7NLhVVYISijX+6QaA3HJxMfa7yOtO6m5u0h13GMuNL1pk9FDlJCFBSZH7tey08XYMQQnALapQoYLee+89hYeHa/v27WrXrp169uypf//9VydPntTJkyf14Ycf6u9/dmrAmIma88MSffjaSKWkmXVvzdv12wv36s2e9XVb6SI6L2ncOKN3P+srMDDn9osXS3fdZfzxqnRpYyTBN99c227PHumBByRvb6Nds2bX/wMaigSG4QGANQkJ0oEDme8PH5YiIiQfH2MfpdGjpUcekVq3lu67z5hj9PPP0rp1mdcMGGCEogkTjPdbtxr7KzVubHwdN84Y0vfSS5nXvPii1KOHEbpOnlTUc6NV+rJFS+u20ZiugXqaoATgFvXo0SPb+/Hjx2v69OkKCwvTkCFDtGjRIm05eFYv/LJbe6K95HnP4zr7y0ea+VhjdahXXiaTyU6V29BNbtEgyfj3/quvGoHKxUX65RdjCLWfnzEXVcrbdhIoEghLAGDN9u1GCEo3apTxdeBAYwGGBx805idNmCA9/7yxceyiRcZ/LNNFRUkOWTrwk5KMvZYOHTKG33XrZvx1skyZzDbHj0v9+klnzyrB6zb9fXstffD4RxrauzlBCYDNpaWlaeHChUpMTFRQUJCizl7Uu7/u0fJ/YyQZ85La1PbWr394q2P9O+xcrQ3dxBYNGdq2zf7+hReMzcU3bcoMS3nZTgJFgslisVjsXURW9t6lFwAKg6mr9+ujlcYcpZe7BOqZtvxHF4Dt7Ny5U0FBQUpKSpKHh4e+nPO19rvW1OxNR5SSZpaDSerfvLIGNPFRh9ZBeuyxxzR+/Hh7l20b48ZJH3xgDJdzc5OCgow/fFWqdONrLRZpzRpjuN2SJVLHjsYIAW9vY5TApk3Sjh1S1apSSIjUq1c+P0zxZ+9sQFgCgEKGoAQgv6WkpCgqKkr/nTuvd6fN1rKF38q33wS53F5J99a8Xa91r6typSzq2LGjfHx8tHTpUjk7O9u7bNv47TdjqHXt2sbWDW++aQyN3rVL8sxh6fO4OGNYdXKy5OgoffaZ9MQTxrmYGKlcOalUKemddzKHZr/yirR2bc4rpOKm2DsbMAwPAAqRT9dkBqWXutQmKAHIFy4uLjrjcJve2hyt3QHd5OT7h7TrV3351ZdqX8dPCQkJ6ty5izw9PRUaGlp8gpJ03S0aNGSI9Ws8PY15qwkJ0urVxtDsatWMIXp53U4CRQJhCQAKiU/X7NeHv2cGpWfb1rBzRQCKo2P/GfOSfttlzEvydHOSm4+77q7low51/RUfH6/OnTvL1dVVS5culVtxX6TgyhYN2Rb1uZqDg1Tjyr+TGzc2Vr6bMMEIS9fbTmLTpnwqGgWFpcMBoBAgKAHIb4nJlzVx+V41un+QQn9bpbS4WHUql6T2F1ZpX8RWPf74Y4qPj1enTp2UmJioWbNmKT4+XjExMYqJiVFaWpq9HyF/JCQYq9mVK3fz15jNxpA86da3k0ChRs8SANjZtLUHMoLS6M4EJQC2t/N4nJ777i8dOXtRKQnnlbJiilIu/Kcl3t5q2LChVqxYoY4dO2rdunXaunWrJKlGjez/Ljp8+LCqVKlih+pt7KotGvTGG8Y8pH79jPNXb/swYYKxz1L16kZA+vVXYyXT6dMz73kz20mgSCIsAYAdTVt7QB+sMP4aObpzbQXfR1ACYDsWi0WzNh3WxOV7lZpmUXlvN81c8I061PGzul9S27ZtVcjW/rK9LFs0yNfX2PIhLMz4Xrp224fEROnZZ43r3N2N/ZbmzTPCUbqb2U4CRRKr4QGAnRCUAOSnswnJGv3jP1qz95QkqXM9f03s01BlSrnYuTLg5tk7G9CzBAB2QFACkJ+2HDyrEd/vUGx8slycHDS2ex091qKy1d4kADkjLAFAASMoAcgvl9PM+mT1fk1de0AWi1Tdt7Sm9rtTdcszWgfIC8ISABSgz9ZlBqUXO9UiKAGwmRPnL2nEgh3aduScJOnhuypo3AP1VMqFX/eAvMrV0uHTp09Xw4YN5eXlJS8vLwUFBem3337LOJ+UlKTg4GCVLVtWHh4e6tOnj2JjY21eNAAURZ+tO6D3l2cGpeHtatq5IgDFxYp/Y9Tt443aduScPFyd9HHfxnr/oUYEJeAW5SosVahQQe+9957Cw8O1fft2tWvXTj179tS///4rSRo5cqR+/vlnLVy4UOvXr9fJkyfVu3fvfCkcAIoSghKA/JCUmqY3ftqlp74JV9ylVDWs4K1lz9+jno3vsHdpQLFwy6vh+fj46IMPPtBDDz0kX19fzZ8/Xw899JAkae/evapTp462bNmiFi1a3NT97L3iBQDY2vR1BzVx+V5J0v91rKXn2hOUANy6A6cS9Nx3O7QnOl6SNPTeqhrdOVAuTrn6WzhQqNk7G+S5bzYtLU0LFy5UYmKigoKCFB4ertTUVHXo0CGjTWBgoCpVqnTdsJScnKzk9B2QZfxAAKC4ICgBsDWLxaIfw4/r9Z/+1aXUNJUt7aIPH26k+2r72bs0oNjJdVjauXOngoKClJSUJA8PD4WGhqpu3bqKiIiQi4uLypQpk629v7+/YmJicrzfhAkT9Oabb+a6cAAo7D5fnxmURhGUANjAhaRUvbZkl36KOClJalm9rKY80lh+Xm52rgwonnLdT1u7dm1FRERo69ateuaZZzRw4EDt3r07zwWEhIQoLi4u43Xs2LE83wsACovP1x/Ue79lBqXnCUoAbtE/x8/r/qmb9FPESTk6mDS6c219M6R54QxK48ZJJlP2V2Bgzu0XL5buuksqU0YqXVpq3Fj65pvsbWJjpUGDpPLlpVKlpC5dpP378+8ZAOUhLLm4uKhGjRpq2rSpJkyYoEaNGunjjz9WQECAUlJSdP78+WztY2NjFRAQkOP9XF1dM1bXS38BQFFGUAKKthut/itJW7ZsUbt27VS6dGl5eXmpdevWunTpUr7UYzZb9OXGQ+ozfbOOnr2oO8q46/thLRR8Xw05OhTiTWbr1ZOiozNfmzbl3NbHR3r1VWnLFumff6TBg43XihXGeYtF6tVLOnRI+uknaccOqXJlqUMHKTGxQB4HJdMtrydpNpuVnJyspk2bytnZWatXr1afPn0kSZGRkYqKilJQUNAtFwoARcEXWYLSyA4EJaAoSl/9t2bNmrJYLJo7d6569uypHTt2qF69etqyZYu6dOmikJAQTZ06VU5OTvr777/l4GD7hRXOJiTrxYV/a23kaUlSl3oBmtinobxLOdv8s2zOyUm6zh/Ms2nbNvv7F16Q5s41AlbnzkYPUliYtGuXEcIkafp04/7ffSc9+aRNSwfS5SoshYSEqGvXrqpUqZIuXLig+fPna926dVqxYoW8vb01ZMgQjRo1Sj4+PvLy8tJzzz2noKCgm14JDwCKsi/WH9SELEHphQ4EJaAo6tGjR7b348eP1/Tp0xUWFqZ69epp5MiRev755zVmzJiMNrVr17Z5HZsPntGIBRE6dSFZLk4OGnt/XT3WvJJMpkLcm5TV/v3GkDk3NykoSJowQapU6cbXWSzSmjVSZKQ0caJxLH0xMLcsQw4dHCRXVyNQEZaQT3L1J5BTp05pwIABql27ttq3b69t27ZpxYoV6tixoyRp8uTJuv/++9WnTx+1bt1aAQEBWrx4cb4UDgCFCUEJKJ7S0tK0YMGCjNV/T506pa1bt2rWrFlydHSUg4ODvLy89OGHH15zrcViUdeuXWUymbRkyZKb/szLaWZN+j1S/b/cqlMXklXDz0M/BbfS4y0qF52g1Ly5NGeOtHy50QN0+LB0773ShQs5XxMXJ3l4SC4uUvfu0tSp0pXfMRUYaAStkBDp3DkpJcUIUsePG0P8gHySq56lWbNmXfe8m5ubpk2bpmnTpt1SUQBQlMzYkBmURnSoSVACioGcVv8NCwuTJCUkJGj8+PEKDAzUu+++q9GjR6tu3brq1q1bxj2mTJmS63Bz4vwljViwQ9uOnJMkPXJXRb3xQF2VcrnlmRMFq2vXzO8bNjTCU+XK0g8/SEOGWL/G01OKiJASEqTVq6VRo6Rq1Ywhes7OxiIQQ4YY85scHY35Sl27Gj1RQD4pYv/PA4DCZcaGg3r318ygNKJDLTtXBMAW0lf/jYuL048//qiBAwdq/fr1MpvNkqThw4dnDMPr1auXnJyc9Omnn2aEpYiICH300Ufavn27ypUrd1OfueLfGL304z+Ku5QqD1cnvdu7gR5oVD5/HrCglSkj1aolHTiQcxsHB6lGDeP7xo2lPXuMoXvp85maNjXCVFyc0bPk62uEsLvuyt/aUaIRlgAgj2ZuOERQAoqp9NV/Jalp06batm2bnnrqKZ0+bSy0MHnyZK1du1avvvqqEhISZLFYtHXr1mt6ksaNG3fDz0pKTdO7v+7R11uOSpIaVfDWJ/2aqHLZ0rZ9KHtKSJAOHpQef/zmrzGbM+cqZeXtbXzdv1/avl16+23b1AhYQVgCgDyYueGQxv+6R5L0QnuCElDUWSwWHT17UZXLlrI6dM5sNsvFxUUfffSRnnjiCbVt21ahoaHq0aOHPDw8VKVKFaWmpqpPnz66dOmS0tLSNGnSJJUqVUpffPFFjp974FSChs//S3tjjLk8T7Wupv/rVFsuTrZfWa9Avfii1KOHMfTu5EnpjTeMoXP9+hnnBwyQ7rjD6DmSjK933SVVr24EpF9/NfZZmj49854LFxq9SZUqSTt3Givm9eoldepU4I+HkoOwBAC5dHVQGtmRoAQUZZfTzBr5w9/6+e+T6t6gnEr/84Pu797N6uq/HTt2VEhIiN544w199NFHeuWVV+Tv76+DBw+qQYMGiomJ0Z49e7Rjxw55eHjk+JkWi0ULw4/rjZ/+1aXUNJUt7aKPHm6ktrX9CvDJ89Hx40YwOnvWCDj33GMs/e3ra5yPijKG3aVLTJSefda4zt3dWNBh3jzpkUcy20RHG/OYYmOlcuWMwDV2bME+F0ock8VSuGbFxcfHy9vbW3FxcWxQC6DQ+XLjIb2zjKAEFBeX08wa8X2Efvknc0U197CZunQkQtHR0fL29lbDhg318ssvZ6z+K0nvvvuuPvroI/33339q3LixHB0ddfLkSZ0/fz5jc1qTySSTySSz2SwHBwfde++9WrdunS4kpeq1Jbv0U8RJSVKrGmU1+eHG8vNyE4Ds7J0N6FkCgJtEUAKKl6xBydnRpCfvraYvNx7SpRZD1X1oOU3p21jOjtmHw129St6yZcvUrVs3tWvXTi4uLgoMDNTq1asVExOj1NRUeXh4KD4+XpMnT1aPHj300GODtOy335Ucf1YmZzfVa9JMrwyYSlACCinCEgDchKxB6XmCElDkXR2UPuvfVB3r+uuuyrfp6XnhWrbT6GnKGpiO/XdRkUke6vdof93d7C7t2LFDjz32mPr06ZMxTC8pKUkPPfSQatasqc2bN2vQoEGSjGF3q49btOE/T3l3eUF3VKioUa3L6fsvJqtrl846fPiwHB0d7fXjAJADhuEBwA1cE5Q61Cw6G0MCuEbWOUpZg1K61Xti9fS8cKWmWdS9gdHDtD82Qf2/DNO5i6ly2zJDSUf/VnR0tCwWi3x9fTVnzpxsw/QkKTExMWPeUu37HlLS3YMkSV3rB+i93g3lXcpZ//zzjxo1aqQDBw6oevXqBfYzAIoKe2cDepYA4DoISkDxcqOgJEnt6/jr88ea6pl5f2nZzmglplzW38fO69zFVElSUtAwdXkyQFMfbaLOHTuoUqVK1wQlSQoPDze+cXBSfLV28nBy0Ov311X/5pVkMpmUmJio2bNnq2rVqqpYsWK+PzuA3Cvi61ICQP7JFpTa1SAoAUXc1UFp2qN3XhOU0rWv46/pj90pF0cHrYs8rXMXU+X81wI9VStZpguntXRdmO7uNUTr1q1T//79dfDgQb399tsKDw/X8uXL5ebmpjZt2kgmB/n1flV169bV0uGt9FiLypo+fbo8PDzk4eGh3377TStXrpSLi0sB/zQA3AyG4QGAFbM2Hdbbv+yWdCUodaxFUAKKMGtBqVO9gBtet2ZvrJ6bv0N1ynnJPWymNq5fq5Mno2V2dpezbxW1f2SoQt99RjEnT+ixxx7Trl27lJCYKKfSt8lUrq4c3D11ed8GbdywTk0bNZQkxcXF6dSpU4qOjtaHH36oEydO6I8//pCbG4s8AFezdzYgLAHAVbIGpefa1dAoghJQpF1OM2vUD39raS6DUrpLKWlyc3bI9u+BtXtP6alvwpWSZlaXesaQPGdHBy3fFaOXF/2juEup8nR10ru9G+jj/xug6tWrW92cNiUlRbfddpu+/PJL9UvfsBVABntnA+YsAUAWBCWgeMkalJwcch+UJMnd5dpV6u4L9NMXA5rqqa/DtfzfGD03f4f8vFz19ZajkqRGFctoat8mqlS2lCabzUpOTrZ6b4vFIovFkuN5APbFnCUAuOIrghJQrFwdlD7rn/ugdD331TYCk4ujg5b/G6OvtxzVufVz1MnnP33QuZziTh5USEhIxrymQ4cOacKECQoPD1dUVJQ2b96s//3vf3J3d1e3bt1sVhcA2yEsAYCMoPTWlaA0/D6CElDUXU4z6/8W5l9QSpcemFydHFS2tIvuucNFv382Vg3q1VH79u21bds2rVixQh07dpSbm5s2btyobt26qUaNGnrkkUfk6empzZs3y8/Pz+a1Abh1zFkCUOLN/uOw3vw5Myj9XyeCElCUpQelnyKuDL3rf6c650NQyupsQrJKuThZHbIHIO/snQ2YswSgRCMoAcWLPYKSJJX1cM33zwBQ8BiGB6DEyhqUgu+rTlACijh7BSUAxRdhCUCJNOeqoPRip9oEJaAISzNbCEoAbI6wBKDEmfPHYY27EpSebUtQAoq6NLNFo36IyAhKnz5aQoLSuHGSyZT9FRiYc/vUVOmtt6Tq1SU3N6lRI2n58mvbnTghPfaYVLas5O4uNWggbd+eb48BFGbMWQJQoszdfCRbUBrdmaAEFGXWglKX+iUgKKWrV09atSrzvdN1frV77TVp3jxp5kwjVK1YIT34oLR5s9SkidHm3DmpVSvpvvuk336TfH2l/ful227L3+cACinCEoASY+7mI3pj6b+SCEpAcZBmtuj/SnJQkoxwFHCTz/zNN9Krr0rpezo984wRtD76yAhRkjRxolSxojR7duZ1VavatmagCGEYHoASIWtQeoagBBR56UFpSUZQalLygpJk9PqULy9Vqyb17y9FReXcNjnZGH6Xlbu7tGlT5vulS6W77pL+9z/Jz8/ocZo5M39qB4oAwhKAYu/rLdmD0ksEJaBIsx6Uytm7rILXvLk0Z44x72j6dOnwYenee6ULF6y379xZmjTJCFhms7RypbR4sRQdndnm0CHjXjVrGsP0nnlGev55ae7cAnkkoLBhU1oAxdrXW47o9Z8ISkBxQVC6jvPnpcqVjUA0ZMi150+floYOlX7+2VgMonp1qUMH6auvpEuXjDYuLkbP0ubNmdc9/7y0bZu0ZUuBPAaQlb2zAT1LAIqtrEHp6TYEJaCoSzNb9OLCvzOC0tR+BKVsypSRatWSDhywft7XV1qyREpMlI4elfbulTw8jCF86cqVk+rWzX5dnTrXH94HFGOEJQDF0tVB6eUuBCWgKEsPSqE7TmQEpa4NCErZJCRIBw8aged63NykO+6QLl+WFi2SevbMPNeqlRQZmb39vn1GjxVQAhGWABQ732QJSk+1qUZQAoq4rEHJkaCU6cUXpfXrpSNHjGFzDz4oOTpK/foZ5wcMkEJCMttv3WrMUTp0SNq4UerSxZi79NJLmW1GjpTCwqR33zV6qObPl2bMkIKDC/TRgMKCpcMBFCvfbDmisVmC0pgugQQloAhLM1s0OktQ+pSglOn4cSMYnT1rDLG75x4j6Pj6GuejoiSHLH8XT0oy9lo6dMgYftetm7GceJkymW2aNZNCQ42Q9dZbxrLhU6YYK+0BJRALPAAokjZs2KAPPvhA4eHhio6OVmhoqC74N84ISmXDv9Rfq5Zku6Zz585abm23egCFUnpQWkxQAkose2cDepYAFEmJiYlq1KiRnnjiCfXu3VvrIk9pSdiVHqXW1RQZ4y2/Ll00O8vGiq6urvYqF0AuEZQAFAaEJQBFUteuXdW1a9eM9/O3RqlUrTv0VOtqGtM1UIN/MMJRwM3ubA+g0CAoASgsWOABQJE2L+xoxvfpQSl9jtK6devk5+en2rVr65lnntHZs2ftVSaAm5Rmtmj0j5lBicUcANgTPUsAiqx5YUf12pJdkqRO9fyzBaUuXbqod+/eqlq1qg4ePKhXXnlFXbt21ZYtW+To6GjPsgHkICMo/ZUZlLoRlADYEWEJQJGUNShJUp87K2Rb9a5v374Z3zdo0EANGzZU9erVtW7dOrVv375AawVwYwQlAIURw/AAFDnfbs0MSkPvrSpJN1wevFq1arr99tt1IKed7QHYTZrZopd+/CcjKH3Sl6AEoHAgLAEoUr7delSvhmYGpVe61bmp644fP66zZ8+q3I12tgdQoNKD0qK/jmcEpe4N+f8pgMKBsASgyJi/NSojKA24y0/dyifr77//liQdPnxYERERioqKUkJCgkaPHq2wsDAdOXJEq1evVs+ePVWjRg117tzZno8AIAuCEoDCjjlLAIqElMtmvfmzsY9S53r+uq/sBd15Z7uM86NGjZIkDRw4UNOnT9c///yjuXPn6vz58ypfvrw6deqkt99+m72WgELi6qD0cd/GBCUAhQ5hCUCR4OLkoO4Ny2nxXye0Zu8p/a9pU1kslhzbr1ixogCrA5AbaWaLXl6UPSjd37C8vcsCgGswDA9AkfF+n4bq3rCcUtMseubbcK3aHWvvkgDkUnpQ+jGcoASg8CMsASgynBwd9PEjjbMFptV7CExAUXF1UJryCEEJQOFGWAJQpGQEpgZGYHp6HoEJKArMZovGXBWUejQiKAEo3AhLAIocJ0cHYzL4lcD0zLy/CExAIWa+0qO0kKAEoIghLAEokpwcHTTlSmBKSTPrmXl/ac1eAhNQ2BCUABRlhCUARZbzlcDUrUGAUtLMevobAhNQmGQNSg4mEZQAFDmEJQBFmrOjgz7u2yRbYFq795S9ywJKpGnTpqlKlSpyc3NT8+bNNWDitxlB6eO+TQhKAIocwhKAIi89MHWtbwSmp74JJzABBez777/XqFGj9MYbb2j79nAleVbQd28+LcvF8wUblNLSpLFjpapVJXd3qXp16e23pevsy5bNH39ITk5S48a2vS+AIomwBKBYcHZ00Cf9CEyAvUyaNElDhw7VwIGDNHfPZZ1vOkgmZ1e1Mf1bsD1KEydK06dLn34q7dljvH//fWnq1Btfe/68NGCA1L69be8LoMgiLAEoNqwGpkgCE5DfUlJSFB4ernbt2mvM4vTFHBzUum07xR35t2CL2bxZ6tlT6t5dqlJFeughqVMn6c8/b3zt009Ljz4qBQXZ9r4AiizCEoBiJT0wdal3JTB9TWAC8tuZM2eUlpamRXsu6IftVxZz6NtEd9WpqpiYmIItpmVLafVqad8+4/3ff0ubNkldu17/utmzpUOHpDfesO19ARRphCUAxY6zo4OmPpolMH0TrnUEJiDfmM3GvJ01e0/JwSRNfqSxHrDXYg5jxkh9+0qBgZKzs9SkiTRihNS/f87X7N9vXDdvnjFfyVb3BVDkEZYAFEvpgalzPX+lXDZrGIEJyBdms0WTN0ZLJgeZL57X5Ecaq2fjOyRJsbGxCggIKNiCfvhB+vZbaf586a+/pLlzpQ8/NL5ak5ZmDL17802pVi3b3RdAsWCyWArXMi7x8fHy9vZWXFycvLy87F0OgCIuNc2s4fP/0op/Y+Xi5KAZjzdV29p+9i4LKBbMZotCFu/U99uPKebrUWrfuqWWLZh95ZxZlSpVUvfu3XXy5EmFh4crOjpaoaGh6tWrV/4VVbGi0QsUHJx57J13jF6jvXuvbX/+vHTbbZKjY9YHM1a5c3SUfv9datcu9/cFYBP2zgb0LAEo1pwdHTS1353ZepjW7ztt77KAIu9ymlnVXvlV328/JgeT9NwLI7R6yXeaO3eu9uzZo2eeeUaJiYlq06aNGjVqpGnTphVMYRcvSg5X/Xrj6GgEIGu8vKSdO6WIiMzX009LtWsb3zdvnrf7AigWchiYCwDFh4uTEZiGz/9Lv++O1dCvt2vmgLvUppavvUsDiqz2k9ZnfN/v7koa/2B3VS6dptdff10nTpyQm5ubLBaLRowYoZYtW+rxxx8vmMJ69JDGj5cqVZLq1ZN27JAmTZKeeCKzTUiIdOKE9PXXRgCqXz/7Pfz8JDe37Mdv5r4Aih16lgCUCC5ODvr00TvVqa7RwzT06+30MAG34KfgVhnfh+44oa2Hzmr48OE6evSoOnTooE8//VR//vmnVq5cqdTUVHXq1KlgCps61VjW+9lnpTp1pBdflJ56ythANl10tBQVZfv7Aih2mLMEoERJuWxW8Py/tHK3MYfpywF3qTU9TECeXEpJ07Bvtmvj/jMq5eKo2YOaqXm1ste0O336tPz8jLmC+T5nCUCxYu9sQM8SgBLFxclB0x69Ux2v9DA9+fV2baCHCcgTdxdHzRxwl+6tebsupqRp0Oxt2nro7DXt4uLi7FAdANw6whKAEufqwDSUwATkmZtzZmC6lHptYDKbzRoxYoRatWp1nbsAQOFEWAJQIqUHpg51/JV8JTBt3E9gAvLieoEpODhYu3bt0oIFC+xcJQDkHmEJQInl4uSgz/pnBqYn5xKYgLxKD0xB1crqUmqahn69XU8/G6yff/5Z06ZN05kzZyRJhw8fVkREhKJyu8ACANgBYQlAiZYZmPwyAtOm/WfsXRZQJJ08f0mHziTIYrEofs0X+vmnJXrvvfd0//33q0mTJpKkUaNGqUmTJqpRo4aCgoL022+/2blqAMgZYQlAiWcEpqYZgWnI3G0EJiCXYuKS1G9mmGLjk2Xe9KXO/bNG8+fPV4cOHRQdHa3o6GgtXLhQy5Yt0759+7Rr1y61a9dOPXv21L///mvv8gHAKsISAOjKHKYsPUy5CUwbNmxQjx49VL58eZlMJi1ZsiTHtk8//bRMJpOmTJlim8KBQmLr4bOKjU+WJB3f/JPi4+LUtm1blStXLuOVkJCgbt26qWbNmqpVq5bGjx8vDw8PhYWF2bl6ALCOsAQAV7g6OV4TmP44cOPAlJiYqEaNGmnatGnXbRcaGqqwsDCVL1/eViUDhUbnegEZe5YFvvabwg6ekcViyfYaNGhQRvu0tDQtWLBAiYmJCgoKslPVAHB9hCUAyCI9MLUPNALTE3NuHJi6du2qd955Rw8++GCObU6cOKHnnntO3377rZydnW1dNmB3bs6OmvF4U7Wu5Wt1CfF0O3fulIeHh1xdXfX0008rNDRUdevWtUPFAHBjhCUAuIqrk6M+eywzMN1sD1NOzGazHn/8cY0ePVr16tWzYaVA4WItMIVdFZhq166tiIgIbd26Vc8884wGDhyo3bt326liALg+whIAWJEemNoF+ikp1QhMm/MYmCZOnCgnJyc9//zzNq4SKHyuDkyDrwpMLi4uqlGjhpo2baoJEyaoUaP/b+/O42s88/+Pv0/2iAgJsiAEJWpJg1aDtjpNGVWli+JrlGqnm04t007plOqiKdNVa/jpKLrRdqZV1cWgRY19iaVqbeySUGQji5z798ctJ8JJSHJO7iRez8fjPPTc93Xf55PLqZPPua7rc8XonXfesTBiACgeyRIAFMPXy1PTLkiYhpUhYdq4caPeeecdzZ49WzabzU2RApXL5RKmC9ntduXk5FRwhABwZUiWAKAE5U2Yfv75Z6WmpioyMlJeXl7y8vLSgQMH9Ne//lVNmjRxX+CAxS5OmIbNXq+RT/9NK1as0P79+7Vt2zaNHTtWy5Yt06BBg6wOFwCcIlkCgMsoSJhubVmvMGHad2UJ0+DBg7V161YlJiY6HhEREXrmmWe0aNEiN0cOWMvP21NtG9SSJHl62HTyxHE98MADatmypW677TatX79eixYt0u23325xpADgnJfVAQBAVeDr5anpgzvosY826qddxzVs9np9MPR6dW5WV5mZmdq7d6+jbVJSkhITExUcHKzIyEiFhIQUuZe3t7fCwsLUsmXLiv4xgAq1at8J/XPZPknSa/e0U692PSyOCABKh5ElALhC5ghTB8cI01NzNyvfbmjDhg2KjY1VbGysJGn06NGKjY3V+PHjLY4YsM7JrFyN+ixRhiH179hIvdqFWx0SAJQayRKAymXCBMlmK/qIji6+fbdul7a32aRevQrbDB166fk//rFM4fl5mwmTzSadyMzVqTO56tat2yWbbxqGodmzZzu9x/79+zVy5MgyvT5QFRiGob/9e6tS0nPUtF6AXriLfZQAVE2lSpYSEhJ0/fXXKzAwUPXr11ffvn21a9euIm2ys7M1fPhwhYSEqGbNmrr33nuVkpLi0qABVHOtW0vHjhU+Vq4svu2XXxZtu3275Okp9etXtN0f/1i03dy5ZQ7Pz9tTwTV8JEnHM6jiBVzs4zUHtOTXFPl4eujdgbGq4cOsfwBVU6mSpeXLl2v48OFas2aNFi9erLy8PHXv3l1ZWVmONqNGjdI333yjL774QsuXL9fRo0d1zz33uDxwANWYl5cUFlb4qFu3+LbBwUXbLl4s1ahxabLk61u0XZ065QqxXqCvJJIl4GK7kjP0yre/SpKe7Rmt1hFBFkcEAGVXqq96fvjhhyLPZ8+erfr162vjxo26+eablZaWppkzZ+rTTz/VH/7wB0nSrFmz1KpVK61Zs0Y33nij6yIHUH3t2SNFREh+flJcnJSQIEVGXtm1M2dKAwZIAQFFjy9bJtWvbyZJf/iD9Mor0kWFF0qjXqCvdiZnKJVkCXDIzsvXX+ZuUs45u7q1rKdhXZpYHRIAlEu51iylpaVJkoKDgyWZmy/m5eUpPj7e0SY6OlqRkZFavXq103vk5OQoPT29yAPAVaxTJ2n2bOmHH6Rp06SkJOmmm6SMjMtfu26dOQ3v4YeLHv/jH6UPP5SWLpUmTZKWL5d69pTy88sc5sUjSytWrFDv3r0VEREhm82m+fPnF2k/YcIERUdHKyAgQHXq1FF8fLzWrl1b5tcHKqNXvt2h3SmZqlvTV6/3i2EjZgBVXpmTJbvdrpEjR6pLly5q06aNJCk5OVk+Pj6qXbt2kbahoaFKTk52ep+EhAQFBQU5Ho0aNSprSEDJEhKk66+XAgPNEYa+faWL1twpOVkaPNicphUQILVvL/3nP+W/74wZZiGCWrXM4gKnT7vu56puevY0p9C1ayf16CF9953ZX59/fvlrZ86U2raVbrih6PEBA6S77jLP9e0rLVworV9vjjaV0cXJUlZWlmJiYjR16lSn7Vu0aKH33ntP27Zt08qVK9WkSRN1795dx48fL3MMQGWy6JdkfbzmoCTpzftjVLemr8URAUD5lTlZGj58uLZv36558+aVK4CxY8cqLS3N8Th06FC57gcUa/lyafhwac0ac11LXp7Uvbt0wZo7PfCAmegsWCBt2ybdc490//3S5s3lu++ZM+boxnPPue/nq65q15ZatJAu2MfIqawsad486aGHLn/Ppk3NdVCXu2cJ6p3/RfB4ppks9ezZU6+88oruvvtup+3/7//+T/Hx8WratKlat26tN998U+np6dq6dWuZYwAqi2NpZ/Xsf8z38iM3N9XNLepZHBEAuEaZytM8+eSTWrhwoVasWKGGDRs6joeFhSk3N1enT58uMrqUkpKisLAwp/fy9fWVry/fPqECXLTmTrNnmyNBGzdKN99sHlu1ypz6VTAy8fzz0ltvmW3O76FTpvsWlIkux0jGVSszU9q3zxzxK8kXX0g5OdKf/nT5ex4+LP3+uxRe9n1f6tfykySlpmeX+trc3FzNmDFDQUFBiomJKXMMQGWQbzc06rNEnT6Tp7YNgvR0dzZbBlB9lGpkyTAMPfnkk/rqq6/0448/Kioqqsj5Dh06yNvbW0uXLnUc27Vrlw4ePKi4uDjXRAy4yvk1dzq/5k6S1Lmz9Nln0smTkt1ujlRkZ5tT6MpzX1y5p582R+v27zeT17vvNkuBDxxonn/gAWns2EuvmznTnGJ3cdGGzEzpmWfMkb/9+811S336SM2bm9P8yujikaUrsXDhQtWsWVN+fn566623tHjxYtUtqdIfUAVMW7ZXa347qRo+npoyMFY+XmzhCKD6KNXI0vDhw/Xpp5/q66+/VmBgoGMdUlBQkPz9/RUUFKSHHnpIo0ePVnBwsGrVqqW//OUviouLoxIeKhe73Rzt6dJFOr/mTpK5LqZ/f/MXbi8vswT1V1+Zv1iX5764cocPm4nR779L9epJXbuaiU6989N6Dh6UPC76ZWzXLnMvpv/+99L7eXpKW7dKc+aYa58iIsxpki+/bJYTL6OylA6/9dZblZiYqBMnTuj999/X/fffr7Vr16p+/fpljgOw0sYDp/TWkj2SpJf6tFFU3YDLXAEAVUupkqVp06ZJkrpd9C37rFmzNHToUEnSW2+9JQ8PD917773KyclRjx499M9//tMlwQIuM3y4WTXt4s1Ox40zf6FessRc0zJ/vrlm6eefzeIAZb0vrtzl1kE6m8rYsqVkGM7b+/tLixaVO6yL1a9lJksZ2eeUnZcvP2/Py14TEBCg5s2bq3nz5rrxxht1zTXXaObMmRrrbKQMqOTSs/M0Yt5m5dsN3RUToXvbN7A6JABwuVIlS0Zxv4xcwM/PT1OnTi22IhRguSefNKuhrVghXbDmTvv2Se+9ZyY7rVubx2JizERp6lRp+vSy3RfVUqCvl3y9PJRzzq7jGTlqFFyj1Pew2+3KyWGfJlQ9hmHo719t1+FTZ9Wwjr9eubsNZcIBVEtlKvAAVEmGIf3lL+a0umXLpIvW3OnMGfPPi6d4eXqa0+vKel9USzabTfUCfXX41FmlZuSojo9dey+orpeUlKTExEQFBwcrJCREEydO1F133aXw8HCdOHFCU6dO1ZEjR9SvXz8LfwqgbP698bC+2XJUnh42TRkYq1p+3laHBABuQbKEq8fw4dKnn0pff23uiVSw91dQkDlVKzraXJv06KPS66+b65bmzzfLgS9cWHif224ziw48+eSV3VcyjyUnF5aq3rbNbBsZSSGIKiov3y673RxtTz+bpw0btujWW291nB89erQkaciQIZo+fbp27typOXPm6MSJEwoJCdH111+vn3/+Wa0LRjGBKuK345l6YcEvkqTRt7dQ+8g6FkcEAO5DsoSrx/k1d5dUtps1Sxo6VPL2NjdAHTNG6t3brKLWvLlZGOCOOwrb79snnThx5feVzCl8L75YeK6gpPiFbVClzFm1X0fTslWnhrfaR9ZRUHS3Eqcqf/nllxUYHeAeuefsGjEvUWdy83Vj02A9dkszq0MCALeyGVeyEKkCpaenKygoSGlpaapVq5bV4QDAJVLSs3XbG8uVmXNOk+5tq/7XR1odElAhXv3uV81Y8Ztq1/DWDyNuVliQn9UhAajmrM4N2AwBAK7QihUr1Lt3bzVr3Ei/vPRHhZ7cqn4dGkmS8vLy9Oyzz6pt27YKCAhQRESEHnjgAR09etTiqAHXWLH7uGas+E2SNPnediRKAK4KJEsAcIWysrIUEtlCNW59RJL0f50i5eFhVgA7c+aMNm3apHHjxmnTpk368ssvtWvXLt11111Whgy4xInMHI3+fIskafCNjdW9dZjFEQFAxWDNEgBcofjuPfTWzhqqEZgpSWocUrgBZ1BQkBYvXlyk/XvvvacbbrhBBw8eVGQkU/VQNdnthp7+YotOZOaoZWig/t6rldUhAUCFYWQJAK7QnFX7tTslU8EBPlfUPi0tTTabTbVr13ZvYIAbzVq1X8t2HZevl4emDIy9og2YAaC6IFkCgCuQkp6ttxbvliSN+WP0ZdtnZ2fr2Wef1cCBAylWgypr+5E0Tfp+pyTp+V6t1DIs0OKIAKBikSwBwBWY+O2vysrNV2xkbd3XoWGJbfPy8nT//ffLMAxNKygtD1QxZ3LP6al5m5Wbb9ft14bqTzc2tjokAKhwJEtXqKAKVkREhGw2m+bPn1/kvGEYGj9+vMLDw+Xv76/4+Hjt2bPHmmABlOhy/z9/+eWX6t69u0JCQmSz2TT7m5+0YMtRedikl/u0cRR1cKYgUTpw4IAWL17MqBKqrBcX7NBvx7MUVstPk+9tJ5ut+Pc9AFRXJEtXKCsrSzExMZo6darT85MnT9aUKVM0ffp0rV27VgEBAerRo4eys7MrOFIAl3O5/5+zsrLUtWtXTZo0SZI0bdk+SdKfbmysNg2Cir1vQaK0Z88eLVmyRCEhIa4PHqgA3249ps82HJLNJr3ZP0Z1rnCdHgBUN1TDu0I9e/ZUz549nZ4zDENvv/22nn/+efXp00eS9OGHHyo0NFTz58/XgAEDKjJUAJdR0v/PkjR48GBJUlJSkiTp0MmzCm/qo0fjGigxMdHRLikpSYmJiQoODlZ4eLjuu+8+bdq0SQsXLlR+fr6Sk5MlScHBwfLx4ZdNVA2HT53RmC+3SpKe6NZMnZvVtTgiALAOI0sukJSUpOTkZMXHxzuOBQUFqVOnTlq9erWFkQEoiyOnz+rdpXs0YMYax7ExPaO1Z8cWxcbGKjY2VpI0evRoxcbGavz48Tpy5IgWLFigw4cP67rrrlN4eLjjsWrVKqt+FKBUzuXbNXJeojKyzyk2srZGxrewOiQAsBQjSy5Q8O1xaGhokeOhoaGOcwAqt+y8fC36JVlfbDis/+07IcOQzqWdlSTd276B7m3fUB4ejWQYRrH3KOkcUBVM+XGvNhw4pUBfL00ZECtvT75TBXB1I1kCcNUqSG4+Wn1A4zYvUUbOOce5uKYhuiUiWI9Plx66qWmJRR2A6mBd0km996NZmOiVu9uoUXANiyMCAOuRLLlAWFiYJCklJUXh4eGO4ykpKbruuussigpAcVLSs/XlpiP698ZDkqSf9xxXjRbN1bCOv+7r0FD3tm+oRsE1tH//fmsDBSpI2pk8jZy3WXZDurd9Q/W5roHVIQFApUCy5AJRUVEKCwvT0qVLHclRenq61q5dq8cff9za4FBtXTzl6+IZYBdPCHM2RezSNhefL/k1nMdV+ntcLlZnL3vJfS7zunZDWr3vd32x8ZBW7D4u+wWnb2wWojF/7qQbo0IYQcJVxzAMjflyq46mZatJSA292Ke11SEBQKVBslSCvamZevqLLUo7m6dzOWd19sQRFfxG9vTM/+qV5cfl5R8o3zqh8o/trTHjJmjWtrPyrROuA/+dJVtAsN7bV0dTJ/9Y5L5Of1m8zC+hZfnlsWy/pJbcwhW/6Dr/+S/z810mESjz617m57tcHGW5R1mSFriWPfesWvpnKv7aUI2RdGuEVCPjsA4fPqPIyEidPHlSBw8e1NGjRyVJu3btkmSOIheMJAPVxdx1h/T99mR5e9r07sD2qunLrwYAUMBmVLIVyenp6QoKClJaWprlmzlOX75Pr32/U5KUfXCrUuY+d0mbgDa3qW6vUTIMQ2krP1HGlh9kz86SX8NrFdz9CXkHM5UBqCzCg/x0T/sGapidpP/re8cl54cMGaLZs2dr9uzZevDBBy85/8ILL2jChAkVEClQMfakZKj3eyuVnWfXc3dE65Gbm1kdEgAUYXVuQLJUgn8u26vJP+xSt5b19OStzYucc76Rua3ENhdf4mw39EvbXHy+5NdwGlUZ7lHaa5yFcel9y3IPW4ltLhen8zgucw83/b1cpjvKdI/S9o+z17nkaWX9e7mCe1yufzxszv9+gatRdl6++k79n3YmZ+ima+pqzoM3MA0VQKVjdW7AWHsJCn45CwnwVccmwRZHAwCA67z2/U7tTM5QSICP3rg/hkQJAJxgA4USFHwBffGaFAAAqrKlv6Zo9qr9kqTX+8WofqCftQEBQCVFslQCx3ds5EoAgGoiNT1bg596Tgcm3anwHfN0a3R9977gkSPSn/4khYRI/v5S27bShg3Ftx861Py28uJH6wuq9K1YIfXuLUVEmOfmz3fvzwDgqkWyVAKWNgAAqhO73dCQSXOVuv5bBUY0c/8U81OnpC5dJG9v6fvvpR07pDfekOrUKf6ad96Rjh0rfBw6JAUHS/36FbbJypJiYqSpU90bP4CrHmuWrgADSwCA6mDKom1aMu15RfQaofD938nT3euUJk2SGjWSZs0qPBYVVfI1QUHmo8D8+WbSdWGFyp49zQcAuBkjSyUoKPBQyQoGAgBQalsOnda4v42Wf7Pr9Y+Rg+Tv7en+F12wQOrY0RwVql9fio2V3n+/dPeYOVOKj5caN3ZPjABQApKlEhQWeAAAoOrKzDmnAWPeUE7yXg184lnd37FRxbzwb79J06ZJ11wjLVokPf649NRT0pw5V3b90aPm9L2HH3ZvnABQDKbhXQEGlgAAVdmofy3R7vnvqe3DkzV5QMeK22/MbjdHll591XweGytt3y5Nny4NGXL56+fMkWrXlvr2dWeUAFAsRpZKUPBhQq4EAKiq5m8+oq+XrpT9zGltn/q4QgL95eXlpeXLl2vKlCny8vJSfn6+e148PFy69tqix1q1kg4evPy1hiF98IE0eLDk4+Oe+ADgMhhZKgHF8AAAVdmB37P0/Pzt8msco2dnLNSf4grX/Tz44IOKjo7Ws88+K09PN61f6tJF2rWr6LHdu69s/dHy5dLevdJDD7knNgC4AiRLV4ACDwCAqsYwDD39xRZl5pzTjS0bauJDNxapfhcQEKCQkBC1adPGfUGMGiV17mxOw7v/fmndOmnGDPNRYOxYcy+mDz8seu3MmVKnTpKz+DIzzUSqQFKSlJholhiPjHTLjwLg6sQ0vBJQ4AEAUFV9vz1Z6/efkr+3p94acJ37y4Q7c/310ldfSXPnmknPyy9Lb78tDRpU2ObYsUun5aWlSf/5T/GjShs2mOufYmPN56NHm/89frxbfgwAVy9Glkrg+FghWwIAVCG55+x67fudkqRHbm6qBrX9L2mzbNmyignmzjvNR3Fmz770WFCQdOZM8dd060b1JQAVgpGlEhQWeOAfZABA1fHRmgM6ePKM6gX66pGbm1odDgBUWSRLJXBMwyNXAgBUEWln8jRl6R5J0l9vb6EAXyaRAEBZkSyVgGp4AICq5r2f9ijtbJ5ahgaqX0VtPgsA1RTJUkkKpuExsgQAqAIO/n5Gc1YdkCSNvSPamqIOAFCNkCxdAdYsAQCqgsmLdio3366brqmrW1rUszocAKjySJZKUPB9HCNLAIDKbtPBU1q49ZhsNmlsz1aOIkUAgLIjWSoB+ywBAKoCwzD06re/SpLua99Q10bUsjgiAKgeSJZKYBNrlgAAld+iX5K14cAp+Xl76K/dW1odDgBUGyRLJWAGAwCgsiuyAe1NTRUW5GdxRABQfZAslaAwV2JoCQBQOX2y9oD2/35GdWv66pFbmlkdDgBUKyRLV4BpeACAyijtbJ7eOb8B7ejbW6gmG9ACgEuRLJWAAg8AgMrsnz/t1ekzebqmfk3d37Gh1eEAQLVDslSCwgIPpEsAgMrl0MkzmvW//ZKk5+5oJS9PPtIBwNX4l7UkjCwBACqpfyzapdx8u7o0D1G3lmxACwDuQLJUAorhAQAqo8RDp7Vgy1HZbOaoEhvQAoB7kCyVoODDh1l4AIDK4sINaO+JbajWEUEWRwQA1RfJUgkKvqcjVwIAVBb/3ZGidftPytfLQ0/3aGF1OABQrZEsXQEKPAAAKoO8/MINaP98U1OFB/lbHBEAVG8kSyVgCjgAoDL5dO1BJZ3IUt2aPnqsGxvQAoC7kSyVwLHPEgNLAACLpWfn6e0luyVJI+PZgBYAKgLJUgls1MMDAFQS//xpn06dyVOzegEacH0jq8MBgKsCyVIJHCNLlHgAAFjoyOmz+uB/SZLYgBYAKhL/2l4BpuEBAKz0+qJdyj1nV1zTEP0hur7V4QDAVaNyJ0v5+dK4cVJUlOTvLzVrJr388uWzl6lTpVatzGtatpQ+/PDSNl98IUVHS35+Utu20nffFXs7kiUAgFW2HU7TV5uPSJL+3osNaAGgIlXu1aGTJknTpklz5kitW0sbNkgPPigFBUlPPeX8mmnTpLFjpfffl66/Xlq3Tvrzn6U6daTevc02q1ZJAwdKCQnSnXdKn34q9e0rbdoktWnjuJVjU1qm4QEALGAYhiZ+t0OSdE9sA7VpwAa0AFCRKneytGqV1KeP1KuX+bxJE2nuXDMBKs5HH0mPPir1728+b9pUWr/eTLwKkqV33pH++EfpmWfM5y+/LC1eLL33njR9uuNWjk1pyZUAABZY+muq1vxmbkD71x4trQ4HAK46lXsaXufO0tKl0m6zVKq2bJFWrpR69iz+mpwcc2rdhfz9zQQrL898vnq1FB9ftE2PHubxCzDTAQBglbx8u179/ldJ0kNdo9SgNhvQAkBFq9wjS2PGSOnp5toiT09zDdPEidKgQcVf06OH9K9/mdPq2reXNm40n+flSSdOSOHhUnKyFBpa9LrQUPP4BQpKhzOwBACoaPPWH9Jvx7MUEuCjx9mAFgAsUbmTpc8/lz75xFxT1Lq1lJgojRwpRURIQ4Y4v2bcODPpufFGc/5caKjZdvJkyaN0A2mOkSWyJQBABcrIztPbi81ZFSPir1Ggn7fFEQHA1alyT8N75hlzdGnAALNi3eDB0qhRZmGG4vj7Sx98IJ05I+3fLx08aK51CgyU6tUz24SFSSkpRa9LSTGPX6AwVyJbAgC434QJE2Sz2VTL30ebxnfXgUl3auKDf7Q6LAC4alXuZOnMmUtHgzw9Jbv98td6e0sNG5rt580zq94V3CsuzlwLdaHFi83jTlDgAQBQUVpGX6umIz5Ww+Efae6yLfrfypWufYEJE8ypExc+oqOLb//ll1LHjlLt2lJAgHTddWYxpQulpEhDh5ozP2rUMIso7dnj2rgBwAKVexpe797mGqXISHMa3ubN0ptvSsOGFbYZO1Y6cqRwL6Xdu81iDp06SadOme23bzfLjxcYMUK65RbpjTfMSnvz5pllyWfMKPLyFHgAAFS0k2fPqYZfbcVFBav/zW3ds69S69bSkiWFz71K+HUgOFj6+9/NhMrHR1q40NzGo359c52wYZjrhL29pa+/lmrVMj974+OlHTvMBAsAqqjKnSy9+665BumJJ6TUVPMbq0cflcaPL2xz7Jg51a5Afr6ZBO3aZf7DfeutZgnyJk0K23TubK6Dev556bnnpGuukebPL7LHkokCDwCAipOanq0TRw/IY+oDOlcnUH9a0UUJCQmKjIx07Qt5eV0y9bxY3boVfT5ihPkF5MqVZrK0Z4+0Zo35xWTr1mabadPM+8+dKz38sEtDB4CKVLmTpcBA6e23zUdxZs8u+rxVK3ME6nL69TMfJSj4Ms9gHh4AwM0Mw9Av50IVcscodY+7Tg9cV1svvviibrrpJm3fvl2BgYGue7E9e8wvIP38zCnoCQnmLI7LByn9+KP5heSkSeaxnBzzzwu37fDwkHx9zYSKZAlAFVa51yxZjGJ4AICK8tOuVB2o0UJ12tys1/7cWz169NB3332n06dP6/PPP3fdC3XqZH7R+MMP5ghQUpJ0001SRkbx16SlSTVrmtPwevUyZ37cfrt5LjraTLTGjjWnv+fmmonU4cPm7A8AqMIq98iSxQrmiTOwBABwp3P5dr363U5J0oNdmqhRcA1JUu3atdWiRQvt3bvXdS924cbu7dqZyVPjxuZ2HQ895PyawEBz+47MTLNA0ujRUtOm5hQ9b2+zCMRDD5nrmzw9zfVKPXvyAQqgyiNZugL8Uw8AcKfPNhzS3tRM1anhrSe6NXccz8zM1L59+zR48GD3vXjt2lKLFlJJCZmHh9T8fFzXXSf9+qs5da9gPVOHDmYylZZmjizVq2cmYR07ui9uAKgATMMrAcXwAADulplzTm+d34A29NcvlLhulfbv369Vq1bp7rvvlqenpwYOHOjGADKlffuk8PArv8ZuL1yrdKGgIDNR2rPHrDLbp4/r4gQACzCyVAJHtVamEQAA3OTz9Yd0IjNXUXUDVCspXQMHDtTvv/+uevXqqWvXrlqzZo3qFWyq7gpPP21uzdG4sXT0qPTCC+bUuYKE7IEHpAYNCjeAT0gwR4iaNTMTpO++M/dZmjat8J5ffGEmSZGR0rZtZsW8vn2l7t1dFzcAWIBkqQSOanjWhgEAqMa+3nJUkjQkrrGGPv2Z+1/w8GEzMfr9dzPB6drVLP1dkJAdPFh0Q/isLHMLj8OHJX9/s6DDxx9L/fsXtjl2zFzHlJJijlA98IC59QcAVHEkSyWwiQIPAAD3OfB7lrYcOi0Pm9SrXUTFvOi8eSWfX7as6PNXXjEfJXnqKfMBANUMa5ZK4hhZIlsCALjeN+dHlTo3q6t6gb4WRwMAuFipk6UVK1aod+/eioiIkM1m0/z584ucNwxD48ePV3h4uPz9/RUfH689e/a4Kt4KxZIlAIA7LTifLN0VU0GjSgCAUil1spSVlaWYmBhNnTrV6fnJkydrypQpmj59utauXauAgAD16NFD2dnZ5Q4WAIDqYmdyunanZMrH00M92oRZHQ4AwIlSr1nq2bOnel64od0FDMPQ22+/reeff159zpcL/fDDDxUaGqr58+drwIABl1yTk5OjnAvKj6anp5c2JLdhU1oAgLssSDRHlbq1rKcgf2+LowEAOOPSNUtJSUlKTk5WfHy841hQUJA6deqk1atXO70mISFBQUFBjkejRo1cGVK5OKbhWRoFAKC6MQxD32w9PwXvOqbgAUBl5dJkKTk5WZIUGhpa5HhoaKjj3MXGjh2rtLQ0x+PQoUOuDKlcHKXDGVoCALjQ5kOndejkWQX4eOq26NDLXwAAsITlpcN9fX3l61s5KwDZHGNLAAC4TsEUvNuvDZW/j6fF0QAAiuPSkaWwMHOBakpKSpHjKSkpjnNVSeHIkrVxAACqj3P5di3cekwSU/AAoLJzabIUFRWlsLAwLV261HEsPT1da9euVVxcnCtfqkIwrgQAcLU1v53Uicwc1a7hra7N61kdDgCgBKWehpeZmam9e/c6niclJSkxMVHBwcGKjIzUyJEj9corr+iaa65RVFSUxo0bp4iICPXt29eVcVcoNqUFALjKgi1HJEk924TLx4u94QGgMit1srRhwwbdeuutjuejR4+WJA0ZMkSzZ8/W3/72N2VlZemRRx7R6dOn1bVrV/3www/y8/NzXdQVhWl4AAAXyjmXr++3mwWP2IgWACq/UidL3bp1K7E6nM1m00svvaSXXnqpXIFVBgUFHsiVAACusHzXcWVkn1NoLV/dEBVsdTgAgMtg/L8EF5cOz8jI0MiRI9W4cWP5+/urc+fOWr9+vYURWis/P1/jxo1TVFSU/P391axZM7388suUWgeAYizYYlbB690uQp4erIwFgMrO8tLhldnFm9I+/PDD2r59uz766CNFRETo448/Vnx8vHbs2KEGDRpYFaZlJk2apGnTpmnOnDlq3bq1NmzYoAcffFBBQUF66qmnrA4PACqVrJxzWvKrWS2WKngAUDUwslQCm63wW7+zZ8/qP//5jyZPnqybb75ZzZs314QJE9S8eXNNmzbNwiits2rVKvXp00e9evVSkyZNdN9996l79+5at26d1aEBQKWz5NcUZefZ1SSkhto2CLI6HADAFSBZuhKGdO7cOeXn519SqMLf318rV660KDBrde7cWUuXLtXu3bslSVu2bNHKlSvVs2dPiyMDgMrn6/Mb0d4VE1HkyzgAQOXFNLwSONYsSQoMDFRcXJxefvlltWrVSqGhoZo7d65Wr16t5s2bWxqnVcaMGaP09HRFR0fL09NT+fn5mjhxogYNGmR1aABQqZzKytWK3cclMQUPAKoSRpZK4FizdL5gwUcffSTDMNSgQQP5+vpqypQpGjhwoDw8rs5u/Pzzz/XJJ5/o008/1aZNmzRnzhy9/vrrmjNnjtWhAUCl8v32ZJ2zG2oVXkvN6wdaHQ4A4AoxslSCC0eWJKlZs2Zavny5srKylJ6ervDwcPXv319Nmza1LEYrPfPMMxozZowGDBggSWrbtq0OHDighIQEDRkyxOLoAKDyKNiIlr2VAKBqIVkqkZkt5dsNpWfnFR729FFAnbo6cCxVixYt0osTE4qeL4ZLKmq74B6GC27i6+WpM2fOXDKq5unpKbvdXu77A0B1kZyWrbVJJyVJvWPCLY4GAFAaJEslKBhZOnzqrNpN+K/O/rZRkuQV3EDnTh3TqWUfyFYjTG/uj9BbE/5rYaQVz8fTQ9ffcrsmTpyoyMhItW7dWps3b9abb76pYcOGWR0eAFQaC7celWFIHRrXUcM6NawOBwBQCiRLJWhev6Ya1PbXkdNnJUn2nDM6vWKOzmWckKdfoGq07KzaNz8gm+fV1425+XbdOvRZRUeG6YknnlBqaqoiIiL06KOPavz48VaHBwCVxjfnN6LtQ2EHAKhybIbhkslhLpOenq6goCClpaWpVq1aVocju91QXhmnldlUttKwZakoW9YitGUpX/v8/O2au+6gRsW30Ij4a8r4ygBQ/e0/kaVury+Tp4dNa5+7TXVr+lodEgBUKVbnBlffkEgpeXjY5OvhaXUYlQrbgwDAlVlwflSpc7MQEiUAqIKuzprXKJeCsUiSJgAonmEYjmSJKngAUDWRLAEA4Aa/HsvQ3tRM+Xh5qEebMKvDAQCUAckSAABuUDCqdGvLeqrl521xNACAsiBZQhmY8/CYhQcAzhmG4aiCd1dMA4ujAQCUFckSAAAutungKR05fVYBPp66rVV9q8MBAJQRyRIAAC62INEcVereOkx+3lRUBYCqimQJpUY1PAAo3rl8u77ddkySdBcb0QJAlUayBACAC63+7XedyMxVnRre6tq8rtXhAADKgWQJAAAX+vr8FLw72obL25OPWQCoyvhXHKVWOA2PeXgAcKHsvHwt2p4siY1oAaA6IFkCAMBFlu06royccwoP8tP1TYKtDgcAUE4kSwAAuEjB3kp3tguXhwej7wBQ1ZEsodSM85vSAgAKZeac05JfUySxES0AVBckSwAAuMDiHcnKOWdXVN0AtWlQy+pwAAAuQLIEAIALFGxE2zsmggI4AFBNkCyh1NiUFgCKOpmVq5/3nJBEFTwAqE5IlgAAKKfvth3TObuh1hG11Lx+TavDAQC4CMkSAADltOB8FTxGlQCgeiFZQqkV1MKziXl4AHAs7azW7z8pSbqTZAkAqhWSJQAAymHhlmMyDOn6JnXUoLa/1eEAAFyIZAmlRoEHACjEFDwAqL5IlgAAKKOkE1nadiRNnh423dE23OpwAAAuRrJU2eTnS+PGSVFRkr+/1KyZ9PLLhcM5xVm2TGrfXvL1lZo3l2bPLnq+SRNzKOjix/DhbvpBAKD6K9hbqUvzugqp6WtxNAAAV/OyOgBcZNIkado0ac4cqXVracMG6cEHpaAg6amnnF+TlCT16iU99pj0ySfS0qXSww9L4eFSjx5mm/XrzUSswPbt0u23S/36lTpE43yJB2bhAbiaGYahr7cckcQUPACorkiWKptVq6Q+fczkRzJHhObOldatK/6a6dPNkag33jCft2olrVwpvfVWYbJUr17Ra157zRy1uuUWl/8IAHA1+OVoun47niUfLw/1aB1qdTgAADdgGl5l07mzOTK0e7f5fMsWM/Hp2bP4a1avluLjix7r0cM87kxurvTxx9KwYVRpAIAy+uZ8YYfbousr0M/b4mgAAO7AyFJlM2aMlJ4uRUdLnp7m1LmJE6VBg4q/JjlZCr3oW83QUPM+Z8+aa58uNH++dPq0NHRo2WKkGh6Aq5zdbjiSJabgAUD1RbJU2Xz+ubnu6NNPzTVLiYnSyJFSRIQ0ZIhrXmPmTHOkKoIPeAAoi40HT+loWrZq+nrp1uj6VocDAHATpuFVNs88Y44uDRggtW0rDR4sjRolJSQUf01YmJSSUvRYSopUq9alo0oHDkhLlpgFIAAAZVJQBa9761D5eXu67sYrVki9e5tfZtls5kyAC335pdS9uxQSYp5PTCzd/efNM6/r27f4No89ZrZ5++3S3RsAqiGSpcrmzBnJ46K/Fk9PyW4v/pq4OHOd04UWLzaPX2zWLKl+/cICEmVQUMTcRj08AFehc/l2fbftmCQ3TMHLypJiYqSpU4s/37WrWTm1tPbvl55+WrrppuLbfPWVtGYNMw8A4Dym4VU2vXuba5QiI81peJs3S2++aRZjKDB2rHTkiPThh+bzxx6T3ntP+tvfzHY//mhO5/v226L3ttvNZGnIEMmLv3oAKIv/7ftdv2flKjjAR12a13XtzXv2LLmgz+DB5p/795fuvvn55trXF1+Ufv7ZXLd6sSNHpL/8RVq0qFxfqAFAdcLIUmXz7rvSffdJTzxhlgB/+mnp0UfNjWkLHD0qLV9euHFtfLzUv785mhQTY5YQ/9e/CsuGF3jjDengQTP5crZxbUaGuT6qcWPzvp07m/szAQAcCqbg3dE2TN6eVeRj9KWXzFkFDz3k/LzdbiZizzxjflEHAJDEyFLlExhozhMvaa54y5bmqNHFG9dOnFjyxrUTJkijR5vrlZxtXPvww+ZmtR99ZE7B+PhjMxHbsUNq0MBxK8M4vykts/AAXGWy8/K16JdkSdJdMQ0u07qSWLnSLOxT0vqmSZPMGQfFfYYAwFWKZKkqcsfGtWfPSv/5j/T119LNN5ttJkyQvvlGmjZNeuUVd/5EAFAl/LQzVZk55xQR5KeOjetYHc7lZWSYI0bvvy/VLWbK4MaN0jvvSJs28S0YAFykiswfQBHu2Lj23DlzTrufX9E2/v7mvQEAWnB+b6XeMRHy8KgCicW+feb6pt69zZEjLy9zveuCBeZ/79tnrmFKTTXXyha0OXBA+utfzS/jAOAqxshSVeSOjWsDA83qeS+/bI46hYaao1WrV5vrmy5gCACuPhnZeVq6M1WSmSxVCdHR0rZtRY89/7w54vTOO1KjRubIk7Mv0wYPNqd4A8BVjGSpKnLXxrUffWRW02vQwEzC2reXBg40p2gAwFXuv7+kKPecXU3rBah1RC33vEhmprR3b+HzpCTz3/jgYHPk5+RJs1DPUXOES7t2mX+GhZkPSXrgAfPf8YQEc7ZAmzZFX6N2bfPPguMhIebjQt7e5v1atnTlTwcAVQ7JUlV04ca1krl57YED5gdjccnSlWxc26yZWWUvK8sccQoPN6vsNW3qvp8FAKqIgil4d8VEyOautT0bNki33lr4fPRo888hQ8wKpgsWFB3tKfgceOEFc52pZCZTF+/XBwAoE5KlqqisG9d+913RY8VtXBsQYD5OnTL325g8ucjp88Xw3PfLAgBUMr9n5mjl3hOS3LAR7YW6dSv8R9aZoUPNR0mWLSv5/MXbRjhT2n2cAKCaIlmqity1ce2iReaHdMuW5jSQZ54x57szZx3AVe677cnKtxtq06CWmtaraXU4AIAKQrJUFb37rjRunLlxbWqquVbp0Uel8eML2xw7Zk7FKBAVZSZGo0aZi3obNrx049q0NDPJOnzYnB9/771mUubtXeTlC77zZFwJwNXim8TCKXgAgKsHyVJVdCUb1zqbZtGtmzkKVZz77zcfAACHI6fPat3+k5KkO9uRLAHA1YQVoAAAlGDh+cION0QFK6K2v8XRAAAqEskSSs04v/iY+g4ArgYXVsEDAFxdSJYAACjGvuOZ+uVourw8bLqjbbjV4QAAKhjJEgAAxVhwvrBD12vqKjjAx+JoAAAVjWQJpUY1PABXA8Mw9A1T8ADgqkayBACAE78cTddvJ7Lk6+Wh7q3DrA4HAGABkiUAAJwoKOxwW6v6qunLThsAcDUiWULpnZ+HZ6McHoBqym5nCh4AgGQJAIBLrN9/UsfSshXo66VuLetbHQ4AwCIkSwAAXKRgCl731mHy8/a0OBoAgFVIllBqhtiUFkD1lZdv13fbjkmS+lzHFDwAuJqRLAEAcIGVe0/o1Jk81a3po87NQqwOBwBgIZIlAAAu8M35jWjvaBsuL08+JgHgasanAErNKKiGZ20YAOBy2Xn5WvRLsiSq4AEASJYAAHD4cWeqsnLz1aC2v9pH1rE6HACAxUiWUGaj7+kqm812yWP48OFWhwYAZfLpj5t14pvXtfnVexQQUENt27bVhg0brA4LAGARtiRHqRVMw5vwwQLdG1s4TWX79u26/fbb1a9fP4siA4CyO3AsVZ+98KB8G7XTB3O/VKdro7Rnzx7VqcMIEwBcrUiWUGa16oQoLCzM8fy1115Ts2bNdMstt1gYFQCUzYgxE+QZWFedhv5d/e+4RTabTVFRUVaHBQCwENPwUGYXFnjIzc3Vxx9/rGHDhsnGBkwAqqBli7+XT9g1+v3rSQoNDVVsbKzef/99q8MCAFiIZAmlVrAp7YXmz5+v06dPa+jQoRUfEACU04nMHKWnHlHG5u/UuX0bLVq0SI8//rieeuopzZkzx+rwAAAWYRoeXGLmzJnq2bOnIiIotQug6vlu2zEZhqE6jaP1z7f/IUmKjY3V9u3bNX36dA0ZMsTiCAEAVnDbyNLUqVPVpEkT+fn5qVOnTlq3bp27XgoVzLHP0vnZdgcOHNCSJUv08MMPWxcUAJTDgsSj8qxZR62vvbbI8VatWungwYMWRQUAsJpbkqXPPvtMo0eP1gsvvKBNmzYpJiZGPXr0UGpqqjteDhabNWuW6tevr169elkdCgCU2pHTZ7XhwCn5NbxWuScPFzm3e/duNW7c2KLIAABWc8s0vDfffFN//vOf9eCDD0qSpk+frm+//VYffPCBxowZ446XhAV2JWdoyY5jmjbjX/rDnfdpxd7frQ4JAErtp53HJUlxdw3Wstcf06uvvqr7779f69at04wZMzRjxgyLIwQAWMXlyVJubq42btyosWPHOo55eHgoPj5eq1evvqR9Tk6OcnJyHM/T09NdHRJczNPDnH/34eoD+n+ffqXUY0e0wtZWq2ezcSOAqmto33iN6PKVxo4dq5deeklRUVF6++23NWjQIKtDAwBYxOXJ0okTJ5Sfn6/Q0NAix0NDQ7Vz585L2ickJOjFF190dRhwo0GdGis1I0d5+Xap4a3STT9bHRIAlEtEkL/6XtdAAb6Ndeedd1odDgCgkrC8Gt7YsWM1evRox/P09HQ1atTIwohwOV2vqauu19S1OgwAAADArVyeLNWtW1eenp5KSUkpcjwlJUVhYWGXtPf19ZWvr6+rwwAAAACAcnF5NTwfHx916NBBS5cudRyz2+1aunSp4uLiXP1yAAAAAOAWbpmGN3r0aA0ZMkQdO3bUDTfcoLfffltZWVmO6ngAAAAAUNm5JVnq37+/jh8/rvHjxys5OVnXXXedfvjhh0uKPgAAAABAZWUzDMOwOogLpaenKygoSGlpaapVq5bV4QAAAACwiNW5gcvXLAEAAABAdUCyBAAAAABOkCwBAAAAgBMkSwAAAADgBMkSAAAAADhBsgQAAAAATpAsAQAAAIATJEsAAAAA4ATJEgAAAAA4QbIEAAAAAE6QLAEAAACAEyRLAAAAAOAEyRIAAAAAOEGyBAAAAABOkCwBAAAAgBMkSwAAAADgBMkSAAAAADhBsgQAAAAATpAsAQAAAIATJEsAAAAA4ATJEgAAAAA4QbIEAAAAAE6QLAEAAACAEyRLAAAAAOCEl9UBXMwwDElSenq6xZEAAAAAsFJBTlCQI1S0SpcsZWRkSJIaNWpkcSQAAAAAKoOMjAwFBQVV+OvaDKvStGLY7XYdPXpUgYGBstlsVoej9PR0NWrUSIcOHVKtWrWsDqfaoF/dh751D/rVPehX96Fv3YN+dQ/61T2qQ78ahqGMjAxFRETIw6PiVxBVupElDw8PNWzY0OowLlGrVq0q+yarzOhX96Fv3YN+dQ/61X3oW/egX92DfnWPqt6vVowoFaDAAwAAAAA4QbIEAAAAAE6QLF2Gr6+vXnjhBfn6+lodSrVCv7oPfese9Kt70K/uQ9+6B/3qHvSre9Cv5VfpCjwAAAAAQGXAyBIAAAAAOEGyBAAAAABOkCwBAAAAgBMkSwAAAADgBMkSAAAAADhBsnQZU6dOVZMmTeTn56dOnTpp3bp1VodUpaxYsUK9e/dWRESEbDab5s+fX+S8YRgaP368wsPD5e/vr/j4eO3Zs8eaYKuQhIQEXX/99QoMDFT9+vXVt29f7dq1q0ib7OxsDR8+XCEhIapZs6buvfdepaSkWBRx1TBt2jS1a9fOsdN5XFycvv/+e8d5+tQ1XnvtNdlsNo0cOdJxjL4tmwkTJshmsxV5REdHO87Tr2V35MgR/elPf1JISIj8/f3Vtm1bbdiwwXGez6/Sa9KkySXvV5vNpuHDh0vi/Voe+fn5GjdunKKiouTv769mzZrp5Zdf1oVFr3nPlg3JUgk+++wzjR49Wi+88II2bdqkmJgY9ejRQ6mpqVaHVmVkZWUpJiZGU6dOdXp+8uTJmjJliqZPn661a9cqICBAPXr0UHZ2dgVHWrUsX75cw4cP15o1a7R48WLl5eWpe/fuysrKcrQZNWqUvvnmG33xxRdavny5jh49qnvuucfCqCu/hg0b6rXXXtPGjRu1YcMG/eEPf1CfPn30yy+/SKJPXWH9+vX6f//v/6ldu3ZFjtO3Zde6dWsdO3bM8Vi5cqXjHP1aNqdOnVKXLl3k7e2t77//Xjt27NAbb7yhOnXqONrw+VV669evL/JeXbx4sSSpX79+kni/lsekSZM0bdo0vffee/r11181adIkTZ48We+++66jDe/ZMjJQrBtuuMEYPny443l+fr4RERFhJCQkWBhV1SXJ+OqrrxzP7Xa7ERYWZvzjH/9wHDt9+rTh6+trzJ0714IIq67U1FRDkrF8+XLDMMx+9Pb2Nr744gtHm19//dWQZKxevdqqMKukOnXqGP/617/oUxfIyMgwrrnmGmPx4sXGLbfcYowYMcIwDN6v5fHCCy8YMTExTs/Rr2X37LPPGl27di32PJ9frjFixAijWbNmht1u5/1aTr169TKGDRtW5Ng999xjDBo0yDAM3rPlwchSMXJzc7Vx40bFx8c7jnl4eCg+Pl6rV6+2MLLqIykpScnJyUX6OCgoSJ06daKPSyktLU2SFBwcLEnauHGj8vLyivRtdHS0IiMj6dsrlJ+fr3nz5ikrK0txcXH0qQsMHz5cvXr1KtKHEu/X8tqzZ48iIiLUtGlTDRo0SAcPHpREv5bHggUL1LFjR/Xr10/169dXbGys3n//fcd5Pr/KLzc3Vx9//LGGDRsmm83G+7WcOnfurKVLl2r37t2SpC1btmjlypXq2bOnJN6z5eFldQCV1YkTJ5Sfn6/Q0NAix0NDQ7Vz506LoqpekpOTJclpHxecw+XZ7XaNHDlSXbp0UZs2bSSZfevj46PatWsXaUvfXt62bdsUFxen7Oxs1axZU1999ZWuvfZaJSYm0qflMG/ePG3atEnr16+/5Bzv17Lr1KmTZs+erZYtW+rYsWN68cUXddNNN2n79u30azn89ttvmjZtmkaPHq3nnntO69ev11NPPSUfHx8NGTKEzy8XmD9/vk6fPq2hQ4dK4t+B8hozZozS09MVHR0tT09P5efna+LEiRo0aJAkfucqD5IloIobPny4tm/fXmSdAsquZcuWSkxMVFpamv79739ryJAhWr58udVhVWmHDh3SiBEjtHjxYvn5+VkdTrVS8K2xJLVr106dOnVS48aN9fnnn8vf39/CyKo2u92ujh076tVXX5UkxcbGavv27Zo+fbqGDBlicXTVw8yZM9WzZ09FRERYHUq18Pnnn+uTTz7Rp59+qtatWysxMVEjR45UREQE79lyYhpeMerWrStPT89LqrCkpKQoLCzMoqiql4J+pI/L7sknn9TChQv1008/qWHDho7jYWFhys3N1enTp4u0p28vz8fHR82bN1eHDh2UkJCgmJgYvfPOO/RpOWzcuFGpqalq3769vLy85OXlpeXLl2vKlCny8vJSaGgofesitWvXVosWLbR3717es+UQHh6ua6+9tsixVq1aOaY48vlVPgcOHNCSJUv08MMPO47xfi2fZ555RmPGjNGAAQPUtm1bDR48WKNGjVJCQoIk3rPlQbJUDB8fH3Xo0EFLly51HLPb7Vq6dKni4uIsjKz6iIqKUlhYWJE+Tk9P19q1a+njyzAMQ08++aS++uor/fjjj4qKiipyvkOHDvL29i7St7t27dLBgwfp21Ky2+3KycmhT8vhtttu07Zt25SYmOh4dOzYUYMGDXL8N33rGpmZmdq3b5/Cw8N5z5ZDly5dLtmOYffu3WrcuLEkPr/Ka9asWapfv7569erlOMb7tXzOnDkjD4+iv9Z7enrKbrdL4j1bLlZXmKjM5s2bZ/j6+hqzZ882duzYYTzyyCNG7dq1jeTkZKtDqzIyMjKMzZs3G5s3bzYkGW+++aaxefNm48CBA4ZhGMZrr71m1K5d2/j666+NrVu3Gn369DGioqKMs2fPWhx55fb4448bQUFBxrJly4xjx445HmfOnHG0eeyxx4zIyEjjxx9/NDZs2GDExcUZcXFxFkZd+Y0ZM8ZYvny5kZSUZGzdutUYM2aMYbPZjP/+97+GYdCnrnRhNTzDoG/L6q9//auxbNkyIykpyfjf//5nxMfHG3Xr1jVSU1MNw6Bfy2rdunWGl5eXMXHiRGPPnj3GJ598YtSoUcP4+OOPHW34/Cqb/Px8IzIy0nj22WcvOcf7teyGDBliNGjQwFi4cKGRlJRkfPnll0bdunWNv/3tb442vGfLhmTpMt59910jMjLS8PHxMW644QZjzZo1VodUpfz000+GpEseQ4YMMQzDLGU5btw4IzQ01PD19TVuu+02Y9euXdYGXQU461NJxqxZsxxtzp49azzxxBNGnTp1jBo1ahh33323cezYMeuCrgKGDRtmNG7c2PDx8THq1atn3HbbbY5EyTDoU1e6OFmib8umf//+Rnh4uOHj42M0aNDA6N+/v7F3717Hefq17L755hujTZs2hq+vrxEdHW3MmDGjyHk+v8pm0aJFhiSnfcX7tezS09ONESNGGJGRkYafn5/RtGlT4+9//7uRk5PjaMN7tmxshnHB1r4AAAAAAEmsWQIAAAAAp0iWAAAAAMAJkiUAAAAAcIJkCQAAAACcIFkCAAAAACdIlgAAAADACZIlAAAAAHCCZAkAAAAAnCBZAgAAAAAnSJYAAAAAwAmSJQAAAABw4v8DVYChnUhUrEoAAAAASUVORK5CYII=\n"
-          },
-          "metadata": {}
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#centerx, centery, radius = get_circle(new_line[7], new_line[50], new_line[45])\n",
-        "centerx, centery, radius = get_circle(new_line[16], new_line[18], new_line[21])\n",
-        "print(centerx, centery, radius)"
-      ],
-      "metadata": {
-        "id": "wAzQl2sdLZMD",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "9c0f2f10-e71e-4b0d-84d1-541a0945f76d"
-      },
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "28.201591063209122 19.577485930188082 2.4983033721166876\n"
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/dxf_viewer/divers/main.py b/dxf_viewer/divers/main.py
deleted file mode 100644
index 9aa1a0e..0000000
--- a/dxf_viewer/divers/main.py
+++ /dev/null
@@ -1,210 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import ezdxf
-import sys
-import numpy as np
-from rdp import rdp
-import pprint as pp
-from collections import defaultdict
-import matplotlib.pyplot as plt
-from matplotlib.widgets import Button
-import mplcursors
-
-np.set_printoptions(precision=3, suppress=True)
-
-def print_entity(e):
-    print("LINE on layer: %s\n" % e.dxf.layer)
-    print("start point: %s\n" % e.dxf.start)
-    print("end point: %s\n" % e.dxf.end)
-
-def print_entity2(e):
-    print(e.dxf.layer, e.dxf.start, e.dxf.end )
-
-def transform(vertices, new_center, axis1, axis2):
-    mat = np.linalg.inv(np.array([axis1, axis2])) @ np.array([[1, 0], [0, 1]])
-    transformed_vertices = (vertices - new_center) @ mat
-    return transformed_vertices
-
-def transform_single_axis(vertices, new_center, axis1, direct):
-    if direct:
-        axis2 = np.array([-axis1[1], axis1[0]])
-    else:
-        axis2 = np.array([axis1[1]], -axis1[0])
-    return transform(vertices, new_center, axis1, axis2)
-    
-point1 = None
-point2 = None
-def on_click(event):
-    global point1, point2
-
-    if event.button == 1:  # Clic gauche
-        if point1 is None:
-            point1 = (event.xdata, event.ydata)
-            print("Point 1 sélectionné :", point1)
-        elif point2 is None:
-            point2 = (event.xdata, event.ydata)
-            print("Point 2 sélectionné :", point2)
-            compute_distance()
-            # Réinitialiser les points sélectionnés pour permettre de mesurer une nouvelle distance
-            point1 = None
-            point2 = None
-
-
-def compute_distance():
-    global point1, point2
-
-    if point1 is not None and point2 is not None:
-        distance = ((point2[0] - point1[0]) ** 2 + (point2[1] - point1[1]) ** 2) ** 0.5
-        print("Distance entre les deux points :", distance)
-
-
-
-def plot(l, fig=True):
-    
-
-    if fig:
-        fig, ax = plt.subplots()
-
-    mplcursors.cursor(hover=True)
-    cid = fig.canvas.mpl_connect('button_press_event', on_click)
-    ax.plot(list(l[:, 0]) + [l[0, 0]], list(l[:, 1]) + [l[0, 1]])
-    for i, vertice in enumerate(l):
-        ax.annotate(str(i), vertice)
-    plt.axis('equal')
-
-def perp(a) :
-    b = np.empty_like(a)
-    b[0] = -a[1]
-    b[1] = a[0]
-    return b
-
-def seg_intersect(a1, a2, b1, b2) :
-    da = a2-a1
-    db = b2-b1
-    dp = a1-b1
-    dap = perp(da)
-    denom = np.dot( dap, db)
-    num = np.dot( dap, dp )
-    return (num / denom.astype(float))*db + b1
-
-def envelope(polygon, dist):
-    shifted_segments = []
-    for i in range(len(polygon)):
-        a, b = polygon[i], polygon[(i+1)%len(polygon)]
-        dx = b[0] - a[0]
-        dy = b[1] - a[1]
-        normal = np.array([dy, -dx])
-        normal /= np.linalg.norm(normal)
-        shifted_segments.append((a + dist*normal, b + dist*normal))
-    new_polygon = []
-    for i in range(len(shifted_segments)):
-        seg1 = shifted_segments[(i-1)%len(shifted_segments)]
-        seg2 = shifted_segments[i]
-        new_polygon.append(seg_intersect(seg1[0], seg1[1], seg2[0], seg2[1]))
-    return np.array(new_polygon)
-
-def get_circle(x, y, z):
-    x, y, z = x[0]+x[1]*1j, y[0]+y[1]*1j, z[0]+z[1]*1j
-    w = (z-x) / (y-x)
-    c = (x-y)*(w-abs(w)**2)/2j/w.imag-x
-    return -c.real, -c.imag, abs(c+x)
-
-def array2dict(lst):
-    res_dict = {}
-    for i in range(0, len(lst), 1):
-        res_dict[i] = lst[i]
-    return res_dict
-
-doc = ezdxf.readfile("../mgf.dxf")
-msp = doc.modelspace()
-
-object_type = set()
-
-group = msp.groupby(dxfattrib="layer")
-a = defaultdict(lambda: defaultdict(lambda: 0))
-
-for layer, entities in group.items():
-    for entity in entities:
-        object_type.add(entity.dxftype())
-        a[layer][entity.dxftype()] += 1
-a = {k: dict(a[k]) for k in a}
-# pp.pprint(a)
-
-# print(object_type)
-
-lines = []
-all_vertices = []
-layer='05-Bâti_contour'
-
-
-
-for polyline in msp.query(f'LWPOLYLINE[layer=="{layer}"]'):
-  line = []
-  for vertice in polyline:
-    line.append([vertice[0], vertice[1]])
-    all_vertices.append([vertice[0], vertice[1]])
-  
-  line = np.array(line)
-
-
-  lines.append(line)
-
-
-
-
-
-
-plot(lines[0])
-
-# # NORMALIZE POLYLINE + new center + new axis
-# line = lines[0]
-# #new_center = (line[22] + line[31])/2
-# new_center = (line[9] + line[7])/2
-# new_center = seg_intersect(line[7],line[9], line[13],line[11])
-
-# #axis1 = line[31] - line[22]
-# axis1 = line[7] - line[9]
-# axis1 /= np.linalg.norm(axis1)
-# new_line = transform_single_axis(line, new_center, axis1, True)
-# print(new_line)
-
-
-# plot(new_line)
-
-# #
-# # Reduce Points
-# #
-# simple_line = rdp(new_line, epsilon=0.2)
-# print(len(new_line), len(simple_line))
-
-
-# plot(simple_line)
-
-# # convert Array into Dict
-# dict_line = array2dict(simple_line)
-# pp.pprint(dict_line)
-
-# int_line = envelope(simple_line, 2.)
-
-
-# plot(simple_line, False)
-
-# #plot(int_line, False)
-# lengths = []
-# for i in range(len(simple_line)):
-#     a, b = simple_line[i], simple_line[(i+1)%len(simple_line)]
-#     dx, dy = b[0]-a[0], b[1]-a[1]
-#     normal = np.array([dy, -dx])
-#     normal /= np.linalg.norm(normal)
-#     length = np.linalg.norm(a - b)
-#     lengths.append(length)
-#     if length > 5:
-#         plt.annotate("%.2f" % length, (a+b)/2 - 3.*normal - 1., color='red')
-# print(np.array(lengths))
-
-# #centerx, centery, radius = get_circle(new_line[7], new_line[50], new_line[45])
-# centerx, centery, radius = get_circle(new_line[16], new_line[18], new_line[21])
-# print(centerx, centery, radius)
-
-plt.show()
-
diff --git a/dxf_viewer/divers/requirements.txt b/dxf_viewer/divers/requirements.txt
deleted file mode 100644
index f28833d..0000000
--- a/dxf_viewer/divers/requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-ezdxf >= 1.0.3
-mixpeek >= 1.7
-rdp >= 0.8
\ No newline at end of file
diff --git a/dxf_viewer/divers/tools.py b/dxf_viewer/divers/tools.py
index c316e25..0410fb4 100644
--- a/dxf_viewer/divers/tools.py
+++ b/dxf_viewer/divers/tools.py
@@ -1,6 +1,7 @@
 import numpy as np
 import time
-from tkinter import *
+import tkinter as tk
+
 
 def transform(vertices, new_center, axis1, axis2):
     mat = np.linalg.inv(np.array([axis1, axis2])) @ np.array([[1, 0], [0, 1]])
@@ -88,7 +89,6 @@ def wrapper(*args, **kwargs):
                 last_call_time = current_time
                 return result
         return wrapper
-
     return decorator
 
 
@@ -108,11 +108,11 @@ def showtip(self, text):
         x, y, cx, cy = self.widget.bbox("insert")
         x = x + self.widget.winfo_rootx() + 30
         y = y + cy + self.widget.winfo_rooty() + 30
-        self.tipwindow = tw = Toplevel(self.widget)
+        self.tipwindow = tw = tk.Toplevel(self.widget)
         tw.wm_overrideredirect(1)
         tw.wm_geometry("+%d+%d" % (x, y))
-        label = Label(tw, text=self.text, justify=LEFT,
-                      background="#ffffe0", relief=SOLID, borderwidth=1,
+        label = tk.Label(tw, text=self.text, justify=tk.LEFT,
+                      background="#ffffe0", relief=tk.SOLID, borderwidth=1,
                       font=("tahoma", "8", "normal"))
         label.pack(ipadx=1)
 
@@ -141,4 +141,29 @@ def generate_json(name,points):
 def get_file_name(file_path):
     file_path_components = file_path.split('/')
     file_name_and_extension = file_path_components[-1].rsplit('.', 1)
-    return file_name_and_extension[0]
\ No newline at end of file
+    return file_name_and_extension[0]
+
+class DragDropListbox(tk.Listbox):
+    """ A Tkinter listbox with drag'n'drop reordering of entries. """
+    def __init__(self, master, **kw):
+        kw['selectmode'] = tk.SINGLE
+        tk.Listbox.__init__(self, master, kw)
+        self.bind('<Button-1>', self.setCurrent)
+        self.bind('<B1-Motion>', self.shiftSelection)
+        self.curIndex = None
+
+    def setCurrent(self, event):
+        self.curIndex = self.nearest(event.y)
+
+    def shiftSelection(self, event):
+        i = self.nearest(event.y)
+        if i < self.curIndex:
+            x = self.get(i)
+            self.delete(i)
+            self.insert(i+1, x)
+            self.curIndex = i
+        elif i > self.curIndex:
+            x = self.get(i)
+            self.delete(i)
+            self.insert(i-1, x)
+            self.curIndex = i
\ No newline at end of file
diff --git a/dxf_viewer/graphic/plus.png b/dxf_viewer/graphic/plus.png
new file mode 100644
index 0000000000000000000000000000000000000000..de142f8867b18e4d687567feccac1bc4fc36308a
GIT binary patch
literal 463
zcmV;=0WkiFP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800009a7bBm000XU
z000XU0RWnu7ytkPfk{L`RCt{2l}kzkK@dP6BwHu=+iE<Kv(a&*5>Nu(LJdg796?2s
zQ^edN30^~2PF9hIYG{g{|ELJ_pkSElu1|MWH8eE*Lps0-a0@((nD0n*KgIzt0am~|
zL5yw;bnAA0mEl-R4D{=A{*dD6LnKK*tRwTak~we+Y&z?<fHPp>S>La6=PPCG4rrz9
zX-U@lI!e{V#N*t>RQwEh0|KSfLA(}q-ci}lJ(-7&-h8{Xfu%YH9b_tz%D~*Y=E%{T
zZ_T-~;aii)Ky5ZfW=|#*V<SgDl7FF->5j5thE;B!RI6ELIc9*V35(mJkG~bbw2lA<
z%ILQI4+>ntZj~#D)MhheiWXt7N)ZOC4Hp@0c<5=vch!a)6l9z+*8?fIsi(*F`|&~v
zx)Ql-=w7l*qU~}11?*9hzNgBUGGuIF+Me&JW4CfiMTRLY_bHO3*Y5{aP9n}R1KeZ3
zpl0^vRZ9ybmVzsN=Xo#{e+=Bn#58g(eO|cL8XEX(z5!KU?mgz=2B`o5002ovPDHLk
FV1f$^$!Y)q

literal 0
HcmV?d00001

diff --git a/dxf_viewer/graphic/polyline.png b/dxf_viewer/graphic/polyline.png
new file mode 100644
index 0000000000000000000000000000000000000000..751340fcf1653ce90a71aaa23c48cff31bae54bc
GIT binary patch
literal 743
zcmV<D0vP>?P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800009a7bBm000XU
z000XU0RWnu7ytkQnMp)JRCt`dmpf<`Q4oedjTRz`ULS=Pq9G~ts-UeA3m-vAr51vS
zSo*+D)WS$Ag%n9ZL<>RCLPZ6MrIlKViK3!5B0+p0n#Tn%i7{6u%))RuyL-;Pn+yyr
zyEF6uXU;h@vrxaB1HJ>_fV0f990Y2P?w>92ZNQ+1fV^v)DbTq<2k_hj?CJn;1ejk0
z@Dkt*FysOHo${RMkoroDAlV4?0#|@`pbw}xLH_~wbsL(1?W#?h{s(GfeJUEOU1JMI
z*#}<DNNYtMn*$cothO$Bt5ugoUy9*Z;37~WUKRtVfzK(id#rJ<$KVz)kH$q}-1fxp
zwnk;o7CZ*#P>gH>{+QTfz<SrHtZDgV3{O&=YzD?PZhw~H2E(?h?2D3*8uvq<;VF}a
zx4?pe2=r^ralN{!B76VHkdQ-Kg!Gu0Yx9g(YPS>PDZNsy4H7tE2<#1UXjkyWNuIkJ
zAkb}MjRHGDoZdUvQ%JPb0lv;zjOgnS$6-$q*<A;L1D-geAyv%Q1<_x?(nxS=R6jig
z?&djm8skar_0kDr<d`WyqCa%y0=_)UaVs#PP9wmYNMO0=mz)(}3msGznyMvwI1p5Z
zj|;#J;ED173mlJOf7LkOiCFQ=l*wsl4ER2CUA_d)0#em3d%!1Si`NRB^OO6&%lR(j
z*DGzO_jKlaku#)r#tf(rGwOdSr6z>vptj@O>rzvF=jniZGUhuWeh63voCj`d$+m<i
zG#f2i$VzUR95bzQi-%yVr<A?{7G*4IwN6&Gl*8GUoZe^VgZ%TQNtYoptY;!bj;3ti
z0GhJo#nZe&K~pGQav5>b;UO?0AEYcMgJSNG(16IEyMIvAz2Leskw4y<7TI%2yWmat
Zg8wn6Kw)D!zqJ4W002ovPDHLkV1hB{P-y@F

literal 0
HcmV?d00001

diff --git a/dxf_viewer/graphic/sel_point.png b/dxf_viewer/graphic/sel_point.png
new file mode 100644
index 0000000000000000000000000000000000000000..e09a0c67301bc1b20f0922adcf5e3997a6c7e31a
GIT binary patch
literal 568
zcmV-80>}M{P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800009a7bBm000XU
z000XU0RWnu7ytkP>PbXFRCt`l*Gq^_VI0Tt4}&QSmlRDxA(xfZWP!wn$igMFu|r9T
z63K#;aw!WWE1Oxk45iqpu~1}3L^c+(n1#Cx6A`0RfAysIGBeLPuV4M^Iq&mye&6#x
zm-9Q+*JK>PP29l+EY~8f#Cr_ZsEZg=rTIMc;}_0i5vF4cUIoPIDgiEq$-x?Z)9?;I
zF{=vmQStPj&{k*6;Q-uK1;B*3`Ge%QrFe<+alIkN9IFCgGzQQY?Lx<s1-KdOqP<&1
zx)KK4;(C7qa1ZTxjhR&e%*HqTz$UCt0Di}gSfXOBz(?H1_yGC~u|td0fkV;mO#p8A
z589gme8#vMW4f?2*2olWkB2BlbN)GwS79!W#2VR{^gYCj1a?hX5YH2nGw4Yc=0KhI
z#$fa<E(73Xa?}1ek_U%aPa2%8L)Nlk7}lz-GS!B+832!zpzh3nVL>iHS0+G_u(C8M
zvcO0IZYe>}G60G-l&zl3X_(l|U~C+{-H{24<g+$%z)^h71eo6}lJ#a9G^>S;06Ho*
zFKTMDDcFb0xQ_b`z7IxHADWrho0iV_Aj#Q+MctLDPCU&3xT*xT<3wb};h6W8oup^r
z6y7v2{f=v~jk90J>Zpik#kuh%F@B6a5zShr^*A@&^z#RJUTQ9Y1^h1n0000<MNUMn
GLSTZH5(2vb

literal 0
HcmV?d00001

diff --git a/dxf_viewer/requirements.txt b/dxf_viewer/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..db7dced4ff87ab1b185cd6813b4bb472f239989d
GIT binary patch
literal 6590
zcmZ{oTW?!c5QX<M690jB<WM_Fn;;>TmbRjz5E`UDBHMAUzSVZpI6od(-(F`t=QKf<
zQ}^uIb6K-y_U!ZTKf^LDlQJu#a#hCVCw=;5uN>*yFW;7L%CO9}vMvifdtRRDDKf`e
zf7X%NN@`Kp_VxU^zJq4}s;so~rLLiS&|2G+jaJunZP2Ws8OuMHTdiKozbko%Ra-pN
z{=-K1gJf3nzbD@piejd}^PMGIJ9<)<T@me|`fIDhk~*)-nWX0O;!5A`PTtWQos^!H
z3)$Z^zO?m&NTBhQ{7QC4+G`y8O`L&4+oQCBezHRR<0h6t%^fH`jwN@lwP&QgW9_^u
z%NkvvhNrpzm9jsQ?rDvjyxF(?is-0n*j5c7=_n&o_;jZ4So$M(&aizO)x6Hjjr6Z}
z$U3hh#kJ9QfA@S)y*exhjb*Qs^ES?d>O)Aq(i(E`Co)ZJ$5qE`#WohZCgruH$T8B6
z)I4*%t^yEVN#?4YH`?&X@xX>b<Jnm2Ap!gPVro<pYiO8BSNKDn7!Q0I$_9)xVh45Y
z>-BYA@5y6gpJ@;AJyieDYOm8K)$O`u#gW0>aosl-{_JwSNAAFNTJ;aB1ti#sN6rA;
z8Hz)f@)aItj*$t>R;n5JwNPaszm&YI2(BRM+8m3K=%9i(^60AOBX|LV_T7GOtM9Su
zh``!7o>dfY8XPAb{t;zJ(bLS0>@9fpyt3m=9<1f>Rx+3J%RL1zj4z&?={ZOdVIY)!
z?@TdG)%B==%iVhL*j~J;7;ejn&_NeSMh^%S>CHoFnX0ec=@;21M$pQ-aoysT`<0Pj
zG)NAree=;Wca0qENbmP+{n)pOICWO;#aUuAzI$3{|9SO$qrXd8h}e%?S)vBe4U2+f
z_?Q`Zt2G#8{u$MXIoEpSaStNn_OUHT70=|4`(hhK``ng&SJ?=f#9$QB3ez5I{!N-M
zDv}XtX1T5PgLDyfNYNKu30<kHrW&XmWWgo*+m=14-f;qx$+Mm2%yw6rem)o8baj{#
zp16~cxwibr@}``Yzm!dw8nWnihiuE9%2%os3!H>K?OW)>E?0b<$=zMfJ{<eC{86R5
z)!dc-v;3x0e=1A#<yq4!;6`@Q_Kr{T;%(I${50O@@{Ep7jnK)=2K?M_ar8nq7R?&j
z$Bwx|x0>iP*WRcPR}T_<LYIA;hAS7sg&B!nu+p#Z%1eD=%%*&=NbqAR`5(&<`uO>!
z_Kc*7Ju^M!ly#OjdWKY2=U%h#rTWvcBo1Z!NI4$s{}W|kB)^!=p6U0Yn6j^xi6ZJ(
z8Gav0=0N{{UjHI<Q1!qHe4HuPLw#e`a=fuh1Vj1Y?!s@Tw&=mg!ginDFm)~oxZ%2X
zO>y#p9OtO*^z;OLhuYy<WRK6ps6@}6UU$8aD`cE&P+r&l^Xea+l+z@w$EkK*y#}*|
zc60vGe~7};WHveQUP#Ofd)z%)O-!z<=bRAuo&DYOk>kCV9ZxwvVc3oSSY>+SlnJ&Q
zF;~+I$(f7HM_XZrHy2G*_Qik65GN)l4H~C9CE9sGpJ&f$MQJI$flYR(Y2610z%y~)
zuX#1n(aWQ^qlH}bYgA$5zA}k5EN8!`JKo4YRssn}$jVA<w?gw&zt0={=1%09QxF#7
zMeqk*ppe~RCjajxMfLh*!Pbj<YH>H9u6s?4@UYz<K!bRkAGk^<qUV8Y+)|Km4+D8-
z_UN>Zs;$9mJ=wgksFH1NN&Fk=WfswOA*(PneMg^XF4ldz<%tbXoSnI>Y&6UMqK<g5
zLm5v!W6c!_w>-1VQBXzJ?N#QT%um+BLc6}ci{UpC&U<)Gk7zR$Oq^vT=9Phtot5M!
zt4xUGFIeLIBj=1DL%nu;6bLv5vhLi+oukXZrF^5)U}N53<UZoQb)x6gLEKf{(b77n
zD*f-SVwCg0YktslKPDniA)n=IWEoHTJ0xxzlsKmXZ>)Ltgm-YARVI9HQNcbiN%qlA
z$vV?s=y6`)W_#85W7rdNcoev%mY#M^m1}3w%#EHMJF$>EsUj*MPI^yM_~|}wPw2|m
zJ2Y4g4ctb#6?p<7HjoI;tQ8skn%oUkx!fu_TOwjKIZw93Yy$e-X&Sb}ld!p!hPCwg
zU4|<x>Vz5?OGo#F!w#pZt!yig{azs7nV1K`#cgF<-1XS+{(y!P*?3no_o>FiO~UU-
z@P)4@Fy!7BrW~+GM`Fs_2SstA33(yjM|Qfqe^(r@8*H%;zKH^zbh*>rMJN!+YIfe+
zI8hJ0eV`((2OIQ!cLjX>D4D27d?SkV07ka!g#C#!toJ?5a|bb^qu=4kR#KO(IJy?%
z{?@BG<7{j54cYW}DSuNQo34Y2yvSJ>95Tx(&nZFYrXoWgyumfPB>KNd0^Nx$Q4^QX
zDSPqI<b}5ktVcy`>q$S?|6?v;<_lgj1$d2$cQwR(^B8?gbAQeLfi3r;&o#FT;pVPE
z9K`PY_&(39$Nk|!pWrBcE@I(*hM9qNpG402t+X;jyGN1-I%sN#7b(*dwvW#s<MRJ|
z;(YfztUNVcsg7eUZ|R_%PU|{*bnk=C98(%66Vp*oe4o_*@b#NUvS3Ma7!{c_5VIz4
z)adKpYc?liVRGQenlo{#r`)x<Pj~f#0R0&xBOdNfoMYw}J7+szT>p>vcs3`lYw3#j
z9nLm+w;xnvb{g&yQOn%pyQtv3>zq!@do$+7JnzsQ>qN$M=yQ*rvcL1#+&(Q&-wlbM
zlkA|Wu(en-6(Z5SqhlcB3SxrbzQg^BnJI6+c_M-)8hra}&%@?u_<biXaJ$QQ7|CGz
z0!(M(AVW;%RHW@0*+2lEdiHMT-ua9*b1&lQ*Ph_4Y!ow74Qs@}4KHfKZ#B6Q&=2Cq
z<F}aL9Mwmc!6)}ac<kO`4*jkDPfxH|O5AQ0EfYkbpOs{;I3gx$^OIXEUXw+?gXb=R
zb#8F@*ORWeb%w9@(mA*jr<g#nOt#w785qD&qx6)dF@f!Q<8jBv2l}+{<xC(<VVno{
z0(NJvKUH6E>RVW5r^uq?LYLoEc%HKc^FQ*$M6zmjx+la8@F2TOeb8yvcqdx_1A?iz
Aa{vGU

literal 0
HcmV?d00001


From ce6b7ba0d424baedb1063bd1483044d42dea8d21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9mie=20Lambert?= <jerelam51@gmail.com>
Date: Sun, 1 Oct 2023 12:02:15 +0200
Subject: [PATCH 3/3] Requirements.txt a jour et fonction pour ajouter des
 points manuellement

---
 dxf_viewer/app.py           |  94 ++++++++++++++++++------------------
 dxf_viewer/requirements.txt | Bin 6590 -> 248 bytes
 2 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/dxf_viewer/app.py b/dxf_viewer/app.py
index eb1ca43..9eaaac0 100644
--- a/dxf_viewer/app.py
+++ b/dxf_viewer/app.py
@@ -1,4 +1,4 @@
-
+#Imports
 import tkinter as tk
 from tkinter import filedialog
 import os
@@ -6,7 +6,6 @@
 import sys
 import numpy as np
 from rdp import rdp
-import pprint as pp
 from collections import defaultdict
 import matplotlib.pyplot as plt
 import sys
@@ -17,32 +16,19 @@
 from matplotlib.lines import Line2D
 from matplotlib.patches import Rectangle
 from matplotlib.widgets import Cursor
-sys.path.append("./divers")
-from tools import *
 import mplcursors
 from pprint import pprint
 matplotlib.use('TkAgg')
 from tkinter.filedialog import asksaveasfile
+sys.path.append("./divers")
+from tools import *
 
-"""
-In this verson, the lower left btton ( supposed to let u add points manually doesnt work ), its to add
-also, the export to json func is not working properly i think
-The new feature is the lowest box where selected points appaears, 
-you can select a first bunch of points with the area selection and then add points
-one by one with the selector (hand icon)
-In the box you can order the points as you want by drag and drop them
-The polyline button removes all the non selected point and draw a polyline
-between remaining points in the order they are in the box 
-the line appears not to be close atm
-to be fix and can be fix quickly
-"""
-
+# To be done: json export funcion
+# Add a button to select ponint to delete from the drawing
 
 class App(tk.Tk):
-    def __init__(self):
-        
+    def __init__(self):   
         super().__init__() # create CTk window like you do with the Tk window
-        
         self.initial_width = 1600
         self.initial_height = 900
         self.geometry(f"{self.initial_width}x{self.initial_height}")
@@ -83,6 +69,7 @@ def __init__(self):
         self.lines_to_draw = []
         self.point_id = []
 
+
         #Menu
         self.buton_size = 33
         #bouton fichier
@@ -131,15 +118,16 @@ def __init__(self):
         self.are_equals = True
         CreateToolTip(self.json, text = "Export selected points\n" + \
                                         "to Json")
-       
+        
 
         #bouton add_points
         self.add_point_border = tk.Frame(self, bg="#d9d9d9")
         self.add_point_border.place(relx=0.75, rely=0.63, width=self.buton_size+4, height=self.buton_size+4)   
         self.add_point_icone = tk.PhotoImage(file="graphic/plus.png")
-        self.add_point_button = tk.Button(self.add_point_border, image=self.add_point_icone,command=self.add_point,bg="white")
+        self.add_point_button = tk.Button(self.add_point_border, image=self.add_point_icone,command=self.on_click_add,bg="white")
         self.add_point_button.place(x=2,y=2,width=self.buton_size, height=self.buton_size)
         CreateToolTip(self.add_point_button, text = "Add a Point")
+        self.add = False
 
 
         #bouton select_point with area
@@ -163,7 +151,7 @@ def __init__(self):
         self.plus_button.place(x=2,y=2,width=self.buton_size, height=self.buton_size)
         CreateToolTip(self.plus_button, text = "Select points by "+\
                                                 "click")
-        self.adding_points = False
+        self.selecting_points = False
         self.selected_points = {}
 
         
@@ -234,8 +222,6 @@ def __init__(self):
         self.mainloop()
 
 
-    
-    
 ########Fonctions liées au boutons################
 
 #Bouton fichier
@@ -365,7 +351,6 @@ def mesurer(self):
     
 #Mesure 
     def on_click_mesure(self,event):
-
         if self.point1 == []:
             if self.close: self.point1 = self.close
             else: self.point1 = [event.xdata, event.ydata]
@@ -411,8 +396,6 @@ def equalize_xy(self):
 
         self.horizontal_line = self.ax.axhline(0, color='red', linestyle='--', visible=False, lw=1)
         self.vertical_line = self.ax.axvline(0, color='red', linestyle='--', visible=False, lw=1)
-        self.fig.canvas.mpl_connect('motion_notify_event', self.cursor_hover)
-        self.fig.canvas.mpl_connect('axes_leave_event', self.cursor_leave)
         self.canvas.draw_idle()
 
 #Bouton séléction de points par aire 
@@ -481,10 +464,9 @@ def choosed_area(self,event,x_start,y_start):
         if x and y :
             for c,i in enumerate(self.lines_to_draw):
                 ids_points = self.point_id[c]
-                if not False in np.equal(i[0,:],i[-1,:]):
+                if not False in np.equal(i[0,:],i[-1,:]) and np.shape(i)[0]>1:
                     i = i[:-1,:]
                     ids_points = self.point_id[c][:-1]
-
                 self.selection += list(i[(i[:,0]>min(x_start,x))*(i[:,0]<max(x_start,x))*\
                               (i[:,1]>min(y_start,y))*(i[:,1]<max(y_start,y)),:])
                 self.id_selected += list(ids_points[(i[:,0]>min(x_start,x))*(i[:,0]<max(x_start,x))*\
@@ -513,14 +495,14 @@ def export_to_json(self):
     
 #Bouton séléction de points
     def selection_points(self):
-        if not self.adding_points:
+        if not self.selecting_points:
             self.escape(None)
-            self.adding_points = True
+            self.selecting_points = True
             self.config(cursor="hand2")
             self.plus_border["bg"] = 'black'
             self.choose_curs = self.ax.figure.canvas.mpl_connect('button_press_event', self.choose_point)
         else:
-            self.adding_points = False
+            self.selecting_points = False
             self.config(cursor="arrow")
             self.plus_border["bg"] = '#d9d9d9'
             self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
@@ -552,6 +534,7 @@ def extract_points(self):
             for i in range(self.box_points.size()):
                 item = self.box_points.get(i)
                 line.append(self.selected_points[item])
+            line.append(line[0])
             self.lines_to_draw = np.array([line])
             self.redefine_origin()
             if self.selected:
@@ -564,8 +547,23 @@ def extract_points(self):
             self.id_selected = []
         
 #Add point
-    def add_point(self):
-        pass     
+    def on_click_add(self):
+        if not self.add:
+            self.escape(None)
+            self.add_point_border["bg"] = 'black'
+            self.add_curs = self.ax.figure.canvas.mpl_connect('button_press_event', self.add_point) # evenemnt sélection
+            self.add = True
+        else:
+            self.add_point_border["bg"] = '#d9d9d9'
+            self.ax.figure.canvas.mpl_disconnect(self.add_curs)
+            self.add = False
+    
+    def add_point(self,event):
+        x = event.xdata
+        y = event.ydata
+        if x and y: 
+            self.lines_to_draw.append(np.array([[x,y]]))  
+        self.plot_on_canvas(self.lines_to_draw)
 
 ####################################################
 
@@ -581,8 +579,8 @@ def cursor_hover(self,event):
             y = event.ydata
 
             # Mettre à jour les positions des lignes
-            self.horizontal_line.set_ydata(y)
-            self.vertical_line.set_xdata(x)
+            self.horizontal_line.set_ydata([y])
+            self.vertical_line.set_xdata([x])
 
             # Afficher les lignes
             self.horizontal_line.set_visible(True)
@@ -744,9 +742,6 @@ def plot_on_canvas(self,lignes):
         self.ax.set_aspect('equal')
         self.horizontal_line = self.ax.axhline(0, color='red', linestyle='--', visible=False, lw=1)
         self.vertical_line = self.ax.axvline(0, color='red', linestyle='--', visible=False, lw=1)
-        self.fig.canvas.mpl_connect('motion_notify_event', self.cursor_hover)
-        self.fig.canvas.mpl_connect('axes_leave_event', self.cursor_leave)
-        self.fig.canvas.mpl_connect('axes_notify_event', self.closest_pt)
         self.canvas.draw()
 
 #Met en surbrillance le point le plus proche
@@ -791,10 +786,11 @@ def closest_pt(self,event):
     def highlight_selected(self,list_selected):
         if self.selected:
             self.selected.remove()
-        list_selected = np.array(list_selected)
-        self.selected = None
-        self.selected = self.ax.scatter(list_selected[:,0],list_selected[:,1],c="blue",s=80)
-        self.canvas.draw()
+        if len(list_selected) != 0:
+            list_selected = np.array(list_selected)
+            self.selected = None
+            self.selected = self.ax.scatter(list_selected[:,0],list_selected[:,1],c="blue",s=80)
+            self.canvas.draw()
 
 ####################################################
 
@@ -896,8 +892,8 @@ def escape(self,event):
             self.canvas.draw_idle()
             self.axis_bouton.configure(state='normal')
         
-        if self.adding_points:
-            self.adding_points = False
+        if self.selecting_points:
+            self.selecting_points = False
             self.config(cursor="arrow")
             self.plus_border["bg"] = '#d9d9d9'
 
@@ -905,7 +901,11 @@ def escape(self,event):
             self.button_border["bg"] = '#d9d9d9'
             self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
             self.choose = False
-            self.ax.figure.canvas.mpl_disconnect(self.choose_curs)
+
+        if self.add:
+            self.add_point_border["bg"] = '#d9d9d9'
+            self.ax.figure.canvas.mpl_disconnect(self.add_curs)
+            self.add = False
 
 #Place the leftest point to 0 and the lower one too
     def redefine_origin(self):
diff --git a/dxf_viewer/requirements.txt b/dxf_viewer/requirements.txt
index db7dced4ff87ab1b185cd6813b4bb472f239989d..f83bb81be28717d06c5890373032bb22af56fe6c 100644
GIT binary patch
literal 248
zcmXAkOOC=Y42Ji)3s#yI#Kw1+8;n94Ai|BK#D#WFKTeT%{`@~2I18_}?1%&Cn6L+m
z716@rz?%3sZ}-kDjOMP#!b}Zuf@xIzN}tr2-d!=k1ZT5&Da1nQhB(4iZ<az~t&OY7
zES$laye{8BcTrw^c=<=l4@5U=gP%miAN8{uI+(H-U)zC|9t(MLKFwa@Dv4C3G0xPv
bbpNYqX*-_j-m(`}{>DvWZi(~JyqEe1D=AC_

literal 6590
zcmZ{oTW?!c5QX<M690jB<WM_Fn;;>TmbRjz5E`UDBHMAUzSVZpI6od(-(F`t=QKf<
zQ}^uIb6K-y_U!ZTKf^LDlQJu#a#hCVCw=;5uN>*yFW;7L%CO9}vMvifdtRRDDKf`e
zf7X%NN@`Kp_VxU^zJq4}s;so~rLLiS&|2G+jaJunZP2Ws8OuMHTdiKozbko%Ra-pN
z{=-K1gJf3nzbD@piejd}^PMGIJ9<)<T@me|`fIDhk~*)-nWX0O;!5A`PTtWQos^!H
z3)$Z^zO?m&NTBhQ{7QC4+G`y8O`L&4+oQCBezHRR<0h6t%^fH`jwN@lwP&QgW9_^u
z%NkvvhNrpzm9jsQ?rDvjyxF(?is-0n*j5c7=_n&o_;jZ4So$M(&aizO)x6Hjjr6Z}
z$U3hh#kJ9QfA@S)y*exhjb*Qs^ES?d>O)Aq(i(E`Co)ZJ$5qE`#WohZCgruH$T8B6
z)I4*%t^yEVN#?4YH`?&X@xX>b<Jnm2Ap!gPVro<pYiO8BSNKDn7!Q0I$_9)xVh45Y
z>-BYA@5y6gpJ@;AJyieDYOm8K)$O`u#gW0>aosl-{_JwSNAAFNTJ;aB1ti#sN6rA;
z8Hz)f@)aItj*$t>R;n5JwNPaszm&YI2(BRM+8m3K=%9i(^60AOBX|LV_T7GOtM9Su
zh``!7o>dfY8XPAb{t;zJ(bLS0>@9fpyt3m=9<1f>Rx+3J%RL1zj4z&?={ZOdVIY)!
z?@TdG)%B==%iVhL*j~J;7;ejn&_NeSMh^%S>CHoFnX0ec=@;21M$pQ-aoysT`<0Pj
zG)NAree=;Wca0qENbmP+{n)pOICWO;#aUuAzI$3{|9SO$qrXd8h}e%?S)vBe4U2+f
z_?Q`Zt2G#8{u$MXIoEpSaStNn_OUHT70=|4`(hhK``ng&SJ?=f#9$QB3ez5I{!N-M
zDv}XtX1T5PgLDyfNYNKu30<kHrW&XmWWgo*+m=14-f;qx$+Mm2%yw6rem)o8baj{#
zp16~cxwibr@}``Yzm!dw8nWnihiuE9%2%os3!H>K?OW)>E?0b<$=zMfJ{<eC{86R5
z)!dc-v;3x0e=1A#<yq4!;6`@Q_Kr{T;%(I${50O@@{Ep7jnK)=2K?M_ar8nq7R?&j
z$Bwx|x0>iP*WRcPR}T_<LYIA;hAS7sg&B!nu+p#Z%1eD=%%*&=NbqAR`5(&<`uO>!
z_Kc*7Ju^M!ly#OjdWKY2=U%h#rTWvcBo1Z!NI4$s{}W|kB)^!=p6U0Yn6j^xi6ZJ(
z8Gav0=0N{{UjHI<Q1!qHe4HuPLw#e`a=fuh1Vj1Y?!s@Tw&=mg!ginDFm)~oxZ%2X
zO>y#p9OtO*^z;OLhuYy<WRK6ps6@}6UU$8aD`cE&P+r&l^Xea+l+z@w$EkK*y#}*|
zc60vGe~7};WHveQUP#Ofd)z%)O-!z<=bRAuo&DYOk>kCV9ZxwvVc3oSSY>+SlnJ&Q
zF;~+I$(f7HM_XZrHy2G*_Qik65GN)l4H~C9CE9sGpJ&f$MQJI$flYR(Y2610z%y~)
zuX#1n(aWQ^qlH}bYgA$5zA}k5EN8!`JKo4YRssn}$jVA<w?gw&zt0={=1%09QxF#7
zMeqk*ppe~RCjajxMfLh*!Pbj<YH>H9u6s?4@UYz<K!bRkAGk^<qUV8Y+)|Km4+D8-
z_UN>Zs;$9mJ=wgksFH1NN&Fk=WfswOA*(PneMg^XF4ldz<%tbXoSnI>Y&6UMqK<g5
zLm5v!W6c!_w>-1VQBXzJ?N#QT%um+BLc6}ci{UpC&U<)Gk7zR$Oq^vT=9Phtot5M!
zt4xUGFIeLIBj=1DL%nu;6bLv5vhLi+oukXZrF^5)U}N53<UZoQb)x6gLEKf{(b77n
zD*f-SVwCg0YktslKPDniA)n=IWEoHTJ0xxzlsKmXZ>)Ltgm-YARVI9HQNcbiN%qlA
z$vV?s=y6`)W_#85W7rdNcoev%mY#M^m1}3w%#EHMJF$>EsUj*MPI^yM_~|}wPw2|m
zJ2Y4g4ctb#6?p<7HjoI;tQ8skn%oUkx!fu_TOwjKIZw93Yy$e-X&Sb}ld!p!hPCwg
zU4|<x>Vz5?OGo#F!w#pZt!yig{azs7nV1K`#cgF<-1XS+{(y!P*?3no_o>FiO~UU-
z@P)4@Fy!7BrW~+GM`Fs_2SstA33(yjM|Qfqe^(r@8*H%;zKH^zbh*>rMJN!+YIfe+
zI8hJ0eV`((2OIQ!cLjX>D4D27d?SkV07ka!g#C#!toJ?5a|bb^qu=4kR#KO(IJy?%
z{?@BG<7{j54cYW}DSuNQo34Y2yvSJ>95Tx(&nZFYrXoWgyumfPB>KNd0^Nx$Q4^QX
zDSPqI<b}5ktVcy`>q$S?|6?v;<_lgj1$d2$cQwR(^B8?gbAQeLfi3r;&o#FT;pVPE
z9K`PY_&(39$Nk|!pWrBcE@I(*hM9qNpG402t+X;jyGN1-I%sN#7b(*dwvW#s<MRJ|
z;(YfztUNVcsg7eUZ|R_%PU|{*bnk=C98(%66Vp*oe4o_*@b#NUvS3Ma7!{c_5VIz4
z)adKpYc?liVRGQenlo{#r`)x<Pj~f#0R0&xBOdNfoMYw}J7+szT>p>vcs3`lYw3#j
z9nLm+w;xnvb{g&yQOn%pyQtv3>zq!@do$+7JnzsQ>qN$M=yQ*rvcL1#+&(Q&-wlbM
zlkA|Wu(en-6(Z5SqhlcB3SxrbzQg^BnJI6+c_M-)8hra}&%@?u_<biXaJ$QQ7|CGz
z0!(M(AVW;%RHW@0*+2lEdiHMT-ua9*b1&lQ*Ph_4Y!ow74Qs@}4KHfKZ#B6Q&=2Cq
z<F}aL9Mwmc!6)}ac<kO`4*jkDPfxH|O5AQ0EfYkbpOs{;I3gx$^OIXEUXw+?gXb=R
zb#8F@*ORWeb%w9@(mA*jr<g#nOt#w785qD&qx6)dF@f!Q<8jBv2l}+{<xC(<VVno{
z0(NJvKUH6E>RVW5r^uq?LYLoEc%HKc^FQ*$M6zmjx+la8@F2TOeb8yvcqdx_1A?iz
Aa{vGU