diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b0c7024af..338ffe157 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,11 +6,13 @@ on:
       - main
       - dev
       - alpha-dev
+      - python_helios
   pull_request:
     branches:
       - main
       - dev
       - alpha-dev
+      - python_helios
   workflow_dispatch:
 
 jobs:
@@ -21,11 +23,11 @@ jobs:
       matrix:
         os:
           - ubuntu-latest
-          - macos-latest
-          - windows-latest
+        #  - macos-latest
+         # - windows-latest
         python:
           - "3.8"
-          - "3.12"
+         # - "3.12"
     
     defaults:
       run:
@@ -53,9 +55,17 @@ jobs:
         env:
           SETUPTOOLS_SCM_SUBPROCESS_TIMEOUT: "120"
 
-      - name: Run tests
+      - name: Run unmarked tests
         # Disable MacOS for now - we do not yet officially support it and we need to invest a bit
         # more efforts into investigating broken LAZ files written by Helios on MacOS.
         if: runner.os != 'macOS' 
         run: |
           python -m pytest
+
+      - name: Run marked tests
+        if: runner.os != 'macOS' 
+        run: |
+          python -m pytest -m exe
+          python -m pytest -m pyh
+
+
diff --git a/.gitignore b/.gitignore
index 5117f0919..a18104591 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,7 +28,6 @@ valgrind.xml
 *.exe
 libhelios.so
 pyhelios.so
-helios
 
 # Output log
 *.log
diff --git a/CMakeLists.txt b/CMakeLists.txt
old mode 100644
new mode 100755
index b32028f4a..9b20b01cd
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,6 +19,21 @@ else()
   set(HELIOS_VERSION_FULL "1.3.0")
 endif()
 
+# Fetch pybind11
+find_package(pybind11 QUIET)
+
+if (NOT pybind11_FOUND)
+    message(STATUS "pybind11 not found, using FetchContent to download pybind11.")
+
+    FetchContent_Declare(
+        pybind11
+        GIT_REPOSITORY https://github.com/pybind/pybind11.git
+    )
+    FetchContent_MakeAvailable(pybind11)
+else()
+    message(STATUS "Found pybind11: ${pybind11_DIR}")
+endif()
+
 project(Helios++
   VERSION ${HELIOS_VERSION}
   LANGUAGES C CXX
@@ -131,32 +146,21 @@ if(HELIOS_BUDDING_METRICS)
   target_compile_definitions(helios PUBLIC BUDDING_METRICS=ON)
 endif()
 
-# Add the HelIOS++ executable
+# # Add the HelIOS++ executable
 add_executable(helios++)
 
 target_link_libraries(helios++ PRIVATE helios)
 
 if(BUILD_PYTHON)
-  find_package(Python COMPONENTS Interpreter Development)
-  find_package(Boost REQUIRED COMPONENTS python)
-
-  add_library(_pyhelios MODULE)
-
-  target_link_libraries(_pyhelios
-  PRIVATE
-    helios
-    Boost::python
-    Python::Module
-  )
-
-  # Control the output name of the produced shared library
-  set_target_properties(_pyhelios PROPERTIES PREFIX "")
-  set_target_properties(_pyhelios PROPERTIES OUTPUT_NAME "_pyhelios")
-  if(WIN32)
-    set_target_properties(_pyhelios PROPERTIES SUFFIX ".pyd")
-  endif()
+  include_directories(${Python_INCLUDE_DIRS})
+  include_directories(${CMAKE_SOURCE_DIR}/src/python)
+  pybind11_add_module(_helios MODULE python/helios/helios_python.cpp)
+  target_link_libraries(_helios PUBLIC helios pybind11::module)
+  install(TARGETS _helios DESTINATION .)
 endif()
 
+
+
 # Traverse the source tree to add all relevant sources
 add_subdirectory(src)
 
@@ -174,13 +178,5 @@ install(
   DESTINATION pyhelios/bin
 )
 
-if(BUILD_PYTHON)
-  install(
-    TARGETS
-      _pyhelios
-    DESTINATION .
-  )
-endif()
-
 include(FeatureSummary)
 feature_summary(WHAT ALL)
diff --git a/environment-dev.yml b/environment-dev.yml
index 6a57d1b94..7f41d3945 100644
--- a/environment-dev.yml
+++ b/environment-dev.yml
@@ -28,3 +28,11 @@ dependencies:
   - pytest
   - laspy
   - lazrs-python
+  - scipy
+  - polyscope
+  - tqdm
+  - pandas
+  - pdal
+  - ipywidgets
+variables:
+  PYTHONPATH: "python"
\ No newline at end of file
diff --git a/example_notebooks/A-arboretum_notebook.ipynb b/example_notebooks/A-arboretum_notebook.ipynb
index 8b9d73ce7..f7c586b2f 100644
--- a/example_notebooks/A-arboretum_notebook.ipynb
+++ b/example_notebooks/A-arboretum_notebook.ipynb
@@ -79,7 +79,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "3f994392",
    "metadata": {},
    "outputs": [],
@@ -132,19 +132,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "9b8236b8",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "File already exists. Great!\n",
-      "File already exists. Great!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "def reporthook(count, block_size, total_size):\n",
     "    percent = min(int(count * block_size * 100 / total_size), 100)\n",
@@ -181,25 +172,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "cb134167",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "69691bb7009e478b97698c7c28d7d7fd",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Dropdown(description='Which version do you want to run?', index=2, options=('light', 'medium', 'heavy'), style…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "style = {'description_width': 'initial'}\n",
     "\n",
@@ -235,7 +211,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "82884e98",
    "metadata": {},
    "outputs": [],
@@ -245,21 +221,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "b1d5aff0",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.1"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "voxel_size"
    ]
@@ -290,7 +255,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "5a02940f",
    "metadata": {},
    "outputs": [],
@@ -310,7 +275,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "b70b08be",
    "metadata": {},
    "outputs": [],
@@ -341,7 +306,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "e154bce0",
    "metadata": {},
    "outputs": [],
@@ -361,7 +326,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "4fa17317",
    "metadata": {},
    "outputs": [],
@@ -385,7 +350,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "aa34ae38",
    "metadata": {},
    "outputs": [],
@@ -405,7 +370,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "ea87db39",
    "metadata": {},
    "outputs": [],
@@ -429,7 +394,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "id": "9e1c393c",
    "metadata": {},
    "outputs": [],
@@ -467,7 +432,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "907160ca",
    "metadata": {},
    "outputs": [],
@@ -541,43 +506,7 @@
    "execution_count": 18,
    "id": "a2bef3db",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",
-      "<document>\n",
-      "    <scene id=\"arboretum\" name=\"Arboretum\">\n",
-      "        \n",
-      "        <part>\n",
-      "            <filter type=\"geotiffloader\">\n",
-      "                <param type=\"string\" key=\"filepath\" value=\"data\\sceneparts\\arboretum_hd\\2021-06-18_TLS_Arboretum_VZ-2000i_dtm_50cm.tif\" />\n",
-      "                <param type=\"string\" key=\"matfile\" value=\"data/sceneparts/basic/groundplane/groundplane.mtl\" />\n",
-      "                <param type=\"string\" key=\"matname\" value=\"None\" />\n",
-      "            </filter>\n",
-      "            \n",
-      "        </part>\n",
-      "\n",
-      "        <part>\n",
-      "            <filter type=\"xyzloader\">\n",
-      "                <param type=\"string\" key=\"filepath\" value=\"data\\sceneparts\\arboretum_hd\\2021-06-18_TLS_Arboretum_VZ-2000i_vegetation.xyz\" />\n",
-      "                <param type=\"string\" key=\"separator\" value=\",\" />\n",
-      "                <param type=\"double\" key=\"voxelSize\" value=\"0.1\" />\n",
-      "                <!-- Normal estimation using Singular Value Decomposition (SVD)\n",
-      "                MODE 1: simple mode / MODE 2: advanced mode for large files, which works in batches -->\n",
-      "                <param type=\"int\" key=\"estimateNormals\" value=\"1\" />\n",
-      "                <!-- If less than three points fall into one voxel, it is discarded.\n",
-      "                To avoid this, a default Normal can be assigned to these voxels with:-->\n",
-      "                <param type=\"vec3\" key=\"defaultNormal\" value=\"0;0;1\" /> \n",
-      "            </filter>\n",
-      "            \n",
-      "        </part>\n",
-      "    </scene>\n",
-      "</document>\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(scene_content)"
    ]
@@ -698,18 +627,7 @@
    "execution_count": 24,
    "id": "b60b9c2c",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmYAAAHACAYAAAAIgaTkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB0xklEQVR4nO3de1xUdcLH8e8wIyAIU4CAlBdKZU0wNBUlS1oNNdNcXQtR1FbNVtHM3E2fbfOylWvbxd1tKzO8UCpaqdm26y3N8gJ4GwU1xVveQM3LgGKDwHn+YM/EMAMOw8yc2/f9es3rWc/85sxhnmH4dOac89MJgiCAiIiIiCTnI/UGEBEREVEVhhkRERGRTDDMiIiIiGSCYUZEREQkEwwzIiIiIplgmBERERHJBMOMiIiISCYYZkREREQywTAjIiIikgmGGREREZFMMMwU5LvvvsOAAQMQFRUFnU6HtWvX1nsdgiDgrbfeQtu2beHn54fmzZvjjTfecP/GEhERUb0ZpN4Act7Nmzfx4IMP4tlnn8WQIUNcWscLL7yAjRs34q233kJcXBzMZjN++uknN28pERERuULHScyVSafTYc2aNRg0aJB1WVlZGV555RUsW7YM169fR2xsLObNm4ekpCQAwJEjR9ChQwfk5+cjJiZGmg0nIiKiWvGrTBV59tlnsWPHDmRlZeHgwYMYOnQo+vbti4KCAgDAV199hfvuuw///ve/ER0djVatWmHs2LG4evWqxFtOREREAMNMNU6cOIEVK1bgs88+wyOPPIL7778f06ZNQ48ePbB48WIAwMmTJ/Hjjz/is88+Q2ZmJpYsWYK9e/fit7/9rcRbT0RERACPMVONffv2QRAEtG3b1ma5xWJBaGgoAKCyshIWiwWZmZnWcRkZGXjooYdw9OhRfr1JREQkMYaZSlRWVkKv12Pv3r3Q6/U29zVp0gQA0KxZMxgMBpt4a9euHQDgzJkzDDMiIiKJMcxUomPHjqioqMClS5fwyCOPOBzz8MMPo7y8HCdOnMD9998PADh27BgAoGXLll7bViIiInKMZ2UqyI0bN3D8+HEAVSH2zjvv4LHHHkNISAhatGiBESNGYMeOHXj77bfRsWNH/PTTT9iyZQvi4uLwxBNPoLKyEl26dEGTJk0wf/58VFZWYuLEiQgODsbGjRsl/umIiIiIYaYg3377LR577DG75aNGjcKSJUtw+/ZtvPbaa8jMzMT58+cRGhqK7t27Y/bs2YiLiwMAXLhwAZMmTcLGjRsRGBiIfv364e2330ZISIi3fxwiIiKqgWFGREREJBO8XAYRERGRTDDMiIiIiGSCZ2UqQGVlJS5cuICgoCDodDqpN4eIiIicIAgCSkpKEBUVBR8f5/aFMcwU4MKFC2jevLnUm0FEREQuOHv2LO69916nxjLMFCAoKAhA1f9jg4ODJd4aIiIickZxcTGaN29u/TvuDIaZAohfXwYHBzPMiIiIFKY+hyHx4H8iIiIimWCYEREREcmEpGE2a9Ys6HQ6m1tkZKRTj92xYwcMBgPi4+NtliclJdmtU6fToX///tYxc+fORZcuXRAUFITw8HAMGjQIR48etVnP6tWr0adPH4SFhUGn08FkMtltg6PnSklJsRlz7do1pKWlwWg0wmg0Ii0tDdevX3fqZyQiIiJtkXyPWfv27VFYWGi95eXl3fExZrMZI0eORK9evezuW716tc368vPzodfrMXToUOuYbdu2YeLEicjOzsamTZtQXl6O5ORk3Lx50zrm5s2bePjhh/HXv/61zm0ZN26czfMtWLDA5v7U1FSYTCasX78e69evh8lkQlpa2h1/RiIiItIeyQ/+NxgMTu8lE40fPx6pqanQ6/VYu3atzX0153zMyspCQECATZitX7/eZszixYsRHh6OvXv34tFHHwUAazydPn26zm0JCAiodfuPHDmC9evXIzs7GwkJCQCAhQsXonv37jh69ChiYmLu+LMSERGRdki+x6ygoABRUVGIjo5GSkoKTp48Wef4xYsX48SJE5g5c6ZT68/IyEBKSgoCAwNrHWM2mwHYR50zli1bhrCwMLRv3x7Tpk1DSUmJ9b5du3bBaDRaowwAunXrBqPRiJ07d9b7uYiIiEjdJN1jlpCQgMzMTLRt2xYXL17Ea6+9hsTERBw6dAihoaF24wsKCjB9+nR8//33MBjuvOm5ubnIz89HRkZGrWMEQcDUqVPRo0cPxMbG1mv7hw8fjujoaERGRiI/Px8zZszAgQMHsGnTJgBAUVERwsPD7R4XHh6OoqKiWtdrsVhgsVis/y4uLq7XdhEREZEySRpm/fr1s/7vuLg4dO/eHffffz+WLl2KqVOn2oytqKhAamoqZs+ejbZt2zq1/oyMDMTGxqJr1661jklPT8fBgwexffv2em//uHHjrP87NjYWbdq0QefOnbFv3z506tQJgONrlwiCUOc1TebOnYvZs2fXe3uIiIhI2ST/KrO6wMBAxMXFoaCgwO6+kpIS7NmzB+np6TAYDDAYDJgzZw4OHDgAg8GALVu22IwvLS1FVlYWxo4dW+vzTZo0CevWrcPWrVudniqhLp06dUKjRo2s2x8ZGYmLFy/ajbt8+TIiIiJqXc+MGTNgNputt7NnzzZ424iIiEj+JD/4vzqLxYIjR47gkUcesbsvODjY7ozN999/H1u2bMHnn3+O6Ohom/tWrVoFi8WCESNG2K1LEARMmjQJa9aswbfffmv3WFcdOnQIt2/fRrNmzQAA3bt3h9lsRm5urnWvXU5ODsxmMxITE2tdj5+fH/z8/NyyTURERKQckobZtGnTMGDAALRo0QKXLl3Ca6+9huLiYowaNQpA1Z6j8+fPIzMzEz4+PnbHgIWHh8Pf39/hsWEZGRkYNGiQw2PVJk6ciOXLl+PLL79EUFCQ9Xgvo9GIxo0bAwCuXr2KM2fO4MKFCwBgvc5ZZGQkIiMjceLECSxbtgxPPPEEwsLCcPjwYbz00kvo2LEjHn74YQBAu3bt0LdvX4wbN856GY3nnnsOTz75JM/IJCIiIjuSfpV57tw5DBs2DDExMRg8eDB8fX2RnZ2Nli1bAgAKCwtx5syZeq/32LFj2L59O8aMGePw/g8++ABmsxlJSUlo1qyZ9bZy5UrrmHXr1qFjx47WC9OmpKSgY8eO+PDDDwEAvr6++Oabb9CnTx/ExMRg8uTJSE5OxubNm6HX663rWbZsGeLi4pCcnIzk5GR06NABn3zySb1/JiIiIlI/nSAIgtQbQXUrLi6G0WiE2WzmJOZEGlJZKaCsohL+jfR3HkxEsuPK329ZHfxPRERVfrphwYD3tqPb3G+w+/RVqTeHiLyEYUZEJDM/3bBg2EfZOHShGNdLb2PUolzGGZFGMMyIiGREjLKCSzcQGeyPbveFoLSsgnFGpBEMMyIimagZZVnPdcOSZ7vikTZhjDMijWCYERHJgKMoaxUWCP9Geiwc2ZlxRqQRDDMiIonVFmUixhmRdjDMiIgkdKcoEzkbZ4IgIP+8GbfKKryx+UTkZgwzIiKJOBtlojvFmSAI+Mu/j+DJf27HU//ajqs3y7zxYxCRGzHMiIgkUN8oE9UWZ2KULdpxCgBw7OINjFyUA/Ot257+UYjIjRhmRERe5mqUiRzF2VP/2mGNshd6tUFooC/yzxfj2cW5uGkp99SPQkRuxjAjIvKihkaZqGacHTxnBgDMHRyHFx9vi0/HJsDYuBH2nbmOsUv34OfbPOaMSAkYZkREXuKuKBP5GXzQPCTAZlnr8CYAgHbNgpH5u65o4mfArpNX8PtP96KsvLJB209EnscwIyLyAndHmXhM2fKcMzbLq58Q8GDzu7BodBf4N/LB1qOX8ULWfpRXMM6I5IxhRkTkYZ6KMvGYsrmD4/DDX/o6PFuza3QIFo7sDF+9D/6bX4Q/fn4QlZWCW34uInI/hhkRkQd5I8qGdW1R56U0HmnTFP8a3gkGHx1W7z+PV77MhyAwzojkiGFGROQh3ooyUV1x9vgDEXj3mXjodMDynDN47esjjDMiGWKYERF5gLejTFRXnA14MArzhnQAAGRsP4V3Nx1zeXuIyDMYZkREbiZVlInqirOnOzfHnKfaAwD+seU4Pvj2hMvbRUTuxzAjInIjqaNMVFecjezeCtP7/QoAMG/9D1jyv3UTkfQYZkREbiKXKBPVFWfP97wfk3u1AQDM+uowVu0+6/J2EpH7MMyIiNxAblEmqivOXuzdBuMeiQYAvLz6IL40nXd5e4nIPRhmREQNJNcoE9UWZzqdDv/3RDsMT2gBQQCmrjqAjYeKXH4eImo4hhkRUQPIPcpEdcXZX56KxeBO96CiUkD68v3Yduxyg5+PiFzDMCMicpFSokxUW5z5+Ojw5pAO6B/XDGUVlRj/yR7knLzituclIucxzIiIXKC0KBPVFmcGvQ/efSYev/5VOH6+XYnfLdmN/Weuuf35iahuDDMionpSapSJaoszX4MP3h/eCYn3h+Lm/5YfumD22HYQkT2GGRFRPSg9ykS1xZm4/KGWd6P453KMzMjF8UslHt8eIqrCMCMicpJaokxUW5wF+hmw+NkuiLvHiCs3yzD84xz8eOWm17aLSMsYZkRETlBblIlqi7Ng/0bI/F1XxEQE4WKxBakLc3Dh+i2vbx+R1jDMiIjuQK1RJqotzu4O9MUnY7siOiwQ56/fwvCPc3Cp5GfJtpNICxhmRER1UHuUiWqLs/Agfywbm4B77mqMUz/dRNrHubh2s0zqzSVSLUnDbNasWdDpdDa3yMhIpx67Y8cOGAwGxMfH2yxPSkqyW6dOp0P//v2tY+bOnYsuXbogKCgI4eHhGDRoEI4ePWqzntWrV6NPnz4ICwuDTqeDyWSyuf/q1auYNGkSYmJiEBAQgBYtWmDy5Mkwm23PYGrVqpXdtkyfPt35F4mIJKOVKBPVFmdRdzXG8nEJiAj2w9GLJRi5KBfFP9+WenOJVEnyPWbt27dHYWGh9ZaXl3fHx5jNZowcORK9evWyu2/16tU268vPz4der8fQoUOtY7Zt24aJEyciOzsbmzZtQnl5OZKTk3Hz5i8Ht968eRMPP/ww/vrXvzrchgsXLuDChQt46623kJeXhyVLlmD9+vUYM2aM3dg5c+bYbNMrr7zizEtDRBLSWpSJaouzlqGBWDY2AaGBvsg7b8bvFu9GaVm51JtLpDoGyTfAYHB6L5lo/PjxSE1NhV6vx9q1a23uCwkJsfl3VlYWAgICbMJs/fr1NmMWL16M8PBw7N27F48++igAIC0tDQBw+vRph9sQGxuLL774wvrv+++/H6+//jpGjBiB8vJyGAy/vLRBQUH1/hmJSDpajTKRGGfjMvfg+4KfMGpRLpb+riu6tApB5piuGPZRNvb8eA3jMvcgY1QX+DfSS73JRKoh+R6zgoICREVFITo6GikpKTh58mSd4xcvXowTJ05g5syZTq0/IyMDKSkpCAys/UNV/PqxZtTVl9lsRnBwsE2UAcC8efMQGhqK+Ph4vP766ygrq/v4DIvFguLiYpsbEXmH1qNMVNues/ZRRiz9XVcE+uqx4/gVTFi2D2XllVJvLpFqSBpmCQkJyMzMxIYNG7Bw4UIUFRUhMTERV644nqOtoKAA06dPx7Jly+zix5Hc3Fzk5+dj7NixtY4RBAFTp05Fjx49EBsb6/LPcuXKFfzlL3/B+PHjbZa/8MILyMrKwtatW5Geno758+djwoQJda5r7ty5MBqN1lvz5s1d3i4iqp8Jy/ZpPspEtcVZxxZ3I2N0F/g38sGWHy7hxZUmlFcwzojcQdIw69evH4YMGYK4uDj07t0bX3/9NQBg6dKldmMrKiqQmpqK2bNno23btk6tPyMjA7GxsejatWutY9LT03Hw4EGsWLHCtR8CQHFxMfr3748HHnjAbk/eiy++iJ49e6JDhw4YO3YsPvzwQ2RkZNQanwAwY8YMmM1m6+3s2bMubxsR1Y/uf/+3UhBQKQgur0fpUSaqLc663ReKBWmd4av3wdd5hfjjFwdRWen660VEVST/KrO6wMBAxMXFoaCgwO6+kpIS7NmzB+np6TAYDDAYDJgzZw4OHDgAg8GALVu22IwvLS1FVlZWnXvLJk2ahHXr1mHr1q249957XdrmkpIS9O3bF02aNMGaNWvQqFGjOsd369YNAHD8+PFax/j5+SE4ONjmRkTe8f7wToiJCMKlEgtSPsrGycs36r0OtUSZqLY469m2Kd5L7Qi9jw6r953Hn7/Mh9CAmCUimYWZxWLBkSNH0KxZM7v7goODkZeXB5PJZL09//zziImJgclkQkJCgs34VatWwWKxYMSIEXbrEgQB6enpWL16NbZs2YLo6GiXtre4uBjJycnw9fXFunXr4O/vf8fH7N+/HwAc/oxEJL3QJn5YPi7B5ThTW5SJaouz5PaReOfpB6HTActyzuCN/xxhnBE1gKRhNm3aNGzbtg2nTp1CTk4Ofvvb36K4uBijRo0CUPWV3siRI6s21McHsbGxNrfw8HD4+/sjNjbW7uD+jIwMDBo0CKGhoXbPO3HiRHz66adYvnw5goKCUFRUhKKiIty69ct0I1evXoXJZMLhw4cBAEePHoXJZEJRURGAqj1l4iU2MjIyUFxcbF1PRUUFAGDXrl149913YTKZcOrUKaxatQrjx4/HwIED0aKF8j+oidTK1ThTa5SJaouzp+LvwV8HxwEAFn5/Cu9utv/Wg4icI2mYnTt3DsOGDUNMTAwGDx4MX19fZGdno2XLlgCAwsJCnDlzpt7rPXbsGLZv3+7wmmIA8MEHH8BsNiMpKQnNmjWz3lauXGkds27dOnTs2NF6YdqUlBR07NgRH374IQBg7969yMnJQV5eHlq3bm2zHvGYMD8/P6xcuRJJSUl44IEH8Oqrr2LcuHENOp6NiLyjvnGm9igT1RZnz3RpgVkDHgAA/OObAny47YTEW0qkTDqB+5xlr7i4GEaj0Xo5DiLynis3qibwPnqxBOFBfsh6rhvua9rEZoxWoqy6n29XWK9zFuCrt17n7P1vj+PN9VUzqcx5qj16tYtA0yZ+8DXI6sgZIq9w5e83w0wBGGZE0qorzrQYZaLa4uztjUfxzy2/nODUJrwJlo1LQHjQnY/DJVITV/5+8z9hiIjuoLavNbUcZUDtX2tOfbwtDD4667iCSzeQujAHl0p+lnBriZSBe8wUgHvMiOSh5p6z9lHB2Hr0MgDtRVl1Nfec/fpX4fj3wUK7ca3Dm2A595yRhnCPGRGRB9Xcc8Yoq1Jzz5kYZeN73offdLzHOu4495wR3RHDjIioHkICfdGuWZDNsoTohs2zqwb+jfTo0TrMZlnvdhH42287oF9spHUZ44yobgwzIiIniceUrTVdsFnu6gwBarJ052nM/e8PNstGLcrF/rPX8feUjkiKaWpdzjgjqh3DjIjICY4O9N/7Su8GT9+kBkt3nsbMdYcAAL9Puh8//KWvzQkBB85dx4cjHkL3+3654DfjjMgxhhkR0R3UdvZlQ6dvUoOaUfbHPjEOz9bMO2/Gx6M6o1OLu6yPZZwR2WOYERHV4U6XxNBynDmKMp2u6jIZjuLscGExFj/bFbH3/HJ2GuOMyBbDjIioFs5ep0yLcVZXlIkcxdmxiyXI/F0C2oT/MnsC44zoFwwzIiIH6nvxWC3FmTNRJnIUZycu38CysQloFRpgHcc4I6rCMCMiqsHVK/prIc7qE2UiR3H249VSLBvXDffc1dg6jnFGxDAjIrLR0GmW1BxnrkSZyFGcXbh+C8vGJiA8yM86jnFGWscwIyL6H3fNfanGOGtIlIkcxdnlGxYsG5uAkEBf6zjGGWkZw4yICO6LMpGa4swdUSZyFGfXb91G5u+6IsjfYB3HOCOtYpgRkea5O8pEaogzd0aZyFGc3bpdgSXPdkWAr946jnFGWsQwIyJN81SUiZQcZ56IMpGjOKsUBGSM6gI/wy9/mhhnpDUMMyLSLE9HmUiJcebJKBM5ijODXocFaQ+hkf6X52KckZYwzIhIk7wVZSIlxZk3okzkKM4C/Qz457BO0Pswzkh7GGZEpDnejjKREuLMm1EmchRnoU188fbQB1H9qRlnpAUMMyLSFKmiTCTnOJMiykSO4uyeuxvjjd/E2YxjnJHaMcyISDOkjjKRHONMyigTOYqz1uFN8OqTD9iMY5yRmjHMiEgT5BJlIjnFmRyiTOQozuLuNeIPfWJsxjHOSK0YZkSkenKLMpEc4kxOUSZyFGddo0Mw8bH7bcYxzkiNGGZEpGpyjTKRlHEmxygTOYqznm3DMTqxlc04xhmpDcOMiFRL7lEmkiLO5BxloppxNnpxLp6Ia4aULs1txjHOSE0YZkSkSkqJMpE340wJUSZyFGeDOt6Dp+KjbMYxzkgtGGZEpDpKizKRN+JMSVEmqhlnv1uyGyldWqBP+wibcYwzUgOGGRFJ6nKJBU9/uAvPLNiFKzcsDV6fUqNM5Mk4U2KUiWrG2ZiluzGyeyv0bNvUZhzjjJSOYUZEkrlcYkHqwmzknr6KnFNXkbowp0FxpvQoE3kizpQcZaKacTYucw/GPhKNhOgQm3GMM1IyScNs1qxZ0Ol0NrfIyEinHrtjxw4YDAbEx8fbLE9KSrJbp06nQ//+/a1j5s6diy5duiAoKAjh4eEYNGgQjh49arOe1atXo0+fPggLC4NOp4PJZLLbBovFgkmTJiEsLAyBgYEYOHAgzp07ZzPm2rVrSEtLg9FohNFoRFpaGq5fv+7Uz0ikZmKUFVy6gchgf4QH+eHoxRKX40wtUSZyZ5ypIcpENeNs/Cd78XzS/ejY4i6bcYwzUirJ95i1b98ehYWF1lteXt4dH2M2mzFy5Ej06tXL7r7Vq1fbrC8/Px96vR5Dhw61jtm2bRsmTpyI7OxsbNq0CeXl5UhOTsbNmzetY27evImHH34Yf/3rX2vdjilTpmDNmjXIysrC9u3bcePGDTz55JOoqKiwjklNTYXJZML69euxfv16mEwmpKWlOfvyEKlSzShb8Vw3rHium8txprYoE7kjztQUZaKacTZx2T6kP9YaDzQLthnHOCMl0gmCIEj15LNmzcLatWsd7o2qS0pKCtq0aQO9Xn/Hx8+fPx+vvvoqCgsLERgY6HDM5cuXER4ejm3btuHRRx+1ue/06dOIjo7G/v37bfbOmc1mNG3aFJ988gmeeeYZAMCFCxfQvHlz/Oc//0GfPn1w5MgRPPDAA8jOzkZCQgIAIDs7G927d8cPP/yAmBjbK1nXpri4GEajEWazGcHBwXd+AJGMOYqy6LCq380Tl29g2EfZuFRiQUxEEJaPS0BoE78616fWKKvuyg0LUhfm4OjFEoQH+SHruW64r2mTOz5OjVFW3c+3q77O/L7gJwT46vHO0/F4a+NRHL9UFa86HSAIQOvwJlg+LgHhQf4SbzFpjSt/vyXfY1ZQUICoqChER0cjJSUFJ0+erHP84sWLceLECcycOdOp9WdkZCAlJaXWKAOqIgsAQkJCah1T0969e3H79m0kJydbl0VFRSE2NhY7d+4EAOzatQtGo9EaZQDQrVs3GI1G6xhHLBYLiouLbW5EalBXlAHA/U2b1GvPmRaiDHBtz5naowyw33M2dZUJU3q3QcvQAACAXqeDr96He85IUSQNs4SEBGRmZmLDhg1YuHAhioqKkJiYiCtXrjgcX1BQgOnTp2PZsmUwGAx3XH9ubi7y8/MxduzYWscIgoCpU6eiR48eiI2NdXrbi4qK4Ovri7vvvttmeUREBIqKiqxjwsPD7R4bHh5uHePI3LlzrcekGY1GNG/evNaxREpxpygTORtnWokyUX3iTAtRJqoZZ3/8/CBe7N0WUUZ/lFcKMOh1aNxIzzgjxZA0zPr164chQ4YgLi4OvXv3xtdffw0AWLp0qd3YiooKpKamYvbs2Wjbtq1T68/IyEBsbCy6du1a65j09HQcPHgQK1ascO2HqEEQBJsPQEcfhjXH1DRjxgyYzWbr7ezZs27ZNiKpOBtlojvFmdaiTORMnGkpykQ14+z/1uRhyuNt0TTID6VlFfBv5GONs+lf3Pk4ZiIpSf5VZnWBgYGIi4tDQUGB3X0lJSXYs2cP0tPTYTAYYDAYMGfOHBw4cAAGgwFbtmyxGV9aWoqsrKw695ZNmjQJ69atw9atW3HvvffWa1sjIyNRVlaGa9eu2Sy/dOkSIiIirGMuXrxo99jLly9bxzji5+eH4OBgmxuRUtU3ykS1xZlWo0xUV5xpMcpENeNs1rpDmNK7De4OaIRrpbdx63bVSVni15xEciWrMLNYLDhy5AiaNWtmd19wcDDy8vJgMpmst+effx4xMTEwmUw2x3EBwKpVq2CxWDBixAi7dQmCgPT0dKxevRpbtmxBdHR0vbf1oYceQqNGjbBp0ybrMvEs0MTERABA9+7dYTabkZubax2Tk5MDs9lsHUOkZq5GmchRnL240qTZKBM5irNZ6w5pNspENePs9a+PoH2U0WbMH/o4d9IVkVQkPStz2rRpGDBgAFq0aIFLly7htddew7Zt25CXl4eWLVtixowZOH/+PDIzMx0+vq6zOh955BHcc889yMrKsrtvwoQJWL58Ob788kubMyONRiMaN24MALh69SrOnDmDCxcuoH///sjKykJMTAwiIyOt11r7/e9/j3//+99YsmQJQkJCMG3aNFy5cgV79+6FXq8HUPV17YULF7BgwQIAwHPPPYeWLVviq6++cvp14lmZpEQNjbLqTly+gZSPsnG55JevM7UaZdVVP1tTpNUoq6762Zo19W4XgQ9GdEIjvaz2S5BKKe6szHPnzmHYsGGIiYnB4MGD4evri+zsbLRs2RJA1R6oM2fO1Hu9x44dw/bt2zFmzBiH93/wwQcwm81ISkpCs2bNrLeVK1dax6xbtw4dO3a0Xpg2JSUFHTt2xIcffmgd8+6772LQoEF4+umn8fDDDyMgIABfffWVNcoAYNmyZYiLi0NycjKSk5PRoUMHfPLJJ/X+mYiUxJ1RBgD3hQUiNsr2Qy35gdoPB9CK0CZ+6BNre1HuoQ/dq+koA6r2nD3Txfakqcm92sDX4IPNRy7ixZUmVFRKtk+CqE6S7jEj53CPGSmJu6Os5jFlImevc6Zm1Y8pE9XnOmdqtfnwRfx+2V7crvjlz1uArx6jE1th4fcncbtCwNCH7sW8IR3g46PtiCXPUtweMyJSF09H2dzBcfjmpZ4Nnr5JDWoe6L/3ld4emfhcaapHWf8OzZA/u4/1mLMlO08jrVsr+OiAz/aew+yvDoH7JkhuGGZE5BbeiLJhXVvU+yK0auTo7EtPTHyuNDWj7O/PxKOJn8HmhICs3WfwTJcW0OmApbt+xLz1RxlnJCsMMyJqMG9FmUjLcVbXJTG0HGeOoszwvwP8a56t+aXpPAbF3wMA+HDbCfxzy3EpN53IBsOMiBrE21Em0mKcOXOdMi3GWV1RJqoZZxsOFaFv+6oTJ97ZdAwff1/3dIBE3sIwIyKXSRVlIi3FWX0uHqulOHMmykQ14+y7gst4tG1TAMBrXx/Bp9k/enPTiRximBGRS6SOMpEW4syVK/prIc7qE2WimnG25/RVdGlVNefxn7/Mx+p957yx6US1YpgRUb3JJcpEao6zhkyzpOY4cyXKRDXj7NCFYrSPCoYgANM+O4D/5BV6eOuJascwI6J6kVuUidQYZ+6Y+1KNcdaQKBPVjLOTl2/ivrBAVArA5BX7seUH+3mOibyBYUZETpNrlInUFGfunJBcTXHmjigTVY+zW7crcMF8C1FGf5RXCnj+033Yedx+SiciT2OYEZFT5B5lIjXEmTujTKSGOHNnlImqx9nPtyvx080y3B3QCGXllRibuQd7f7zqpq0ncg7DjIjuSClRJlJynHkiykRKjjNPRJmoepyVlVfihqUcjRvpUVpWgdGLdiPvnNktz0PkDIYZEdVJaVEmUmKceTLKREqMM09Gmah6nN2uEGApr4CPDiixlCNtUQ6OFpW49fmIasMwI6JaKTXKREqKM29EmUhJceaNKBNVj7NKAaj830xN10tvY/jHObJ9jUhdGGZE5JDSo0ykhDjzZpSJlBBn3owyUfU4q+6nGxYM/zgHZ6+WevT5iRhmRGRHLVEmknOcSRFlIjnHmRRRJqotzgrNP2P4xzm4WPyzV7aDtIlhRkQ21BZlIjnGmZRRJpJjnEkZZaLa4uzM1VIM/1j69w6pF8OMiKzUGmUiOcWZHKJMJKc4k0OUiWqLs+OXbmBERi7Mpbcl2S5SN4YZEQFQf5SJ5BBncooykRziTE5RJqotzo4UFmPU4lzcsJRLtGWkVgwzItJMlImkjDM5RplIyjiTY5SJaosz09nr+N2S3bhVViHRlpEayeNdT0SS0VqUiaSIMzlHmUiKOJNzlIlqi7PcU1cx/tO9sJQzzsg95PXOJyKv0mqUibwZZ0qIMpE340wJUSaqLc6+O3YZk5bvx+2KSom2jNREnu9+IvI4rUeZyBtxpqQoE3kjzpQUZaLa4mzj4Yt4adUBVIhXpSVykbx/A4jIIyorBYxalKv5KBN5Ms6UGGUiT8aZEqNMVFucrTtwAf+3Og+VjDNqAGX8FhCRW5VVVOL89VsAgFZhAWhm9Hd5XUqPMpEn4kzJUSbyRJwpOcpEtcXZyj1nMeffhyEIjDNyjbJ+E4jILfwb6fFR2kMI8NUj++RVjMvcg59v1//gZbVEmcidcaaGKBO5M87UEGWi2uJsyc7T+NuGoxJtFSmdMn8biKjBEu4LxeLRXRDgq8f3BT/VO87UFmUid8SZmqJM5I44U1OUiWqLs/e/PYH3thRItFWkZMr+jSCiBnE1ztQaZaKGxJkao0zUkDhTY5SJaouztzYeQ8b2UxJtFSmVOn4riMhl9Y0ztUeZyJU4U3OUiVyJMzVHmai2OPvLvw9jec4ZibaKlEhdvxlE5BJn40wrUSaqT5xpIcpE9YkzLUSZqLY4+9PaPKzZf85mWVl5JU8QIIfU+dtBRPV2pzjTWpSJnIkzLUWZyJk401KUiRzFmSAA0z47iPX5hQCAg+eu4+F5W9D/H9txqeRnqTaVZErS35BZs2ZBp9PZ3CIjI5167I4dO2AwGBAfH2+zPCkpyW6dOp0O/fv3t46ZO3cuunTpgqCgIISHh2PQoEE4etT2DBpBEDBr1ixERUWhcePGSEpKwqFDh6z3nz592uHz6HQ6fPbZZ9ZxrVq1srt/+vTpLrxaRJ5XW5xpNcpEdcWZFqNMVFecaTHKRI7irKJSwKQV+/GPbwow4uMcXC6x4HBhMVIX5jDOyIZOkHBf6qxZs/D5559j8+bN1mV6vR5Nmzat83FmsxmdOnVC69atcfHiRZhMJut9V69eRVlZmfXfV65cwYMPPoiPP/4Yo0ePBgD07dsXKSkp6NKlC8rLy/GnP/0JeXl5OHz4MAIDqy6yOW/ePLz++utYsmQJ2rZti9deew3fffcdjh49iqCgIFRUVODy5cs22/XRRx/hzTffRFFREZo0aQKgKszGjBmDcePGWcc1adLEer8ziouLYTQaYTabERwc7PTjiFyVc/IKnl2yG6VlFXikTRiahwRYj5PRWpRVd+LyDQz7KBuXSiyIiQhCn9hI/OObqjPvtBZl1V25YUHqwhwcvViC8CA/jHvkPry54QdNRll1P9+uwLjMPfi+4Ce7+zq2uAtF5p9RaP4ZrcObYPm4BIQHuX49QZInV/5+Sx5ma9eutQkrZ6SkpKBNmzbQ6/V3fPz8+fPx6quvorCw0BpdNV2+fBnh4eHYtm0bHn30UQiCgKioKEyZMgUvv/wyAMBisSAiIgLz5s3D+PHjHa6nY8eO6NSpEzIyMqzLWrVqhSlTpmDKlCn1+hmrY5iRFHJOXsHoxbtxq9rXmVqOMlH1OBNpOcpE1eNMpOUoE9UWZ5m/64qWoQFI+SibcaZirvz9lvy3paCgAFFRUYiOjkZKSgpOnjxZ5/jFixfjxIkTmDlzplPrz8jIQEpKSq1RBlTtgQOAkJAQAMCpU6dQVFSE5ORk6xg/Pz/07NkTO3fudLiOvXv3wmQyYcyYMXb3zZs3D6GhoYiPj8frr79us0ePSK66Roegdbjtnt3fdLxHoq2Rj/ubNkG/WNtDLsb2iNZ0lAFVX2uO6RFts2xKrzaajjKg6mvNyb3a2C2fuHwfSn4uR9Zz3dDM6I/jl27wa00CIHGYJSQkIDMzExs2bMDChQtRVFSExMREXLlyxeH4goICTJ8+HcuWLYPBYLjj+nNzc5Gfn4+xY8fWOkYQBEydOhU9evRAbGwsAKCoqAgAEBERYTM2IiLCel9NGRkZaNeuHRITE22Wv/DCC8jKysLWrVuRnp6O+fPnY8KECXVut8ViQXFxsc2NyJvEY8ryzpttlrs6Q4CaLN15Gkt3/WizzBMTnyvN5sMX8ae1eTbLhn+c4/aJz5Xm4LnrGLNkt93ykp/LkZaRA0t5JeOMbEgaZv369cOQIUMQFxeH3r174+uvvwYALF261G5sRUUFUlNTMXv2bLRt29ap9WdkZCA2NhZdu3atdUx6ejoOHjyIFStW2N1X87+ABUFw+F/Ft27dwvLlyx3uLXvxxRfRs2dPdOjQAWPHjsWHH36IjIyMWuMTqDo5wWg0Wm/Nmzev68ckcitHB/qvfK6byzMEqEnNA/2/eamnRyY+V5qaB/rn/l8vj0x8rjQHz13HiI9zUPxzOR5qeTf2vNLb5oSAa6W3MfzjHFQKYJyRlaz2MQcGBiIuLg4FBfbTWJSUlGDPnj1IT0+HwWCAwWDAnDlzcODAARgMBmzZssVmfGlpKbKysurcWzZp0iSsW7cOW7duxb333mtdLp4ZWnPv2KVLl+z2ogHA559/jtLSUowcOfKOP2O3bt0AAMePH691zIwZM2A2m623s2fP3nG9RO5Q29mXDZ2+SQ0cnX3piYnPlcbR2Zfhwf5un/hcaWpG2dLfdUVYEz+7szUvl1gwfGE29D46xhkBkFmYWSwWHDlyBM2aNbO7Lzg4GHl5eTCZTNbb888/j5iYGJhMJiQkJNiMX7VqFSwWC0aMGGG3LkEQkJ6ejtWrV2PLli2IjrY9LiI6OhqRkZHYtGmTdVlZWRm2bdtm91UlULVnbuDAgXc8mxQA9u/fDwAOf0aRn58fgoODbW5EnnanS2JoOc7quiSGluOsrktiuHPic6VxFGVN/KoOv3F0KY0L5p8x/OMcNG6kZ5yRtGE2bdo0bNu2DadOnUJOTg5++9vfori4GKNGjQJQtedI3Avl4+OD2NhYm1t4eDj8/f0RGxtrd3B/RkYGBg0ahNDQULvnnThxIj799FMsX74cQUFBKCoqQlFREW7dugWg6ivMKVOm4I033sCaNWuQn5+P0aNHIyAgAKmpqTbrOn78OL777juHe+Z27dqFd999FyaTCadOncKqVaswfvx4DBw4EC1aaPvMNpIXZ69TpsU4c+Y6ZVqMM2euU6bFOKsrykSO4uzHK6UY/nEOmvgZGGcaJ2mYnTt3DsOGDUNMTAwGDx4MX19fZGdno2XLlgCAwsJCnDlT/znGjh07hu3btzs85gsAPvjgA5jNZiQlJaFZs2bW28qVK61j/vjHP2LKlCmYMGECOnfujPPnz2Pjxo0ICgqyWdeiRYtwzz332JzBKfLz88PKlSuRlJSEBx54AK+++irGjRvn8Hg2IqnU9+KxWoqz+lw8VktxVp+Lx2opzpyJMpGjOCu4dAMjF+XirgBfxpmGSXodM3IOr2NGntKQK/rXvAjtwpGd4d9I78nN9SpXr+hf8yK0y8clILSJn6c312tcvaJ/zYvQZj3XDfc1df5C23JXnyirztF1zjq2uAufjEnAlRsWXudM4RR5HTMikkZDp1lS856zhkyzpOY9Zw2ZZknNe85cjTLA8Z6z/WeuY+zS3YgI9ueeMw1imBFpkLvmvlRjnLlj7ks1xpk75r5UY5w1JMpEjuIs++RVPP/pXkQaGWdawzAj0hh3T0iupjhz54Tkaoozd05IrqY4c0eUiRzF2bdHL+OFFSbcc1djxpmGMMyINMTdUSZSQ5y5M8pEaogzd0aZSA1x5s4oEzmKs/WHijDtswO49+4AxplGMMyINMJTUSZScpx5IspESo4zT0SZSMlx5okoEzmKs7WmC3hlbR5ahDDOtIBhRqQBno4ykRLjzJNRJlJinHkyykRKjDNPRpnIUZytyD2LOf8+zDjTAIYZkcp5K8pESoozb0SZSElx5o0oEykpzrwRZSJHcbZ4x2m8vfEYWoYGMs5UjGFGpGLejjKREuLMm1EmUkKceTPKREqIM29GmchRnL239Tj+tfU440zFGGZEKiVVlInkHGdSRJlIznEmRZSJ5BxnUkSZyFGc/W3DUSzafopxplIMMyIVkjrKRHKMMymjTCTHOJMyykRyjDMpo0zkKM7m/PswsnLPMM5UiGFGpDJyiTKRnOJMDlEmklOcySHKRHKKMzlEmchRnM1Yk4cvTecZZyrDMCNSEblFmUgOcSanKBPJIc7kFGUiOcSZnKJMVDPOBAGYuuoA1ucXMc5UhGFGpBJyjTKRlHEmxygTSRlncowykZRxJscoE9WMs4pKAZNW7MO3Ry8xzlRCHr+BRNQgco8ykRRxJucoE0kRZ3KOMpEUcSbnKBPVjLPbFQLGf7IXu05cYZypgLx+C4mo3pQSZSJvxpkSokzkzThTQpSJvBlnSogyUc04s5RXYszS3dh35hrjTOHk+ZtIRE5RWpSJvBFnSooykTfiTElRJvJGnCkpykQ146y0rAKjF+Xi0AUz40zB5P3bSKQiP92w4PlP9uKtDUdRWSk0eH1KjTKRJ+NMiVEm8mScKTHKRJ6MMyVGmahmnBX/XI60jFwUXCxhnCmUMn4jiRTupxsWDPsoG+sPFeG9rccxY3Veg+JM6VEm8kScKTnKRJ6IMyVHmcgTcabkKBPVjLOrN8sw/OMcnP7pJuNMgZT1W0mkQGKUFVy6gdBAX/jogJV7zrocZ2qJMpE740wNUSZyZ5ypIcpE7owzNUSZqGacXSqxYPjHOTh//RbjTGGU+ZtJpBDVoywy2B9f/D4R7z4T73KcqS3KRO6IMzVFmcgdcaamKBO5I87UFGWimnF2/votDF+YjUvFPzPOFETZv51EMlYzyrKe64ZWYYF4Kv4el+JMrVEmakicqTHKRA2JMzVGmaghcabGKBPVjLPTV0oxIiMHV2+WMc4UQh2/oUQyU1uUieobZ2qPMpErcabmKBO5EmdqjjKRK3Gm5igT1YyzYxdvYOSiHJhv3WacKYC6fkuJZOBOUSZyNs60EmWi+sSZFqJMVJ8400KUieoTZ1qIMlHNOMs/X4xnF+fipqWccSZz6vxNJZKIs1EmulOcaS3KRM7EmZaiTORMnGkpykTOxJmWokxUM872nbmOsUurfpdqxtn4T/ZCEBp+GR9qOHX/thJ5UX2jTFRbnGk1ykR1xZkWo0xUV5xpMcpEdcWZFqNMVDPOdp28gt9/uhdl5ZXQ++ig96n6vSmvYJTJhU5gIstecXExjEYjzGYzgoODpd4ccsDVKKvuS9N5vLjShEoBeKZzczT21WPJztMAtBdl1eWcvIJnl+xGaVkFHmkThh6twzD3vz8A0F6UVXfi8g0M+ygbl0osiIkIwpge0fjT2jxNRll1V25YkLowB0cvliA8yA9/6t8Of16br8koq+7n2xUYl7kH3xf8BAB48F4jLpdYcMH8M1qFBiDrue6INPpLvJXq48rfb4aZAjDM5M0dUSaqHmciLUeZqHqcibQcZaLqcSbScpSJqseZSMtRJqoZZwDQIiQAq8YzyjzFlb/f2v3NJXIDd0YZAAx8MAohgX42y57p3Lyhm6l4CfeF4rGYcJtlL/Rqo+koA6q+1hz3yH02y2Y++YCmowyo+lpzxhO/slk2a0B7TUcZUPW15swB7W2WtQlvgohgv1oeQVLQ9m8vUQO4O8rEY8p+qnEwd0Onb1KDpTtP4+u8Qptlnpj4XGk2H76INzf8YLMsLSPX7ROfK83Bc9cxecV+m2Vjlu52+8TnSnPuWilGL861WfbND5fw2tdHeOC/jDDMiFzgqSirfqD/31NcnyFATWoe6L/yuW4emfhcaWoe6L/xxUc9MvG50tQ80P+7PzzmkYnPlebctVKkfJSNc9duoVVoAL6dlmQ9ISBj+ym8u+mYxFtIIoYZUT15I8qGdW3h8gwBauLo7EtPTHyuNI7OvmwbEeT2ic+VxtHZly1CA9w+8bnS1IyyrOe6o1VYoM3Zmv/YchwffHtC4i0lQOIwmzVrFnQ6nc0tMjLSqcfu2LEDBoMB8fHxNsuTkpLs1qnT6dC/f3/rmLlz56JLly4ICgpCeHg4Bg0ahKNHj9qsRxAEzJo1C1FRUWjcuDGSkpJw6NChOz5XSkqKzZhr164hLS0NRqMRRqMRaWlpuH79uvMvEsmKt6JMpOU4q+uSGFqOs7ouieHOic+Vpq5LYrhz4nOlcRRl4oH+NS+lMW/9D1jyv88iko7ke8zat2+PwsJC6y0vL++OjzGbzRg5ciR69epld9/q1att1pefnw+9Xo+hQ4dax2zbtg0TJ05EdnY2Nm3ahPLyciQnJ+PmzZvWMW+++SbeeecdvPfee9i9ezciIyPx+OOPo6SkxOb5xo0bZ/N8CxYssLk/NTUVJpMJ69evx/r162EymZCWllbfl4lkwNtRJtJinDlznTItxpkz1ynTYpw5c50yLcZZXVEmqhlns746jFW7z0qxufQ/kl4uY9asWVi7di1MJlO9HpeSkoI2bdpAr9ff8fHz58/Hq6++isLCQgQGOv4jevnyZYSHh2Pbtm149NFHIQgCoqKiMGXKFLz88ssAAIvFgoiICMybNw/jx48HULXHLD4+HvPnz3e43iNHjuCBBx5AdnY2EhISAADZ2dno3r07fvjhB8TExDj18/JyGdKTKsqqq3mds7mD4+Djo76zEut78dia1zlbOLIz/BvpvbW5XlPfi8fWvM7Z8nEJCG2ivrPv6nvx2JrXOct6rhvua9rEi1vsHc5EWXXVL6Wh0wHzn4nHU/H3eHGL1UmRl8soKChAVFQUoqOjkZKSgpMnT9Y5fvHixThx4gRmzpzp1PozMjKQkpJSa5QBVXvgACAkJAQAcOrUKRQVFSE5Odk6xs/PDz179sTOnTttHrts2TKEhYWhffv2mDZtms0etV27dsFoNFqjDAC6desGo9Fot57qLBYLiouLbW4kHTlEGaCNPWeuXNFfC3vOXLmivxb2nLlyRX8t7Dmrb5QBtnvOBAGYuuoANh4q8tIWU3WShllCQgIyMzOxYcMGLFy4EEVFRUhMTMSVK1ccji8oKMD06dOxbNkyGAx3vh5Nbm4u8vPzMXbs2FrHCIKAqVOnokePHoiNjQUAFBVVvRkjIiJsxkZERFjvA4Dhw4djxYoV+Pbbb/HnP/8ZX3zxBQYPHmy9v6ioCOHhttdeAoDw8HCb9dQ0d+5c6zFpRqMRzZvzOlZSkUuUidQcZw2ZZknNcdaQaZbUHGcNmWZJzXHmSpSJqsdZRaWA9OX7se3YZQ9vMdUkaZj169cPQ4YMQVxcHHr37o2vv/4aALB06VK7sRUVFUhNTcXs2bPRtm1bp9afkZGB2NhYdO3atdYx6enpOHjwIFasWGF3X80/CoIg2CwbN24cevfujdjYWKSkpODzzz/H5s2bsW/fvlrX4Wg9Nc2YMQNms9l6O3uW3/dLQW5RJlJjnLlj7ks1xpk75r5UY5y5Y+5LNcZZQ6JMVD3OyioqMf6TPcg9ddVDW0yOSP5VZnWBgYGIi4tDQUGB3X0lJSXYs2cP0tPTYTAYYDAYMGfOHBw4cAAGgwFbtmyxGV9aWoqsrKw695ZNmjQJ69atw9atW3Hvvfdal4tnhtbcq3Xp0iW7vWjVderUCY0aNbJuf2RkJC5evGg37vLly3Wux8/PD8HBwTY38i65RplITXHmzgnJ1RRn7pyQXE1x5s4JydUUZ+6IMlH1OPv5diXe23rczVtLdZFVmFksFhw5cgTNmjWzuy84OBh5eXkwmUzW2/PPP4+YmBiYTCab47gAYNWqVbBYLBgxYoTdugRBQHp6OlavXo0tW7YgOjra5v7o6GhERkZi06ZN1mVlZWXYtm0bEhMTa93+Q4cO4fbt29bt7969O8xmM3Jzf7nSck5ODsxmc53rIWnJPcpEaogzd0aZSA1x5s4oE6khztwZZSI1xJk7o0wkxtkf+sRg8q9bu2lLyRmSnpU5bdo0DBgwAC1atMClS5fw2muvYdu2bcjLy0PLli0xY8YMnD9/HpmZmQ4fX9dZnY888gjuueceZGVl2d03YcIELF++HF9++aXNmZFGoxGNGzcGAMybNw9z587F4sWL0aZNG7zxxhv49ttvcfToUQQFBeHEiRNYtmwZnnjiCYSFheHw4cN46aWX0LhxY+zevRt6fdVZYf369cOFCxesl9F47rnn0LJlS3z11VdOv048K9N7lBJl1Sn1bE1PRFl1Sj1b0xNRVp1Sz9b0RJRVp9SzNT0RZeQ+Hj0r89y5cy5vWF3rHDZsGGJiYjB48GD4+voiOzsbLVu2BAAUFhbizJkz9V7vsWPHsH37dowZM8bh/R988AHMZjOSkpLQrFkz623lypXWMX/84x8xZcoUTJgwAZ07d8b58+exceNGBAUFAQB8fX3xzTffoE+fPoiJicHkyZORnJyMzZs3W6MMqDprMy4uDsnJyUhOTkaHDh3wySef1PtnIs9TYpQBytxz5ukoA5S558zTUQYoc8+Zp6MMUOaeM0aZOjm9x+yuu+7CP//5T14cVQLcY+Z5So2y6pSy58wbUVadUvaceSPKqlPKnjNvRFl1StlzxihTBo/uMXvjjTcwceJEDBkypNbLWRApkRqiDFDGnjNvRxmgjD1n3o4yQBl7zrwdZYAy9pwxytTN6d/8CRMm4MCBA7h27Rrat2+PdevWeXK7iLxCLVEmknOcSRFlIjnHmRRRJpJznEkRZSI5xxmjTP1cOvj/vffew4svvoh27drZXei1+jW8yD34VaZnqC3KqpPb15pSRll1cvtaU8ooq05uX2tKGWXVye1rTUaZ8rjy97veYfbjjz9i9OjROHz4MJ577jm7MHN2qiRyHsPM/dQcZSK5xJlcokwklziTS5SJ5BJncokykVzijFGmTB4Ps4ULF+Kll15C7969sWDBAjRt2tTljSXnMczcSwtRJpI6zuQWZSKp40xuUSaSOs7kFmUiqeOMUaZcHj34v2/fvnj55Zfx3nvvYfXq1YwyUiQtRRkg7TFnco0yQNpjzuQaZYC0x5zJNcoAaY85Y5Rpj9OfBhUVFTh48CBGjhzpye0h8hitRZlIijiTc5SJpIgzOUeZSIo4k3OUiaSIM0aZNjn9ibBp0yab+SSJlESrUSbyZpwpIcpE3owzJUSZyJtxpoQoE3kzzhhl2iXPTwUiN9J6lIm8EWdKijKRN+JMSVEm8kacKSnKRN6IM0aZtsn7k4GogSzlFUhdyCgTeTLOlBhlIk/GmRKjTOTJOFNilIk8GWeMMlLGpwORiy5c/xnHLlZ9YD7ZoZmmo0zkiThTcpSJPBFnSo4ykSfiTMlRJvJEnDHKCGCYkcpFhwXiD31iAAAfbz+Ff2097tJ61BJlInfGmRqiTOTOOFNDlIncGWdqiDKRO+OMUUYiZX5KENXDxMdaW+PsbxuO1jvO1BZlInfEmZqiTOSOOFNTlIncEWdqijKRO+KMUUbVKfuTgshJrsaZWqNM1JA4U2OUiRoSZ2qMMlFD4kyNUSZqSJwxyqgmdXxaEDmhvnGm9igTuRJnao4ykStxpuYoE7kSZ2qOMpErccYoI0fU9YlBdAfOxplWokxUnzjTQpSJ6hNnWogyUX3iTAtRJqpPnDHKqDbq/NQgqsOd4kxrUSZyJs60FGUiZ+JMS1EmcibOtBRlImfijFFGdVH3JwdRLWqLM61GmaiuONNilInqijMtRpmorjjTYpSJ6oozRhndiU4QBO/MaEwuc2V2enLOv7Yex982HAUA/KFPDK7cKNNslFX3pek8XlxpQqUAPNO5OX7VLAizvzoMQHtRVl3OySt4dslulJZV4JE2YXimS3O8uNKkySir7sTlGxj2UTYulVgQExGEGU/8CpNX7NdklFV35YYFqQtzcPRiCcKD/PD20w9ixuo8RpmGuPL3m2GmAAwzz6oeZyItR5moepyJtBxloupxJtJylImqx5lIy1Emqh5nIkaZdrjy91u7nyJE/zMh6X6bf7cICdB8lAFVX2t2bHG3zbI/JGs7yoCqrzXTurW0WTZvSAdNRxlQ9bXmn/q3s1n27tPxmo4yoOprzb8N7WCz7I3BcYwyqpW2P0lI88Rjyqo7c7XU5RkC1GTpztPY++M1m2WemPhcaTYfvmj9ulv0+0/3un3ic6U5eO46/rw232bZuMw9bp/4XGnOXSvFhGX7bJZNyTK5feJzUg+GGWmWowP9GzJDgJrUPND/7ymemfhcaWoe6L98XIJHJj5XmpoH+q9Lf9gjE58rTc0D/b+e3MMjE5+TujDMSLM2VdvzMeep9hjWtUWDp29SA0dnX3pi4nOlcXT2ZeL9YW6f+FxpHJ192eHeu9w+8bnSODr7sn2U0e0Tn5P6MMxIs6LDAuHfqOpXYOsPl2Apr/qDquU4q+uSGFqOs7ouieHOic+Vpq5LYrhz4nOlqeuSGO6c+JzUiWFGmtUmIgiLRnWBfyMfbD16Gc9/slfTcebMdcq0GGfOXKdMi3HmzHXKtBhnzlynjHFGdWGYkaYltg5jnKF+F4/VUpzV5+KxWoqz+lw8VktxVp+LxzLOqDYMM9I8rceZK1f010KcuXJFfy3EmStX9NdCnLlyRX/GGTnCMCOCduOsIdMsqTnOGjLNkprjrCHTLKk5zhoyzRLjjGpimBH9j9bizB1zX6oxztwx96Ua48wdc1+qMc7cMfelozg79dNND20xyZ2kYTZr1izodDqbW2RkpFOP3bFjBwwGA+Lj422WJyUl2a1Tp9Ohf//+1jFz585Fly5dEBQUhPDwcAwaNAhHj9pOySMIAmbNmoWoqCg0btwYSUlJOHTokPX+q1evYtKkSYiJiUFAQABatGiByZMnw2w226ynVatWdtsyffr0er5S5C1aiTN3Tkiupjhz54Tkaoozd05IrqY4c+eE5KFN/PDp2AQ08TPgUokF//imwM1bS0oh+R6z9u3bo7Cw0HrLy8u742PMZjNGjhyJXr162d23evVqm/Xl5+dDr9dj6NCh1jHbtm3DxIkTkZ2djU2bNqG8vBzJycm4efOX/0J588038c477+C9997D7t27ERkZiccffxwlJVXznV24cAEXLlzAW2+9hby8PCxZsgTr16/HmDFj7LZpzpw5Ntv0yiuvuPJSkZeoPc7cGWUiNcSZO6NMpIY4c2eUidQQZ+6MMgCoqBQwb/0PuGEph95HhwEPNnPj1pKSSDqJ+axZs7B27VqYTKZ6PS4lJQVt2rSBXq+/4+Pnz5+PV199FYWFhQgMDHQ45vLlywgPD8e2bdvw6KOPQhAEREVFYcqUKXj55ZcBABaLBREREZg3bx7Gjx/vcD2fffYZRowYgZs3b8JgqPrgatWqFaZMmYIpU6bU62esjpOYS2Pn8Z/wu6W78fPtSjwW0xQfpj0EP4MegO3E53/oE4OJj7WWclOd5okoq676xOfPdG6OuYPj4OMj/7k1PRFl1VWf+PyRNmFYOLIz/Bvp3bZ+T/FElFVXfeLzmIggLB+XgNAmfm5bv6d4Ispe/uIgPt97DnofHf6R0hH9OzDM1ECRk5gXFBQgKioK0dHRSElJwcmTJ+scv3jxYpw4cQIzZ850av0ZGRlISUmpNcoAWL9+DAkJAQCcOnUKRUVFSE5Oto7x8/NDz549sXPnzjrXExwcbI0y0bx58xAaGor4+Hi8/vrrKCsrq3ObLRYLiouLbW7kfWrbc+bpKAOUuefM01EGKHPPmaejDFDmnjNGGXmapGGWkJCAzMxMbNiwAQsXLkRRURESExNx5coVh+MLCgowffp0LFu2zC5+HMnNzUV+fj7Gjh1b6xhBEDB16lT06NEDsbGxAICioiIAQEREhM3YiIgI6301XblyBX/5y1/s9qa98MILyMrKwtatW5Geno758+djwoQJdW733LlzYTQarbfmzZvf8Wclz1BLnHkjykRKijNvRJlISXHmjSgTKSnOGGXkDZKGWb9+/TBkyBDExcWhd+/e+PrrrwEAS5cutRtbUVGB1NRUzJ49G23btnVq/RkZGYiNjUXXrl1rHZOeno6DBw9ixYoVdvfV/MMlCILDP2bFxcXo378/HnjgAbs9eS+++CJ69uyJDh06YOzYsfjwww+RkZFRa3wCwIwZM2A2m623s2fP3ulHJQ9Sepx5M8pESogzb0aZSAlx5s0oEykhzhhl5C2Sf5VZXWBgIOLi4lBQYH82SklJCfbs2YP09HQYDAYYDAbMmTMHBw4cgMFgwJYtW2zGl5aWIisrq869ZZMmTcK6deuwdetW3Hvvvdbl4pmhNfeOXbp0yW4vWklJCfr27YsmTZpgzZo1aNSoUZ0/Y7du3QAAx4/X/gfcz88PwcHBNjeSllLjTIooE8k5zqSIMpGc40yKKBPJOc4YZeRNsgozi8WCI0eOoFkz+zdocHAw8vLyYDKZrLfnn38eMTExMJlMSEhIsBm/atUqWCwWjBgxwm5dgiAgPT0dq1evxpYtWxAdHW1zf3R0NCIjI7Fp0ybrsrKyMmzbtg2JiYnWZcXFxUhOToavry/WrVsHf/87/6Lu378fABz+jCRvSoszKaNMJMc4kzLKRHKMMymjTCTHOGOUkbdJGmbTpk3Dtm3bcOrUKeTk5OC3v/0tiouLMWrUKABVX+mNHDmyakN9fBAbG2tzCw8Ph7+/P2JjY+0O7s/IyMCgQYMQGhpq97wTJ07Ep59+iuXLlyMoKAhFRUUoKirCrVu3AFR9hTllyhS88cYbWLNmDfLz8zF69GgEBAQgNTUVQNWeMvESGxkZGSguLraup6Ki6gN2165dePfdd2EymXDq1CmsWrUK48ePx8CBA9GiRQuPva7kOUqJMzlEmUhOcSaHKBPJKc7kEGUiOcUZo4ykIGmYnTt3DsOGDUNMTAwGDx4MX19fZGdno2XLlgCAwsJCnDlzpt7rPXbsGLZv3+7wmmIA8MEHH8BsNiMpKQnNmjWz3lauXGkd88c//hFTpkzBhAkT0LlzZ5w/fx4bN25EUFAQAGDv3r3IyclBXl4eWrdubbMe8ZgwPz8/rFy5EklJSXjggQfw6quvYty4cQ6PZyPlkHucySnKRHKIMzlFmUgOcSanKBPJIc4YZSQVSa9jRs7hdczkSY7XOZNjlFUn1XXO5Bhl1Ul1nTM5Rll1Ul3njFFG7qLI65gRKZXc9pzJPcoAafacyT3KAGn2nMk9ygBp9pwxykhq8vp0IlIYucSZEqJM5M04U0KUibwZZ0qIMpE344xRRnIgz08oIgWROs6UFGUib8SZkqJM5I04U1KUibwRZ4wykgt5f0oRKYRUcabEKBN5Ms6UGGUiT8aZEqNM5Mk4Y5SRnCjjk4pIAbwdZ0qOMpEn4kzJUSbyRJwpOcpEnogzRhnJjbI+rYhkzltxpoYoE7kzztQQZSJ3xpkaokzkzjhjlJEcKfMTi0jGPB1naooykTviTE1RJnJHnKkpykTuiDNGGcmVsj+1iGTKU3GmxigTNSTO1BhloobEmRqjTNSQOGOUkZyp45OLSIbcHWdqjjKRK3Gm5igTuRJnao4ykStxxigjuVPXpxeRzLgrzrQQZaL6xJkWokxUnzjTQpSJ6hNnjDJSAnV+ghHJSEPjTEtRJnImzrQUZSJn4kxLUSZyJs4YZaQU6v4UI5IJV+NMi1EmqivOtBhlorriTItRJqorzhhlpCScxFwBOIm5etRn4vMmfgbNRll1NSc+79UuHBOX79NklFVXc+Lzyb3aYMyS3ZqMsupqTnz+t6EdMGHZPkYZScKVv98MMwVgmKmLs3Em0nKUiarHmUjLUSaqHmciLUeZqHqciRhlJAVX/n5r9xONSCJ3+lozItjPZrzWowyo+lrzyQ5RNsvefVrbUQZUfa059fG2NssWpD2k6SgDqr7WfPvpB22W/Wt4J0YZKYK2P9WIJFJbnC3deRoXi20PWn7/2xMSbaV8bD58Ef/NL7RZ9ue1+W6f+FxpDp67jn98U2Cz7MWVJrdPfK40566VYsbqPJtlU1cecHmGAEYZeRPDjEgiNeNs4D932BxT5qmJz5Wm5oH+7zz9oEcmPleamgf6Lxrd2SMTnytNzQP9l49NaNAMAYwy8jaGGZGEqsfZ0YslAH45pswTE58rjaOzLwd3utftE58rjaOzL3/9qwi3T3yuNI7OvkxsHebyDAGMMpICw4xIYomtw7BodBe0jWiClx5va3NMmZbjrK5LYrhz4nOlqeuSGO6c+Fxp6rokhiszBDDKSCo8K1MBeFYm1byUxsTHWku8RZ7l7HXKal5KY+7gOPj4qPdECWevU1bzUhoLR3aGfyO9BFvsHc5ep6zmpTSWj0tAaBM/u3GMMnIXnpVJpFJa2nNWn4vHamnPWX0uHqulPWf1uXisM3vOGGUkNYYZkUJoIc5cuaK/FuLMlSv6ayHOXLmif11xxigjOWCYESmImuOsIdMsqTnOGjLNkprjrCHTLDmKs8slFkYZyQKPMVMAHmNGNantmDN3zX2ptmPO3DX3pdqOOXPX3JfVjzlr4mfADUs5o4zciseYEWmEmvacuXNCcjXtOXPnhORq2nPmzgnJq+85Y5SRXDDMiBRKDXHmzigTqSHO3BllIjXEmTujTHR/0ybIeq4bBsVHYeHIhxhlJDl+lakA/CqT6qLUrzU9EWXVKfVrTU9EWXVK/VrTE1FG5Gn8KpNIg5S458zTUQYoc8+Zp6MMUOaeM0YZaQnDjEgFlBRn3ogykZLizBtRJlJSnDHKSGsYZkQqoYQ482aUiZQQZ96MMpES4oxRRlokaZjNmjULOp3O5hYZGenUY3fs2AGDwYD4+Hib5UlJSXbr1Ol06N+/v3XM3Llz0aVLFwQFBSE8PByDBg3C0aNHbdYjCAJmzZqFqKgoNG7cGElJSTh06JDNGIvFgkmTJiEsLAyBgYEYOHAgzp07ZzPm2rVrSEtLg9FohNFoRFpaGq5fv+78i0RUD3KOMymiTCTnOJMiykRyjjNGGWmV5HvM2rdvj8LCQustLy/vjo8xm80YOXIkevXqZXff6tWrbdaXn58PvV6PoUOHWsds27YNEydORHZ2NjZt2oTy8nIkJyfj5s2b1jFvvvkm3nnnHbz33nvYvXs3IiMj8fjjj6OkpMQ6ZsqUKVizZg2ysrKwfft23LhxA08++SQqKn75YEtNTYXJZML69euxfv16mEwmpKWlufpyEd2RHONMyigTyTHOpIwykRzjjFFGWibpWZmzZs3C2rVrYTKZ6vW4lJQUtGnTBnq9/o6Pnz9/Pl599VUUFhYiMDDQ4ZjLly8jPDwc27Ztw6OPPgpBEBAVFYUpU6bg5ZdfBlC1dywiIgLz5s3D+PHjYTab0bRpU3zyySd45plnAAAXLlxA8+bN8Z///Ad9+vTBkSNH8MADDyA7OxsJCQkAgOzsbHTv3h0//PADYmJinPp5eVYmuUIuZ2vKIcqqk8vZmnKIsurkcrYmo4zURJFnZRYUFCAqKgrR0dFISUnByZMn6xy/ePFinDhxAjNnznRq/RkZGUhJSak1yoCqPXAAEBISAgA4deoUioqKkJycbB3j5+eHnj17YufOnQCAvXv34vbt2zZjoqKiEBsbax2za9cuGI1Ga5QBQLdu3WA0Gq1jiDxFDnvO5BZlgDz2nMktygB57DljlBFJHGYJCQnIzMzEhg0bsHDhQhQVFSExMRFXrlxxOL6goADTp0/HsmXLYDDc+UMsNzcX+fn5GDt2bK1jBEHA1KlT0aNHD8TGxgIAioqKAAARERE2YyMiIqz3FRUVwdfXF3fffXedY8LDw+2eMzw83DrGEYvFguLiYpsbkSukjDM5RplIyjiTY5SJpIwzRhlRFUk/Jfv164chQ4YgLi4OvXv3xtdffw0AWLp0qd3YiooKpKamYvbs2Wjbtq1T68/IyEBsbCy6du1a65j09HQcPHgQK1assLtPp7P9ekMQBLtlNdUc42j8ndYzd+5c68kCRqMRzZs3r/M5ieoiRZzJOcpEUsSZnKNMJEWcMcqIfiGrT8rAwEDExcWhoKDA7r6SkhLs2bMH6enpMBgMMBgMmDNnDg4cOACDwYAtW7bYjC8tLUVWVlade8smTZqEdevWYevWrbj33nuty8UzQ2vu1bp06ZJ1L1pkZCTKyspw7dq1OsdcvHjR7nkvX75stzeuuhkzZsBsNltvZ8+erXUskTO8GWdKiDKRN+NMCVEm8macMcqIbMnq09JiseDIkSNo1sx+rrLg4GDk5eXBZDJZb88//zxiYmJgMplsjuMCgFWrVsFisWDEiBF26xIEAenp6Vi9ejW2bNmC6Ohom/ujo6MRGRmJTZs2WZeVlZVh27ZtSExMBAA89NBDaNSokc0Y8SxQcUz37t1hNpuRm5trHZOTkwOz2Wwd44ifnx+Cg4NtbkQN5Y04U1KUibwRZ0qKMpE34oxRRmRP0k+GadOmYcCAAWjRogUuXbqE1157DcXFxRg1ahSAqj1H58+fR2ZmJnx8fKzHgInCw8Ph7+9vtxyo+hpz0KBBCA0Ntbtv4sSJWL58Ob788ksEBQVZ94wZjUY0btwYOp0OU6ZMwRtvvIE2bdqgTZs2eOONNxAQEIDU1FTr2DFjxuCll15CaGgoQkJCMG3aNOvXsgDQrl079O3bF+PGjcOCBQsAAM899xyefPJJp8/IJHIn8czMv204aj1j011nayoxykRPxd8DAHhxpQkr91TtoXbX2ZpKjDKRGGfPLtltjTN3na3JKCNyTNJPh3PnzmHYsGH46aef0LRpU3Tr1g3Z2dlo2bIlgKo9UGfOnKn3eo8dO4bt27dj48aNDu//4IMPAFRdjLa6xYsXY/To0QCAP/7xj7h16xYmTJiAa9euISEhARs3bkRQUJB1/LvvvguDwYCnn34at27dQq9evbBkyRLo9b98aC1btgyTJ0+2nr05cOBAvPfee/X+mYjcxRNxpuQoE3kizpQcZSJPxBmjjKh2kl7HjJzD65iRJ7jrOmdqiLLq3HWdMzVEWXXuus4Zo4y0RJHXMSMiabjjmDO1RRngnmPO1BZlgHuOOWOUEd2Zsj9BiahBGhJnaowyUUPiTI1RJmpInDHKiJyjjk9RInKZK3Gm5igTuRJnao4ykStxxigjcp66PkmJyCX1iTMtRJmoPnGmhSgT1SfOGGVE9aPOT1Miqjdn4kxLUSZyJs60FGUiZ+KMUUZUf+r+RCWieqkrzrQYZaK64kyLUSaqK84YZUSu4eUyFICXyyBvq3kpjZiIIM1GWXU1L6WRmtACaRnajLLqal5KY+aA9hi9OJdRRprnyt9vhpkCMMxICtXjTKTlKBNVjzORlqNMVD3ORIwy0jpex4yI3GbiY63RqcVdNsu0HmVA1deaY3rYzq+7+Nkumo4yoOprzdd/Yzs93pJnuzLKiOpJ25+wRFSrzYcvIu+82WbZgu9OSrQ18nHw3HWs3H3WZtnr/z7i9onPlebctVK8vfGYzbI/f5nv9onPidSOYUZEdmoe6D/18bYAXJ8hQC1qHuj/xm/iGjRDgFrUPND/H8M6NmiGACIt0/a+dyKyc/ZqqcMD/fU+OrdOfK40tZ19Geind+vE50pT29mXEUF+bp34nEgruMeMiGzofXTQ/y8sSi3lqPjf+UHumFtTqeq6JIY75tZUqrouieGOuTWJtIhhRkQ2ou5qjEWjusC/kQ+2Hr2M5z/ZC0t51R9ULcaZM9cp02KcOXOdMsYZUf0xzIjITmLrMMYZ6nfxWC3FWX0uHss4I6ofhhkROaT1OHPliv5aiDNXrujPOCNyHsOMiGql1ThryDRLao6zhkyzxDgjcg7DjIjqpLU4c8fcl2qMM3fMfck4I7ozhhkR3ZFW4sydE5KrKc7cOSF5wn2hyBjVBTod8H3BT8jYfsrNW0ukbAwzInKK2uPMnVEmUkOcuTPKAKCiUsDne89BEKouzdKx+V3u21giFWCYEZHT1BpnnogykZLjzBNR9sfPD+KLfeeg99HhHykdkdg6zI1bTKR8DDMiqhe1xZkno0ykxDjzRpT179DMjVtMpA4MMyKqN7XEmTeiTKSkOGOUEUmHYUZELlF6nHkzykRKiDNGGZG0GGZE5DKlxpkUUSaSc5wxyoikxzAjogZRWpxJGWUiOcYZo4xIHhhmRNRgSokzOUSZSE5xxigjkg+GGRG5hdzjTE5RJpJDnDHKiOSFYUZEbiPXOJNjlImkjDNGGZH8MMyIyK3kFmdyjjKRFHHGKCOSJ4YZEbmdXOJMCVEm8macMcqI5EvSMJs1axZ0Op3NLTIy0qnH7tixAwaDAfHx8TbLk5KS7Nap0+nQv39/65jvvvsOAwYMQFRUFHQ6HdauXWu3/osXL2L06NGIiopCQEAA+vbti4KCAuv9p0+fdvg8Op0On332mXVcq1at7O6fPn16/V4oIgWSOs6UFGUib8QZo4xI3iTfY9a+fXsUFhZab3l5eXd8jNlsxsiRI9GrVy+7+1avXm2zvvz8fOj1egwdOtQ65ubNm3jwwQfx3nvvOVy/IAgYNGgQTp48iS+//BL79+9Hy5Yt0bt3b9y8eRMA0Lx5c5vnKSwsxOzZsxEYGIh+/frZrG/OnDk241555ZX6vEREiiVVnCkxykSejDNGGZH8Sf5JZTAYnN5LJho/fjxSU1Oh1+vt9naFhITY/DsrKwsBAQE2YdavXz+7eKquoKAA2dnZyM/PR/v27QEA77//PsLDw7FixQqMHTsWer3ebrvXrFmDZ555Bk2aNLFZHhQUVO+fkUgtxDj73dLd1jj7MO0h+Bn0mPhYawBVYfa3DUcBwLrMVUqOMtFT8fcAAF5cacLKPWcBAHMHx8HHR+fyOhllRMog+R6zgoICREVFITo6GikpKTh58mSd4xcvXowTJ05g5syZTq0/IyMDKSkpCAwMdHqbLBYLAMDf/5cPLb1eD19fX2zfvt3hY/bu3QuTyYQxY8bY3Tdv3jyEhoYiPj4er7/+OsrKyu74/MXFxTY3IiXz1p4zNUSZyJ17zhhlRMohaZglJCQgMzMTGzZswMKFC1FUVITExERcuXLF4fiCggJMnz4dy5Ytg8Fw5w/b3Nxc5OfnY+zYsfXarl/96ldo2bIlZsyYgWvXrqGsrAx//etfUVRUhMLCQoePycjIQLt27ZCYmGiz/IUXXkBWVha2bt2K9PR0zJ8/HxMmTKjz+efOnQuj0Wi9NW/evF7bTyRHno4zNUWZyB1xxigjUhZJw6xfv34YMmQI4uLi0Lt3b3z99dcAgKVLl9qNraioQGpqKmbPno22bds6tf6MjAzExsaia9eu9dquRo0a4YsvvsCxY8cQEhKCgIAAfPvtt+jXrx/0er3d+Fu3bmH58uUO95a9+OKL6NmzJzp06ICxY8fiww8/REZGRq3xCQAzZsyA2Wy23s6ePVuv7SeSK0/FmRqjTNSQOGOUESmP5F9lVhcYGIi4uDibsx9FJSUl2LNnD9LT02EwGGAwGDBnzhwcOHAABoMBW7ZssRlfWlqKrKyseu8tEz300EMwmUy4fv06CgsLsX79ely5cgXR0dF2Yz///HOUlpZi5MiRd1xvt27dAADHj9f+R8fPzw/BwcE2NyK1cHecqTnKRK7EGaOMSJlkFWYWiwVHjhxBs2b2v+zBwcHIy8uDyWSy3p5//nnExMTAZDIhISHBZvyqVatgsVgwYsSIBm2T0WhE06ZNUVBQgD179uCpp56yG5ORkYGBAweiadOmd1zf/v37AcDhz0ikFe6KMy1Emag+ccYoI1IuST/Bpk2bhgEDBqBFixa4dOkSXnvtNRQXF2PUqFEAqr7SO3/+PDIzM+Hj44PY2Fibx4eHh8Pf399uOVAVS4MGDUJoaKjdfTdu3LDZY3Xq1CmYTCaEhISgRYsWAIDPPvsMTZs2RYsWLZCXl4cXXngBgwYNQnJyss26jh8/ju+++w7/+c9/7J5n165dyM7OxmOPPQaj0Yjdu3fjxRdfxMCBA63PQ6RVDT1bU0tRJnLmbE1GGZGySbrH7Ny5cxg2bBhiYmIwePBg+Pr6Ijs7Gy1btgQAFBYW4syZM/Ve77Fjx7B9+3aHx3wBwJ49e9CxY0d07NgRADB16lR07NgRr776qnVMYWEh0tLS8Ktf/QqTJ09GWloaVqxYYbeuRYsW4Z577rELNqDqK8mVK1ciKSkJDzzwAF599VWMGzfO4XqItMjVPWdajDJRXXvOGGVEyqcTBME7s+WSy4qLi2E0GmE2m3m8GanSzuM/4XdLd+Pn25V4LKapdc8ZAPxr63HrXrM/9InBI23CNBtl1X1pOo8XV5pQKQDPdG6O9F+3xrCFjDIiOXHl7zfDTAEYZqQFzsaZSMtRJqoeZyJGGZF8uPL3W1YH/xORdt3pa82+7W1nz9B6lAFVX2tO+9/XvaLl47oxyogUjGFGRLJRW5wdPHcdO0/8ZDN26c7T0mykjJy7VorlObbH4f59c4HLMwQwyoikxzAjIlmpGWejFuXaHFM2Iel+AO6f+Fxpah7o/39P/KpBMwQwyojkQdvfAxCRLFW/lEb2yasAbI8pC/QzuHXic6Wp7ezLiGB/lyY+Z5QRyQf3mBGRLIlxdldAI/RoHWZzTJk7Jz5XmrouieHKDAGMMiJ54R4zIpKtxNZh2P2n3mikt/9vSGcuQqs2zlynzJmL0IoYZUTywzAjIllzFGUiLcVZfS4e60ycMcqI5IlhRkSKpoU4c+WK/nXFGaOMSL4YZkSkeGqOs4ZMs+Qozl7/TSxe/iKPUUYkUwwzIlIFNcaZO+a+rBln2aeu4McrpYwyIplimBGRaqgpztw5IXn1OGOUEckbw4yIVEUNcebOKBM9FX8PDD4++Oi7E/h9Umv0jY2884OIyOsYZkSkOkqOM09Emah/h2bcS0Ykc7zALBGpkhIvQuvJKCMiZWCYEZFqKSnOGGVEBDDMiEjllBBnjDIiEjHMiEj15BxnjDIiqo5hRkSaIMc4Y5QRUU0MMyLSDDnFGaOMiBxhmBGRpsghzhhlRFQbhhkRaY6UccYoI6K6MMyISJOkiDNGGRHdCcOMiDTLm3HGKCMiZzDMiEjTvBFnjDIichbDjIg0z5NxxigjovpgmBERwTNxxigjovpimBER/Y8744xRRkSuYJgREVXjjjhjlBGRqxhmREQ1NCTOGGVE1BCShtmsWbOg0+lsbpGRkU49dseOHTAYDIiPj7dZnpSUZLdOnU6H/v37W8d89913GDBgAKKioqDT6bB27Vq79V+8eBGjR49GVFQUAgIC0LdvXxQUFNzxuVJSUmzGXLt2DWlpaTAajTAajUhLS8P169ed+hmJSDquxBmjjIgaSvI9Zu3bt0dhYaH1lpeXd8fHmM1mjBw5Er169bK7b/Xq1Tbry8/Ph16vx9ChQ61jbt68iQcffBDvvfeew/ULgoBBgwbh5MmT+PLLL7F//360bNkSvXv3xs2bN23Gjhs3zub5FixYYHN/amoqTCYT1q9fj/Xr18NkMiEtLc2Zl4aIJFafOGOUEZE7GCTfAIPB6b1kovHjxyM1NRV6vd5ub1dISIjNv7OyshAQEGATZv369UO/fv1qXX9BQQGys7ORn5+P9u3bAwDef/99hIeHY8WKFRg7dqx1bEBAQK3bf+TIEaxfvx7Z2dlISEgAACxcuBDdu3fH0aNHERMTU6+fm4i8b+JjrQFUhdnfNhy1WSZilBGRu0i+x6ygoABRUVGIjo5GSkoKTp48Wef4xYsX48SJE5g5c6ZT68/IyEBKSgoCAwOd3iaLxQIA8Pf/5YNVr9fD19cX27dvtxm7bNkyhIWFoX379pg2bRpKSkqs9+3atQtGo9EaZQDQrVs3GI1G7Ny5s87nLy4utrkRkXTq2nPGKCMid5J0j1lCQgIyMzPRtm1bXLx4Ea+99hoSExNx6NAhhIaG2o0vKCjA9OnT8f3338NguPOm5+bmIj8/HxkZGfXarl/96ldo2bIlZsyYgQULFiAwMBDvvPMOioqKUFhYaB03fPhwREdHIzIyEvn5+ZgxYwYOHDiATZs2AQCKiooQHh5ut/7w8HAUFRXV+vxz587F7Nmz67XNRORZjvacPRUfxSgjIreSNMyqf50YFxeH7t274/7778fSpUsxdepUm7EVFRVITU3F7Nmz0bZtW6fWn5GRgdjYWHTt2rVe29WoUSN88cUXGDNmDEJCQqDX69G7d2+7rz/HjRtn/d+xsbFo06YNOnfujH379qFTp04AAJ1OZ7d+QRAcLhfNmDHD5ucvLi5G8+bN6/UzEJH71YwzMdAYZUTkLpIfY1ZdYGAg4uLi7M5+BICSkhLs2bMH+/fvR3p6OgCgsrISgiDAYDBg48aN+PWvf20dX1paiqysLMyZM8elbXnooYdgMplgNptRVlaGpk2bIiEhAZ07d671MZ06dUKjRo1QUFCATp06ITIyEhcvXrQbd/nyZURERNS6Hj8/P/j5+bm03UTkWRMfa43z129hec4Z6zJGGRG5i+THmFVnsVhw5MgRNGvWzO6+4OBg5OXlwWQyWW/PP/88YmJiYDKZbI7jAoBVq1bBYrFgxIgRDdomo9GIpk2boqCgAHv27MFTTz1V69hDhw7h9u3b1u3v3r07zGYzcnNzrWNycnJgNpuRmJjYoO0iImmcu1aK745dtln2xb5zEm0NEamNpHvMpk2bhgEDBqBFixa4dOkSXnvtNRQXF2PUqFEAqr7SO3/+PDIzM+Hj44PY2Fibx4eHh8Pf399uOVD1NeagQYMcHqt248YNHD/+y8G7p06dgslkQkhICFq0aAEA+Oyzz9C0aVO0aNECeXl5eOGFFzBo0CAkJycDAE6cOIFly5bhiSeeQFhYGA4fPoyXXnoJHTt2xMMPPwwAaNeuHfr27Ytx48ZZL6Px3HPP4cknn+QZmUQKVPNA/0fbNkXmrh9rPVuTiKi+JA2zc+fOYdiwYfjpp5/QtGlTdOvWDdnZ2WjZsiUAoLCwEGfOnLnDWuwdO3YM27dvx8aNGx3ev2fPHjz22GPWf4vHc40aNQpLliyxPvfUqVNx8eJFNGvWDCNHjsSf//xn62N8fX3xzTff4O9//ztu3LiB5s2bo3///pg5cyb0er113LJlyzB58mRr0A0cOLDW66cRkXzVdvZlRLB/nZfSICKqD50gCILUG0F1Ky4uhtFohNlsRnBwsNSbQ6RJ2SevYPTiXEQG+9sdU/avrcetYfaHPjGMMyIC4Nrfb1kd/E9EJFfd7gvF0me7omVooN2B/s5chJaIyBkMMyIiJyXcZ3/MqohxRkTuIKuzMomIlMyVic+JiKpjmBERuRHjjIgagmFGRORmjDMichXDjIjIA2rG2fvfMs6I6M548D8RkYeIB/+/s+kYWoQESLw1RKQEDDMiIg+a+Fhr9GkfidbhTaTeFCJSAH6VSUTkYYwyInIWw4yIiIhIJhhmRERERDLBMCMiIiKSCYYZERERkUwwzIiIiIhkgmFGREREJBMMMyIiIiKZYJgRERERyQTDjIiIiEgmGGZEREREMsEwIyIiIpIJhhkRERGRTDDMiIiIiGTCIPUG0J0JggAAKC4ulnhLiIiIyFni323x77gzGGYKUFJSAgBo3ry5xFtCRERE9VVSUgKj0ejUWJ1Qn4wjSVRWVuLChQsICgqCTqeTenM8pri4GM2bN8fZs2cRHBws9eYoGl9L9+Fr6R58Hd2Hr6X7ePq1FAQBJSUliIqKgo+Pc0ePcY+ZAvj4+ODee++VejO8Jjg4mB82bsLX0n34WroHX0f34WvpPp58LZ3dUybiwf9EREREMsEwIyIiIpIJhhnJhp+fH2bOnAk/Pz+pN0Xx+Fq6D19L9+Dr6D58Ld1Hjq8lD/4nIiIikgnuMSMiIiKSCYYZERERkUwwzIiIiIhkgmFGLpk7dy50Oh2mTJliXabT6Rze/va3v1nHFBUVIS0tDZGRkQgMDESnTp3w+eef26z72LFjeOqppxAWFobg4GA8/PDD2Lp1q82YM2fOYMCAAQgMDERYWBgmT56MsrIymzF5eXno2bMnGjdujHvuuQdz5syp17QY3iL1a+noeT788EObMXwtgX379uHxxx/HXXfdhdDQUDz33HO4ceOGzRi1vC+lfh35ngROnDiB3/zmN2jatCmCg4Px9NNP4+LFizbrvnbtGtLS0mA0GmE0GpGWlobr16/bjFHLexKQ/rX02vtSIKqn3NxcoVWrVkKHDh2EF154wbq8sLDQ5rZo0SJBp9MJJ06csI7p3bu30KVLFyEnJ0c4ceKE8Je//EXw8fER9u3bZx3TunVr4YknnhAOHDggHDt2TJgwYYIQEBAgFBYWCoIgCOXl5UJsbKzw2GOPCfv27RM2bdokREVFCenp6dZ1mM1mISIiQkhJSRHy8vKEL774QggKChLeeustz79A9SD1aykIggBAWLx4sc3zlZaWWu/naykI58+fF+6++27h+eefF3744QchNzdXSExMFIYMGWJdh1rel1K/joLA9+SNGzeE++67T/jNb34jHDx4UDh48KDw1FNPCV26dBEqKiqs6+nbt68QGxsr7Ny5U9i5c6cQGxsrPPnkk9b71fKeFATpX0tB8N77kmFG9VJSUiK0adNG2LRpk9CzZ0+bX5CannrqKeHXv/61zbLAwEAhMzPTZllISIjw8ccfC4IgCJcvXxYACN999531/uLiYgGAsHnzZkEQBOE///mP4OPjI5w/f946ZsWKFYKfn59gNpsFQRCE999/XzAajcLPP/9sHTN37lwhKipKqKysdO2HdzM5vJaCUPVhs2bNmlqfm6+lICxYsEAIDw+3+SDfv3+/AEAoKCgQBEEd70s5vI6CwPfkhg0bBB8fH+v7RhAE4erVqwIAYdOmTYIgCMLhw4cFAEJ2drZ1zK5duwQAwg8//CAIgjrek4Igj9dSELz3vuRXmVQvEydORP/+/dG7d+86x128eBFff/01xowZY7O8R48eWLlyJa5evYrKykpkZWXBYrEgKSkJABAaGop27dohMzMTN2/eRHl5ORYsWICIiAg89NBDAIBdu3YhNjYWUVFR1vX26dMHFosFe/futY7p2bOnzbVp+vTpgwsXLuD06dNueCUaTg6vpSg9PR1hYWHo0qULPvzwQ1RWVlrv42sJWCwW+Pr62sx117hxYwDA9u3bAajjfSmH11Gk5fekxWKBTqez+fn8/f3h4+Nj834zGo1ISEiwjunWrRuMRiN27txpHaP09yQgj9dS5I33JcOMnJaVlYV9+/Zh7ty5dxy7dOlSBAUFYfDgwTbLV65cifLycoSGhsLPzw/jx4/HmjVrcP/99wOo+g5/06ZN2L9/P4KCguDv7493330X69evx1133QWg6jiWiIgIm/Xefffd8PX1RVFRUa1jxH+LY6Qkl9cSAP7yl7/gs88+w+bNm5GSkoKXXnoJb7zxhvV+vpbAr3/9axQVFeFvf/sbysrKcO3aNfzf//0fAKCwsBCA8t+XcnkdAb4nu3XrhsDAQLz88ssoLS3FzZs38Yc//AGVlZU277fw8HC79YWHh9f5flPSexKQz2sJeO99yTAjp5w9exYvvPACPv30U/j7+99x/KJFizB8+HC7sa+88gquXbuGzZs3Y8+ePZg6dSqGDh2KvLw8AIAgCJgwYQLCw8Px/fffIzc3F0899RSefPJJmw9unU5n95yCINgsrzlG+N8BmI4e601yey1feeUVdO/eHfHx8XjppZcwZ84cmwNnAb6W7du3x9KlS/H2228jICAAkZGRuO+++xAREQG9Xm9dj1Lfl3J7HbX+nmzatCk+++wzfPXVV2jSpAmMRiPMZjM6derU4PebM2P4Wlap+Tp57X3p9JeepGlr1qwRAAh6vd56AyDodDpBr9cL5eXl1rHfffedAEAwmUw26zh+/LgAQMjPz7dZ3qtXL2H8+PGCIAjC5s2b7Y4HEISqg9jnzp0rCIIg/PnPfxY6dOhgc794zMCWLVsEQRCEtLQ0YeDAgTZj9u3bJwAQTp482YBXouHk9Fo6sn37dgGAUFRUJAgCX8uaioqKhJKSEuHGjRuCj4+PsGrVKkEQlP2+lNPr6IjW3pPVXb58Wbh27ZogCIIQEREhvPnmm4IgCEJGRoZgNBrtxhuNRmHRokWCICj7PSkI8notHfHU+5J7zMgpvXr1Ql5eHkwmk/XWuXNnDB8+HCaTyea/PDIyMvDQQw/hwQcftFlHaWkpANgcXwIAer3e+j19bWN8fHysY7p37478/HybvT4bN26En5+f9dip7t2747vvvrM5LXzjxo2IiopCq1atGvJSNJicXktH9u/fD39/f+vXnXwtbUVERKBJkyZYuXIl/P398fjjjwNQ9vtSTq+jI1p7T1YXFhaGu+66C1u2bMGlS5cwcOBAAFWvgdlsRm5urnVsTk4OzGYzEhMTrWOU+p4E5PVaOuKx96XTCUdUg6OzY8xmsxAQECB88MEHduPLysqE1q1bC4888oiQk5MjHD9+XHjrrbcEnU4nfP3114IgVP0XTWhoqDB48GDBZDIJR48eFaZNmyY0atTI+l9C4ingvXr1Evbt2yds3rxZuPfee21OAb9+/boQEREhDBs2TMjLyxNWr14tBAcHy+4UcJFUr+W6deuEjz76SMjLyxOOHz8uLFy4UAgODhYmT55sfS6+llX++c9/Cnv37hWOHj0qvPfee0Ljxo2Fv//979b71fa+lOp15HuyyqJFi4Rdu3YJx48fFz755BMhJCREmDp1qs2Yvn37Ch06dBB27dol7Nq1S4iLi3N4uQy1vCcFQbrX0pvvS4YZuczRL8iCBQuExo0bC9evX3f4mGPHjgmDBw8WwsPDhYCAAKFDhw52p9fv3r1bSE5OFkJCQoSgoCChW7duwn/+8x+bMT/++KPQv39/oXHjxkJISIiQnp5uc4qyIAjCwYMHhUceeUTw8/MTIiMjhVmzZsnm9O+apHot//vf/wrx8fFCkyZNhICAACE2NlaYP3++cPv2bZv18LWs+poiJCRE8PX1dXi/IKjrfSnV68j3ZJWXX35ZiIiIEBo1aiS0adNGePvtt+1+vitXrgjDhw8XgoKChKCgIGH48OHWr+pEanpPCoJ0r6U335c6QZDh5X2JiIiINIjHmBERERHJBMOMiIiISCYYZkREREQywTAjIiIikgmGGREREZFMMMyIiIiIZIJhRkRERCQTDDMiIiIimWCYEREREckEw4yIyIsqKiqQmJiIIUOG2Cw3m81o3rw5XnnlFYm2jIjkgFMyERF5WUFBAeLj4/HRRx9h+PDhAICRI0fiwIED2L17N3x9fSXeQiKSCsOMiEgC//jHPzBr1izk5+dj9+7dGDp0KHJzcxEfHy/1phGRhBhmREQSEAQBv/71r6HX65GXl4dJkybxa0wiYpgREUnlhx9+QLt27RAXF4d9+/bBYDBIvUlEJDEe/E9EJJFFixYhICAAp06dwrlz56TeHCKSAe4xIyKSwK5du/Doo4/iv//9L958801UVFRg8+bN0Ol0Um8aEUmIe8yIiLzs1q1bGDVqFMaPH4/evXvj448/xu7du7FgwQKpN42IJMYwIyLysunTp6OyshLz5s0DALRo0QJvv/02/vCHP+D06dPSbhwRSYpfZRIRedG2bdvQq1cvfPvtt+jRo4fNfX369EF5eTm/0iTSMIYZERERkUzwq0wiIiIimWCYEREREckEw4yIiIhIJhhmRERERDLBMCMiIiKSCYYZERERkUwwzIiIiIhkgmFGREREJBMMMyIiIiKZYJgRERERyQTDjIiIiEgmGGZEREREMvH/rScQlKoQBb8AAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "plot = flight_planner.plot_flight_plan(wp)"
    ]
@@ -826,9 +744,9 @@
    "source": [
     "# Sim context.\n",
     "# Set logging.\n",
-    "pyhelios.loggingQuiet()\n",
+    "pyhelios.logging_quiet()\n",
     "# Set seed for random number generator.\n",
-    "pyhelios.setDefaultRandomnessGeneratorSeed(\"123\")"
+    "pyhelios.default_rand_generator_seed(\"123\")"
    ]
   },
   {
@@ -858,16 +776,7 @@
    "execution_count": 31,
    "id": "16c31e67",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 3856.0078990000184 seconds\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# build the simulation \n",
     "sim = simB.build()"
@@ -878,23 +787,7 @@
    "execution_count": 32,
    "id": "dcb50cbd",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Simulation has started!\n",
-      "Survey Name: Arboretum\n",
-      "Scanner: riegl_vux-1uav\n",
-      "Device[0]: riegl_vux-1uav\n",
-      "\tAverage Power: 4 W\n",
-      "\tBeam Divergence: 0.5 mrad\n",
-      "\tWavelength: 1064 nm\n",
-      "\tVisibility: 23 km\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Start the simulation.\n",
     "start_time = time.time()\n",
@@ -902,8 +795,8 @@
     "\n",
     "if sim.isStarted():\n",
     "    print('Simulation has started!\\nSurvey Name: {survey_name}\\n{scanner_info}'.format(\n",
-    "        survey_name = sim.sim.getSurvey().name,\n",
-    "        scanner_info = sim.sim.getScanner().toString()))"
+    "        survey_name = sim.sim.survey.name,\n",
+    "        scanner_info = sim.sim.scanner.to_string()))"
    ]
   },
   {
@@ -911,16 +804,7 @@
    "execution_count": 33,
    "id": "d2b14ea0",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Simulation is running since 0 min and 20 sec. Please wait.\n",
-      "Simulation has finished!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "while sim.isRunning():\n",
     "    duration = time.time()-start_time\n",
@@ -946,24 +830,15 @@
    "execution_count": 34,
    "id": "be701a05",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of measurements : 10620153\n",
-      "Number of points in trajectory : 6420\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Create instance of PyHeliosOutputWrapper class using sim.join(). \n",
     "# Contains attributes 'measurements' and 'trajectories' which are Python wrappers of classes that contain the output vectors.\n",
     "output = sim.join()\n",
     "\n",
     "# Create instances of vector classes by accessing 'measurements' and 'trajectories' attributes of output wrapper.\n",
-    "measurements = output.measurements\n",
-    "trajectories = output.trajectories\n",
+    "measurements = output[0]\n",
+    "trajectories = output[1]\n",
     "\n",
     "# Get amount of points in trajectory and amount of measurements by accessing length of measurement and trajectory vectors.\n",
     "print('Number of measurements : {n}'.format(n=len(measurements)))\n",
@@ -1022,21 +897,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "id": "263a7692",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Matplotlib figure.\n",
     "fig = plt.figure(figsize=(8,5))\n",
@@ -1063,7 +927,7 @@
     "# Set title.\n",
     "ax.set_title(label='Point cloud and trajectory from pyhelios simulation in Heidelberg')\n",
     "# Set subtitle.\n",
-    "ax.text2D(0.1, 0.97, \"survey: {s}\".format(s=sim.sim.getSurvey().name, n=len(trajectories)),\n",
+    "ax.text2D(0.1, 0.97, \"survey: {s}\".format(s=sim.sim.survey.name, n=len(trajectories)),\n",
     "                                                                              fontsize='10', transform=ax.transAxes)\n",
     "ax.view_init(elev=10, azim=145)\n",
     "\n",
@@ -1118,18 +982,7 @@
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 900x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Matplotlib figure.\n",
     "fig = plt.figure(figsize=(9,5))\n",
@@ -1199,18 +1052,7 @@
    "execution_count": 40,
    "id": "e2191048",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x1200 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "fig, axs = plt.subplots(2, 1, figsize=(8,12))\n",
     "axs[0].scatter(section_or[:, 1], section_or[:, 2], color=\"orange\", s=0.01)\n",
@@ -1259,7 +1101,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+   "version": "3.12.5"
   }
  },
  "nbformat": 4,
diff --git a/example_notebooks/I-getting-started.ipynb b/example_notebooks/I-getting-started.ipynb
index 7e09a1787..e443335ab 100644
--- a/example_notebooks/I-getting-started.ipynb
+++ b/example_notebooks/I-getting-started.ipynb
@@ -36,18 +36,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "190276b5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2.0.0a3.dev10+g9e1844ae.d20240528\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import pyhelios\n",
     "\n",
@@ -56,7 +48,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "0d4d3428",
    "metadata": {},
    "outputs": [],
@@ -75,19 +67,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "5411a736",
    "metadata": {},
    "outputs": [],
    "source": [
     "# pyhelios.loggingQuiet()\n",
     "# pyhelios.loggingSilent()\n",
-    "pyhelios.loggingDefault()\n",
+    "pyhelios.logging_default()\n",
     "# pyhelios.loggingVerbose()\n",
     "# pyhelios.loggingVerbose2()\n",
     "\n",
     "# Set seed for default random number generator.\n",
-    "pyhelios.setDefaultRandomnessGeneratorSeed(\"123\")"
+    "pyhelios.default_rand_generator_seed(\"123\")"
    ]
   },
   {
@@ -100,19 +92,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "5e5fd46a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 0.06853010000486393 seconds\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "simBuilder = pyhelios.SimulationBuilder(\n",
     "    \"data/surveys/toyblocks/als_toyblocks.xml\", [\"assets/\"], \"output/\"\n",
@@ -161,27 +144,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "b744c735",
    "metadata": {
     "pycharm": {
      "is_executing": true
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Simulation is started!\n",
-      "Simulation is paused!\n",
-      "Simulation is not running.\n",
-      "Simulation is resumed!\n",
-      "Simulation is running since 0 min and 3 sec. Please wait.\n",
-      "Simulation has finished.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import time\n",
     "\n",
@@ -235,19 +205,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "26589610",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Trajectory starting point : (-30.0, -50.0, 100.0)\n",
-      "Trajectory end point : (69.9, 50.0, 100.0)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Create instance of PyHeliosOutputWrapper class using sim.join().\n",
     "# Contains attributes 'measurements' and 'trajectories' which are Python wrappers\n",
@@ -255,20 +216,20 @@
     "output = sim.join()\n",
     "\n",
     "# Create instances of vector classes by accessing 'measurements' and 'trajectories' attributes of output wrapper.\n",
-    "measurements = output.measurements\n",
-    "trajectories = output.trajectories\n",
+    "measurements = output[0]\n",
+    "trajectories = output[1]\n",
     "\n",
     "# Each element of vectors contains a measurement point or point in trajectory respectively.\n",
     "# Access through getPosition().\n",
-    "starting_point = trajectories[0].getPosition()\n",
-    "end_point = trajectories[len(trajectories) - 1].getPosition()\n",
+    "starting_point = trajectories[0].position\n",
+    "end_point = trajectories[len(trajectories) - 1].position\n",
     "\n",
     "# Access individual x, y and z vals.\n",
     "print(\n",
-    "    f\"Trajectory starting point : ({starting_point.x}, {starting_point.y}, {starting_point.z})\"\n",
+    "    f\"Trajectory starting point : ({starting_point[0]}, {starting_point[1]}, {starting_point[2]})\"\n",
     ")\n",
     "print(\n",
-    "    f\"Trajectory end point : ({end_point.x:.1f}, {end_point.y:.1f}, {end_point.z:.1f})\"\n",
+    "    f\"Trajectory end point : ({end_point[0]:.1f}, {end_point[1]:.1f}, {end_point[2]:.1f})\"\n",
     ")"
    ]
   },
@@ -282,7 +243,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "cf678697",
    "metadata": {},
    "outputs": [],
@@ -292,33 +253,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "41887ac9",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "First three rows of measurement array:\n",
-      "\n",
-      "[[-29.846 -13.246 0.012 -50.000 -49.915 89.871 0.001 0.342 -0.940 4.339\n",
-      "  0.000 1.000 1.000 1.000 0.000 0.000 -2147483648.000]\n",
-      " [-24.944 -13.595 0.012 -49.997 -49.915 89.871 0.047 0.339 -0.940 4.970\n",
-      "  0.000 1.000 1.000 33.000 0.000 0.000 -2147483648.000]\n",
-      " [-29.693 -13.259 0.046 -50.000 -49.915 89.871 0.003 0.342 -0.940 5.601\n",
-      "  0.000 1.000 1.000 2.000 0.000 0.000 -2147483648.000]]\n",
-      "\n",
-      "First three rows of trajectory array:\n",
-      "\n",
-      "[[-30.000 -50.000 100.000 -2147483648.000 0.000 0.000 4.712]\n",
-      " [-29.700 -50.000 100.000 -2147483648.000 0.000 0.000 4.712]\n",
-      " [-29.400 -50.000 100.000 -2147483648.000 0.000 0.000 4.712]]\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -373,7 +311,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+   "version": "3.12.5"
   }
  },
  "nbformat": 4,
diff --git a/example_notebooks/II-the-survey.ipynb b/example_notebooks/II-the-survey.ipynb
index 52c728a45..3ffb993a4 100644
--- a/example_notebooks/II-the-survey.ipynb
+++ b/example_notebooks/II-the-survey.ipynb
@@ -25,7 +25,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -39,7 +39,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -49,24 +49,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 0.02677209999819752 seconds\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "pyhelios.loggingDefault()\n",
+    "pyhelios.logging_default()\n",
     "# build simulation parameters\n",
     "simBuilder = pyhelios.SimulationBuilder(\n",
     "    \"data/surveys/toyblocks/als_toyblocks.xml\", [\"assets/\"], \"output/\"\n",
@@ -92,25 +83,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "toyblocks_als\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# obtain survey path and name\n",
-    "survey_path = simB.sim.getSurveyPath()\n",
-    "survey = simB.sim.getSurvey()\n",
+    "survey_path = simB.sim.survey_path\n",
+    "survey = simB.sim.survey\n",
     "survey_name = survey.name\n",
     "print(survey_name)"
    ]
@@ -130,48 +113,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.0"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "survey.getLength()"
+    "survey.length"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "400.0\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "survey.calculateLength()\n",
-    "print(survey.getLength())"
+    "survey.calculate_length()\n",
+    "print(survey.length)"
    ]
   },
   {
@@ -189,31 +153,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Scanner: riegl_vq-880g\n",
-      "Device[0]: riegl_vq-880g\n",
-      "\tAverage Power: 4 W\n",
-      "\tBeam Divergence: 0.3 mrad\n",
-      "\tWavelength: 1064 nm\n",
-      "\tVisibility: 23 km\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "scanner = simB.sim.getScanner()\n",
+    "scanner = simB.sim.scanner\n",
     "# print scanner characteristics\n",
-    "print(scanner.toString())"
+    "print(scanner.to_string())"
    ]
   },
   {
@@ -229,35 +179,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Device ID:               riegl_vq-880g\n",
-      "\n",
-      "Average power:           4.0      W\n",
-      "Beam divergence:         0.0003   rad\n",
-      "Wavelength:              1064.0   nm\n",
-      "Scanner visibility:      23.0     km\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\n",
     "    f\"\"\"\n",
-    "{'Device ID:' : <25}{scanner.deviceId : ^8}\n",
+    "{'Device ID:' : <25}{scanner.device_id : ^8}\n",
     "\n",
-    "{'Average power:' : <25}{scanner.averagePower : <8} W\n",
-    "{'Beam divergence:' : <25}{scanner.beamDivergence : <8} rad\n",
+    "{'Average power:' : <25}{scanner.average_power : <8} W\n",
+    "{'Beam divergence:' : <25}{scanner.beam_divergence : <8} rad\n",
     "{'Wavelength:' : <25}{scanner.wavelength*1000000000 : <8} nm\n",
     "{'Scanner visibility:' : <25}{scanner.visibility : <8} km\n",
     "\"\"\"\n",
@@ -277,39 +212,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Number of subsampling rays:   19\n",
-      "Pulse length:                 2.0 ns\n",
-      "Supported pulse frequencies:  [150000, 300000, 600000, 900000] Hz\n",
-      "Maximum number of returns:    unlimited\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "if scanner.maxNOR == 0:\n",
+    "if scanner.max_nor == 0:\n",
     "    max_nor = \"unlimited\"\n",
     "else:\n",
-    "    max_nor = scanner.maxNOR\n",
+    "    max_nor = scanner.max_nor\n",
     "\n",
     "\n",
     "print(\n",
     "    f\"\"\"\n",
-    "{'Number of subsampling rays:' : <30}{scanner.numRays}\n",
-    "{'Pulse length:' : <30}{scanner.pulseLength_ns} ns\n",
-    "{'Supported pulse frequencies:' : <30}{list(scanner.getSupportedPulseFrequencies())} Hz\n",
+    "{'Number of subsampling rays:' : <30}{scanner.num_rays}\n",
+    "{'Pulse length:' : <30}{scanner.pulse_length} ns\n",
+    "{'Supported pulse frequencies:' : <30}{list(scanner.supported_pulse_freqs_hz)} Hz\n",
     "{'Maximum number of returns:': <30}{max_nor}\n",
     "\n",
     "\"\"\"\n",
@@ -332,24 +253,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 3.1580837999936193 seconds\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "pyhelios.loggingDefault()\n",
+    "pyhelios.logging_default()\n",
     "# build simulation parameters\n",
     "simBuilder = pyhelios.SimulationBuilder(\n",
     "    \"data/surveys/demo/tls_arbaro_demo.xml\", [\"assets/\"], \"output/\"\n",
@@ -364,57 +276,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Scanner: riegl_vz400\n",
-      "Device[0]: riegl_vz400\n",
-      "\tAverage Power: 4 W\n",
-      "\tBeam Divergence: 0.3 mrad\n",
-      "\tWavelength: 1064 nm\n",
-      "\tVisibility: 23 km\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "scanner = simB.sim.getScanner()\n",
-    "print(scanner.toString())"
+    "scanner = simB.sim.scanner\n",
+    "print(scanner.to_string())"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Max. rotation speed: 60 degrees per second\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "head = scanner.getScannerHead()\n",
+    "head = scanner.scanner_head\n",
     "# get scanner rotation speed and range\n",
     "print(\n",
     "    f\"\"\"\n",
-    "Max. rotation speed: {round(head.rotatePerSecMax * 180 / math.pi)} degrees per second\n",
+    "Max. rotation speed: {round(head.rotate_per_sec_max * 180 / math.pi)} degrees per second\n",
     "\"\"\"\n",
     ")"
    ]
@@ -432,32 +320,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Scanner deflector type:  POLYGON_MIRROR\n",
-      "Scan frequency range:    3.0 - 120.0 Hz\n",
-      "Scan angle range:        120° FOV\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "deflector = scanner.getBeamDeflector()\n",
+    "deflector = scanner.beam_deflector\n",
     "print(\n",
     "    f\"\"\"\n",
-    "{'Scanner deflector type:': <25}{deflector.getOpticsType() : <8}\n",
-    "{'Scan frequency range:' : <25}{deflector.scanFreqMin} - {deflector.scanFreqMax} Hz\n",
-    "{'Scan angle range:' : <25}{round(deflector.scanAngleMax * 180 / math.pi)}° FOV\n",
+    "{'Scanner deflector type:': <25}{deflector.optics_type : <8}\n",
+    "{'Scan frequency range:' : <25}{deflector.scan_freq_min} - {deflector.scan_freq_max} Hz\n",
+    "{'Scan angle range:' : <25}{round(deflector.scan_angle_max * 180 / math.pi)}° FOV\n",
     "\"\"\"\n",
     ")"
    ]
@@ -475,32 +351,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Accuracy:           0.005 m\n",
-      "Minimum range:      1.5 m\n",
-      "Maximum range:      1.7976931348623157e+308 m\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "detector = scanner.getDetector()\n",
+    "detector = scanner.detector\n",
     "print(\n",
     "    f\"\"\"\n",
     "{'Accuracy:' : <20}{detector.accuracy} m\n",
-    "{'Minimum range:' : <20}{detector.rangeMin} m\n",
-    "{'Maximum range:': <20}{detector.rangeMax} m\n",
+    "{'Minimum range:' : <20}{detector.range_min} m\n",
+    "{'Maximum range:': <20}{detector.range_max} m\n",
     "\"\"\"\n",
     ")"
    ]
@@ -519,31 +383,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Full waveform settings for riegl_vz400\n",
-      "Bin size:                0.2 ns\n",
-      "Window size:             1.25 ns\n",
-      "Beam sample quality:     3\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\n",
-    "    f\"\"\"Full waveform settings for {scanner.deviceId}\n",
-    "{'Bin size:' : <25}{scanner.fwfSettings.binSize_ns} ns\n",
-    "{'Window size:' : <25}{scanner.fwfSettings.winSize_ns} ns\n",
-    "{'Beam sample quality:' : <25}{scanner.fwfSettings.beamSampleQuality}\n",
+    "    f\"\"\"Full waveform settings for {scanner.device_id}\n",
+    "{'Bin size:' : <25}{scanner.FWF_settings.bin_size} ns\n",
+    "{'Window size:' : <25}{scanner.FWF_settings.win_size} ns\n",
+    "{'Beam sample quality:' : <25}{scanner.FWF_settings.beam_sample_quality}\n",
     "\"\"\"\n",
     ")"
    ]
@@ -564,51 +416,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Scanner is active:            True\n",
-      "Pulse frequency:              100000 Hz\n",
-      "Scan angle:                   100.0°\n",
-      "Minimum vertical angle:       -40.0°\n",
-      "Maximum vertical angle:       +60.0°\n",
-      "Scan frequency:               120.0 Hz\n",
-      "Beam divergence:              0.3 mrad\n",
-      "Trajectory time interval:     1.0 s\n",
-      "Start angle of head rotation: 100.0°\n",
-      "Start angle of head rotation: 225.0°\n",
-      "Rotation speed:               10.0° per s\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# get the first leg\n",
-    "leg = simB.sim.getLeg(0)\n",
+    "leg = simB.sim.get_leg(0)\n",
     "\n",
     "# scanner settings\n",
     "print(\n",
     "    f\"\"\"\n",
-    "{'Scanner is active:' : <30}{leg.getScannerSettings().active}\n",
-    "{'Pulse frequency:' : <30}{leg.getScannerSettings().pulseFreq} Hz\n",
-    "{'Scan angle:' : <30}{leg.getScannerSettings().scanAngle * 180 / math.pi}°\n",
-    "{'Minimum vertical angle:' : <30}{leg.getScannerSettings().verticalAngleMin * 180 / math.pi:+.1f}°\n",
-    "{'Maximum vertical angle:' : <30}{round(leg.getScannerSettings().verticalAngleMax * 180 / math.pi):+.1f}°\n",
-    "{'Scan frequency:' : <30}{leg.getScannerSettings().scanFreq} Hz\n",
-    "{'Beam divergence:' : <30}{leg.getScannerSettings().beamDivAngle * 1000} mrad\n",
-    "{'Trajectory time interval:' : <30}{leg.getScannerSettings().trajectoryTimeInterval} s\n",
-    "{'Start angle of head rotation:' : <30}{leg.getScannerSettings().headRotateStart * 180 / math.pi}°\n",
-    "{'Start angle of head rotation:' : <30}{leg.getScannerSettings().headRotateStop * 180 / math.pi}°\n",
-    "{'Rotation speed:' : <30}{leg.getScannerSettings().headRotatePerSec * 180 / math.pi}° per s\n",
+    "{'Scanner is active:' : <30}{leg.scanner_settings.is_active}\n",
+    "{'Pulse frequency:' : <30}{leg.scanner_settings.pulse_frequency} Hz\n",
+    "{'Scan angle:' : <30}{leg.scanner_settings.scan_angle * 180 / math.pi}°\n",
+    "{'Minimum vertical angle:' : <30}{leg.scanner_settings.min_vertical_angle * 180 / math.pi:+.1f}°\n",
+    "{'Maximum vertical angle:' : <30}{round(leg.scanner_settings.max_vertical_angle * 180 / math.pi):+.1f}°\n",
+    "{'Scan frequency:' : <30}{leg.scanner_settings.scan_frequency} Hz\n",
+    "{'Beam divergence:' : <30}{leg.scanner_settings.beam_divergence_angle * 1000} mrad\n",
+    "{'Trajectory time interval:' : <30}{leg.scanner_settings.trajectory_time_interval} s\n",
+    "{'Start angle of head rotation:' : <30}{leg.scanner_settings.rotation_start_angle * 180 / math.pi}°\n",
+    "{'Start angle of head rotation:' : <30}{leg.scanner_settings.rotation_stop_angle * 180 / math.pi}°\n",
+    "{'Rotation speed:' : <30}{leg.scanner_settings.head_rotation * 180 / math.pi}° per s\n",
     "\"\"\"\n",
     ")"
    ]
@@ -627,22 +459,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 0.04844519999460317 seconds\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "simBuilder = pyhelios.SimulationBuilder(\n",
     "    \"data/surveys/toyblocks/als_toyblocks.xml\", [\"assets/\"], \"output/\"\n",
@@ -666,67 +489,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "    Scanner template name: scanner1\n",
-      "    Pulse frequency: 300.0 kHz\n",
-      "    \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "leg = simB.sim.getLeg(0)\n",
+    "leg = simB.sim.get_leg(0)\n",
     "\n",
-    "ss = leg.getScannerSettings()\n",
-    "if ss.hasTemplate():\n",
-    "    ss_tmpl = ss.getTemplate()\n",
+    "ss = leg.scanner_settings\n",
+    "if ss.has_template():\n",
+    "    ss_tmpl = ss.base_template\n",
     "    print(\n",
     "        f\"\"\"\n",
     "    Scanner template name: {ss_tmpl.id}\n",
-    "    Pulse frequency: {ss_tmpl.pulseFreq/1000} kHz\n",
+    "    Pulse frequency: {ss_tmpl.pulse_frequency/1000} kHz\n",
     "    \"\"\"\n",
     "    )  # Print the pulse frequency defined in the template"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "    Platform template name:  platform1\n",
-      "    Speed:         30.0 m/s\n",
-      "    Altitude:      100.0 m\n",
-      "    \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "ps = leg.getPlatformSettings()\n",
-    "if ps.hasTemplate():\n",
-    "    ps_tmpl = ps.getTemplate()\n",
+    "ps = leg.platform_settings\n",
+    "if ps.has_template():\n",
+    "    ps_tmpl = ps.base_template\n",
     "    print(\n",
     "        f\"\"\"\n",
     "    {'Platform template name:' : <25}{ps_tmpl.id}\n",
-    "    {'Speed:' : <15}{ps_tmpl.movePerSec} m/s\n",
+    "    {'Speed:' : <15}{ps_tmpl.speed_m_s} m/s\n",
     "    {'Altitude:' : <15}{ps_tmpl.z} m\n",
     "    \"\"\"\n",
     "    )"
@@ -745,21 +545,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "New altitude: 120.0 m\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "ps_tmpl.z += 20\n",
     "print(f\"New altitude: {ps_tmpl.z} m\")"
@@ -778,29 +570,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "On ground? False\n",
-      "Position: (-50.0, -50.0, 89.110947)\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\n",
     "    f\"\"\"\n",
-    "On ground? {leg.getPlatformSettings().onGround}\n",
-    "Position: ({leg.getPlatformSettings().x}, {leg.getPlatformSettings().y}, {leg.getPlatformSettings().z})\n",
+    "On ground? {leg.platform_settings.is_on_ground}\n",
+    "Position: ({leg.platform_settings.x}, {leg.platform_settings.y}, {leg.platform_settings.z})\n",
     "\"\"\"\n",
     ")"
    ]
@@ -821,25 +602,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Shift = (20.0,0.0,10.889053)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "scene = simB.sim.getScene()\n",
-    "shift = scene.getShift()\n",
-    "print(f\"Shift = ({shift.x},{shift.y},{shift.z})\")"
+    "scene = simB.sim.scene\n",
+    "shift = scene.shift\n",
+    "print(f\"Shift = ({shift[0]},{shift[1]},{shift[2]})\")"
    ]
   },
   {
@@ -856,35 +629,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Leg 0\tposition = -30.0,-50.0,100.0\tactive = True\n",
-      "Leg 1\tposition = 70.0,-50.0,100.0\tactive = False\n",
-      "Leg 2\tposition = 70.0,0.0,100.0\tactive = True\n",
-      "Leg 3\tposition = -30.0,0.0,100.0\tactive = False\n",
-      "Leg 4\tposition = -30.0,50.0,100.0\tactive = True\n",
-      "Leg 5\tposition = 70.0,50.0,100.0\tactive = False\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "for i in range(simB.sim.getNumLegs()):\n",
-    "    leg = simB.sim.getLeg(i)\n",
+    "for i in range(simB.sim.num_legs):\n",
+    "    leg = simB.sim.get_leg(i)\n",
     "    print(\n",
     "        f\"Leg {i}\\tposition = \"\n",
-    "        f\"{leg.getPlatformSettings().x+shift.x},\"\n",
-    "        f\"{leg.getPlatformSettings().y+shift.y},\"\n",
-    "        f\"{leg.getPlatformSettings().z+shift.z}\\t\"\n",
-    "        f\"active = {leg.getScannerSettings().active}\"\n",
+    "        f\"{leg.platform_settings.x+shift[0]},\"\n",
+    "        f\"{leg.platform_settings.y+shift[1]},\"\n",
+    "        f\"{leg.platform_settings.z+shift[2]}\\t\"\n",
+    "        f\"active = {leg.scanner_settings.is_active}\"\n",
     "    )"
    ]
   },
@@ -903,24 +663,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 0.11666349999723025 seconds\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "pyhelios.loggingDefault()\n",
+    "pyhelios.logging_default()\n",
     "default_survey_path = \"data/surveys/default_survey.xml\"\n",
     "\n",
     "# default survey with the toyblocks scene (missing platform and scanner definition and not containing any legs)\n",
@@ -960,22 +711,22 @@
     "pulse_freq = 300_000\n",
     "scan_freq = 200\n",
     "scan_angle = 37.5 / 180 * math.pi  # convert to rad\n",
-    "shift = simB.sim.getScene().getShift()\n",
+    "shift = simB.sim.scene.shift\n",
     "for j, wp in enumerate(waypoints):\n",
-    "    leg = simB.sim.newLeg(j)\n",
-    "    leg.serialId = j  # assigning a serialId is important!\n",
-    "    leg.getPlatformSettings().x = wp[0] - shift.x  # don't forget to apply the shift!\n",
-    "    leg.getPlatformSettings().y = wp[1] - shift.y\n",
-    "    leg.getPlatformSettings().z = altitude - shift.z\n",
-    "    leg.getPlatformSettings().movePerSec = speed\n",
-    "    leg.getScannerSettings().pulseFreq = pulse_freq\n",
-    "    leg.getScannerSettings().scanFreq = scan_freq\n",
-    "    leg.getScannerSettings().scanAngle = scan_angle\n",
-    "    leg.getScannerSettings().trajectoryTimeInterval = (\n",
+    "    leg = simB.sim.new_leg(j)\n",
+    "    leg.serial_id = j  # assigning a serialId is important!\n",
+    "    leg.platform_settings.x = wp[0] - shift[0]  # don't forget to apply the shift!\n",
+    "    leg.platform_settings.y = wp[1] - shift[1]\n",
+    "    leg.platform_settings.z = altitude - shift[2]\n",
+    "    leg.platform_settings.speed_m_s = speed\n",
+    "    leg.scanner_settings.pulse_frequency = pulse_freq\n",
+    "    leg.scanner_settings.scan_frequency = scan_freq\n",
+    "    leg.scanner_settings.scan_angle = scan_angle\n",
+    "    leg.scanner_settings.trajectory_time_interval = (\n",
     "        0.05  # important to get a trajectory output\n",
     "    )\n",
     "    if j % 2 != 0:\n",
-    "        leg.getScannerSettings().active = False"
+    "        leg.scanner_settings.is_active = False"
    ]
   },
   {
@@ -991,23 +742,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Simulation is started!\n",
-      "Simulation is running since 0 min and 0 sec. Please wait.\n",
-      "Simulation has finished.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import time\n",
     "\n",
@@ -1043,24 +784,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdIAAAHoCAYAAAD9gW79AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d7xtVXX+j7/nXH3X02/jUrwWMKElYIyaSFERW9RYolFBEo0tMcYkftSoGEtijfkajalYomg0EQuGoIL+NIKCBUs0gnRuO/eU3Vafa/7+GGtvONzLBUVAk/28XofLWWe12eca4xnPUNZayxRTTDHFFFNM8RNB39MvMMUUU0wxxRQ/z5gupFNMMcUUU0xxJzBdSKeYYoopppjiTmC6kE4xxRRTTDHFncB0IZ1iiimmmGKKO4HpQjrFFFNMMcUUdwLThXSKKaaYYoop7gSmC+kUU0wxxRRT3AlMF9IppphiiimmuBOYLqQ/41BK3aGfL3zhC/f0qwJw7bXXopTive997z39KncY3/zmN3noQx9Kt9tFKcU73vGOA54XxzFnn332Aev67LPPRinFvn377tqXvQM488wzOfzww++RZ9+Z9t+5cydnn3023/rWt37q7/Xe974XpRTXXnvtT/3et4eTTjqJk0466Se69jOf+Qxnn332T/V9xn31nsAXvvCFn6n56qcF955+gSkOjksuuWTD76973eu4+OKLueiiizYcv//97393vtZtYsuWLVxyySXs2LHjnn6VO4yzzjqL0WjEhz/8YWZnZ29zEYrjmNe+9rUAP/HEeHfgVa96FS9+8Yvv6df4sbFz505e+9rXcvjhh3Pcccfd06/zU8O73/3un/jaz3zmM7zrXe/6qS+mU/x0MV1If8bxwAc+cMPvi4uLaK33O/6zgiAIfmbf7bbw3e9+l+c85zmcfvrp9/Sr/FTw87SJ+b+An5VN7hR3Haam3f8FWF1d5QUveAHbtm3D933uda978cpXvpIsyzacp5TiRS96EX/3d3/Hfe97X4Ig4P73vz8f/vCHD3r/oihYWlrimc985n5/W19fJ4oi/uiP/gi4bdPelVdeydOf/nSWlpYIgoCjjjqKd73rXZO/W2vZtGkTL3zhCyfHjDHMzs6itWbPnj2T429/+9txXZf19fWDvvd3v/tdfuM3foPZ2VnCMOS4447jfe973+TvY3NfWZb87d/+7cRMfiBce+21LC4uAvDa1752cu6ZZ5654bw9e/bwtKc9jW63y6ZNmzjrrLPo9XobzrHW8u53v5vjjjuOKIqYnZ3lSU96EldfffVBywOwvLzMc5/7XLZv304QBCwuLvLgBz+Yz33uc5NzDmTaHbf9Oeecw/3udz+iKOKEE07g0ksvxVrLW97yFo444gharRannHIKV1111YbrDz/88P3KCnfMbHnVVVfx7Gc/m/vc5z40Gg22bdvGYx/7WL7zne9MzvnCF77AiSeeCMCzn/3sSf3e8kvs8ssv53GPexxzc3OEYcjxxx/Pv/7rv+73vEsvvZQHP/jBhGHI1q1befnLX05RFAd9xzHOPPNMWq0W3/ve9zj11FNpNpssLi7yohe9iDiON5ybpikvf/nLOeKII/B9n23btvHCF75wv3556zoaj5G3vvWtvP3tb5/U+6/+6q9y6aWXbniX8Ri5pRvn9szTF1xwAaeeeirdbpdGo8FRRx3FX/zFXxz0mqqqePOb38yRRx5JEAQsLS3xrGc9ixtvvHHDeT9OP/jBD37AIx/5SBqNBgsLCzzvec9jMBgc9D1+bmGn+LnCGWecYZvN5uT3JEnsMcccY5vNpn3rW99qL7zwQvuqV73Kuq5rH/WoR224FrDbt2+397///e25555rP/nJT9pHPvKRFrAf/ehHD/rcl7zkJTaKItvr9TYcf/e7320B++1vf9taa+0111xjAXvOOedMzvne975nu92uPfroo+373/9+e+GFF9qXvvSlVmttzz777Ml5v/Vbv2Xve9/7Tn6/9NJLLWCjKLIf/OAHJ8dPP/10+4AHPOCg7/uDH/zAttttu2PHDvv+97/fnn/++fZpT3uaBeyb3vQma621e/futZdccokF7JOe9CR7ySWX2EsuueSA90vT1F5wwQUWsL/zO78zOfeqq66y1lr7mte8xgL2fve7n331q19tP/vZz9q3v/3tNggC++xnP3vDvZ7znOdYz/PsS1/6UnvBBRfYD33oQ/bII4+0mzZtsrt37z5ouU477TS7uLho//7v/95+4QtfsOedd5599atfbT/84Q9PzjnjjDPsYYcdtuE6wB522GH2QQ96kP33f/93+/GPf9ze9773tXNzc/YlL3mJ/Y3f+A376U9/2n7wgx+0mzZtssccc4ytqmpy/WGHHWbPOOOM/d7noQ99qH3oQx86+f1A7f/FL37RvvSlL7Uf+9jH7Be/+EX78Y9/3D7+8Y+3URTZH/zgB9Zaa3u9nj3nnHMsYP/sz/5sUr833HCDtdbaiy66yPq+b3/t137NfuQjH7EXXHCBPfPMMw/Y1xqNxqSPf+ITn7CnnXaaPfTQQy1gr7nmmoPW7xlnnGF937eHHnqofcMb3mAvvPBCe/bZZ1vXde1jHvOYyXlVVdnTTjvNuq5rX/WqV9kLL7zQvvWtb7XNZtMef/zxNk3T262jww8/3D7ykY+05513nj3vvPPs0UcfbWdnZ+36+rq11tqrrrrKPulJT7LApD4uueSSDfe+Nf7xH//RKqXsSSedZD/0oQ/Zz33uc/bd7363fcELXjA5Z9xXb4nnPve5FrAvetGL7AUXXGDf85732MXFRbt9+3a7vLw8Oe+O9oPdu3fbpaUlu23bNnvOOefYz3zmM/a3f/u3J+1w8cUXH7Qdft4wXUh/znDrhfQ973mPBey//uu/bjjvTW96kwXshRdeODk2XpRuOVmXZWmPPPJIe+973/ugz/32t79tAfv3f//3G44/4AEPsL/8y788+f1AE+lpp51mDznkkP0W4Re96EU2DEO7urpqrZVJALDXX3+9tdba17/+9fbII4+0j3vc4yaLUZ7nttls2le84hUHfd/f+q3fskEQTO41xumnn24bjcZkshrXywtf+MKD3s9aa5eXly1gX/Oa1+z3t/Hk9OY3v3nD8Re84AU2DMPJojReuN/2trdtOO+GG26wURTZP/3TPz3oO7RaLfuHf/iHBz3nthbSzZs32+FwODl23nnnWcAed9xxGxbNd7zjHRs2R9beuYX01ijL0uZ5bu9zn/vYl7zkJZPjl1122W1ee+SRR9rjjz/eFkWx4fhjHvMYu2XLFmuMsdZa+9SnPvU2+/gdXUgB+9d//dcbjr/hDW+wgP3yl79srbWTTdWt2/sjH/nIfuPkturo6KOPtmVZTo5/7Wtfs4A999xzJ8de+MIX7rfo3RYGg4HtdDr2IQ95yIb2vDVuvZB+//vft8CGxdZaa7/61a9aYMNYu6P94GUve5lVStlvfetbG857+MMf/r9yIZ2adn/OcdFFF9FsNnnSk5604fjY/PL5z39+w/FTTz2VTZs2TX53HIenPvWpXHXVVfuZcW6Jo48+ml/+5V/mnHPOmRz7/ve/z9e+9jXOOuus27wuTVM+//nP84QnPIFGo0FZlpOfRz3qUaRpOjFnPexhDwOYmCk/+9nP8vCHP5yHPexhfPaznwWEfDUajSbnHqxeTj31VLZv375fvcRxvB+J66eFxz3ucRt+P+aYY0jTlL179wLw6U9/GqUUz3jGMzbUxebNmzn22GNvl834gAc8gPe+9728/vWv59JLL73DJkuAk08+mWazOfn9qKOOAuD000/fYNIeH7/uuuvu8L0PhrIseeMb38j9739/fN/HdV183+fKK6/k+9///u1ef9VVV/GDH/yA3/7t357c75Z9aNeuXfzP//wPABdffPFt9vEfB+NnjfH0pz99cn9gQva7tZnzyU9+Ms1mc79xdyA8+tGPxnGcye/HHHMM8JPX+1e+8hX6/T4veMELfixW7rhMty7LAx7wAI466qg7VJYD3fMXfuEXOPbYYzccH9fj/zZMF9Kfc6ysrLB58+b9Bs7S0hKu67KysrLh+ObNm/e7x/jYrc+9Nc466ywuueQSfvCDHwBwzjnnEAQBT3va0w76fmVZ8s53vhPP8zb8POpRjwKYhIwcdthh7Nixg8997nOTxW68kN544438z//8D5/73OeIoogHPehBt1svW7Zs2e/41q1b71BZf1LMz89v+D0IAgCSJAHEh2prf/Ct6+PSSy+93fCZj3zkI5xxxhn84z/+I7/6q7/K3Nwcz3rWs9i9e/ftvtvc3NyG333fP+jxNE1v9553BH/0R3/Eq171Kh7/+MfzqU99iq9+9atcdtllHHvssZN6ORjG/vE//uM/3q/OXvCCFwA396HxeLg1DnTstuC67n7teOsxsrKyguu6E7/5GEopNm/efIf61+31lR8Xy8vLABxyyCE/1nXjd72t8fKTjJWfRjv8PGHK2v05x/z8PF/96lex1m5YTPfu3UtZliwsLGw4/0AT7vjYrQf2rfG0pz2NP/qjP+K9730vb3jDG/jABz7A4x//eGZnZ2/zmtnZWRzH4ZnPfOYGItEtccQRR0z+/9RTT+UTn/gEX/ziF6mqipNOOol2u83WrVv57Gc/y+c+9zl+7dd+bTLp3Bbm5+fZtWvXfsd37twJsF+93F1YWFhAKcWXvvSlA5bh9sq1sLDAO97xDt7xjndw/fXX88lPfpL/9//+H3v37uWCCy64q16bMAz3I6+BLGC3V5f/8i//wrOe9Sze+MY37nftzMzM7T57fP+Xv/zlPPGJTzzgOfe73/0AafeD9fE7grIsWVlZ2TAebj1G5ufnKcuS5eXlDYuptZbdu3dPiFN3J8bvcTDL0oEwLtOuXbv2W4R37ty5oX3vaD/4abTDzxOmX6Q/5zj11FMZDoecd955G46///3vn/z9lvj85z+/gQFrjOEjH/kIO3bsuN2d7OzsLI9//ON5//vfz6c//Wl27959ULMuQKPR4OSTT+ab3/wmxxxzDCeccMJ+P7ecsB72sIexZ88e3vGOd/DABz6Qdrs9KcfHP/5xLrvssts1647Pv+iiiyYL5y3rpdFo/EQhOnf2iwHgMY95DNZabrrppgPWxdFHH32H73XooYfyohe9iIc//OF84xvf+Inf6Y7g8MMP59vf/vaGYz/84Q8nJtWDQSm13wbh/PPP56abbtpw7Lbq9373ux/3uc99uOKKKw5YZyeccMKkn5x88sm32cd/HHzwgx/c8PuHPvQh4Ob44fG4+pd/+ZcN5/3bv/0bo9Fov3H3k+LH6XMPetCD6Ha7vOc978Fae4efccoppwD7l+Wyyy7j+9///oay3NF+cPLJJ/O9732PK664YsPxcT3+b8P0i/TnHM961rN417vexRlnnMG1117L0UcfzZe//GXe+MY38qhHPWq/RWdhYYFTTjmFV73qVTSbTd797nfzgx/84HZDYMY466yz+MhHPsKLXvQiDjnkkDu0qP31X/81D3nIQ/i1X/s1nv/853P44YczGAy46qqr+NSnPrVBXOKUU05BKcWFF144ET8AWWDPOOOMyf/fHl7zmtfw6U9/mpNPPplXv/rVzM3N8cEPfpDzzz+fN7/5zXS73TtU3lui3W5z2GGH8YlPfIJTTz2Vubk5FhYWfiwVoQc/+ME897nP5dnPfjaXX345v/7rv06z2WTXrl18+ctf5uijj+b5z3/+Aa/t9XqcfPLJPP3pT+fII4+k3W5z2WWXccEFF9zml9pPC8985jN5xjOewQte8AJ+8zd/k+uuu443v/nN+5k2D4THPOYxvPe97+XII4/kmGOO4etf/zpvectb9tu47dixgyiK+OAHP8hRRx1Fq9Vi69atbN26lb/7u7/j9NNP57TTTuPMM89k27ZtrK6u8v3vf59vfOMbfPSjHwXgz/7sz/jkJz/JKaecwqtf/WoajQbvete7GI1Gd7isvu/ztre9jeFwyIknnshXvvIVXv/613P66afzkIc8BICHP/zhnHbaabzsZS+j3+/z4Ac/mG9/+9u85jWv4fjjjz9gqNhPgvHG6k1vehOnn346juNwzDHHTMzvt0Sr1eJtb3sbv/u7v8vDHvYwnvOc57Bp0yauuuoqrrjiCv7mb/7mgM+43/3ux3Of+1ze+c53orXm9NNP59prr+VVr3oV27dv5yUvecnk3DvaD/7wD/+Qf/7nf+bRj340r3/969m0aRMf/OAHJ26hW+ILX/gCJ598Mq95zWt+foUn7lGq0xQ/Nm7N2rXW2pWVFfu85z3Pbtmyxbquaw877DD78pe/fD+aPDU79d3vfrfdsWOH9TzPHnnkkRtCS24Pxhi7fft2C9hXvvKV+/39tlib11xzjT3rrLPstm3brOd5dnFx0T7oQQ+yr3/96/e7x/HHH28B+1//9V+TYzfddJMF7Pz8/EEZibfEd77zHfvYxz7Wdrtd6/u+PfbYYw/ICOUOsnattfZzn/ucPf74420QBBaYMBjHTMhbhgpYaychHbdmi/7zP/+z/ZVf+RXbbDZtFEV2x44d9lnPepa9/PLLb/PZaZra5z3vefaYY46xnU7HRlFk73e/+9nXvOY1djQaTc67Ldburcs4bqu3vOUtG45ffPHF+4VEVVVl3/zmN9t73eteNgxDe8IJJ9iLLrroDrF219bW7O/8zu/YpaUl22g07EMe8hD7pS99ab9rrbX23HPPtUceeaT1PG8/hvQVV1xhn/KUp9ilpSXreZ7dvHmzPeWUU+x73vOeDff4r//6L/vABz7QBkFgN2/ebP/kT/7E/v3f//0dZu02m0377W9/25500kk2iiI7Nzdnn//8529gPFsroWcve9nL7GGHHWY9z7Nbtmyxz3/+8+3a2tqG826rjm5d79ba/cqcZZn93d/9Xbu4uGiVUneoDJ/5zGfsQx/6UNtsNiehQOOQL2sPHP5ijLFvetOb7H3ve1/reZ5dWFiwz3jGMybhR2Pc0X5grbX//d//bR/+8IfbMAzt3Nyc/Z3f+R37iU98Yj/W7qc+9SkL7NeOP09Q1v4YNoApfq6hlOKFL3zhbe5Mp5ji/zrOPPNMPvaxjzEcDu/pV/k/gz/90z/l3HPP5corryQMw3v6dX4iTH2kU0wxxRRT3GO4+OKLedWrXvVzu4jC1Ec6xRRTTDHFPYjLLrvsnn6FO42paXeKKaaYYoop7gSmpt0ppphiiimmuBOYLqRTTDHFFFNMcScwXUinmGKKKaaY4k5gupBOMcUUU0wxxZ3AdCGd4n89xgm8by8h8s8qzj777DuUzWN83u0J3/800Ov10Frzjne843bP3blzJ0op/uEf/gEQPdo///M/54tf/OJtXvP1r3+dZz/72Rx22GEEQcD8/DyPfvSj+dKXvrTfucPhEMdxeOtb33rQ9xgMBgRBwFve8pbbfeefBAcr12c+8xmUUhPpzoOhqiparRYvfelL74rXnOIuwHQhnWKKKX5sXH755VhrecADHnC75zabTS655JJJlqAf/vCHvOY1rzlgUgEQeccHPOAB3HDDDfz5n/85F1xwAW9/+9u58cYbOemkk/bTwf36179OVVX8yq/8ykHfQynFF7/4RZ773OfewVL+eDhYucZayL/8y798u/f53ve+x2g0ukeE76f4yTCNI51iirsIcRzTaDTu6de4S3D55ZfjeR6/9Eu/dLvndrvdDUkCvv71rwMHXlRe/epX87rXvY63vOUt/PEf//GGv/3Wb/0Wv/ALv8ALX/hCHvOYx0z0ki+//HIcx7ndRarVav1EyQruKA5Wrm984xs0Gg2OPPLI273P1772NYDpQvpzhOkX6RQ/s/jBD37A0572NDZt2kQQBBx66KE861nP2pDG6ctf/jKnnnoq7XabRqPBgx70IM4///zbvfcdve7MM888oCj9rc2t49+/8Y1v8KQnPYnZ2Vl27Ngx+fuVV17J05/+dJaWlgiCgKOOOop3vetd+933/PPP57jjjiMIAo444ojbNVceCDfccANPfOIT6XQ6dLtdnvGMZ0xyVQJ86UtfQinFueeeu9+173//+1FK3W6Q/GWXXcbRRx/NpZdeyqmnnkqr1WLz5s38+Z//+X7nPuIRj+DXf/3XAVlkxkmz73vf+6KUot1uY63lkksu4Q1veANnnHHGfosoSCaU5z73ufR6vQ3Jpi+77DJ+8Rd/ka985Sv82q/9Gs1mk3vf+9771e8TnvCE/RJNg/SFRzziEXS7XWZnZ3n0ox/NlVdeud95X/rSl3jCE57A0tISYRiyY8cO/vRP//R2ywWyyB577LEbEnkD/MM//ANHH300YRjyi7/4i/znf/4nX/va1/brP1P8jOMeU/mdYoqD4Fvf+pZttVr28MMPt+95z3vs5z//efsv//Iv9ilPeYrt9/vWWmu/8IUvWM/z7C//8i/bj3zkI/a8886zj3jEI6xSyn74wx+e3OvWwvF39DprDywAb+3+wt/j3w877DD7spe9zH72s5+15513nrXW2u9973u22+3ao48+2r7//e+3F154oX3pS19qtdb27LPPntzjc5/7nHUcxz7kIQ+x//7v/24/+tGP2hNPPNEeeuih+4mMHwi3fIc/+ZM/sf/5n/9p3/72t9tms2mPP/54m+f55Nzjjz/ePvjBD97vHieeeKI98cQTb/dZhx12mN2+fbs9/vjj7fve9z77+c9/3j75yU+2gP3CF76w4dyFhQX7h3/4h9Zaay+//HJ7wgkn2F/6pV+yl1xyib3kkkvst771LWuttY985COt4zj2uuuuu83nfvSjH7WA/f/+v/9vcmzHjh1227Zt9sQTT7Qf/vCH7QUXXGAf85jHWMB+/OMfn5x3yCGH2LPOOmu/OtNa27POOsuef/759mMf+5g9+uij7fbt2+1gMJic97a3vc0qpewTn/hEe+6559rPfvaz9q1vfav93d/93dst1759+yxgX/SiF2149otf/GIbhqH9sz/7M3vRRRfZd7/73XbTpk12+/bt9uEPf/jttsEUPzuYLqRT/EzilFNOsTMzM3bv3r23ec4DH/hAu7S0tGHCK8vS/uIv/qI95JBDJllibr2Q3tHrrP3xF9JXv/rV+5172mmn2UMOOcT2er0Nx1/0ohfZMAzt6uqqtdbaX/mVX7Fbt261SZJMzun3+3Zubu7HWkhf8pKXbDj+wQ9+0AL2X/7lXybHxnXyzW9+c3Lsa1/7mgXs+973voM+Z3l52QL2xBNP3JBh6MYbb7SAffe73z05du2111rAfuADH5gcW1pasn/wB3+w4Z6rq6vWcRx7+umnH/TZ4/d+73vfO7kOsL/wC79g4zienDcajezc3Jx96lOfaq21ds+ePRawf/u3fzs5Z5x15M1vfvOGZ/zwhz/cUF//8R//cZvZWm6JA5XLWmsvvPDC/TLifOxjH7PAfhu3N77xjRawr3jFKw76rCl+tjA17U7xM4c4jvniF7/IU57ylNvMdzkajfjqV7/Kk570JFqt1uS44zg885nP5MYbbzxg0umf9Lo7it/8zd/c8Huapnz+85/nCU94Ao1Gg7IsJz+PetSjSNOUSy+9lNFoxGWXXcYTn/jEDeLd7Xabxz72sT/WO4xNjGM85SlPwXVdLr744smxpz3taSwtLW0wf77zne9kcXGRpz71qQe9/9js+/rXv35Dwu6VlRUAtm7dOjk29huOfak33HADe/fu3c+PeMUVV2CMud3E5pdccsmG+11++eUAvO51ryOKosl5jUaD+9znPpME3+N3PuGEEybnvPrVr2bHjh28+MUv3tAuRxxxBFEUcfXVVwPwile8ghNOOOGA5uYxbqtcB6qD8fueeOKJ+9X1/e9///3ec4qffUwX0il+5rC2toYxZr/Ez7c+x1rLli1b9vvbeCIfT+w/jevuKG5935WVFcqy5J3vfCee5234edSjHgXAvn37WFtbo6oqNm/evN89D3TsYLj1+a7rMj8/v6FcQRDwe7/3e3zoQx9ifX2d5eVl/vVf/5Xf/d3f3bA4HgiXX345URRxyimnbDg+ZqYef/zxG441m80Jyea2CDn9fh/goInCB4MB5557LkcdddRkwb388stpNps87nGP2+/83bt3s3379sl5vu9zzDHHTP72zW9+kx/96EcEQbBf2yRJwszMDLt27eKb3/zmhHF8W7g9olEYhpNFcvfu3VxxxRU8/elP3+/cG2+8EZgSjX7eMGXtTvEzh7m5ORzHmUwqB8Ls7Cxa6wOGGuzcuROAhYWFO31dGIYbyE1j3Fas5q3jPWdnZydfuy984QsPeM0RRxxBGIYopdi9e/d+fz/QsYNh9+7dbNu2bfJ7WZasrKwwPz+/4bznP//5/OVf/iX//M//TJqmlGXJ8573vNu9/+WXX86xxx6L67r7HV9YWODQQw+dHPv617/Occcdh9Z68vuB2KvjBe9gsb5vfvObGQwGvPa1r93wzKWlpf1IPF/5yle47rrrePSjHz0575hjjsH3fUC+IAH+6q/+ioc85CEHfN6OHTv40Y9+BLChPg+E2yoXyEJ6y/oa9+sDbeY+9KEPsXnz5oNuIqf4GcQ9bVueYooD4ZRTTrGzs7N2eXn5Ns/51V/9Vbt58+YNvjFjjD366KMP6iO9o9dZa+1f/MVfWK213b179+RYlmX23ve+9wF9pAd634c97GH22GOPtVmWHbTMd7WP9JZ+yjGe/vSn2x07dtjt27fbxz/+8bf7DGut3bJli33hC1+43/EHPvCB9rTTTttwbGlpyf7+7//+5PfHPe5x9pd+6Zf2u9YYY+91r3vZubm5ic/4lvjABz5gtdb22c9+9obj27dvt0EQ2LW1tcmxoijsQx7yEHvkkUfaoigm7/z85z9/cs5VV11lAfuOd7zjoGXduXPnHfJZ3la51tfXrVJqw7PHfuM/+7M/23DumEj1mMc85qDPmuJnD9OFdIqfSYxZu/e6173s3//939uLLrrInnvuufZpT3vafqzdX/mVX7Ef/ehH7Sc+8Ql72mmn3WHW7u1dZ621V199tfU8z5500kn2/PPPt//2b/9mH/rQh9ojjjjiDi+k3/ve9+zs7Kx9wAMeYM855xx78cUX209+8pP27W9/uz355JMn51144YVWa20f8pCH2I9//OP2Yx/7mD3xxBPt9u3bfyLW7oUXXmj/6q/+yrZardtcyL/61a9awAL2c5/73O0+Y7yw3JI4Y60sXlEU2Ve+8pWTYzfccMMGYpC11j7rWc+y3W7XnnfeefaSSy6x11577eRvF110kQ3D0O7YsWPS5h/60Ifs4x73uMliZIyZnL93714L2B07dthTTz3V/sd//If9+Mc/bk866STb7Xbtd77zHWvtzSSof/qnf9rwzieffLJttVr29a9/vf3sZz9rL7zwQvu+973Pnnnmmfbiiy+enHfaaafZMAzt6173Ovv5z3/ennfeefZlL3vZHSrXRRddZAH7j//4j5Nzq6qyJ554om02m/av//qv7cUXX2xf+9rXTjZMr33ta2+3Hab42cJ0IZ3iZxb//d//bZ/85Cfb+fl56/u+PfTQQ+2ZZ565gSn6pS99yZ5yyim22WzaKIrsAx/4QPupT31qw31uvZDe0evG+MxnPmOPO+44G0WRvde97mX/5m/+5jZZu7f1BX3NNdfYs846y27bts16nmcXFxftgx70IPv6179+w3mf/OQn7THHHDMp71/+5V/u96zbwvi8r3/96/axj32sbbVatt1u26c97Wl2z549t3nd4Ycfbo866qjbvb+11n7iE5+wgP32t7+94fgVV1xhAfvv//7vk2PnnXfefuf+6Ec/sg996ENts9m0gH3b2962332e/OQn28XFRet5nt26dat9ylOeYr/4xS/u9y7nn3++Beyll15qn/Oc59hOp2M7nY590pOeZH/4wx/u985XXHHFhut7vZ59+ctfbu973/vaMAzt7OysPfbYY+3v//7vb/jCXV1dtS9+8YvtEUccYX3ft4uLi/aRj3yk/e53v3u75XrrW99qAfuNb3xjw7OvueYa+8hHPtK2Wi07MzNjH/vYx9p/+qd/soA9//zzb68ZpvgZwzSx9xRT/B/Gt7/9bY499lje9a538YIXvOCefp27BC9+8Yt53/vex8rKyn6+1Cmm+GlgSjaaYor/g/jRj37Eddddxyte8Qq2bNnCmWeeeU+/0k8dV155JV/72tc455xzePKTnzxdRKe4yzBdSKeY4v8gXve61/GBD3yAo446io9+9KP/KzWBzzjjDK688kqe9KQn8fa3v/2efp0p/hdjatqdYooppphiijuBqSDDFFNMMcUUU9wJTBfSKaaYYoopprgTmC6kU0wxxRRTTHEnMCUb3QpVVbFz507a7fZ+cm9TTDHFFFP834C1lsFgwNatWycSl7eF6UJ6K+zcuXOi+znFFFNMMcX/bdxwww23q308XUhvhXa7DUjldTqde/htpphiiimmuCfQ7/fZvn37ZE04GKYL6a0wNud2Op3pQjrFFFNM8X8cd8TFNyUbTTHFFFNMMcWdwHQhnWKKKaaYYoo7gelCOsUUU0wxxRR3AtOFdIoppphiiinuBKYL6RRTTDHFFFPcCUwX0immmGKKKaa4E5gupFNMMcUUU0xxJzBdSKeYYoopppjiTmC6kE4xxRRTTDHFncB0IZ1iiimmmGKKO4HpQjrFFFNMMcUUdwLThXSKKaaYYoop7gSmovV3IZZvXEEpKPKSsBky6sW0Zhv0lgd0F9r0V4Z05lv09g3oLnYYrg5pzjRJRyle4FGZCqzF8VzSUUprpkl/ZUBnvs36cp/uQluuvcW9Rr2YqBVSZCXa0Tc/vxEw6ie055qs7+0zs9iZXLu+3N/4/GGKF258fp7kNDrRfs/vrwwn95hZ7DBcHxG1QvK0wHEdlIKyMASRv+H543fvzLforwyZWeowWDn486N2yGB1SGehw/re3uQeM4ttevuGUoa14YbnA5hSnh8PElozzUl5+/Xze/sGzCzJ7+25Fsmgfn5pQCm0oynSgqgdMlwb0Zpr0btF/U+ev9BmuD6i0Y7IkhzXc7BWnu+HHskwnTx/ZrHNet0Pbv38uJ8QNAJMUQKgXYciLQhbIaP1Ee351oY6HJelu9hhsDqk2dn4/MpUeIFLOspodht1u7cmz++vDOv+0Kcz32bUi29+vlJorW7uw7d4/rgPdRba9Jb7zCx1J89P4wzPd6kqi60srn9zHxrX2dotyjC71J30qfHzy7zuw1pRZMV+zz/gGFob3fz8W42hLL5l+ffvw+Pjo15M2AxudwyNr23PNenvGzCzqXvQPpzFWT2GpK+O+/Atx9D4+Y12RJ4Wk+dvGEOzzQ3vfss+PFgZ0ppt3tyHb28Mzbfo3aL84zF8yz4Mt/H8xY60+7gvL7YZrAwnY8iPfExpwNpJHx4/vz3fnowhKb/0x1v2odsbQ+Pn33oMbb/ftrt9rp8upHchPn/u/w9bQZ4WNFoR/dUhjVZAWZaSKLbuYMkgpbvUYfn6fWy7zxb2XLfM7OYZkn6KcsAPA4arA5qzLeJ+jOdLs8kAN4SNgLU9PTbfa4nd1+xly72WWN3Vo9kNMcZSZgVhJ6K/t0/UCigLg3YcwKIdh3SU0p1vs/f6FQ45ciu7r9nDwtY5hmsxju/gBx6DlQGtuRaj9RFe5GErefc8KwjDgPXlHpuPWGT31XvZdr8t7Lt+heZMA1NWFHlJoxXR29en0Yko8xKlFSiFUopslNKea7PvplW23Wczu6/Zy+L2BQarQ1zPxQu9m8u/HuOGDgq5vjIVnufQXx2yeOgCe67Zy9b7bGHfDSu0F9qUWUFZGKJWSG95QKMTUWQFjqexFTiuJhmmtOdaLN+wwiH328quq/ew6bAFessDPN/D9R3iQUKj22C4OiBohdjSorSiqiyupxmsDFncPs/ua5bZfr8t7L1+hdZckyIrqCpL1Azo7xvSnGmQJjluXf9Ka5lguxErO9fZft8t7Lp6D0uHLtLb18ePfBxHyyZspsFgbUTQCLGmotKgLfL89Zj5LbPsvXaZbffbwt7rVujMN8nTAmstYSOQ/tdtkA5TXN9DKwtoirwgaIas715jy703seeaZZYOXWR9b4+gIc+PhxnNbkh/JSZseVJ+BRaNdmDUT5jZPMvK9ctsu89m9ly/QnexTTbKAQibQT1BhiTDeoJWoLQiz0rCZsDarnW27NjE3muX2XLEJvbtWqXRibAWWQQ7DforfaJ2RFmUOI6mqsDxNKP1mJnNM+y7fh9b77OFvdctM7tphmSYohX4kc9gbUSz2yAeJPiBh7UW5ShMZvAjn/XlPpsPX2DX1XvZumMzK7vWaHRCKgNFXtDoRAyWh0TtgKI0OFpRGYsTuMTrMTNLXfZcv4/t993C7mv3Mr9ljniQoJXCC1yG6yOaMy3inowhrEIpiyktXuDRW+6x6fBFdl+zl6333cLKjas0uxFVZetFSMZQs9Mgz0tcV2ENKEeTxhmduaaM4fttZc+1y8xvnWO0HuO4Gi9wGK7HtGebDNZigsgDa0FrKmPwfI/evj5Lhy6w+9pltu7YxL6b1mjPNSlzgylKonbE2p4erZkmRV4gU5jCcXW9SWuysnOVrffdwt5r9rJ06AL9fX3cegwN12Nas00GqwOCZoA18nxbVnihS3/fgKVD5tl9/T623Wcze6/bR2ehQ5HlmLKi0YlY392nNdsgTXO0UmilsFpTJimNmSYrN61xwmnHsfuaPTzm9x5xhzK3/DSgrLX2bnnSzwn6/T7dbpder3en06i964/OoSoNRVrS6kas7ukxs0l2jWErIotzPF9T5AYv8DB5iR95lEWF42qMqcCCH3nE/YTWXJP1PQM6Cw1G6xlBwyFPDJ6vKTND0PTJ0pwwDMjzEsdzUEBZVjQ7Aau7+8wuyddTox2SJgWe51CkJV7kUmYlYcOnyOX5RSFfdZ7vEvdTWgstervWac01iAcFYeCQpiVe6FDmMhkVaUEQ+RSFwfUclLWYoiKaCVnb3aO70KG/b0jUCevyO5SFwfXlPcJ2QJ4UuK5DZSq0o3F9TTzMac82WN/Tly/vfkrY8EniDNfXVKXFDz2KtJD3yEp838FUFmssYSdkbfc63aUu/X192XHHMqGXhcGPPIqkJGjKtV7gUuQFruOhHEjjnM58g7XdAzrzTYZrMUHk11++GlPU9T8sCLsBRVrg+i5VKW0YtAP6e/t0Fjr0lgc0ZyLSkXy1FVmJG7qUSUHYjiiSAjfQlHmF42m0o8ninNZ8i7Wd63QWO4zWR4QNjywpcTxp/7Dlkw4LwraPyQs836Oov2rDZkhvX4/uwgy9vT2asw3SuMDzNGUqzy/SkrDlUyQGN3DqfunI8+uv2bW9PWaWugxXRwTNgCzOcD2HIisImgF5XBC2AoqskLotK5TW+KHHaG1Id77N+t4+jdkG6SjHCx2KuMALPfKsJGr65HGBF/mUeSkLrlYUSUFzRibS9mKL4WpM1PLI0wrtQlVUco+4JGz75GmO57mUxuK4miDw6K8N6Sy0WNvVpz3fIO7nBA1PyuC7mFy+eovM4EcueVLihh5UFaYsabQj1vf06Cy26a+MiNoBWWrwtKIsZQyXed2HUoMbuLJpczVu6BGvxrQX26ztXKe72GY0iAlClywxuF7dhxo+WVIQNuq+5XtoLKasiNrBpP57ywMarZA0zfFcVzYWgUNVVASRzANe6FGmMg94ocdwLaY116S3e53OYpu4nxEELllW4vpK+lAjIM9kDGVxQdj0qIw8P2j5DPYN6C50WV/u0ezIptDzHIq8xAtdijQnajXIkhw/cClyg+M4OJ4iGeV0F1qs3LhKZ6lD3EsIAp8sL/A39KEcvxXKv5FLWVRoFEHbp7e3T2devjwbMxFZXOA4mjKXPjQeByY3PP2Vv8nCtvm7ZS2YfpHehYiaIWVR4nkuXujTaIU4rktnoU1VWsJNHbJ+QmOhKWaMwMXzHLQrC0tZL2he6FLmFX7g0pwJcV2H2cUWSZLR3dQk6SU050OowPFdXNdBORovcLFY3KLCDwOiVoDre3QXO1hbMdMMSYYpM1s6YjJpNQCF44PruTiZxnHd2kQHUeBRzDTxfQ9vKSSPUxYWZhmsDmjPt6iMDGKlFMop8DyXCosbWnl+I8ALXdoLDZTShA2fdJQzM9siHiY05wMcrXAcp15gxLTlBC6VhTAKCFshjufRXnAp0oy5TTOM+iNa3YgyK9BNjR94aMfB9TTKVDiOohH5pJ0GQeDQmWuhHE3UCkhHOZ2FFoPVEVE7xPVdXM/BdV201ri+g+M6OFoTRAFRO8f1XDqLbUxhiGYbpL2E9kKbPM5pLcgXnHacyWZIK0UQevitED90ac03cLRmZqlDOkxpzXUZ9RK6S12qykibey6FX6A9F0fLl3sYujTaAZ6nac03sKVldqZJ3Itpz7fIBhnt+QjHdSk9B8dR8uWtFGHDJ2tGhJFH0W3g+R5+5JMOM7qbZVJtzzextRnQ81ycejOglcJ1HKJmQNIIcFyHznxTJvelLskgoTXfJhtkNDoufsOTfui4tfVF1RuTAC/wiLoRvu8RNQKGg5iFbfNiopxrgFU4noPreRSuxvVdbGVxtEMQ+YStAM/zaM83URaijkfST4jmQrJRSmuhgaMVbujhai19yHXwApcwDwkCn0Y3xPM8ZpcCkmHC3JZZRmsjGvMdTFkSuBrP97FaEdTWH1N4+FFA2AxxfY/mbBNHQ6PbJF5P6C60SfspYVv6j9Ia3/fRrsLRGi/0sG0IfJfGTIj2HNrzbfI4o7upQbKeEM1FVKWhOeujtQJH49Wm1aqwBI2AqCnv3ppvoYBuOyAbpjRnpS+5YYD2HLTn4LkuhVuiHYXjuTTaIVEzoJxt4fou3QXZRHSX2iS9lO6mFmVaEAYuvufgei7aUZiqwldKzN1JjuNq2vNttNbMtELSUUJ7fobRWkxrtoVGob0I33VQboHnarQrJlovcIm6TRzHoT3fwhQlc7MdhusxncU2ZWaIuhGe76EdxCJkKhTgBj5hM8SPXBpzDVylCRcCkkFGZ7HFaDWhMevhKNn83Z2YLqR3IUxekiYp2mqszTC5IRkkYhIsKypr5IshSTGlpYxLnJmIdJjS6DTI4pQgDLBVha0MySiXe5ZWvkJyQx5nmKIg6ZcEUUg8jGnPNElGKUrXvlKlSEYpVWFIhim2slSmwvgVZV6QDCzGVPT3ZXTn2wz7Q9ltxjlBaDFFgSkMcZxSZgWZBeVAmRvifoIpLHEvxo9k19uZa5GNMlRTiZ/LVaQ2oShK0mEqX4llgR+4lHlJPIgpi5JsmNCabZGMEpSOSOJMfGUjqbvRMKEqDekoxXEURVZiq5gyM4zKEa7vkMY5ruuSDRN0O6JIcyrPZWRSTFaQDBWmMNI+nkORF8QDMdElw5TmTMSoF9PsNkhHKaEKKfJS2m6YkaclmhTtuGRZBtaSpwXGGFzXIR4mtGeapIOEsPZVu75DHoPNS5JhRpmXlEpRFiV5UcIww5Qlg9U+jU6DZJDgzDaJBylRKyCvv2rjQUZZGPIkBwV5VlKZijwt6q93h3h1RHehTdJPaLQj0rjA9R0ym1PmJaN+SmUM2cigXY0xhmxUYIqSOC+JmgFxPxETdJwRKjBlhTUVoDDGkA4SrEK+VExFkRfY9RiAPC5wPZdkfUSj2yQdyVeHNRW2rEiTDGMq4mGG52tsVdFb7VMZS9wXP2Q8SGjNOqTDjKilKMsSZSEbaaqyIhmlaC3tWBpDmZckfenXo8GQmfk2SS8mqn2lfuhjjcWUhtEgweSG3OYoV2HKinSQUpQlZd8QRgHJIEHParJhhm4qscwoTTKsKEtDNsqoqorCWEwuX6tJb0RVQZYUNDvCc1COIhvl4iscZeR5gYotVW7IqhTHc+RdRhllUVANKlzfJRuktGcapIME1Y5q64ZDPLAy5oYxVWmprAXjUWQGq1Kq0pIliZiv+9KHk1FKEPqYopRrBwlFVqAArcHkFXmSUxYFg9WSIPBIexnOXJNRr/aVZjmu44IFU1SkcUZlKpSFwlGYrCS2CZUxxL2CxkxEvB6jOg2yOEM1AmxhZA7pp1RFQRaD68pGpyptPQ9YHNchHaa0Z9pkgxzV1hPLVWUsRV6S9HNMWVIhi3xZFIzWLJU1xOsVzW5I0k/E93U3YcravQtR5AVFWpDnBRZLHKf4gcfanh5B6LG6q4c/+dclGaSAIksyKmPk+rwkTwvSOMNxFP2VEV7osrq7RxD5rOxcw418BqsjtLakI5moZHBUFGlJnpeYsiIeJbiey9qeHn7os7JrjbAZsLqrjx/6ZKMMU1myuO7cWUGRG4q8Ik9zQDHsxTihw+ruHl4UsLJrbbKAau2SxinWWrKkwJiKLMkpshJjLGmcoz2X3u51/NBj3641vIbURxgFJMMcZSHuJ1hjydOcKjPkaUGe5iirGPRiKf+eHkEjYH1Pf+JfcXyPZJhRVZYsLSjygjwtKVJZRNI4x3Edest9/DBkZXePIAxYvWmVoCFkJCxko5zKVBRZQZEZ8qQgG2XYUiYi1/fYt2udMPJZvmmNsOkz2DdEuw7pIJWyJrm0Q5qTJ/IuWVqgHUV/ZYDvSxv6gcfqzlX8KGDYTwBIhxlFXlKkhUzUuSFPZNEe1c9f2bVO1PBZ271O1PTpLQ/Rta+squvd1H2oLIyUJS1wPc36viFBFEofCl1Wdq4RNEMGvREVkMYZtn53U5SYvCTPcqpKJkI38Fjf2yeMfNbqfri2d102MsOUsixJk5yylMm7yKQPpqMMpRz6+4YEdR/2PY/e3gFe6DFYG9X9X+ouS3PZbKRSd1VVEY+EIyB92GN11zpB6LG2u4f2hVBl6sXWFNJ3irQgzzLSOEMr8Sc7gfRhP/TqcRAyXB2hNaRJDpWiTAvKopQxlJVUlSUdpWjXYW3vAD90WdnTwws8Vnf38ULhO1gFWZxjS+nDZVqQZwVlmqOA/nqMG3ry/GbAyq51vDCkvzqcbMaMsTJuirr+6vIncYbjuazv6xM0QpZ3ruI3AtZ29vAjV8YOTMb/5N/c1GMIRr0Ex3fYt7OH3/LYd5O0/3BlhHYckiSjMjdvEIuklPfPS5I4xfVcest93MBnba/48Vf3rONHPsNegjUyhoypKNJ8MobyrEArxXA9wQ0dVuo5ZHXPOmHNIXA8qcOyNKRJRllK382zElMasjhDu4recr+eQ9fwIp/1Pet4gYxh7biktyAb3h2YfpHehdCOmARBSAFezVxsdhqkNYNN2JA+eVLiuApbVSglTEVlNSiLQuM4GpNX4jtJigkzsdGOqPISPxR/kOs6E6af1grtiFkQC57nUWQ5zW6DLMlodSPSUU6jJT49x5UvBHllK6ZiRwEKpTSmqPBDj3yU0+xGtT8kIo9z3MDBmBLHlb2ZoxETm+eglEYrKX+ZFkSdBkVWEjXFDxI1QrJEnl9Zi+M4whZFgbY4VmMdB1vV/p9Ynj9mIRZpid/0xR/kKECIMEoL41ZrjVa63gEbonZElia0uhFZmhN1IvI4w3WdmkSlUVpjAa3kP47vYFGEoUee5jRa4odqtkKytMRv+JiiQjvCctVKTUyy0gZi3jJ5JXWW5TTaEWVu5PdRhus4VPXz5b3VhJAzJjYFgZjjmm3xMUtZxLddFeIvspVFa3mmkC2EGOXUvqxmKyQZpbRnmuSx9MNsJOUf91vZYyusVVgrpDRbWbzg5j6cxBnNmQZZWhA2A8rcSPnV+MeBymK1RQOO62DKkrD2YY+ZqdKG4tNUVNJeUL97TShRwj52PY88L+uv7Zz2TIs8F0azyUtcV2MVaKXrd9FQ17/j6JrB7ZFlBc12gyIRElERZ/ihJ/1PSx+2NWNbuxoFYMHxXMpMxl+ZljQ7IUWWE7V8iqREu5qqqlBKYbFoFMpRKKQdrbH4oUuR5DQ7oTCZWxGmKPACMYU74zEMNz+/HsOu68jzu02yOKnbMCNsSX9wXAX1HOI4um4Hi0VJ+Wv3Sx7ntLoNcel0pP8FDR9TGJyaKQ2gtfy/rsmBjuuQ1wzyPE1pdxtkeUHUCMiSjCB0MZUFLePXWtBKoRxNZTSlqeryFzTqdo9a0pZ+5GIyIZE5jgbhIoGVj0trwXWFy9HoRCRJRtSKxBzdlvnA813KosB1796lbfpFeleislQWKluhHcRf5juYUog41sigrawwDytr0UpjrQWrsLaSSVRJh0RBVVViEioNnudiCoPWTt3ZlNDNFWCl5xkjz1eqfr52KPOxg97g+U59XNUTgMZaUFqDRsIXrJVJQYO1FY7r1JOmxhrx51pLPYjBVpbSVFRVhTFybVVVMkk4whJ0fBcLUoaqrg9AubKYyDVyr/H1FVDVJlRTiGlSJleHqrRCOqqqms0pjFhbvz9KyqcdMU9qV/zOnutijMEJPColE0BlZOEZM4O1lmvEtFmhXUcY11qLD9qVCdqpqfrKkUnUKqgswg7V9QTniknX8VzxRzpiXpU6tLJoVDIBV8bW5ZdJRClZTB3PwRgxg9mqJqaVJdpzJxsBa4VkVZYVQP27LFJlveAUWYnjC6nLdeuNgyN1LLv5ekOitPTFuh+6niyIruOI6dqt+3LdHtp1aka21IFGFgIr6yIgC0RlDE7gYqsKL/AYz5imNPJMrCxA6ubNkbSvmHs93yXPChzHkXvperJ1HKyysgkY3wPpu1pL/bquQ2kMqh5L2nWoKjFfV8Zg6/FLfa1SSp5vpN+Jy8KpQ3s8aZf6Hm7dh6XMtt4cI/esy++443FXL7y6XnQceT/qhWPc90EWYmOEcZ8nsvHKs1LMnpWMC+l/0g5j06bMJ2DqDdZ4sZY69ChKgxu6Uu+OuH3Gm7cNL42iKo30larC8VwhGbkS5qQ9h6KQ/qAA7WkUCkuFRdpO133YretKuxqqSuahokLVfVdpmcJAFmGLbMwrK/VfFCWe59Ubz5qYWI9DhabIsrvTsjtdSO9KVLUvsiwqjKko691WPEjk336C4zikgwTtSJxVZWv/pTFUVmFy8QGUZYnSYjLSrphwXE+Lv8jRYjbVEg5SFRVVzZa11kwWM5MLwzMd5TiBmEGVdkhHGdoT9qga+75KWQSNqTClwRQVaPH5OIFDMkzxPAkd0a5LPsrAKkxuGBPBK2upbIUtZWKqjMX1xXQzLr/2NMkgrWM1c6gMWLBFhbWymEp9yGYkr0lZo56UP+4naN8hjzNZuArxhWEspjBUlfxuTCnsYNchHcjXVzKIUY4iHWQ4WlHEEqpR1X63qqwoSzGNVsaiVCWMYt9l1E/l314qu/SkQKv6maURn1xuqAq5V1GUNYPRJR1mEnbTT2tTVgaOxEpW1lKWcr6tLKaSexaFEb9cUtR1mOD4mriXorUmTaT9y7zEFJX40JAvware1OR57S+PM/G5DVM8T1wK2nUo4hxbyURXFAW2tPVmyFCVVvxRWYHrS5u5nks6lBCtZJRONjZlXohJNy/FRVCWGGOk/2ldm8eFCa6V1ANKTKq2nmjLsoR6I2DqMVRhKVOJ7Yz70ofSgYyhbJSiPGGNlmVBVVSYopyMQWOkDdGKLM5wHE0yiPG9uj18hyIpJBymlMWvshZbylgY+6NNLps+Kb+EJWmUEH0Cl6owVMZInRsrPzXr1tSbz2yU4QQOcU/M1PFAXC55nKEch6r2J1aVwZaV9MO6X1Wmqn3uOV7okw5rU+Yww6kJeljZgJpCXCqmslL/pgINRVLgeBLS5biOvI+jyZMcx/Nk/ihlHinLkqoUs6qtjGzMtJIx7Mo9cCAepjjaoUxLbGVqk7TUuTXIPern5zWJLekneHVdakeTJUXth7VURSXtXxh5l1L806awdR0K6SkdJPVYlvcpcgn3krqv7ra5fhr+civ8NMNf/uH/fUDi+JBd/KgXE4SefKUWBi/ySAcpYSsgz6Sjhq2AIinxQ1++XFyJtyvzEjdwSQcZXiBsujyRUIO4ntSdekfmBz55VuD5sst0HAftyqLj1zGgVSmhFVma02g3SEcZVOA3Xaq8wvG8ya7fKpnAgsgjiXO00viRSzLMCBu+3DcMQMt5YSskzwuCwMXU4Q+Op0mH2eTrdSySMBoIGaLIc6gQ03Vu8AOXLC3wQw9gEi8aDzNcV6NcjUlLnEg2BGHkS5iCsYRNn2SUEU6C+h0p6yjHrU0/WIUXOGRxRtiKiIcxruMJW7go8QP52gmiQCbF0uCFPqPeEC8McDxNPsrxIo9sJKQoWYArgqaYed2azOS4wuBNhxle6GNMSWUsYTMg6ad16IlYCbxAwkCChkeeFPi+h6kqqCxuKIuu4wkLNR2mBA0pq+/72MpQVRIulSeFhFLVYVCOK+X3GwF5kqGUwgs8smGG3/DEf+k4BL4nptKGT5rmBKGUy1ZChEnqxdciGzW/4RP3EsK2MNQViPk/lrbLMgmHsthJefJcJky/4ZMMUhrtUCZ1z8VzNMbY2vwqoRVVxeTrXcRKXFlwC4PfDOpxJW2trMJvOuSpIYjG5kYPpbSMicAhGeY4jpawskFCo9OQRS1wxWJT5ETNiDQTc3NlqtpEr28hliJf+H7kEY9EfKDMCnEhBA5FZggCnzwvcAMXZS1FavCbXr0JdiXEZJjgBp4QagIPpcHkhqgZSHhaIOZ413NxPPHBu6ELlWxy/VpoJGqFpEPxAfuN2triu+RZjud7oIT86AWebKRqk/FY6GO4HhNEAYqKIq8I2wFZnOOHrrgstJRr1EvqEDmDUsicNMwIQnF1aK1k7qpDp8bvLtYxg+tJWR2vFrrIDI1uyHBVxtXYqhbWpmI/8iYuE8dziPspQV3XFRC1QobrQzEPjzK0oyX8Lit5+iueyMLWubtlLZh+kd6FmJju6jjJylS16lBB1IkkfKIdSFC3q3B8F4X4x2pbFABB5FEURvxgtiKIRHUlakVC1w99KouYeHVtRkN2f27gUhRGBkRZ0miJPzJohVgUUTMir2P+dOCIqckR3ywKjBETclXKwp8lBY12QDxMxS+Ui+KIqSocrXFCd+JTsRYxgxViQsqSjLA5vjYgG2Y0miFYO5koUArtiknV9TXWiOkyT3Lc0JUFuhVKvGo3hMoShp6wSrWoAIHCc5064F5TWSNkqiyvF/mSZieiyA1BIyBLc3zPRymLdsWvNvZTl2VZf6UYvNDBVMgkN0yJOhGVkfjZPC3k3T2vNoFWoMQMW1XSZqYUX2aWZOLjHkgsrMKKD7Yeja7ngGz8saoS31FpJISk9s+N+jFhO8LkhrARghL3ACDt4IuqlHLl68TzxP/m1+a4sBVQpFIfphDTnuNqlCOhT2PfFpVsuCpj8eqFOWgFlMYQtRuUtY+/KkSgwFZiAnVCFxw18fvJgmSEhZwUNGcbFKkoHRVpXsccg3Jrf2hViWnTUpu/LV7Dl5CbVqOOORTfbqMZiA/ec1GuQmmnNk3L4m9KCSkq8kI2skY2rOkokXYYSUywqcQsr8eugWr8fHELBE2/jrX0KfKCsBOSZ+LjV5XFdcVd4TgSNqac2rpqxHRtqeqNLDS7EckwIWxHgKoFEpT4hz2HSomZ13Ek/M1WVmKd6/pO6010OkiImjIePK/uQ1ahdM2RqDkL40212/Ao84qoHUncbjskHeWy2anExK09cRW5jgKtUJ6DtRW+72Ft7WOtN0hFImIzIH3McR2UOLjFPYS4VpzApTIWv+WSpuLTLQtZRONBStCM5J0dEUmpqF0FFaDEVaTH8aKBT16InzzuxzRaEvrm1hshW1UoR/r93YXpQnoXIs9Khr2YMi1I45x0lJHnJaO1GFOWrO/tYw2s7enhOA7re/ooYLA6oixLRoOENE4ZrMYUSU6e5ozWU6qqpL9viK0MKzf1sBr6y32gor/cx5RG2JNJwWg9pkgz0mFGNirIsoJRb0RlDGu716lMxfqePlrD+u51rLWMVoZURkJ1irRk1EtIk4xklJMOU4qiZLgqDMv1vT0cT9Pf10e5it7ePqb+e5aVDNdGFGlBMkxr9qMh7SVURcX6ypCqNKzuXkcpWN/TQ6HoL48wRcFwNaHMC+JBJszFxJAOMqq8ZLA6whaGlZ1roFTNGvXo7e1RGcNgfURRl7VICuKe1GGZ5sRrMUVe0t/Xx1aW/t4+2tesLw+wFfRX+xR5LqE9WUE6TMmSnCwpiHsJpjQM1mLKsmRtdx8sDNaGeK5Lf3kdrGW4PqLIjNR/VjDqxaSJMB/j9YSyqOivDqmsZWXXOq7r0NvTR2mp03GoRp6WDNdi8iyX9qvDKOK1BGsq1vb0sKVhdecqCk1/ZYCpKoarQ8rMkPQz8rr+s1FGkeeMejFVUdHbN8AYw/rePlop1navozSsL/coSwltynJ59yzJyYY56VCYlP29Q4wpWNs7ABRryz2069Bb6WNR9Pf2MVlBvB5TZgXJICWLc5I0IxmmmKyU+i4r1pYHaNdhfbmH0orBygBjKkbrMVlWEg8TiiQjH4+homC4MqIqDL19I4yFlV3rOK6mv9xHVTBcHWIKw3BtSJ4Z4mFCmebkmfRnU1X0V2MqUzFYjSkrS3+5h6WivzrCmJJRP65DhhKyUUbSl35QlIbRWv385SFVVbGyszdhk2JgsNqnqMtd5AWjQUIW5+RJTtyPyTPpw2VRsrprDa0Uq3vW0K6mv29AVVQM10ekWUG8npDGGXFP7lFkhnh9RFVWDNakDOt7BzieQ3+5j9aK/r4heZ4Tr8bkScaol5ClBdkwI+7HFHnBYN+Q0lj6KwOwsLY8kLarx8WgF2OykqQ/IosLhv2YdCSM8ng9xlaW9eUBlTHs27WOchVre3poqxisDiiLOtwrk7GUjDLyUUke55RZQX/fEFNIPSgsqzvXwKp6XrT0V4YSsjdIKRJ5d4kAkDm0NPU8UFWs7e2jFaztWQMFveXBhDB1d2C6kN6F8AL5yvIbPrayNJoBeZLTWWqRxTndxRZZltGalZ19EHq1GVjhex6O4xCEAdpRwnTMDa2ZkKQvIgJpktFd7IjqSycUqbHQq5m7juzQHEXYCrEK+QpMctpzTfI4Z2ZThzTJaM8KezKI/NoMq/BCERYIIg/tKIJGSFUaWjMRyTBldnOXUS9mZqnDaFjIl3Uumq5e4KJdTRC6aNchaARgRSYuTzK6S/LcmU1tklFKd6FVKzMFWCV+VDfwcV2N54tIQ9gIanUZnzQt6C52SIYZc5u79ReeMIH9yEN7Dq7r4AWeqMr43kQmL0vquhslzC51SUcJncU2aVwQNMQE6fguXiTCA17oo7UmbMqXW2s2IhnmzC50iIcpM5u6pPUXZl6IuopyNY7r4PrCvvRDD4uYcrMkozXXJBsmdBbapHFKd6FNFhdEtWya6zt4oSv1H4zbIaCqKqJuRD7K6Sy2SYYZM5s65KmwaIuixA89MX3XXzJaqfr5iCUjN7RmGsS1LGIyzOhu6pKnJVErwJQVbuDihz7adeRfxyFqhFhr5StwWNfhMGd2U6dmgNdfp41AGMu+ix8G9Xv4UAf0m9zQmm3Iuy/W7b8oUo5RM8RWTEQxnLoPiTKST1VVhE35guostcmSnLmlNvlI6jTPS7yGCCnoWlTBdR3CyEMrTdiUNmrPNsgGGbNLHZJRRnexjS1KopaImri+g+95aK3xfAfHcwmiAFvVY2gk4y4dZcwsdcjSjPZ8gzwpCBoBVgm71g+DWp7PF5N35FHmhkYnIhtJu+eJjMM4KUTSMzf4voNbK0r5fj2GQl8EKMZzyEJbxDSWOmSxiGnkqSgzKa3wfAc/GNe/WEmCyMda+RrO4pzZzV3y8XtkMofY2vKhXY2ja1EGLcpICmnDNM7pLrVJRynzW2eIBwndhRZZWgrzV1U4voPruyil8aIQR2txtZQljY5YxbpLHZI4Y3axTRJnNLoNjBFVMceXL3MdSPsHDQ+0mjCOOwsiQDK7uUtcS5zmaUnQDFDKwQ+9SQTB3YHpQnoXoswKiYdMCpxaU9TzXNJ+huu5Im/lemSjHO3eTNQpanJSVUmwu1KavBATaxbn+E0ZkL4vsZ9eUJNdXE2Vl1RUlLnBVoAVgg5WyCy+Lz4PNxCSSRB65KnBi8RspgFT1kSFshaMQETLXdcVkYbAZ7Qu5rDRekzoa/JEFGzKrBSLdE3ysFbi4VCKLCvwaqKM64l/Lmj6jPopeI74M5XCTIgmhqIsJnGhritSgJ4v5JKx7Jkf+fJ3B4q0QFkhKQAoqyiLQpiOWYHjO3Ju4DEaJASNkLgvxKk8LYQZW1bYqhLCR+0fS+MMNfZzepp4lBI1RETdD32JUdWKMitQNUHK1uXPUvGdZaMcx3cpM4MfiUqMH/jEvXQis6Y0QhQqbyF2YKuJCH+eihk+i7M69jXFbwaU5c1s5gqgJrpYC3mtS1rWi2SRlPiBR5mV+E2X4epQJBqzEqUcqlJEBkxRYLICW1myOgbS1H7zIi/xIo+kP67/HEfpibawyUuKsqQqzUR8Ph2Jb3LsD8yTnCD0SXpCeimLUsgmeQkIM7Qqhblc5CVaafI0x/eFK+D6rviHQ1Fo0hoRG1A12aYmGOVZAUr0ej3HJU0K/DqMKGoEjNZiMcGXlTCAc4Otv2bKssTW7eB6QohxvdpXHLqkg5QgCMhGuSiQFSVaQVEYrK1EaKUUZn2RShuVeYnvSxhb4PuM1hMCz5HwmdpvSE2WMXVfLAsjfv6sJurU/T8bic+wiDMh26R5zdaW549Jh0rJOHS1Ik9znJqz4YU+6SgTt0laoFwROlEwISiNyWoiVSlCKknNyxiuiVRkMkjxPSEbOVoLWciOyZZCABITuyPSi75DGmcEUcCwH+NHEj7lea4QC1FgrJj7FRKDqqX8TiAESS9wGa3X/uG6H1S5kLSE9DQ17f6vgFP76bQjsXi2qin8NVW7rBmAVWkmIuYSQ6cm9Hfx1wiTtaqqunNY8izH1iQkp1aocRw1dqsKnZ6qjsWS8AUh98uCMVaG0Y6Ew4xjLEwdLmDHsWdafHwSgCA0evEZVuBoTO1XqYxQ11XNW7c1bd6acThGVcdkaspSmHdlIWEOVWnwXIkbk6JL2ICqY/As4rusLJSlAaUpaqp8WRqJFTQW7Xp1iAgTur2pRPFnHL6hlcLUIRNlbqiUxpYGR0us69inQx1yUFUVZR0OoqzUII7E1CqEiayVDHrH8+p6l3qiDrVwXEcYtA43bzaoZMJ0pN6Vlslf13Gw1PeY+Jq1wlYywWpHtHWVFY1ZW0k/QMu9bFXVzGlbhyU5ooKDxAabmgFepAWOcibhGZUREXdrxN+tlDMxjykt5ZFwAzCZ+ETLosJRCltUaL9OxKDr0I9KRM21lvAc8Z/JRgVlKXIpf2XqkC5T1f61uq/V/YDaT1ohrFvlSJ8RjeGaaV77QXU9TqiELWuR/l/V/nLZqMhzi7So20q4DEVdh9aCrcZjp47t1dJf0eJDrkyFQslGU4v6k3QfK1/ESkKlBLKoI9FhdeiWhEHhSEiJHs8Vbh26U4dfqXEsL3UoUx0fbksJnSsyA1ZJIgqtJFqlvraqyyB9svb9oupkDRKypBzhMDhaQsiUcmT+qbsLqLol6vAxLcFElRmHnUiYmZk8vx4j2MlCJuOkros6G5BWWjZMFmy9ga8KQ4WabMKZhM1VdTvIYu5o2VArR0KHqoq6rquJJKet58C7C9OF9C6E47u4vkPYFDNh1A4pSsPs5i7JKGNh+xxxP2F22wxZWhJ1GigHwlaA44m2qN/w8XyXqClmmfZ8kyI1zG2ZJYsz5g+ZIx6mdBc6WAt+M8DzPYLQF9Om7+JFPq7n0mxHlGXJ7JKYpWY3i07q7OYZySLTjoTN2PBxa41dN3TxA4+wJaSg1kyDPC1YOGSWbJCxdMi8ZK9ZaGNKQ9QJUa6YE33fxQ0ke4yUP8IWhpmlNnlSMLd1lnSYML9tlmyUybVo/MjHdRx5tu/j+66YtoDmjJBU5rfOkPQSNh22QBqLebYsSoKWj+s5hI2AwJc6CCIf7WnCZkBVWjoLYg5b2D5HMUqYP2SOLCtodJsoLec5nocbeASNEN/3alKQQ6MdUuYls1s6pKOEhW2zJKOUzlJbyCyRmIL9RoDrumImDTxcRxO2IypjaS+IaX9uS5d8lIvmbioCDaCJ2hHaE7Oq67lipmv4aO0QdUPyrGT+kBnyJGN+2xzxcER3qYMpLGE3wnMdvIaP63tybSR1ErXEPNuaa1GkJbNbZ0njlPlt82RpQWu2gaosYTtCaWlDNxAza9gM0CghaWWGmc1iFl3YNks8SpjZMoPJ6vZXHn4jwA9d/NDFCzz80CNs+piqoj3XoMiMmOVHOXPbZkVzeKaFtRA0Q1xPTPO+L+8QNMTE32wKsWR2ywzJUNowGaXMbe5SZHUfdh3cyMdzpe6CsDbxNgOqCjrzTbI4Z+GQedJRzsL2eZIkpT3fwhpL1IlEnzf08EIpvxd6eIFLoylkwZmlLlmSs3io9P/5rTMUtdiGsNqlzt3AIQzrMdwK0NbS6Ebkac7c5i7JMGVh+7zIIs63MMYStSIcR9rcD1xcT1wbjufQaIp5vrPYJk1y5rZ2SeKEuS0zFIWQ6LSCoBHgevL+Xm3m9EMPBTRqktTs1hmyYSZZYvoiLWlr8pzjOoTNEM93ZfxFPo6riVphPYZEBnThkFnSQVyPoZJGt1m7Meo2DF28MMCPpA8oR9GcjSiKktktXbI4Y3bLLMkoobPUEiJYM5i4xDxX+lBQZ0EKI5+yqGiP23DbLHk8dvEUtGsd7WanIeFOdxOmC+ldCI0Sdq6pZCFCFoI8K2i2Q0ye02iH4s90NWE7RFUQNHyo/61yMQPaehErckOrK/6wqBOiHYXne3iRfNE2OhFlKZlIrBXGrwKidkBZGZqzEqbQ6EYi3N4OcQKN48i51liiKAClCdsS+uFFErLR7DYoSyOLWVHSmI0mbEY3kDAVP5Cv06AZUFWWRrshvq1OJIzLmSbGGMJ2IO/VakwWDb8RAJbmTAOrZENRWUtQL+JRJ8SYitaspHFqzzaEVRx4eJGHUtBoNcQf2wknLFFjDI1miMXSmIkwtqI126IsCsJWBI4wZf2GDwilXgT4JZ9j2AqkDdsBVivas02sFcFyayFs+nih+NQabRH+b3ZCmTQ6IdZWsoiWFc1OA2sszRkRiI+aAcpzRMS9G0noR+0rDZo+aAjbDWxliVoB1kBzTnI1Rp1IytRs4DXqxboh7NNGWxbNqBXUWUVCaat2iAUa3Qa2EhY5WkJWglYAWtFsBwB4TQ9rxcdeGkvUkX7YnG2RJbLwW8aTtvjVwijEmFLCgSori3dlJfWbhWarQVVBeyaSftAK0I4smlHbR6FotANsKX3I1uPAlIagFVIaQ3O2OVEkqipLoxXhhvVmbSaCytJsCZM5ass7hy3pD422ZHdpzzfJc/HtF7WpVTYrELQCrK3wGh4YJZsDrYhaARUVjZkGeV7QmGlQ5tKHlCdqPGHbp6qM+HstEgpVieD8ePxbBc1ukyKXsQTCH/BCUXYKWgFVZWqfpiVqN2RstxtUygrjOTc0OyGO40ifcyTRQtSOZMw0fagsjVZQj1EpU6MTYLG0uk3KsiRq++DI893aH91ebFEag9dwUcoStgIpZzvEVJWMoaqSNIm5IWo1UI4oeYXNAFAydiuIWlIfQcNHKUnkUVVW0sMZS7PbRDmKIArwoxCtpb9VtiJoChu40QqpKmGLm6qi2Y2wVT0fZjlRM5x8tHihiy0kLZspzd0z0TNdSO9SmFpgvSjNRG/VlFb0IrXDYG2EQliKytEMV0dU1pLG2USvtKokwN2UEuBe5iUWSPsJWmnWl3t4vsdoTUSa01ovNk9yqAXNy7ykSCRQv8jl/tpx6e3t4zgOg5WRJB5Oc2wFWZZTlSVFUmDLCpOLn0x0L0uwiqQXo6ylvzpC18HtWmvSVPwrRV5SVoY0Fs3TIhbd1qowxAOJY+yv9FFK0dvTA0fKZFGMBiPRGE5yqlxE2o2RAO88lcD4tJ+CUgzWRniey3B1gFKKZJhQGkM6SKlsRZYUtW5sKYy/vCIbZhgjjFrtiParoxVxL8Fau0HYvyzNRPvVFNVEQ3S0NkIrRX9tgOM49FeGKK2IRzHGlMQDYRwntW5vHueTQP00yQAY9EYorRmuDXFcZ8JejHvCiMyTXPRFRwllacgz0c7FQDrK0YzZ0g79vQMJjO9nWFuRxXJtkkgcc5EWVIVBGUsyzEBZBusj0Z6t23C0FgOWeJCKnzQtscZQJDlVWcnz0wJTCPvU0Zr+ivSh/r6+5NaNRVC+SEWvd6z5m6UpZVFiKiNa0kDcS9COYrDSQ3uK4foINCSDhKouf1lKPyhNRZmKqIYpTC1c79Bf6YFW9PYNUEozXBlhK0uaiDZyFhcUZUmeZnKPYiyuYEn68aTPaEeT9ER4Px0kEtCfldL+8c1azWUmAgXZSGImh2sxrgODfQO0UsT9DFDkmcRFm6zEGkuR5eR5SZbKtTI3yFhdX+5N+p/jSn5g4TTkFGVJMkopC5lLytRgC0ueZFilWNvbk/dYHaK1YrBe6xWnkgghHUnblVkxEbYoM4O1kKzHaDSD5b6MobWR3GN1KFrTcUFRGPJYdH6LuKDMSkxRSlIKpRj0RjiuZrBvUAulSN9N40wSTMRFrTlc1sIyVc3ZsAzWhqAs/X39iQa2drS0XWXJR0k9h8i8Wabir65KQxJnoBRxLSbS27uO47nE/ZhKM0lscHdhupDehdCOxpaij1rmJUEUMFob0p5tMVgb0p7vMBomhI1QgrlrnVZbWXzfQ9VygCLlJ+ScRqvOcL/YlvyCM02SoZCXxhk6HFeL/6OWKnPH4gKhpJxqzjTpr/ToLrQZ9GKJbU0K8fPVWRYc171ZDrA0eJ6IR0RtSdDcme8Qr8e0Z1siEuC6mEoINromvTiuCxU352mMJLNIe7bBcHVIe65DPJSE2UUyTvYtfryxcIRbizq4nkceZzSavqRcWmgzWovpzAl71fV9TCmmHK11HUsm+RldV+Iv/cAnHkhWjHg9pjvfIe6PaLYb5Jmkm9KIr9LxPUxR4rkiXSbkFImdHa4Oac216K+P6My2hLQUepjCoJCUVbYSzVpbWhzXo8gLvMAj7o1odEKG6yPasy1G4ywtSYbriWNcIZquWHA9D2PAD0TjN4yk/K2ZBr21Ie25NklvRNDwa58zoLTUmaPBmFp/tBRBifURrZmIweqI7rykrxLNZVFbsmUd/1zHHWrXpSyEyZmnuZBD1iVLz2BtJJlWBglhU/owY5+wsWgtUoKe503qMBlmNFoRw5Vh3YYJzY5o/jpatHnHybqpbvadBoGLKSQ7yWh9SHu+Jen75jrE/YQwCoSYh8RfVsaiPZeqquT5ufybjlIaLZ94LZa66yd1Xs1aarCWpXQ9h7KOYbbG4td5Y/0gYNTLaM82Ga6OaM21Gfbq8pflRFPXlJX4QcsKN3Aoi0p0kkfZRIBCnh/TmW0RxyL5Vxbi33VqhaXxGHJ96V9+5DPqSYLy4eqI7kKHYT8RNm0qCl3KQfpd4IlkoSd5QcflDxoeg1WZfwZ1svGkn+AFHkWdaccP3DppvSNWH9+v8/b6JHWS+/7KgJnFLsM6S0yeStpDpcEaIbbZWtJS5jDRyY4aAcO1mO5Ch8G66AXHw6TOBiVKRqpO2u66QgLzA3m+58sc1uiEDPYN6My1JWF6RyIRHFdLHXBzDO3dMtffbU/6P4g8ySWWrTeSL4DVIX4gGVMarYDVnWtErYj1vT205xD3R5JiapCQZwVZUpCMUmxV0V8boRxdZ1vwWL5uhaAVsLJzHT/y6K0MZJfflxjJZJSQjlLyrGDUj7H1DtD3vTpjSMS+nauS/WWn7OZGvRGmznCSxRnpqJD4u8wwWB+iXIfe8gA/8tl30yp+M2LfTasETY/+vj4oRTJMJVZymJANU7K0YDSIpQz1l/f63h5BM2DlphXCliT8dgOH0XosmTv6KVlckI4ykoHE3I56I7QrX/Fhw2f5hhXCZsDyDSsEDa/ezcJwPcaYSuJW6+w5w0EMFQx7I5zAla/4hleXQbLguIHHcK3OfjJKKZKUdJSRjrI6Xm8kX8ArQ/zIY23XGlEjkOwvjYDeXokBHa6PJPZukFCkErcZD0ZgJXOO9l16ywOiRt3+zYDVXWv4gcdwNcE6dR1mOfEgJhlKHOaoV38Brw7xA5f1PT2idsDKzjUa7ZD+8gCttbRhna5OMt+UDOuYw/7qEMd3WdvdI2r47L1xhaglZQhCn+FqjHKs9L+0IE1ysjiVmNbeEEDqP/JZ3b1O0PLZe+MqYTNkbc86aEU8iCVueJBQFAV5ahj2R1SF9H/HdeitDghbAftuXCNoeezbuYbn+/RXB2JtqdPVxaOUMhW5v0FPyjDsx4RRyMrudRrtgH2T50s8s/QXQzqUMuRxThInVKa6uQ+tx/gtX8ZOw2P5pjV836O/MphYJExu6vjhjLIoGfQSUDDsDfF8h9Xda5L1Zlc9hutY8Lg/7n8JWXJz3KgpS4brQ4kTXRkSRgErN63hNaQN/dCjt9IHZRn1EvK8IBkmEvtcFMSDGGsqRmtDXN9jfU+PsOGzcuMKUcunt3eA63kM10eURSWxl1lJnsh9TGEYrA0lTnvfUMbwjStErYiVnfIevToGNe7L/BMPJfazSEviUYy1FaP+CDfw6C/3CZshe6/bSxD5rNZxvMPVIdZamYeygiyW2PPKVAzXYxTQXxvihR6rO9doNHxWd/eJmgH91QHaVWKRyKvJ/FXkJaOe1OuwF8s8tHdA2A5ZvmGFqOmzb9cafuAyWI2prCUZJdysEXzXY7qQ3oWwIKxRhAkpjDrJAYgjuQjHklhKgzG2prhBZY2wfBFmpFIiPm/rzBLCTqvZgkpYhkrrWzjYb84YoWvBdmstVklogsJSFRZVU9SVIwL7SoQ60a7ITTt1RhIAqkq+dNWYPSs6vGNmrwasERakqhnHtrJoK3kDhX2r6wwPN7MaTV7iqFpo2wprVniGwr6rypvFxCWXqKqF+HXtB9E1I1rVAt211u+Ytm8Vpanp8JUVxqlTM36tFlWemj0qcoCyI6ZWNxpn82Ai3i87bKzI1Cml6jrUIto/ZroqTWVld2zKslbKEQ1eW4ejoMVqIYLkJapmd1utQDkonJrxLeEIVS1iX+YGTc18VHVZ6uermvJtreSs1FpjamYuCEsSramKsq5fU4v1G2GxVjVbtqpq3dtKcupWlei/KmHtYqWuxvdQSkvIVc2aHI8C13Xq9lJQmUmYl6lDq6rCoPTNTM2xaLlGEjoURSmsUWUn46gqxmxNI2zzosSpdXorqyYsZQnFQuq6lqYss1L6ZP18WwiL14zF4+tkAcqqSbIHhchqWjv+4pQ6G4dZmVJY5JWxNXt3nLlElLJq4n2tASvtWJUGraA0RsaoscJ6Z9yGUo+mkD5sbIWV1DbyxVsrPqGEees68u4T0m3NPBchfJH5s5PyMBl/lank2mqcGKFCcrcIa1/uhegd13Uz1uU2lZ1YLVzHqfWxbd3ydeiBupm1KyL8EtMyZu2XeYG1iqq4OWnDuB/YytbvY7F1WyslDF+gzjQjeWrHWs+qDvnhFr3wrsY0jdpdCDfwcOvUPmM2ZpnmdDd1yEaZMA9jMXGYoqLZilAoglaI63i4vosX+Fgj5AUqIankaUF3UQLSZzcJA7XZbaJq8ojjSkCyF3iUpcH3XNDCuCuLks5ihzwr6S615V718xutBhZF0IhqbU1hKurSoAgxpaE506RIC2YXuuRxwexSlyRObybPtIJahCDADVy8TFirKFunPCrpLHVIk5zuory7BLWLXJxyJHDbcV1c3xUhikLCTyxCdMmTnNnFLskwEfbyKKM916IqrRAPHIegEUpmC19IGyiE4FVWwjhMCmY3dUnjjJlNM2RxSbPTEIJYK5ro3nq+BxS4rhBfGu0meVbQWWiTpxmzm2fIRjnthfaEIOMo8BsB2nXxPI0fBShVE0/yitZ8izwphD09TJjZ1KFISpozTbBKGI+OQxB6Ii1pDWFTpBeFNWyY2STtP7NJmJ+dubaY/hrCrgwaoYhzJG4t/yaCEKYoac21yOOC7qYuWVows9QhT1Ka3SZVpQhq1rYfBni1TqrIBiqaM01pw8UWeWqY2dQli3PaCx2sMQStAK2FPCKiFC6e7wnhpOlTGktnrk2WlMxtnSVPcrqbu2RxQXu2LUSxRoB2HRk/votfmompW1jL9TunBbOLXcq8pLPQoTCmbrvx87UIhISeLFqtEGxFe1YYn52aeTu7dZYiTml1myggbIZoTwuByfPwPNGtRdX1n5XMLHWlDTd1yeJUnp9LajBQQsByXbzAwfV9lClwdITF0KhdCa15YW/PLs1IasBbENDQwvyVPiw611YponaAyYqaeSyCHNlA+lCaSnoxrYTl6/miyez5PlBMXB6NjpCkOgttskTGXzJMac1EWGNp1MznIPJxfS1tELooFFEtTNKZE8LZ3KYZ0tFYmETkAkV8IcRxRM/ZCyR23amz5TQ7Tco0l/GXpHSXuuSpiGqURSVj2HOFtet5uL4IXVS1qEs5HkNxweximzyWuSQdSnpFkT6V8Xp3YfpFehdCIezICkvYCaQTzTZr9qYwXsMoEgUQLQzfqrKE7VA6fDdCYYm6EVbZmqUJrRmZ6BvtCKU1nu8JO7hmhVZGGHVlURI1fWFPtgO01rQ6TVFo6QrFPmiGstBQs2SNpTkTYUqZeK2V91FaQh9sVdGYjSbMT8fTeJ5LWLMUo06jXqyatfCA5HiMOg20UrRmm1QlNNoNYeg1AzzfR7uaRiuiKkXDtSoNjU6ItYpGR9iszVaENRWtuQZlWdULD7iRhCegoNlpSBhOzVptdqWemx0ZYK2usFajViQTczvE8cWvI+WVcpWlCIdX9eakYsw0lPdSjqLRaaIdhRu5hA2pq/ZcG1OzEm0lVH6lFVGtqdqclc1SsxuBtYSdCKs02lWiHlQ/ryzlWjQ0Z5uglNShlnYXRmSI64tylFeHNnTm26Lp3BF2ZKMT1vq0AdYq6UvW0pyVPhQ1ZcPheh5BMwBb0exKHTa7EY6raXUllGB8r0ZXwmNaMxLq4IUuUVP6RLPVoLKWVl1XwlavaHQbKKXkXtbQmosos5KoE0mYVSAhS1Vlacw2sGVFoxNJIoO2jIPmTANlFa1uRFkYmt2GqGCFLmFLBM/bM81ay7ZBVcqioJSiOdMCpWjNtup2aAgTvBWhUXiBP9EdbtR9uNEVpn3YDqS/d4SJ2uyKTnOjGwHCWvZDD60UUTuc1H9RyMYKLFGrMWGxo6T9x2MYLSpoUTuqF5oG1AtehejiWlTNUoZGp1G3pZQhaEY4rovjKrmmkLozpYzdqjA3Rw10m2itiTpNHKVodho4WuNFPkFzPGaalKa8eT5q+BL61JXQnma3IfNQPbZk0fZxaxW1sjSyKTPVpD6Cho+1RhjZlTDvTVHRaDfwPFmsg6bUc9SOKIuSZrtBZSth7Ro7aY/GjIzdxoxsvP2mjx+5uL6uPzhkHIjF4e7Bz9VCetNNN/GMZzyD+fl5Go0Gxx13HF//+tcnf7fWcvbZZ7N161aiKOKkk07ie9/73j32vkVW1lqvJfkoF39LKT7TshCfgbUVvX19NIr+yoCqqoh74ucZrY9qXcubdTrTQUKRG/orQ8rCMNg3QGnR69Wuprc6EH/E6hAqYWiWpTxfdD9zhutDyqxkfV+fqjKs7FlDOwh7WInWb2Uq4r74xyYao7lkqK+Kiv7akKooWN87ROuaPaphsDLEGENv33DCPC1z0YhN4kz8PX3RQRVN04r12jezvjJAK82oH1MYS9xPJpqvZVGSpYX4TVLROjVlOfH79Orn91cHVFZ8SSY34p8qSuJhRhan5LlhuCa+4MHqEFMaensHaEczXB+CEt1ca8Z1Z0hGmZQhlTYY129ZlqztEa3Z1d3raEeLTqitGKyOMIUhHqQUcUY6SMnTW/h7KtHrpazorwzRGtGpteKHs6X4o0xeEq/F5GlBlmQko4zKVlKGyrC2tyd+p5UBuJr1faJTO1wbiW+1n2BMSTLKKbKcMjfEvaTWGhZ25truXs2eFebrYG2IssLqLfOCYS/G5MLUzONM+t3KiDwrhC2qNGt71nEcLaxRW+u0FhVJPyHLSkbrSa1XnJEMMkxmGNbs2NVdPRzHZW25h+Mo+vsGwlbtiyZ0NpL3zYaZMNqLsV5xydrePljF2p4+Wjus7FmX8veFAT8aJGRpxqg3qvWiU/Gj5qIHbSvL+kofpRCdXE/RXx1APQ6roiQZZBR5QRYX5EkmY2IQU+ZGtF6x9Jb7uFrTWx2hFAzXYqqqIo1zGcODhDwT5ng6knHVXxGd3sHKCKWEO6DrNiyNlXGSC0M5z0RnuEjzmjMQY3LDYC3BUtFb7uG5LmvLfWHRro4wxhCvxxhryUaZaO0mOckgweQF/VrTe31lCCjRKXY068t9TGlljOVGdJrTnLjW/i7zkrg/oixlDsNa1vetoz2H4bqUpb8m4z/pJ8LiHWWUuSHLyroNjfSrspzoNfeXBzIPrQ+pbEXcG1EV1WT8p4OUPMllXl2XNuzvE73m1V19HK3orQzAWlb3CAP47sLPzUK6trbGgx/8YDzP4z/+4z/47//+b972trcxMzMzOefNb34zb3/72/mbv/kbLrvsMjZv3szDH/5wBoPBPfLOjidJah1XfFSu61Cmwp4tC9GUrMo6QbMS/8pY5s3xxAyiHMmG4XiuSJj5HmUq8mzjNFamrBVHLHXiX8lEP2YPKlWrGHlaMsE0wjpVU63tGXhYK8oxokIj2WIqcZowToicZ6XkHk1EF7bIDX7k1uou4tMxpsILfEmAPPaDOuJDdF2RWPPqFHF+6GFr2brKiANvnC0mCMQ369SJj506IbXjuZi8JGyLbqcXuNhS6g3qnKeeK4mv64w7OJJFRjsOZVbrgeZ1mrGymmTXqF1KmKLE9XQtLSiqPEppyefpuRSpmIurvCDq+FAKu1NUWypcR9iikujb1spKklRZUuR5FLG8R14Ygsid+BYdr2bceo4c07V6lFaSBstzyUY5UdOXeogCisLgutI/bClmyKo0k/Lr2v/suA4mFz3iIi2FkVnkWCrKVMISbCUkD1NZEcnP65AXK+FPjiftHTQ8qkJSleV5LU9Z2TptnvgfXV/6kFsnnnccB1tWkmYtE3PlOHtMmRf1xKdqlqYnfdgZcwSU+BIdXWft8aUtI69OVK9q35+k26oKg1u3+9h35zjiD9e+R56XYiYtxGoy9v2rSvyfju/J/eok2doR9qrINOb4UV3/TZ8qlz5srLqZtV4aPNehKstanarCcVWdVk/k+KJmUGdR8WTcjvMJVxa37gdOfY+xApjjSjo4P3Ip8xIvFFar67vkeVn78SWnrue51O5Iaf9avckNXEnz1pT+7wee8BDqOWQ8VquqQk2yKNUKT45IWXqhT5FIHy4KU89pph6zMt9I1p4xd0PuVebSh7IkJ2zU7V9rkWtH1ZKeFa7rUZYWHIWxtR90rKaUyxgqC0kjV5QS810WtU/Ugaoyd+tC+nPjI33Tm97E9u3bOeeccybHDj/88Mn/W2t5xzvewStf+Uqe+MQnAvC+972PTZs28aEPfYjf+73fu7tfGRBJPpSa/CshHR4gEz5YXN+jMuXNkoJKqNta6/oOCskRr3EdTYVM1hZZ6FBW5O2slTyDSgkN39FoR8SvtevgOA4Y6hyP9uZUbbVTX9TpZNGssDioWpLMwXGFoOB6CpnfhQ7kOJI2yakXUseV1FsieyfXu9oROrp2cJSE51BL14FIelFLCErYRE04sFBRy4OpQvxmniMEB62oTE2Pr0kFIscnqZu0EpIHSqNq6UHHkTYQEhSS9sqKvirIPdEieWaVhCI5jsYoDarCUSJcYa1MlhWIrq4rpCyjwHGFqCOZpEQeDyUEFK2FvIIGS4XWoG0tiVjVRAtTb6wchVLSlo7jYq2ppe6ERKGUnpCgFEgfgFqOUcqgtZ5ssJSC8ayqXXmO+JtK8dGlIoCOo2l2mwRNn6gd0OpEssAi5DGl1GRTIjJs8o43SxnKc5RVdT+s61RJ2SfENWRhs6bWRJYRQmWlL6nqZqlKrRRKK6l/V4ht4zy9juuiUfK7tUh11xqRk+eDrqQ+lHLwXM1YGrCylZCalEz4ck9ZgBVKJveapaWsrsup65RpNZkJIbhU1bhMlYyHekwoB7RxgBKtHDxP30yDqWUrQcYuSuO6Gsepx16d0k87kpZMKVlsHEfmDs91sWWF47gSNuWom0llGpk3NKhKo7RsqrRS9XhwsJW5ecNfjwvHlVyhCunPqi6KUqp+LyXlr99P5ACZSFmaum2p+7tylEgf5qWkmKtVMMcbJ8cZ92WRcvQ8B2qCkePKnKHre+p6bDq+SFu6nitjSMu85LgujnLqtp6ydvfDJz/5SU444QSe/OQns7S0xPHHH88//MM/TP5+zTXXsHv3bh7xiEdMjgVBwEMf+lC+8pWv3OZ9syyj3+9v+PlpwdSCzRIMbSjSHCd0GK4McbRmuDJEu4rR+gjP9yThspUvMgl8rmpRgLJOpGtJBhLvNVgb4TqaeD3Bq5PlqloQujIiuF4UEjxdpuUksN3xRQDA8zWj1RGO75AMM0m8HRdUxkosVyaMXJNXFLmYpJSGpJ/i+WI6cj0tAem1EL/yIE9EoNoaS1GWlEUlJkVTkiUZSsNoPcHxNMM1CeaO+3KPLCmwysoXkJHn29JiCiMi/NaSDlO80GG4luD5Tv0e8pWmPRFEr4ylLEryvMDkwvQ1hZloDMfrCW7gMlgd4Xk+g9URjuOSxVnNIixFrLu0ErxfVbW2ra2TQjsMV2Nc7TJYj3E9TTJIcECeX8k7V5XUpSmrWsyiQLuKtBb8HqwlaFdCJhxPng+WIilFCKMoMcZQFpIwHMskVm/UE+H/YS9Bu5qkDkzP42wiGm/KUkTPjcGUJXlaYq1ltBaLXF9ZsfmIRfK0YOnQRSyWmfk2ru8StSKCyCdshvihT6MV0ew2yJIUrSRUSWkYrY1wXIekn8rXUlpMkm6XRmICTW4xpfQh7WqSYYrrewxXJZQi7sUoV5ElOQrR4C0rYV5aY+txVFJZETNxPZfR+gjHk7GkPS3iDq4kqrdWmK6mLOo+bGpRhgKlqkli7WEvwXVFvN1xXPJx/aeltF1hyHMZR2VWi0mkEu89XBvieq4813MZ9aVP52mdICKXpA9VLeRRFiVlnQw7HqTSd9dHuK7DcD1G+x7JKAMtIhZlbqmKijTP5T1SEUPI0xzq5zuey2BliBt6jHojifVN6rGTyxxQ1v9fFJI8oLIS1uN4msFajOe7E9H+dJChHVsLs0gfNpmhKEQ0vyoNWVLUQhRD3NqUq12XuJ8QhC55nEOd5ECSH1SYTJ5dFLWYSpLjBSIA4Xoeg1VJqj4WdcnTDFPXvylKylI0dIuspEgLtLKM1mNc32Owb4jjecS9BN9zSIcppqpqPeupROB+uPrqq/nbv/1b7nOf+/Cf//mfPO95z+MP/uAPeP/73w/A7t27Adi0adOG6zZt2jT524HwF3/xF3S73cnP9u3bf2rvrCx4niepjHynTtgsKcqsoyeyaY12JDJlgUdljQQyI7suCcp3ZVeoFW4gpJIgEt3KsClm0qARUBVitkNJAD8WtKfBkR274zooJRnstdYEzRCsqiXYJEUVGiEfaXAjSV3k+fLFpuqUYFppgqaQl6KWmBbDtpiJw8inspLIV1uF58tXseNJWjDliBygUkrKWwlBw5R1GrVK0p1hLV7gY6ykFVOOEHK069bll3uMpdCiTm2urkkVXuChtRKzXZ3WSzvyhSHPl0TJUAkhywhbsCrE1K2saCXbmrGqPY32HYJgnM5JEjcHkY8thQBS2ZpUUVnc0J8EtKOVkIEcSdw+DlSX50vmnbKUBN3WWrxQzNRuKG3oBrVVw9XSF2pyikir+WAtzbE0ZBigrMKL/DolmSQj145DcyYibAR0N80QdSIWD5nDCz0Wt8/jOJrFQxdwfJeFbXOEkc/MYodGO6I126Q916LVadKZaxE0PTqL7Uky9nGibGPqMpgKJ3RrURBdp8YTQp1C3ZzkOvQBaW9rxExXVRbPl/7uBnIP13NQaBxPrCoKanKVlrRplgmrPWwIycpveIAWIX2t8er2V2o8hkQP1ta6tNZIwmoqpI2VtK1G3l1Y3K5YM4AwlHRpfsOfyBSKu8KnUhbPl3HqjsewL4L9yhGLjMhjhrUuriRGDyMfZURyEqxo3t6i3H5DZBAdLax4pSTZeWUszfEc0vAljVrkCYnKk7J4noRyua70PwUEgQtKtLWVFTnFyliRxrQVbijpBz1PvvD0uA4RVrTC4oceVBVhUwQx/KaPVoi51kpKPIutUwrKHOR6kgA9aIRSzoaHrYlhxhhcz0MpsdyNv5AtkixeBB9k7rAY/KYLGEnRVuv0WivuAwmBuXugrLV337J9J+D7PieccMKGr8s/+IM/4LLLLuOSSy7hK1/5Cg9+8IPZuXMnW7ZsmZzznOc8hxtuuIELLrjggPfNsowsyya/9/t9tm/fTq/Xo9Pp3Kl3ft9rP1J/VYDvOySjTKj5zYD1vX0Wts+z60d72HT4EsvXLzO/dZZRLyFsSZiMchRjpaKykGwbxkiKoPZSm9Wb1pjfPsfuHy2z6fAFVnf1JLQjLnADpzbB6YkZJY0zmShaPsN9Q+a3z7Pr6j1su88Wdl21m7lts4zWY6J2KGm7tJiTHFf8po7jkKU5ZWboLrVZuWmNhUPn2X3VHrbca4mVXeu0ZpqSLi6ofUqOxlqF60rqI1nkXYZrMYuHzbPrqr1sPmKB3dcsM3/L58cFyndQdUYMUxg8T4tsYmlpzzVZ3d1j6bB5dl65h02HzbOya53OfEvyEkaeZPNAFhHXcUiSFK1kYkp6MQvb59j1oz1sufdmdl65h8VD5xiujGjMNMjiHO06YnJ2pPye50hy7tIwM9didWePpR1L3PSDnSwdscDqzrU6x2mGG7gbMnJ4rkOeFzhaJva4l7CwfY7dV+9h6302ceP3d7J0+CL9fSNasw3SYSYbKWrTb23aKrKCsjC0Zxus7e6xcMgCO6/ezebDF9l30yqzm2ZIBilhw6PI6+drjesoOnNt/NBnNBA1LVOUVAo8z2W0NmBmqUt/ZUh7vk3ci0Uvuc44ArKhi/sJYSsgj3MG6yOidsBN/7OLrffdzJ5rlpnd1CEd5fgNX77iHcQU6EimEsfVlMaQxznzW2fZfc1eNu9Y4qb/2c2Wey+xtqtHZ65FGouFwRoxvRsjE3qWZKI/3Ajp7e2zdPgiN/1wF1vvvYnd1+xlYdssw/WEqOmTZaVkVVKipZynRR0/XEofXuyw76YVlg5fYucPd7Hl3ptZ2bkq4TlxJpsEW/vp6wUljTMUshgPVgcsbV9g19V72HrvTey8ei8L2+akD9dqYcqTbxXP1eR5Hb9cFBSpobvUYd+NK2y+l5R/870WWdm1JkkFkkK4A2WF40hGI88Xq5FsQmUMzR0yy+6r97LliCV2/mgP84fMkfQTCRMa5pLxRolCVpEXeL5IgZrC0Jlvse/GNTYdtsDOH+1m8xFL7Nu5xuyi5Nr1w7HvFLDST9I0w1EOrq/pr4xYOHSeXT/ay7Z7L7HrR3uZ3zbHcG1Es875qjwHTZ2xqBSVrTQpqEp5/spNa2w6fJGbrtzFpiOWWL1pjZnNXeK+9OG8jjkf96E8LbFKTL5xL2XhkBl2X73Mlh1L9Riep79vRHsu4pHPPpWlQxd/4vm73+/T7Xbv0Frwc/NFumXLFu5///tvOHbUUUdx/fXXA7B582aA/b4+9+7du99X6i0RBAGdTmfDz08LySBhbU+P4dqAYT9mdXePojDceOVuXN/l2u9cjxf6XPvd6/EDn2u/dyPa1ey6ahdlUbC6c414fcRg34D1PWtkWc7e61cobcX1/70T7Tpc/90bCZse1333Bjzf5Ybv70Qpy/J1+0hHGWu711lf7jFcH7G6aw1jSnZeuQftO1z7nesIQo8fffNqgsjluu/eiOu53HTlHkxesrJrjVE/ob88YG13j3iYsnzjKkpZrv/+TXie3MOPfK7+zg24nsONP9wJWPZct0w+ylnd1WOwb8hgbcja3nXKwrDzR3txPM3VV1yPHzj86NvX4foe1/33jSit5flVxepNq8T9lN5yj96+AfEgZWXXGpWtuPEHO9Fac/W3rscPXK7575twA5cbfrALsOy6ei95nLO2p89gZcBgfUhvz4CiKNh59R5wNVd/5wb80ONH37qOsOlz7XdvRHsON/7Prv8/e38autu27/lBnzHG7OfT/7vV7OY0datSSZkUkkKsMopGIzEFkjeiCUoUCiGhpAo0EZUQLSlRNAQVA6WSaDoxQom+q4Dk4ouUQZK6dfpzz9l7r+bfPn0z+znH8MVvPM86t3whqdxzinvdD6y99lrr/8xmzNHM8ft22H5g9XEl518d2C/3cv6HDc7C+58/YiLFL//GV4RpyLsffSCIDN/8+CNOwfM3L3RNx/Z5x2l74rgp2DzuaJuWp6+f0YHmq7/p2//fe0c8SvnmBx8JYs2Hnz7gnGX5YU3hz39YHihPFcv7Lc46PvzsCRMavv7RO5I04usffiROImlDo3j8eklTtyzvNyRJKGSpuqUqGtqqpa1qylONbXq2LzuCOOT5w1p+/2ZJkIbSX6ywm/uuF7eepqUuWsqiZjTL2TzumNyM+epvvCOIAt795AGH4+GXz3Rtz+ZhS7Eu2C+PbF921GXN8v0apRVf/eA9URLy1b//jjiP+Pp33hOEvg0Hx/q99OHdy4HT9khxKNk877G95f53nzBRwC//xlfEacRXv/OOKAn5+kcf0YHi4Zcv9E3P6mHNaVuwezmwe95T1y3Lj1scjnc/vcdEhq9+5xviLOKrv/mOMAp9+ytW9xuaomHzvOOwOnDayRge2oGHXz5jAsPXP3hHlMT84m98Q5yEfPOjD2ijuP/dR/q+Z32/ptgWbJYHds/+/u+3OCzvf/KRMI745d94R5gFfPPDj4RhwMefPsrc9W5JUzasH3ecdkcOm4Lt88734Rd0oHn3gw+EScgvf+cb4jTm/Y8+orTi/qdP9N3A+n5NeazZvezZvewpDyWr+xV2sLz7yQNRZPj6B++J0oivf/CBKA745icfUcDzuyVN3bF/OXDcnDhuC3ZPB5qm4+MvXtCh4ZsfvCdOAn75O++IkkjuP9B8/Okj1lo292vKU8NudWC/PFEdKlYfV7jB8uEnDwRRwFd/8xv57g8+ECUB7390j9aOx6+e6ZqezdOew+rEfnNi87yn7wYev1qiAsU3f/MDYWT4xe+8I85CvvnhR0ykePeTR4LoN0cB+gOzkP6ZP/Nn+NnPfvZ7/u7nP/85X375JQDf/e53efXqFf/Wv/VvXf69bVt++7d/mz/9p//0b/Raz58zYcZ5xx7cgHLqEhqNUig7CNuTwYcVeqKEE6cVi+QqWgdYz2xV2ruFDN7xxv+7vLgJLjH4TEbrLo4lKCEgObyLjNLexQWsknKT8yC/9tmTzsqxPYFX7ktJiay3FqXkjd/aMwlGGIp2cAyI05F1g2xq/DEu7iZI+LRAGQ43gFAG/H17pxuFwnk2KBaf16pwSlidygjBSSPkHtu7i8OPVuKM4gYnTD5AKyftfGaZOidtOFjs0IPyWZZWnKDkurRkRCpF6Ikt1sqz0Bov/jY+m1Rcd2wvOKswdTxhBSn1ST6rousszskvlMP13tXFCs6sPTHj7AZzVpk7rM/E1L5viAORQlyGhsEymuako4x4lBInIdZ+YnD6i2BwgzhvWQuDz2L1z02YrMqTwPx5vaOWsDsHxrMRQRxcdLrykb4k7SluUAolJKRz4Cf4EHefdetDAi4sU6QNpZ19SDoOZwfvnmX9bjWQdnOXs+B6n8NqtIy3c791+PEn/y7nFGKUHNs7W2GxbrgEjeN/XvqwBe/6hQOlDc67kDl/52d3MefHjfCtxG1JnV24/NQ7DOLahOOie9QKfy3SogrH0MndnbNWh2FgsJJx6nrnyX2ee8gnVx93uX4Z10Jsk7bXOPpzp8BdXMG0J79JHxR3MIt3THI+M9ZZTxBUuOHcRwXOwvfn8zh3g8UNck/4uUNpaYfBijOZ0nLsobPi4Da4T8/fu2dplL+Pc/s7rwgQ0p5co/P35z5NWL+Bzx+YhfQv/sW/yF//63+dv/yX/zK/+MUv+Nf/9X+dv/JX/gr/1D/1TwGyUPyFv/AX+Mt/+S/zV//qX+WHP/wh/8Q/8U+QZRn/2D/2j/0duebY5+olk1RcUSY5fSdOJm3dcfN2QVP3zF9NsYPzWZ4+DzSOiJNYXG6CgNEkwznnI8R6Fq9nNG3P4u2cru0YzUUcH/s4pjiLiUYxYRSQTVN0oBlNc4Z2YHozpm96rj+b0zYd81dThrYTwX+gSXwsURTHpFlMEBiyaYpTMPbONotXM7q6lxzGumNyNfZM0BQTBcRZQpJIHmc2EuF0PhUcaX4zoa1arj9b0LYdi9czEcDPJAcyzmLiJCJK4ktEVzY9m1FIHurs1YSu6nwOYXMxIkjyhCiVWLUwizBhSDY63/+IwVomVxO6tuf6swVd01/uP5/laC3Zp3Ecyz1kMSYyErdmYTTJaLwrS1u3XL2eURcts5sx2EGel89ATfOUMA3FKcYo8nFG30tbdY20Yd90LN4sGBoxAlBe1B6mkbRDGmIiH89mLePZmL4bmN1M6dqBxRvJJZ3eTnz0nIjz4yRivBgzWeQoBwPnFxfr17FPTEmZa2XBkUDuwYcji43dYGU1ONswWs5vVgiWmMXMb+eEkZgqaA1RKiYFcSJGBzrUpB5HnlyJO9X12yvpw28WdHXP9Goirjx54rM0w0/ZmOMUbTT5dETX9cxuZ7SV5NKWp4bZ7ZSh630sn5b80khcjdIsQQeBd71xjOc5fTtw+/kVbSP9oK07RrMxSouoP4pDkiwlTANM6F8UNOSzEX3TM72Z0DW9ZOn6MrVtJOpNTDIiojQiSiLSUYry48/hvBlBz9WbBV0zcPV2Rlt1TG4mPnIulhxdb7QRRKFk1Aaa0WSEtZb57VTG4es5XdMyfy3zQDpJQfks4zQiTmPiXByS0rFEuE3mY5q6k+/UndxD1TK9nvgItlTaPvF5yHHIaJJL+3vDk/P9L97MaLuO2d2Uvm3Jpjlan53FIuI0IR3HBJEhm52NHHK6pmPxdkZXyfnrsmV2OwWDjFefgRonMVEakeUJGDGFGYae6c2YtpS5Q7JV5wyNmFgopX1s3bdko/+vz5/6U3+Kv/pX/yr/xr/xb/An/sSf4C/9pb/Ev/Av/Av84//4P375mX/6n/6n+Qt/4S/wT/6T/yR//9//93N/f89f+2t/jfF4/HfkmrtG9JVNKckaddkQRhHlSRIYTj61o6k6wTG1eNjqQNN4yUFTCVZalw0mUII/JcJSS9OI8lhddHJn+cfQ9JhA05wkaqwtG7RSVEVDGIfURUcYBxS7UlJFml7e4rSwVHHCHNVGUZctaGjKWv5cNIRpIIknaUR1qNCBEnasbI0YGtGQNmULKOqyRiloqoY4iiiONZFPMYniiKpo5W0aRduI/2ZXSkxVU7ag5R6MVlRlS5AElKeWKImpDjVBeNawiRds1/YS6VbUoKCtW4LQ0NS1JFBU0g6nQ0WcRZSFRFIp5A1Z+TYDR1s2BIGmq1uC2FCeaoLIUB5r4jSi2JeSrlP3squ1wnJWWlFXNTioygatNWVZEwQh5bEkjAxlURNmEeWh9q/yeA9fBCMzwnBVQFtJ36mKkjARlnaUBFSegdrWHcrKm/vsZsyb79+CcxfySRyJ3V4QyySrg3OAuibyFn7ZRNyYsklG30v+LFoTpzFBIJaJQRRIYHgsweFRFGGUJpslTBYjXn3/VnxPgb7tIFA0RYM22o8DQ3kQ/O2wLUizkOJYSULIIOxy8N69WnTHyqhPz7CoJUWnqIkzYVzHSShsUr9jF1zP0VUtKCXJOoGiKhvB6quWMDaX754OFWEYyC6wlwpR13QorWjqHqUUdVFjjKE6lpLEVLWEacBpVxCnMU3ViRewtdhW9Kdt2aCcoy5rufaylrFdNJg4oDwK0/W0KwlD4QHYQXZVTdOifd91KPqmRRtN2zREcSBjOQ2pipI4k/OfKzdnLW9btWitacoOlIylwM9DQRxw2peCme9LAp9QZHuHcpauETz5PIarY40+t6UJZB5IIspjTRSHfp5Ql1194PF8lKM5+esovDqgqIW1u5PUnGovbdo2A8PgJTQe36/qBpyjbRvCwFzm0OJQEaUh1bEmyqJLNKBUGUT7LB7dv5nPH5iFFODP/tk/yw9+8APquuYnP/kJf+7P/bnf8+9KKf65f+6f4/Hxkbqu+e3f/m3+xJ/4E3+HrlbmxigMxLc2Ci6TVz/0BGHohd5CZFBatJ62d8JIdI4kk7DqIAjQgRHfXWfFnMELv7HyXRwyCIyh9aJrpTVBYGSnEYh+LIwDH4sUih7TC/+10ahAotjOkVBBLGXLIApQxhAEIU5BGEtKfRAG9L3FBKGwWo0iSLxRQiTXFMVy30EsIdEmNp5VF1xYxbKxEX0jgzDu+n4Q6z6lMEJZxoRnxq4wlIPAt53RKC3EnHgUS9xV5iPcQrl/zqSXyNC1Z9MCK0xaJ/o7fGSaBAiLKYVWoue0SMlLaQgjMXwIkkC0a0YLq9iHQotQX+z2okTYwyoQsoSJRasXpxG2E22qQghVSkvJOMliuq5DhxpjDEEUei2eLy2HXvAfBlgnrNaz+DwKpXQsuwtLPs7E+zgV/9wzezaIDFEcon21QaP8bsMxWYx8sLnY7oVxKH0p9H1KK2HBaggTYbRGiYRyL66mRFnMzecLht4ShQHGGHRgvAezMDbDKBRtrC/16rPm0qmLvjXJhF0bhsFFUykLe+RNM8T/NvR9DK0w3l86yRIx2w+9JlJL8HYQCQkv9Kzqsy5VaSndOyRIfugHwtigBicMaa0JIhmjYRLQ+UgvkCAG601RwiSi7XuSJBJzkiz0EIPADsZoYconPvbOM+l1aFCBAgNRHjN0ljAV1nYUGdBeo+yk7exgCYOAvrESmzYMKKMI0hDXD0RJTN/1mEgJAzbQF+9j56ywut2ZGW3RobpMWmEm7RudWeOhQQdgPAM/yuTegtDQNoM8B/8Mg1jMJUxkxHQmCsCIvtl4XTtaEcT+/MEn8xgp24qBiu3Em1lb73OMgkCjjcaEUp4OQh+xGBicN+sw/vnO38wZvl1I/3B8+kHsALumo9iVdEUj1l61aEqbUhiwEiRt2S+PmECxe9mD1hy3BV0nNndt1VEea4aupy3EsqxvBq/5shx3hVjkLSUk97A6YoeB4vB7I4nKfc3Q9DR1K2HbPmDYWSToOzRsXnboQLSS5/P3VUt9quhbHxHWtDT12faw57QtcA52yx0mkKgm6xzHfUHfDlR7sfkqj7WEK5etBBV3cm0OxCov1GxXB9GobUts31MWFV3bUR8rb3tX0jadaCMrCZAudhKsvX3YYWLDbnnEKUdxkGtujg1d01OdJLS6qRpaH3NWlw0OxWlzxASazeOOIJQdS9cNYtXXif5NLN7Eqq0rWtqiwQ4SG4WC7ZMQd7bPexya015sEJtCLBbrsvUhzXKMvhPLNDc4jmuxaNs8bwkC0RkOw+DbW+Kw2lr6QVt3l5iwobectie0MdRVjQoNz+9WKAebxy1t3XHYnCQW61BT7koh8Twf6Nqe1cc12miev3khCA2PX79gjGH9sGHoBvarI23VcdqdqI8V5bEWi8pmYPeyZxgs6/utEOXeLZlejy6a1d3qQNt11IeKtm4pd6UQl4qWvurF+rGoASiPFeBY+/Y/bI5Y6yj2JV3VUfp2KPalPMP63CcHql2JGxwHHw69fd6hA0W5K+n6geIoNovlqRa7wbKhreV5NkXNYAcKbze5edr5oPUTYCkOJb0PpJdYtArbiV1m7W0k67LGWbHZCwLN+mmHMt6qrxebP7HY7OhaIX31TStjsWywQy/B6k6xfdpjQhlDw+A4HUq6qqc6NbR1R7GvGToZ+61n0TdFA1Zs9kxo2K/2mCDguC2xvaM4ldRVQ3moJF7tVNOWDV3V0vj+Vx0rlFJi9xhH7FYHnBso9qWfpxraoqXcl/StjD3rrTObShj5++VexuFyLzrfbSHfPVa0VUdzOo/Diq5qLrabYkVaAWJ3qQPD9vmAHRynfUnXDNTHRmLhjmIx2LUtbdn6OaTBObGXJFC8vF9hQvMbm+u/XUh/jZ8ki4iiiGSUEsYh2SzHWsdkkQs2dztlGDqm8xGDFR2V1oY4jonSkCAw5KOUIArJxglaI8kJw8B0MaarW0azHOtgNBYcNh0lhFFAHHmMJQ6IshijBKt0yjJe5PStT7BoOzHJdo58KsbycRL55JGANI/F0HyUoJRgJK73GE3bM7+bYQfBDh2Q5QlBIMkzaR4TRqHcSxSQ5gnKOcbTlLYdBCPsWvJJDm4gyxO00iRJ5FNDAuI8JYoi8nGGCQMx7B4cs+sJTSO4Wt8PjCYZFkU2zQiNxzkzOf8Zc8tGMa63jCYpXTcwv5nheks+zcUkfJSIKfxI0ieC0JCME6I4IskjjPb3P1hm1xO6fmB6M8XZgXycShhAnqCQHVqUhJKiEoWSiOF1iqNZRtcOTG4mDP0gyTVI+ysl0o4gjoj8Mwx8KIDRhsw/q9n1iLbpmF6PGQbL9HrMaJaxeLXwpBTn3/K5ENic8wQMfSZsfTK3OrtbOW9Rh49gw+OmdpBSqwMfmCxlZOcdhIb+bCfpwMnv2Sj5FZw5IBslKG0Eqx88Vt9ZxldjCRoYxSgtfUgFmtCIkX4UR2STzI8DMf8fTTP6dmB+OxeD81mGQ8ZQYKSto0jwvSxPiCLpjwoxtu+bnvn1hL7rmV1NGDrHaJqD8uPQaKIwlLETSChBoMWwHeQZ9u3A4nZG33Vi4G8d+ThB+zCAKAok0CFN/DOM/RjOsN3gsfqO8XyEHRT5OAUcWZ4QBiFhFJBkIVEUkowTgihgdD7/JJXzv5rRdj35bMRgRUftNIItRgFRGBLnCWEYkY8FP89nOXZwzG4mkv5zN5OQgnGGU0oSXIyEYSSjVMZw7kv4U7nGyXxE11mPTQ/kk/P9Z2JsP0ol/SYKSSZy/9k4wQS+DQcnqS8+SUdZwa4B0lx4CVESEY+Ty1wShEbCJpRmPM3omoHZ7ZS+7ZhejbH9QD7K0FqwemO+JRv9ofjURUtTy06ib3tOO7/jedoRJhGrjxvCOGb7vCOMxGHFdhJKLCb1EpAsb6EF1ll26wNRHLJ+2BHnEZvHLTpU7DdHlJK396HrqcpGDLPrnroU4/JiX2CMYfuyJ04l2DmOQ7ZPe8JYc1wfGaylPtV0de93P34ncRTz6f3qAIFh+X5DnEWs3q8JI81+dRTHk50EizeVvHV3lQR0t3VHcShQgWL9tCOOQl7er4jj0Bu+B5fdW3mUN/CmaqkOJXXZeKN/CScO4oDV/YYw8eHccchudUDDxei/OtWXYOXqKKbfp10JWsn9xxEvH5eEacjm2b+9rwuslTfwtmxoypbqJLu/s4H+YSMB56vHDVESy24uCNgvJdi72Ff0fUdTSKh53/TUpeyCimOFUmJwHiYhqw9rolgCjsMg4Lg+IuHJpZjkl+1lF1rsy0/3Hxo2j3uSXIKtIx/WrYy+ePrKwujLZdpbRnp2tLXOM1k9Qxh7WSSVkdK7MurMJRKGsZEStHJCz7RObPuUFntA5a3pLlmSOJJRSpJFYljuKwnWicF6FBtWHzfEaSih0KHmuDmhnDhddXVPVdbUR2+Yfqjo207Cn7XsGqMkZHm/JgwDCW1Qykt1BgkHb1rauqH2YfPVSXDvw+pIlEj/j+KA9eOWODXsVntQWkIjuoGyrCVooZFg7b7zIQlasXveEcehjKEkYvd8IEwMh22BtVbGbdNLFaisJOD+ErAuO671vQR6bx63BLG53FvpKy5N1VGXLY0P5xbt7gllNNvlnigOeHm/Iksjdi97TChuQc46ylNF3/gxdJKg7uJQ0nU9x9WRINKsHzako9jPQ7ID1UpJ9ayRkILa9//m2NB1g4QSaM32eU+c+jGchlKJCQIO2yNOSeBF3/W0dSNhB00vO+tu4Lg6oEPD6n5NnEasPmwwcSCm/cpQHSq6WipQTdleguLbuqU4lD5gwJ//w5IwiVg/7bzj21GqWIfyTA7/jXy+XUh/jR9lFFFydkUJJWPP5yOaSEv0F0IIsZeoK9mZOGdJfFyXuOgY4jgiMIHPWTQXdpy2mixPcIOTN/XekfkYMcHoBKM1oSEMjWB6gWQVgiLKI/reMppnF4zUWoleUkaT5BFBGAgbNg6IYvmu9u4zWIgzcTgZzSQKKhsnaCXOQuLEEni8LyKOI3QkzDqntDi7OEeaSyzTZD5m8G4pOjDEeSTXnoRirhDI23JgtLhE+RxU8PFRw8B4mqMGadsgFBal8YSZKJacz9C7PyVJyGAlPswNSFyd0iTjFKMVSRZhIkMYBYRxQBxHhJHEVkWJ4NjpOPHxYckleo1BcC6lIExDgvCcMRkQhUbcoYxvBx+XZS0SNeZjvBRavhsEssMNhTAkeJUmSCLCJOLuy2uMMYznI4Z+YHI9wjq5Dh0aEh+XFseyUw6jiCgNUYGRXczgmF6NGXrZ5Q+99ZFj3oHnnM+ahoRJTJx6bDQNwTlG84yhG5hej3BWcNY4i1jczS8OPyYMSNKQwDv1BJH4JEdJgHISNTc4d9ldppMMpTVRGkhcn392YRJggkAY7ok4TSU+gusc15ZNpR/GuTB1wyS8OEOJZ7Pg9iYIBC8cFGkmMX3ZSOLipFIh7kXaGMIkIggMURRgwhAVSuXBOcTEfrBk40RycccSaxilkThsxQHa97kgConSwGO7kh2sBkhGGX03kI19LuhEsk2jVMZwlESEYSB9IAj9mIiw4B2GJFrO+kzR3g0kY8nCjZJAcorj4DIXBFF4cTqzg8ShnSMYrR3Iphk4mcN0oKVKFRrCSM4dhAFhEgHqwpLNRglD5+9/sERZjPNuSUEUEnsmfxAFhEEgrm9phDgdxQz2HBsn/eA8hrRv6yCUfvPJ4Ulc2pIs8rm9MaAuOPJvbK7/g+Js9Jv6/Adxs/j/9fnf//f/NWGPgWepFSRxjHXivxqnwuDNxinlviDKEtFHaSEnCGkn8uzBljiJKY4FUSCTQt90JOOU4+rIaJZ5H1DtiSfO70CklBeGhvrUClGi6WWhHmcUu4IkT+T8fsDirdysc940W3YxkWcYRnEkpKa6IRulnLYnklwClwNv7ybSNOUN24XkURwroiQSIo0VeVCxr8hmGafNkThP0biLm4yzgDlrQwfPli0JQllQ6rIhn2Yc1keycUJbi5erNqK3C3xihXJiN1adhC3cNaJrjVJDdWjIZhnHzUnuX3mjd3zZUiu/A/OOTPvy8nLSNR3JKOa0KRnNM/FQjYOLUT0Wn+CjhbVZdYSJ8SzWgCiNqA4lcZ5S7E+kY8kMVTi0MvR97y3ZRPsbpxGnbSGTp7PQD4SplziNRJ4UJZIodE7tUQjRSaEuyS+nbclokVPuK8mPbAchiGh55oEPT5DbF40jSkgup33JaJZx3J3IpyPqU4WJDEMjIkITei0tSq7Rwvpp45N3OoI0ku+YgCAytFVLmiccNifJUO0dGDBawgasO4eSOGFa7wriRCZcBkfometRGtKUza/IHhRGKyGtGY0OArq6FcZrWROGEUEciAvUKPZuPLmwxUOZpJ03vxeNthOG+bGSRbPrcdYRJhHVqSIdp+IGlcV+DHsC4GDRQYBWTlJzUmGchmGAiQLaoiGbpOzXJ/KpOHpp/7JrnZjM+9OLH+2pIkxC2qqXF9VxQrktSMeJ+M1mkos6OIdR/hhaxoSkxYSUR/Hndgg7Os4iqkNNksU0dUsQa4wJvTwKb0Yvfbg6VcR5ImqBwBAlAeWxIZ9knHYnolRIdkob8eNS58qG6MrDMBDXrlAWw75uifOYk3eDaspGrEjjUMIdeiuEQm8pWhUNSSqsbaNFKlgfa+Is4bQ/kY4kbzfOIv7sn/uHePWd27/t+fsPpbPRH8RP1/QcdwXVoaI+VNSnhq7r2a8LcJK7p7SS0k4UsPm4wRjD5mGHtY7jpqA51Zy2Be2xpi1qyl3lszSPOAfbxw0m1Lx8WBNoxfZxhwa2j3u6VsqU1ammLhqO2yNtLaQROzh2T1u0UuxedkIyetwLyeRenF/2ywNt01IdaoqtHKc6STbncSWltO1yjzLyexAYKXUqKb0Ntue4OVGVNdWpotqX9HVLsZHy1+ZpJ9992mICw/qjON6sH3cA7FZ72rrjuD1y2hXUZU2xl/vfPG3RwPp+jdaK9cMWHYgbjdaK4/IkeYnbE00lZa36WNM3LYf1gaHv2C6PUmp+3GCMkhKjViwfNoBit9rTNUJQaQrJQqxPQvjarQ44YPdyQAeK5/drTKBZ3W/lmT7ssU5IYE0pJI/T5kRTNpx2Un7fPm6FoPEi5KL1xx0Kx+Zhj8KXKduB4lD6HM2a8iglzmJbYK3PXx0GTruCIDKs7reYQLNf7jGBmIrbXogkXSdkFyGHSL5l38kz0kbK80FgpExqDMf1CYDTrsQO1ufZSqZlW3b0rZTNsY7iUKBDw/7lgNKa7cseY4RstXg9Jx0lUrIsWsm79Xmczjk2zztMoFk/yP2vP27AOXECa3tOu5LS33t9kpLhaXPEWcvBZ4meNifCwLD6sEaj2T5ILulxfaRrJZezPFS0dc9pUzO0PdunLQD7Z7nW9Yc1RksfVhq2T3v63meqli31oRaiTdOxW0ru73F9AKT/mSBg9WGD0jKGFI7j5kRbN5SHmvooebLFTvKGd89bQLF6WGMCxerjFhMa6ctasX8+MAySS1xXNdWxkhJ/JTBJN/TsnjZojYyHQLN52ICC3dNexvDqIGN+W16glmJfCfzjy5/7lYyDzVJIXquPu8v9D72l2BZUx4rTvqI8yFgoDxW2t+yWkv+5ul+jjPZjybB53AKa3fNOYI1DRbUrqYuaw+YgY+hlj3WO9aMfM89bdCAlXhSsPm4YrJP5rxJ4qTqWNFVDsa0ZBsv+5SjjcLkjMNJ2Cnj8xYvs0n9Dn28X0l/jx1pJvxAXIYVtxWu0q1vRGR4blFKiAdOaYRguOizXC/ljcOJKItmMhr7tRVdXdF4r1mOMoWt86sYwXBxKFE4SKHrH0IvjhwnNxUe2Kf11nBrxM+1Fi+ks2Ma7iwwDDuvfjmUHobR4zjrnRF+mvWZVC6HFOocdEKcc67DdgB0kL/J8frSmrcR7tjqIvm/ozxYpYgRgB4scCP9WqumbAR0o0egqaCrZhYpmTnaPbpC0FXGAsQxWdmbDIFKdoRu8rrFFOWiKzmdzSkqItNeA7azXFvr0C+ek/ZW6XHtdiJ9p76sBdpDrdtZediTDcHYvchgT0NeyS2rqTvSuVYcJNX3TXxyBBtt/0sEN4nik/A4riERHmmQRYRiST3PvICM7h8Hai0OROPd4Zysn+bZaG8RN5hPbyJ1/CbtIYqnO20H/XDGevKTwO96zeYz/f3fx05Ff/mekqqEYrEMZJKsyMJfdR1t1BFHI0PT+GYqrjbUWlGXwbYqD7vzdugcjuuogMD79Rvux5rwDkOymxHXLOwUpRd+JvrUt5XxV0Yosqu5wHuftO0+6sp9SiBz4fE3lx6GmKluMvwetJQ/YDedx712ZrDglWWsxSl3GcFP1OGVp60FybptW3IPO/XZw2N5hfZ90SF6pCg1d3fs27LxmVaoXXesj3XpxQMIC3ulo6KWyMrQinauKRq6jaNGI3lccnvzPDtKPejv4Z+H8GDL0lWjk66IVHXPTExojenLk/NbPZTi8wxkSCTjIPHROY+oakbI1ZXtx3rLeeYzB+hQZcbTqe4fWwSW/tj7PYYXs5Lu2xyFkN6V/c2SjPzB5pH8gP0qSL/CLoUMmeeVkcrKDuxBBxE8MnGc+Ou1nLCssSDu4S3YjWkp9Z2u3M8FEeeYlSkgn4qTmLvZz1nqxtp8sZdGTMtrgJ1KMAieLFYiBjbXqInQ+T7JYCQFXnlyitGgAsQ6L9eYGMpkQgHODX1gcRqlL3qFzoI1MdudS9NlK7Hx+Z92nyV6Bc8q3Fd6OzGeI9sjfi5eZDH5PLbWIRVnbdVJ6UpKrec7zPNu6GeOzEM2n8/uDcvaJ01pxfjzOTxRaA72vAyo/cfT27OiHv3CGQeLwnJJyl5LqN8PgLeiclKXPdntiscdlQsc6hq4D5zBhwGQh+OH5eVlv8u6bQETqnC0Z/SRlB4z2tn9WX16nz+Qh600pON+6k++fn5lC4dwg5X/k+tT5lVy5y6KNf244d3E3FFtDPx6s8/Z1DtdLA1iUt6P0bT7Ar6JP0sftp7xSv3BqbzkndpvKv485r6/2lpn47/p2dv6FQCEWkZwJWIPPNcWPISf2ktYa3w89ccvKc0ZpjH9R4DKB+5dg65+hE5tH58uUoDGAVhLM4AZxk1JWea89uRbrSWP4+z5b/mHPfVLGzPktRuH7urNitjnIS60bHOo8F+A+jTfnmdpKXlTx4eSX8Tf4xdjKeZ31i7QsV7/neQxOogbVeez5Y9p+kPI4Ynhivb0j/n4kKs95GEGOf36hFHhFnpNFviO2ivKCeH5hVeAtMp3YBQ6W3yRq+S1G+rd8fj8x0v/j//D/LC4brWAj5aHy4nrJ9bz+7Iqnr5559b1bHr964erNjGJfkk1zmpPgbUMvgvCubgmSUPRizpHNRmwfN9x955aHXz5x8/kV68cts5spTdEQ5xFt2fmYKyt45K6UWCccTdEyfz3j+Zslr757x9PXz1y9mXHcVEwWI6qi9oYHljCKaOuWKI1ojg0WSzbL2T5sufvuLQ+/eOLuy2vWjzum1xOqY0WSx4KZBoa+tyRZSHU4J5pYmrJl/mrGyzdL7r5zy+PXL9y8nXPalmTTjKqoiWIxnjBRyNB2hGlIfWiFiDJO2L/suf3ihoevn7n74prl/Yb5zYTq1JCPE9ktBAZrB+Ikojo2Ish3lqbqmL+asXy/4uaLG56+eubqsznFRjDA8lQTJ6GIyhOJqgtjyV11WvDd4/rI9efXPH31zOvv3PLyfsX0ekx1qkknGU3VEkUBth+I0piqkBzIoRvo6p7ZqymrDytuv3PD0y9fuH4zZ789MZ7lNGVHlAS07UDkk2TiNKDYl4CQK5RSnhAk+GFxqBhf5RSbitEik9zTRHbgoc+KTMcph+2R0TSnLhoxAnDiOpXPMoptwWg+ojpWxGlM1/cYbYS4lCUc1ieyWUaxL8gnmWRcDgNhElHsCsbXI4ptyWieUx0qMf4YLGEScv+7jyR5TOO1r9ObMauPG58C9Mztl9dsn/fMfBsmWUzb9AShZvAxZ8W+ukSiHXclN58teP5a0o+evlmyeD2jOFSMJnJ/QWToO0uUBXRFR5iFtD4zNp9lbHwffvzFEzdfXLF52jO5HtOcGuI0om1agkj6YZSEVMeWMBZ7xboQi8Knr5eSvvL1kqvXU07bivE8ozo1hLERe97IY7RZTH2oxSxjmrF73nH7XUmfufvONavHPdPrEc2pIR1JHw5DLRyFOPT4YoC1kg16/XbB41fPvPryhsdvXrj+bE6xLkmmKW0pmPC5EiR9SMahUxK9t33aSfqNn0O2D1umt1OqY002jqgrMb6wg4yh8lATJAFYS1XULF7PeXm34u67tzz98onrz684rI6MF2Pv/iWcjDAS85YklX6KUiRZzHFz4urtguevX7j7zg3LD2tmN2OqoiXOItmtRpqhd8RJSFVI+w+dpa27Sx+6/VLG0NXbucAcYcA/+uf/4d9Y+su3C+nf8vn9XEj/N3/xX+K4PWKMIclj9qsj05sJ26cds9sp+/WRyXzEfnNicpWzfz5y9XbB7nnH7E4ireI0BKXoqpZ8kbN92DN/PWa/PDFe5Bw3BflMfp9dj9k877n+fM7+xROQCrGni7KIw/rI5HrE7vnI9HbKaXNkNMs5bE6MFxn75xPXX8zZPO6Z3U44bE5koxTrLF3dkU1Sds97ufblkenNmMP6yHg+4rA+Mbkes33ecfP5FfuXA9k0pS5qYZymIcd1weRmzPZpx/RmynF9YHw14bg5MZpm7FYHrl4v2L7smL+ac1zvfb6kBCOPpjmb5z2zm4kM1usxx/WR0XzEcXNkejVm+7zn+rMrNs87posxZVGhlTCkq33F6Cpn9yL3cFj9ShtOEw7rgvmrKbuXA4tXcw7Lg+Ss+oDsbJyyf9kzuZlyWB+Z3YzZr2XhO2yOzK4nbB73XH0+Z788MJqNKA8nz/bUlIeGyfVIfubVjN36QD7L/cQz4rQ5MbubsH06cPVmzu7lIHmzfheX5Am7px3TVzP2yyNvvnOD0ppsmlEeSvJpSrEvmV5NOOxOjCY5x+2JfJrRe3P8OIk4bk+M5jnFtiSf5Zx2J7JxSuUTXY7bgtnNlOPmQDqSYyZj0fjWp5pslnFYHZlcjTisJfat3Jekk5RqXzG+GXPcnJj4vpVPM7qm4+PPH0nHCbvlkfmrKYflgcn1mMPySD7POa5PTO8m7J8OXH02Z788kk1SD0FAksXsX/ZM76bsX47MX03YvhyYznJ26xOjRc5pfWLx2ZzN0575zcQT4WKshbZpGc9HrB+2LO4m7JYneYbLI/ks47A+Mb+bSh96M2e3PpGNEwmTj6QPH9YnJjcyhqQPSTvs/L3sXw4s3szYPx+Y3krfjtMYgK7pyOeyeM9uZxw3B8aLMcfVifH1iMPazw+PexZv5RijRS6WftoQZQGHVcH0ZsLuRc53XB8YX8t4GM0zjuuC+asZu2e5jsPqIC5ag9gPpuPUj78J+82R6dWE0/ZIPs047UomV2M2j1tuP79m87JjPB8JOcnruk87eVnbPu1ZvJpK/1/IsxsvcvbLE4s3M4l4/GzB7uVAmsdYKyXqJE/ZLvfMb6YcNkemt2N2Lycm81zadjFivzqw+EzGXz4ZcdqfxMM51JS7munNWNrwbsp+XTC9yjmuZQztNyemVyPKY8N//S/9l7n9/Po3shZ8i5H+Gj/6HHShtcctuWAgwKWEM7T9JSdRKzyWITihVlpKJ/pcrhxQaCkFKrG0M1rRNS060jg7CNvRDiitBC/T6nJObQJf1rEe70GsxMKQ3vaA8nZnWoT8OEleUVKG8l5tUmZC0hqUQs4fCkYlCTSDZx4KbucGvLhfcCZt5PAK6L0dnh2kpOwGh8aXgQPjsS19aRO0oh8GGZyDlLW7dkBH3u5NeYN1I5hS4HM9zyxU2/tyopXCZN/Jztn2g/gWDxZjYHADxuOCWp/rn6BD9Qn39mWotu4uZVGtxPNUMFPQaHxohzx2n9whvqae2amgbTqUNoLvKifVgFAsDJVVvoQs1n7jWSYSGyWh7Wc7tL71+alNjwnNhTUsJTA5plyEMGGV7xvaaPquRynxyD3fkwkE3zyneqDk+SiPm2pfyrWDeKN2XY9B+jSeNQ3S56c3Ex9uIGX+of+UZILy3zXa+x1LGoqMocGXk0VSppXG2uFS6tahpu8tURzSdb2YTfTDJYnlXPI9Qw+SbKIu5b9hsJfnr408H6UU1l8PSirzw3Aun3os1llfbhXIxPg21FpfIBTJBD4b/nOGK9FGMHsFDL7c2zWCmdthwAQBFp+FOlgwiuE8hrTytoZnJMHSt4Pfdcozcz5Vqu/Ed9udE27O8ITPenVO8FAdGrqm95ahzjN6ZWzJ85ZdscOhtbC6zwlNMoZ7tNLCZsaX462fr4LzhQrUpUCw8t76srPFKT8PxZK9rFDimR0Ilq8kEsiX/D3cAXKfiIscCuGfGEN9qry14G/m8y1G+mv8OKV8sLYMQO1jy3RgRJZgxGdTyq/e79YITmUCDcZ3PK0RsAh0KJOmCQBEbuAAExgYEOmKjxs761DOmLtWGtcLhubwHrEKP4lYCZ12DrQMViGeaFASdWR9p3W9lIpwShZAnJS/+l8B+LXCeczjHGOlPAkgOHsKB7I4GW+6r7WRiRq5BuclOBiFGmQhMUEAVo4RBhrjPTqDQEqm5wKLOv/HY6tKxrEs7IFIa5QW/2F9nvDNp+t1DnDyIqBkBpd7RwlZxk84WivvPxwKJubb/CyZuBB6lPKLgjzv86KAloUQoy6yJX2eOPgUDaW08ZOotNnsZiYLRzvgnJUFT3usVEnfQvvnb2QxFFMF/7s/r3PysgKySEvElRHvYCPHPMdeYZ33+5UXC4WEpgsGrz3efU6RkdZCgQrkWqY3YyG8+fOZUJ63MQajlJctfcJUwT8HfPSWcyjkxUqbAIdcV9/L8+/74XJdKI3TzuPE+rIAgYwzh3gUo7Qv/wvQrfBZZBo+fVVd+q9SGqwfQ86PN6UxgSw0xmhpdi3P1/k/KG1lTDgrbYbvyygfWSje1ZxJWlZeBM6h2mcsXXtZjlbav2hqQGMi7V/ejF8guWCLDvl/5aS9ldLi8xwaf63neUF+l3sSLsAFGLcOp5V/OfHeuIO8gMlzNwxOjD2k/aVvK6cBJZwPqy78jMu1+z6jlPhdD703A1Hqwl844/Tnl3jrfJsN/pqdpBj1g/Oe18r32/8Ak/V/yM+3pd2/5fP7ipH+j/5Nin1BGIfCfqvljd/EAcW2YPF2zsu7JYs3cw6rE0kaooKAoe2I04TyJOkk510PWogTbdszvRmxvt9x9WbO6n7N9HZGc2ouJbCmlHSGpmwupaW+EzaOCQzFruT6iytW79bMXk3Zvuwk7kxrMQzPE5qq8cbQA4HR8lZe93SD2Nptn7ZcfXbFy/s1i1dTin1FEGrCOKJrWqI4Ev1rGsn56x6rHGFoKHYVi7cLlu+WXL1dsH3ek41FTD1YR+yTTmKvT41Cc3lr7/uBfDFi9yDnX31cMb+bUhwaf/5Q0lLiSNito/gTk1YErlTHmvnrOesPG64+W7B+2DKapgye1BVniSR8RBICEHnzir7tvZ1dymEtpfjlhzWz2wnFXrCZKIvoqlaSdsqWJI9l9+R3A9ZBWzQs3ix4eb/k+u2C9f2W0WIkObXOESWCSweRpHLI27UTvD2OSMYpkTcI157x7bfcxLGwKCVZpyYdJT7/Vhax8lSTpBFt3RHGcvyz6b1SGjv0xEks+GAcUhc1SZZczi+YuWCYddlK38Dzi4aBOI9pve65KmrSLKZrBnQok+/6YUPXdExvpyzvt1y/nbH6sGP+akx9qr0xfUhbdYRRSF02JFnsdxwdSilJL1mfuPp8wfLdisWbObvlgTSLvGa0k7L0sSDJxITeaAUG7/jTX2CGqzdzlvcbFrdTKj+GoiSia+T8Xdf5hBzn21FehstdeTn/1ZsF2xdxm5Iq0kAYx1TlGWuXCo1TDtsOdN4acvO4ZfF6zuZhw/R2RnWsLvaUfd35ZJmGII4A2fk65EWy3MsYWr1fMn81Z7fci5mDEyZeEAXUVU2SxnRtd1mo+3bwtoo5++c9i88WLN+tmb+ZctoUhD7+rikboiSkrjoxDTkz0j1Bqy4art4seH635ObtgvXjRiz8/GKb5jKHRUkkQRmB78NNJ6Yx04T9y4nrzwVnXbyactoWErAQBX7uiqjKljSLL7nCaKlw1Kea2d2M9cOW+esZ++c9+TS7uLP9V//Z/xLXbxZ/2/P3txjpf4jP7+dC+i/+d/5lunpgGHpG0xHb5w3z2xn75YF8lskkFOpP5RVtMIGSwGi/k7G9Jc4jyl3F9GbC6n7F9GZKeahkR9IPwsYzmkBJeTiKo0sJT2nF0PSCrz7uPL5yJJsmtHVLGAZS/vVrjAx2Xz4bepwTZ5X6VDNZjFk/bJndjdlvS7JcyAAgb4w+bpcoCun9G7XDMrTDBQuc3E3YPuwZL3LBTz2RQ0pOmjAwDHbAaCM7UydEjbqoGc1zIVTdyoBPxjFt3ctGUvk3U5RPZ/ElVl8GSkcJu5cD87sJm6cdo/mIuqyJwpB+sFKaNNqL2CXxwg4yccV5RFM0jK9GvHyQl4bjRnDFumxFvO+Zusqn5bhB3qAdIsNIJgn75YHZ7ZTN45bp1ZjiIFF0Xdt5Nqfcf98PPqVHJBhhFNA2LZPFmOXHNa+/uCGb5wRhiNZQn2pGi7Fg8IuM4liTjVKa2kuCtFQjum4gTSNOh4osT+gHS9f1InQ/VEyuRpx2J9JJTlNI1JkdZIeCb9fyWJKPUyGdxJJY01UN6VhMNaY3E477knyUUpW1lAGVlKi7VkqHP/13ftcTSjyhrrMe8pAdl7WWKAqlZGrBePORbJqxfd4xv5uyexFcr60b8f71khmlJWXH+g2MQlirURpSH0rGV2NWD3KM064gySLatvdVB+37sBOCjS+PKiMly9F8xO5px+R2wm4pHIS6aqSSg0hflF/Azjsuh2PorB9DDdObMcuPK2a3U4qdvCj3rcienNHQS/k9jiOGcxneM1nzWc7uecvsbs7mccvkekJ5KPwCiYwbJSk7g9+tAb4PGeqyZbIYsXzYsLidcNiVpKOIvhlkd+8rOCCJP+eXM6UsfW/JJzmH1YHZzacxVBUNYShkNNuLrEaqRApjpKI0DHL+rmoZXY9Y32+ZXk847UvSPBIZGBqMZwk75CXRnYPNLUPvSCcph82B6fWE1f1WSGlFLUlCOPpu8BU4RRQF/KP/rX/kW0OGPxQfq6iPkkpRFyVDZy+en307UB1rrHXslzIYdi87jDHsl3t0oEUQ76DYic9qUzY0VS+CfO/9WuwLUIr98148d1dHTKjYLQ8o4LQ90TtLsREP3K7tJAGlG7x/bMdpU2C8f2YQBeye9xgNx+1ZkF/4xI6aumpovA9m1wyc9qUkx6yOhGe/zFBSKDCK4lBjnZLUia6nOxsB+BQZZy3HTYEODLsnMYbYPkmCx2F9xDnnfXYtdSmC8r7tKU81QzNQHUqGwXJYHojCQFI/wkBSIIDjXvxFT9uCoR3Ev9anR5QHSe44bo4EoWH3fEBHAduXPdooDpsjJtSSYNGJ7/BQdzR1T3WsxUf3VINzHJZHwlQ8X01oxHvXwGlf0g8DxbZg6C1N1UoSTNNeUnRO+xLj/Xp1GLBbHVHGcNwcUd771HZWzBiajqpqpU+0HfuXA9Y5Vh/XhLHh4eslYRzy9P4FbYyks3RiDNBUDYUXtddly3FzxHY9h+UeE2ievlkRxhHPX78QJuJn7BxizFG1nLYn6qKhPNUU+4Kuke86YPlxjYkC7n/5RBgFPH4jCTK7lx2utxxWR9pKEoe6qmHorZiLtJZiX0gfWu4JYsPu5YAKYLc8oI0S79thoC5quq6nbwbvnyseyG6w7FcFYWjYPe8lfedlh/HpKw5J52m7Qa6haSVN51jRtT3lvsCh2C33mEiLb20kY0kH3nvXyjhs2148sA/+WezFg/qwOhGFoYw/o9k/H9Bac1jJOCz24l9bn2q6qqfv7GVMCBMbdk87oizksDoQRIbDUswmikOJtU6SbDpLWzXUpaTHVKcap8SYI4hCNk97TBywXx18gs1RjnGssIP3fa47uk7ac+jFn1s5J+0fiW+uDo1P0lGc9pWk8OwK2ranacRHe+gGqlOFtZbTtiT0c0cYhd5cQV/GYXmQFJ76WEsf8IYQdoD6WAOO/cuBINLyHGLDYbn3Y6jypiMnutpePLS7rqc8ylyyXx6k3V8OhFHAy8fNt4YMf1g+WuNBeuvxNiE6BKG56MnOpuKib9MXXBNPrjhrJEEEzlorbM+nUhyC/2gjhJ4zpnAmRXg1PSoQLIMBgkh7jNSA9Xox5a/Dw/jO2wSCveBgCrx1nxCcQLRfxpwxC8GGzvisOmOT52N70wDjS3wXDNcoeZs3cn5jZDcu/BZ5Kz/bpSmjvf2f8hpdRRAYT17yWkc7+Bdr3wJKC7YEHpMWokXgjdmN1p7IcL4nAZicJwKdAVelvH2iJ+fYM+VBKSGpdGe9pOj/FMrvdISo5bytnQ41zirB6DwG56xFa08Sc45Aef2gx4pEgyjYj/ZG8dYNPqfUeI3wmZwygDvvrQCPgxr8d41YGGqv58VXElBCHjmTUwCvc/a2hR5TVo4LznvBSsFrAQ34vuK7sRjbG4+Vef2rWOdpj2Nrv5OQ5+A30RftpOzInO/tMmZM+An3xfeZfvgVfbDHVXHI89K/ogFVZxKQ5yQowYyDsy2lAmU/jSHJ+/X5v/6+wsj43Zq+9AHRNwqOh+flSR/wP6f8+bWc3wRG7lMJrvx7SEo+pF278zg8j2F3wSZxHu+2cnw3iOEF52oMeJKbYIjWypgzXnMbXEho0lZaew2v/3sP8/tfzmPsoJzyhCYrGb2+TYQUCL0b/BXri7ZVaeM11UrIl57gNQz9eRMs1TDZVHr9u0OdjTm0wuhAyhZW8H1lP8095+egfdlZ4S5z5G/i8+1C+mv8ZJOMKA0ZzUcEsWF6NcYBs1cT+rbn9Xeu6VvH3ZdX2MExv5sQhAGTeU6Sx+STlHySEkYBo8WEIDDMbiY4HHdfXNG1PXffuaare67fLrAKJosxQRIzmmdEaUCSR+STEUEUML8dowzMbicM7cDdl9cMg+X2y2vsAItXM7QOGC9GRHFEOs7IxhlRHDBZTNCBYXIlsV1XbxcMnXy3qTuuPrvCYZksJkRpxGiakWYJyShmNBsTJiHTmzHKKOZ3M/p+4NV3bmnrnpvPr3ADLO5mGGMYzXPizB9jkhKnEbOrMcZoZosxzjoWb+f0jeXuO1fUVc/12yucs0yvpwRRSD7LSUYJcR6TTxJMaJjciAn7/G7K0A/cfH5F1/TcfHFN3w8s3szQRjOaTwjjgHySko5i4jRivBgTBJrpzQTnHNefXdG1Vtq/7bn9/JrBSqxaEAdM5mLano4TRuOUIDFMrkYoo3wEWyft3jruvnPD0DlmrxcYoxlfjwnTmGyakuYRURYyWYwIQsXsagycX7a0TBmDIwhlslfemzgItHfSOZf3BjAyUTsvmBdSkAYlAvkglMVGaXBDL5pXK39GKS+y94YzZ0Y3jn7wAdo4JF9dvF1l0dAXpx7lzz+5HtH1AzfnPvzda4au4+qzBU7B5GpEEEVk85HEkWUxk6sxYRwwvRqDg/ndjKbu/DhwXH+2kHi92zEmDBgvcqI0Ihkll2jByfUEExiJ/hosV58t6Gp5Dn3TM38zBw3TxZgwiRjN5RhhHJBNcnSgmV6PAcf81Yy+Hbj7zhV9K9dhe5jeTQmCgPF8RJRGpJOMZJKQpCHTqzEmMBIK0PVcfzana3ruvrymr3puP7/COSf3mkSMZjlRnpDmCaNZThAZ5jcTdKBY3M1o245XX9zQNh23n18xdFbGUBCQzTKiLCKfpiQjGcPjqwmBMUxvJJRg8XbB0A28/t4Nbdtz89k1uIHZ9Zg4ChnNP42hyWIsbbjIcc7ffzdw990b2qbn5rMr+mFg8XpOoI3MA1FANs18nKJhuhhjzm3okDmksbz67jVd03P9do51jsn1VOa82YhkFJONEkaTjCAyzG4naD+HdV3H3Rcy/l5950Zi5d7M0cYwmo2+Dfb+w/IpPQbWlt4QumpIs5jyUAvesC3I85jW2+0prUWzlcXiHZqIOXOYhtRFRZRFlKeKNE84bkvycUa5rwhjEUwPdUeUhxS7E3EWe/FyeMG7qlNDlERUx5p8nnHcFJ6Y1MnbpdGXny33JXEaekPwiLpsiLxZdJanFMeKfJJw2hVEcYjrhYIfp2IsnowSikNJFIdCmkoj6qOYipfHmtEsu2BUTdXKq7NWVCc5X7EthOhwErJUVdRy/qoSofqxJp+mvo0NnbcRC+OA4lgSZ3IPkReRp3lMfayJ8ojiUJNNMo6bkmQkz0N2q5r6IESccl8S5zF10RDGoTcrD2nKmjiLOe0LRtNUSlpxQF232G4gjAIx0R4lFLuSMIm8uYMYZJw9Z/Npxm51Ih3F1KcaZWSnVBcNURpdnk19bIiSmLKoiNKY07EiTkLyaUaWJcyuJwSB5vrNDX038Pb7r6nLltfff03fDSzeLtCBYX47J04iptdj8nFGPskYL0aEccj8dg4OXn/3jrpu+ey33tI2A3df3qGdY343J05kMUvyhNFsxGg2IssTmfTigKu3V/Rdz5vfek1dNLz9o2/p2o6btwt0EHD1ak6SRIxnI8pjTZbHnLaCtxb7SmRHztFWLVGWUBXyM8WhIkkj6nMfLhoJWThWjKYZh00pY6zuwTl06J9VFlPsCuJUCF9hIqSpKA0pDxXZREzes1FGsasuXIWuaonySMzxs8j3pYi2lLFbF9Ifi2NJPss4bUriJKapOiyym6+OFXEWXsZGVdQEsYQsRHFAWdSk45TTrvSBFSWhJyT1TUeUhXLtWUR1LAniQMahH7tJnl7CLvabkycGtoDIWMqj9PdqL21TnyriPKY5VcRpSHEsyUYxxbYgG6dC8IkCgV7aniAynPYFSSpm/lEcURwrPx6EvFfsRDd8XBdk40RsRz3Dtzo1Mg/ti8vcEWcxVSmYsJAoY467gmyWUuxK4kQY6EPXEyWBnM+fJ0xjCbxIIwmeyGLKQ0U6zThsfOjGobqwjOuyJR2ltFX7G5vrv11If40fZx3bFzHePqyPNEV7wbeaumW/PtK0vRiNh4blxxVhGLB8v0YbJabRg+OwPHwywD821FXDaXWkbwe2L5KDufywIUgCnt+vCGLD+n4DzrJfHiQL9ffgWxVN1bBfHRj6nvXjljAyvHyzJEwDlh/WKKPYvIhp9365l0zSfSU4VdNxXIkZ/H55xOJYflgTRIaXd2vCOGR1v/ZG6AeGVjIQ66qhPJVi3l537Fdi/L152BGmn/I5lx83mDBg87TDDgO75Z6mljzR6lBRlw2H1Ym2bdm+HAHN8sOKMJJrj8OIzeMOpeCwOtAPA7vVibpqqU4N5V6M5PebI30/sH/ZoY1i+X5JlEa8fFwRRIbt0xbXO/arI23bc1gXl7Y7rgrasmG/OuFwbB52BEnEy3t5hi/vlyijOLwcsL1lvz5SlQ0nHyLQlR3H9ZGm6dk87tBasXq3Ikojlu9WBB7vtednWA+ctnLdVVGxWx6oyprl/RrnHA9fPWIiw7sffyDJQz785CPaGJbvV/Rtx/phQ3ko2L0c2K+PFMeK9cOWru14eb8CBe9/ck+SxXz9w3fEacT9zx8ZBsfyw4q6qNi97DntCo6bI/vVnqpsWH1YYXvL4y+eCKKAb374gSgNefej9+jA8PJuie16Vg8bymNFcSgvUWCHzZG+6dk978HA6v2aKAp5ebdEGc3qfoPCsXnZeXP9gsYHIBTbkq5pOayOODuwftgShAHLdy+EsZjHB6FhtxTj98P6QFN1vv1LmlK+29WdYLFasXy/Joojnr9ZEiRiPK+1Yr88Cg63OsgYKmpO64K6kjE8KMfmcUsUhSzfrQjTgJcPG8IwZPd8AAvH9YmmajkdSupTRV93FJsTfdezfT7i/BgK4/AyhtYft2ij2C+lD53WR+q64XQsKLcFXdtyWB/p+57N0w4TGF6+eSFKAl7erzGBYfuyQ1nBuZum47AtqAvJ6j1uCtqmZbs8gBLT/DAOeXkv43D1cYMyiv3qQNcIHl/XrQQI7EtaP4d1Xe+DJzTLD2uiNGT5bo0JA7bPW9wg+GvX9Bw2Ej7R1A2nzYm2btm9HHEoyWdNQ17erS4BBCjF/mWP7QRnF45DSbkr6PwYHvqe7fMOFWqW75aYQPuc0m8x0j8UH6cQFqjHPezgsN7AAC16uUBfRIv+O05KdGcjBq+vtNZi0J9E3VoYoYKxgEN+VlnBdewguq+zKcNZw4ln51l7/n/PrfVwn7OCyxpz1pbK8YbBXVi01usnz5jJmWGsjLlgrLYTsEkwmrM208GgRGR9uW7PrD17p7qzp7DzeYISIybt4CPFfM6gsqC8j7C+CMAtPRbrNaW2F09Rc8ahf0Vfe9a7nTW1zuHlL3L8oZNdusZjZIbLc9EaMKLvPV+38vc4eKG+Qsqh1mOG579z/jkLRnnGc9SlfZ21OOUY2sFjUB5LV5CNM4IourQfeL1tbwm0EdMK5zFlzcWgQvn7M4EWzBiPfXksWnSxnj3tHODvweC1sHIMBb5864O9vUb1bLwA7oLtG8UlE1JkNWISMrudkqSRb4tP/37WbQoDXIIDzlrfcxue7ZPPHV9pRG/pHJZPAQd2EH9XN0i/OhubiIG+YMDSLh4h1hoJZ/CAndUXr1ffGsKG9c/wrOeUfuh8udw/E+vNGhDjDefOY0GMTsTA/5Nd7vn5cx5fznp80+tBgb4fxMthkDGEZ8Zq9cn7+vwE1FmLraDv/DX6NjJG/4ouE3D6gik6/8wFnwQ79B5r/YTPc+ZyaOWxVZmLxN/X9yk/Do3RF8MUpcwlqk+d8XfPkvZuH+LbbM/63bPphOdW+Pa3/vwqMPJ9hzebOOPqCNfCV9h+U59vDRl+jZ90FFMfw4uOcXw1Qgea+e2Erh24+eya6lAJVtP1jBcTkiQim2QkeUQyzi4liiRP0FoxWYzpneXq9ZyqqLn+/IryWLJ4tcApTT7LiVM5RpYn9E1HPhZt1XgxRml1wUhuPl9QHCrmr6ceuxIcNp9mgguNU8l3VB1ZlKE8fmXtwPz1lKbsuHp7RXmqmd9N0TjyaU6UCDYSpRFJHpGNU4ZuYDIfozRMrsZ0Tc/VmznVoebm8wVt3TH2GFI+zQmTmHyck2QJStcEYYbWMLoaoZRifjel6wZuvrimPFYs3ixAK8bzEXESkk4y0nFC3/ak40zCrhcTUIKvuMFy/XZOday5ejOnbXrBlyNNNssuxwiSkGDoiZIEBYwXI5TSzF/PBZv+7IryULF4LeXR8WJEnEbk0xHJOKGtO7JxRt93PkhZMDDbOxZv5lSnmqvPrkQacTtFBeKfGyehtGEe0w2WJA1AaSZXE/JxwnFTeFKKTOI6EAN5pYBBXm7Ok5/zhvdhUJGE/y+++Hv/PbKso+970txy2Ij2ZBrHJGnP3TRi+fj3odSfAjcTopPlMsFyIZGoS1qRNlyIUdoTVyyy0Fq/MOuL1ZdjsI7FmxnNSfxqm7JjejtB/Z4+nBNn4vebpmIzN1mMcc4xu53Q9730/23J1Wdz+rZn7LG8fCzPMM5jojylq6QkrwMtOL+V/lefKm4+O/fhBUorRtOMJA3JJoLz920noev9wHg+BmB87fvQZwvKQ8XV2wVd0zK5GmNCef5xlpCOWqI8QauWJExQGsZzGUOLN3O6suXqswVVUTN/NQMF49noMoaTNKZNWpJJKsb28xHKOMaLEXYYuHo7pzxU3Hy+oKk7JtcTtNHko4wojsgnmeTcKkcYZZfxNzikD7ct12+vqIqGq7s5SmlGixFhEpBNR0RJTJK2Pqh8IJ8JRjy9nuCslTF8rLn57IqmaplcT1CxYTTNCCNDMkoxcURkLUGcorVitBjBALO7CV0r/IbqWHN1HkOznCA0ZOOMOI2I85hsnNF1YvGIknHW9wPXb+eUx5qbz69oTi2TmzHGGPJZ9q0hw9/Jz++njvSv/DP/Cn3X07c9o1nG5nHH9HbK7mXPeJ57CzbZxXV1d9F0nnWI2mi6diAdRRT7guntlNXHDdPbKeWukCDcpkMNDh1piecKxZTehAG2E9u8rmoZL0asH3fMX81ET3o7ERN9b3TQ1i1hHDH0/e/RwfXNQDKOKHYls5upCNfvJhy2hQjtux4cl+BmE3mLvTjANgM6lmil0TQTn9zXU7b3OybXI/FQNULt7BsRjA/WeqN3Jy5O3UCUCa41u5mw/LhifjfjsCnIRwlt2+HJuwydtB0IS3VoB98uHaN5zu7lwOxuyuZhx+R6QlVUxLGYqndNJ1hzbwlCb3QQBti2E3ytbJlcjVjdb5jfzTmsDmSTlK7tAGFctrUI+J0SwXzf9ARxQN/05NOU3erI7G560dFVRUUUiV508DaNgzfHt72Y9fdtJ2EBZcPkasJ4npNNMordiXSc0TedD10POW6PzF/N2T7vmXuv5tnigbev/yWCoMQH2/CdP9Zw9qawA3z8KqZrYH7bUxeGt99reXgXEoSOh29CTrvPOZT/ReLx9zntT+SznGJ7IhmlDG2PdT50eytetbvlkfndhMO6IM1juqYjymLaqiEZJRxWR0xg+PizR8IsAmfpqo4gDj/1Iev7cD+IwUbdMJrlrB92XL+esXraMZmPqMsGE4obU1sKB2DoLSYKGNoBE2ts70iyULxkr8esP26YvZpKmHSeSPTWIOz0oZMAeevEaWjoLCbS9O3AaJqyedozezVh+7BjejWhrhvZ5WpFW7WiYfZj2HoHsK7pSXLBwqc3Y17OBh67s+GK2F0qoxlqf/9eP923gz9/z3iWy/nvJmyf9oyvRrQ+xs05sZiMYsFaJfBBGOJd0xNnMfWpYnY94eV+7ftHQT6O6VrRgittxFg/CcXAIg4Z2oEgknkgn2XiU/1qyuZ+x+xmTFk0BF4R0NcdJg4lxCAMRBsfGYamv2Cl06sxy/sVi7s5++2RPPdjSMn5z9p25xzGBz4EPjYun6bs1kcWt1NW96KjrU6lNyYRaWEQybWHkeEf/fP/CG++/+o3shZ8W9r9NX6ctRxWB7puEHyn7gQn3JaCDa0ODN3A+n6LCTXLj2uiJPThwLB92eOGnt1yT9f4gN9TTVM2HLel4IxPB1Cw+rAhygTXOGOkDjisTvSdhCh3TUdT1pT7iqaoOW4KBmtZPXh84/2SOI5YflijFWwedzhn2T8LznrcHSWg+9Rw9MfbvxwAWH9cEyQByw8bwiRg87ADrdk/H+nanv3qRNt0Eo58KOnqlt3yyNANEqgdGlb3G+Ik4uXDCmVg+7TFDgP75Z7B6/3qU0N9ajhtSrpOzu+QcOAgEZw5iAJW59Ds5wPDAPvliab2IeW7kraqOSyPtG3H+nFHGAWsPmxFR/lhJVrQ5x3OOY/ldRT7Utq/qDjtRBe4fzmCdaweNoSxYXm/IggMy/s1KhRNpB0s+7XgQdW+ovL3f1if6Nue7dMepTXrjxsij1HpMJDgaevxpbrjuD1RHErKfSm60LJm87zDWcvz+yVBHArOmQeo4n/Kd7/4Zwna/x2ff2/L7KpjcdsxveoZBug6TVUuaNq3LG5y3n6/oak0d1+0WAu3bzrcoPhjf7Lij/3Jr/kH/sH/OdPkv025+wXlvuTgz799Fhz95f2SIAp4/9MHoizkw08eCALNy/uVYHgPW2rfb8pDJe2/OdA3HZuHrQ8lXxHnkfThSDShzokmumsHH/DcUZxqyl1JW3cctif6Htb3O0wY8PJhTZxFrO5XmFCze977EOkjXdNTHkrqsrlcS9d27F9Er7u+XxPE8uzCOGD9sJHnvzzSNR2H9Ym27mhOEmzdlA3b5wNDbyXYOzIsHzYXfNEEos12znFYH2mrjuPW9+FSMMq+H9g+72UMPWwI85jVw5YoDVj7Pnx4OdG1A/uVH8OnhupQ0nuMvu8H1k87gsiw/LAmySJePnqew+Pe65z39G3H8SDnb4qG0/ZE11p2L0cG6+S+E2nDKI2FZ6EQjLjrOaxPFw15efiEM/e9ZfuwRcUBKz+HvXxco0PRMQOXZ33aFdSnlrpsOK6kPXcvJ2zvWD9siRLhOQRxwOZeAr/3LwcJ8V6d6KteAsaPJV3VclgXgtE+7wRX/7gmjAzLDxviLPqNzfXflnZ/jR+J6tRgB1TgvVkt4uDhxET7IhNQoqU76w6V1x0qozEmpO+7X9H0cdHqae/N6zy+IN/1WiqPv541YvYc9Kv9+XyZTeFlCnLVAOIHrPCeoV7fdsE0PF5y+Y7gOufjOYdo+bTP6URKj3icU3BJn0l6vkbURXPGuSRoHToQjNJ5HeWn8qG7ZH0qrdFe68YZQzvrBLWULUVH6HWPxutXvR5TuU+43jljUeFDnJX3X/Uf+b73U1XuopXEnvMcPXTpfkUL6TFvOHuIiqZQOeft1vA7c3fBbsVc3/qMUMM5Y1OjLtpHwOtZOfcKXr/+v/D61TeUh4BXbzpuXg2MJiGjyR+HYA4qB9sSK4AI6ECH4FrGiwhULx3UNrz97u9Q12uuX3d0DXz5R2qi+F/hdEjYv/xXsFbkTGf8DeUxfAlb9Tie2BKe+9cl89SpS39S+FxTKwH0gv/6AATjlT7Oggpw5/4qYZ4X3am74GlcMmIV3h9Yixyn76zXCivxxNXa66ilr4qvNZdcXPz4ujwTX5o+Y4TKiNezCeQ5a6UuoQ3wK4EASp5n5zHcs3pJMHGvNxbiAq63lxBsd/a/VtK3lT7zHOQgThkZL765z7pZ6XPOezt7nN/jlTjxfFbKXOaNyzg/czWcA20v41Vyix3m0p/1hVsgH+nHxmO8ygcDaPjUhznPc37AeLxWxoO94JrOysA564X9IQHRHVsn7anQknuszlnM8kwvmcbO/sr1/fo/3y6kv8ZPEBp0pAniEKUVcRoy4EjSGIcjGUtZKR0ll8xQZQxhGGICTZhEfjGwREmEcxClEc45kjwF64/R9GTjDGstYRygtMZEoUwWgSYIA5SGOIlAKeI0YrByPgYr+EdnSfIElCaMQrQ3NVfeUDpJQ7TWxJfzSzRTNs2wgyWbZOKRm8YEUUiUnc9v5P4thEmEs44kE7wrHafYQfS2YsUX4yzESUwYGKIkvBBaAi+8j5JYTOJT8S9ORil9M5BOcuzgCFM5b5hE3gjAYKIA56QNBztIrNbgSMYpfWvJ5jlDPxClkXgBp5F45sYhKpCJPwhFjB+lEUPXE+fi/Rn7Y+XTkfw5idCBIU4iMWMPjLebk/InCuJcyo/JKMHZgWQUi41cFmOdxYQBKlCESYgyMmlFibngkP5dQwhcVggi+ej/yfc+/3cYzQZ6C/Orlun1n2R0fQdDByZGnDwCMAnYAnQO9gRuBO4EKkacBJDFVf/HSYIBMIThv082uue4D8jHBWHwL2PViF/s/pvA2SDgU0qRmBh4E3uPkSodyETp5CUhnUhEXzZN6DtHNhFcK0wijFHSl+VWBV/W3rrOOqI0kf43SSXizvskyy5EiX1ioDBRILZ1g72YcoRJSN9b0nECzhKnMba3ZHkmYQp+3IWReN4GkUb75x+mkfTdUcIwWJKxnD8dp3S9JUlinHOEYYQxAUEUSOZrb4l8kkyYRLjOkk9SsQAdJ3KMUYZTjiiNMFqi/5QWcl6QhGh/7Q7nr8MSj2Js74SH4O0sHRDFEUrJPZwX/SgyKBAIZ+iJ05ihk/Hgekc6yWQMxTEaTZREmEATRIGc17c7fBrD2TjFDY50lNL3jmQU45T03fPcI28ShigyoB1xHmEdxKMU6wb53fcHnIx/ZcQzWwcyhkwodpVhEmIRy0esu/AfIg8zxbl4ModxLElRv6HPtxjp3/L5/cRI/6V/9v+E7XvauiebJBy2JZk39AZFkkcc1wWzN1NW7zeMr0bURSMZiIUYRg+DLAD1sSafp+xfjsR5jNZKiCxTj1tcT9gv94yvJmI2nUWCN4WGrhHCy3FXkk0SmlON0prU41XT2wnr+y2TmzH1sSYdJ7Qesxq63usnW/KJZEkmowScxGyNZplgj7djds8H8kVO67Vmbd0R+LSaJI85bguyaUK1rwlCQ5SGFLtKMjoftkyuxhTHinQi2F8Yh4KvpWICn05S9qsjSR6jgK7qyBc5u6c9k5sR25eD+G96HafgLaE3mRfNazpOOO1Kojgg8PrQ8WzE9nnP9HZCsT2RTTO6Sgzb26YnTEKGtvdh4gfSceJ9eAdGc8lmnN5O2DzumFyNfbB6LGHssQRrJ1lEsS9Jpymntejr4jS4ZH+uHrfMb6cc15IVKqEDgpEGkTzLdJqS5Smjec5pKxhp13R89vZ/xd3rd7SN4Xt/VwP8cQi/46OrzjTIANkjd6AisCWoEbgKzBiGE+gEXC9bMhcALef9gFQbNAx/Hdjx9U8k43O70rx7+Iuk2RuO24L5nfjQzm4nHNeik22bTkzg6+6CkWojJdu6aMlnKfvlQXx6VyfyeS54ZxrSdZYoEpwxHSfisTyKqesWjSIZJxxXR8nCfdoxvpJg+WySSv+LA/q6J8oj2qIhnSQcVwVhFqG1oik6JjcjNg8bybd8kQzUvulI8sQHB0g4eDpOJF91IhmtJjQkecJpXTC9HbO+34gP87aU85ctQRrRNy1REtHXPclYconPC1HXDYxnGduXHbObKfuXA+Or0aUPtXUnyTaDJc1Tjtsjo2lKeWrQ2pCOYg6bgslVzuZ+y+xuwmlXeh/gjigJ6WvRprZVTzqO2b8c/aJlaauebJZy8D7Q26cdo6vxxTC+qzuPVcqL32lzIpt6jXQcEUSG6tgwvhL8enYzptiVZLOMrpIg9a7qiNKQvulJRjGH5ZE4TyRyzckL1O5lx+x2xuZpx2Th73+c0NU+2L3znuP7inwmZLswkRfe6lgyvZmy/CgewsdtQTbL+C/8N/7BbzHSPwyfpmxYftxQHEp2L3sOqz3lqeLlneBGH37+CEbx9e+8I4gMH356jzaaDz95QGnF87s17alh87DhsDmyX53YLfe0dcPjV8/0Xc+Hn9yjteLdjz+KjvCHHwhCzcPvPtHWPcuPa8pDw+5lz3G5p9wXLD+s6dqBDz+9Bxzf/OADJtK8++FHdKB595OPOOd4/vqFumxYfdxwWPvzP+9pyoanr56xw8C7H39EB4qvf/QRE2k+/uQBE2juf/eJoZfznw4lu+cdx/WRYleyftjQ95aPv/uIw/HNjz5iYsHXTGD48NOPKODxqyeaumV1v+a0LTisTuyed7RFw8Mvnxmc5ZsffQSjePfjB8LY8O5HH9FGcf/zR2w/8PJhSXks2Txu2S+P8iwed3TtwMPvPuOs491PPmJCLW0XB7z/8T0OePzqma5p2DysOW1PHJZHtss9ddHw/G7FMFi+/qGc/5sffCSIDe9//AEdaj7+/IG+F+yyPFRsnnbsNyfKXcn2aUfbdrz/6RMOxdc/+oAJpP3DOODdjz+ijOLhly+0Zcfq45rj7sRxdaI4VJw8Rjn0PePkf0ae3ZOPLJ9/bwTBPwzhd30P7IEAdAPEQAlE4BrAgBaZEfSy4F5+V0Dn/60FQlAdqBTC/ygE/3muXjluP+sojgHf/+Kf5+kX/zZxIs8wziLe/+QjQRzw8n6FHURnWRUN++WRD794YP285+GrZ+xg+fizB7SRZ2figPc/kjZ8+OqFvul4/rDitCvYvuzZrQ6Up4bVuzV26Hn/k3scjnc/ucfEIe9/JM/w408fwDmev15SVQ2b+w2HzYnDumD7vKOrGp5++QxY3v3wvR87Hwkiw8efP6ADw4fffaRtepYf1hT+uR2WB4p9wfp+S99a7n/2AMryzQ8/YCLD1z/4IGP5J/dY4PmrF5qiY/O45bA5cljLGKqrlpf3K5S1vPvJPVppP4Y17370AW00H3/+SN91LO83VIeK3cuW4+rEcV+z/rBmaOX+cfD+x/cEacC7H92jQ8O7H9+jFTz+8pmmamUMr47sl0fRZRcNj798YRgc7398D0rz9Q8+oiLD+x99QCnF/e8+0fdy/+WxZPu45bA5UewrNg872qbj/hfP2KHn3Y/O/f+eMAl4/+OPaKN5+uULXdOxuvdz2MuB7cue5tSw/LDGDv7+Q+n3URzw/qf3mMhw/7NH+r7n5f3qMoYP2xOnXcnmUXSpD794xjnn9cty30Ec8OHH90TfYqR/OD6XMG+AMwaoz5IEJ/pEr7PTxvu9asHAznihU+qSa6rP/rdWe6zB50p6LMb43EU3iKY08H6cEs4sgOU5AxWvT3UenzFaNHkgXpznku5Zg6g9BniWN8gxPNYEgkUZ423nBHvRWiMI4yccWPxKzxoxyWU8Zw+eMULtMTPBfbxO0DehumCUZ59cj8/Z8/3ggVmv07ygyoINnTNP5efxWJL+lfN7vEh5X9Ezdn32BT5rJ+H3hjY7h/GYKx7/DYzC+KzKYRC7vnOp9oJve/zsHII6nIOwBz75m2rvt+vsxVv0+q3mO2//B0wXLaPpwPzmj0LwHT69Gzsp41qFF0v6fzOXvvhJH/CrOgGDNx6W72oDVl90mzgDhEzu/jMcXv4Gn31vS5wOfO+3/hpt+xXwj3jcTbxzBysaXROcs04VxaYkjiNpd+9HbRQor0uUseA87qwwqIueVPx15RkM9nxc//PqDD6KoPE8/ozSWM8/kOeD75Ueh9dGIEH7q30GwfECLdiv/oRvK20+4aVKcFqF86knfsif+4o649/+vNKhOWdtXjTZiot+W3mHoDMue75i5QSbNf54Z53leZJRznsZe+zxgkn6Zydwza/ci1agJMv1cr/GZ8Sex9A50N55P2AlY95f8CefW/Wpzaz3PB4Ge8GMlRO/aW2k7Uwk35GUmk/46DlH1CHXLb1VeQ2p8xGrZyze8snqWHk9qZ85PjXLb+Tz7UL6a/ycO5wxxpuNC25kPEEIWeckdqzrPQ5hCYLgQv/HhwWf9e5KKzGYP4v5naK3gu/1gyWKQ4kBO2dVBrJoY4RIY8+G19pdFsogCug7S5LG2GEgCAJsJ3Zj9kz+0HI+WfvtrwxI8WNN0piu6QnDgH4YiJPoEmukNH5BkIEYBDLQjZ+0xPxBvuOslfzSQaKsRGAto+Uy+fjIswt5SCuJo2okfspZR5xI6fH8XXxAuixOfmnV5wVWeXtBsSmLohDrBsI09qYYMomgnbwUXNpQzA1wYJKArrUX/CmKY/pe9JVnA3vOk2VgLkb6Sp2DzS1RFqIcnyQ0ccgw+Ov2Lzg6MIRRx6v5P08Q9HzxWw3wZyBcyOpLj+w+G3AJqFYIb6rzi2rv22OQlzilwHagQiH0EMjPugxUIQun7sAGQkARCglYxeTq72EyO3DY/7+5edMRxj9kv/8MN/ynSLIY58Qy0g5iFmCMxmm8Kb4jOAfbawkAiNJQ5EdRIBhaKji0Cg3K+wqry0uQkonUj4sojnBdT5REPiQ7BAdB7EPjjbx44hdih0UHeMKYwmJlDPVWcNh+II5FfnGOIzsT5Oww+PBoebl0OJFddFbu24ohvfPhBvKSefYeVhhtUNpdXiS0UgzOEccSqRbFIW4QTN0OzpsPgNOfDBXOJhlGfzLv7z3OP7RyD9IOxhOV9MUURdYYOb+8fAuJR6CEnjgO6QeJY8TLcOSFQBZX6w3vFfpCvgtCkb3Fo+QSdK8UwseQhy+ESE9mFLMXuX4TyDgP41Bi/SKR4YVhiAPv4/zpRZ/Ly6/5lXlA4fpBOBSeqzB8i5H+nfv8fmKk/+r/+N+krTshJWQRxaESwgmOcl9x88U1z189c/fdWx5++cTtFzcc1yeSSSIBxueJPxA9aZwG1EULzpFOU3aPe1597477nz3y+rfuePlmyfR2IvhCJviKCeWtL45j6qohjAx9N1CfGq4/u+L53ZLX373h4RfPXH+24LgpyOc5XdGgIoPrLaHHt+I0pPL4apLF7J533H3/FR9/ds/r797x8mHF9GZMW3aY2OC6ARVK6kMUGQnKjgM5f9lw9XbB89dLXn33lsfffeL2yxv2yz3JOMG2PUESeW2opvMTTF22QrrIInbLA3f+u6++e8PzNxIOXBcNYR4x1L1gtANEseQxhpGROLmmZ/5qyvLdirvv33D/0yfuvnsr4cgTITCpQHYbOhB3qigJKE+NJ4IEHFYn7r5zzf3Pn/n8j7/m/mePzN/MqY8VcR7R1RalZXjFcSTtn4Z0VU/XdMzuJizfb7j73i0Pv/vIq+/csHvakc4y+rojSCOGZsAHqhAnEa++f8Xbq/8eSVqitebLv/sf8otjiFCWLZgMhr1goa5HHBpywUHNyJd2AQJZfHUEtPhZC2wDeiLHQMuO1lagx4KpqpCz+xE6hnaLtf82j+9CrHP89d/+84zv/ij1obqQdC7uRErz+PUTtreM5hJsffe9W+nD379j9XHD5Hos2FxgvBuS6BTjOJCM00ASWcp9xfXnC56/epE+9Mtnbj6/5rQriccxXdXJjtKzv4feXrxvsY7RXHDF2+/f8fDze15//zUv71dMrsf0VYtJDUPjTfyBJJGg9CCSsPv61HLznSsef/HM2996xcefPnD1dsFpWzBejKhPDSbSDL3zON9AEAW0VYtDkYwjGcPff8XDzx54/f1XPL9fMr3JaatB+lAlGKEdZKFrytZjpgNt1bN4M+Pxq2c++61XfPzpIzdfXnNYHklnqfT/yNB1g9czDySZeG6DkJqO6xO335H+9/aPvOLxl89MbqX94yymqzu0fymIk5C6aomSgKZsaeuWqzdznr5Z8vaPvuH9jz9y9/k1h/WRbJ7S1z0mDC4OVc46GcNF5XelAcftiZu31zx9/cLr793x9PULs1cTmlNLPI4YqgEV+qD0yIfRJ4a6bBiagfnrOc/fvPDmj9xx/7Mnbr5zzf55z3gx4j/3X/tP8+Z7d3/b8/e3wd7/IT6/nwvp//a/+6+yfdpdmKTFvmQ8H3HcHMnGGW3TkmQxxaEkm+Tsljuu3i7YPuy4+eyK9dOW8UJE1w48OenIeDGi3NdEeUxTNiR5JGLzxYjt847bL29ZfdyweD3juD4RZxFKKZqqIZtmnDYn4nFKc6pJRjHNsSEZxxxWR64/v2b5fsndd1+xvl8zWozoyg6lIcljtssD08WI064kGQlxKR7F1IeKdD5i97zl9Zc3vHzccvVaRN9JFgvaVjdk44zDRsgO7aklnsS0p4Z4lHBY7rl6s2D1uOHui1s2DxtGixFt1QnbOAnYr09MFjnFXszr60JMrJtjTbrIZGL67g3L92uu3sw5rE4kuTA5m7oln2TsV4cLoSjOYyrfDsd1wfzVjPXDmtvPr1k/7pheT7ypvLqY6WezjHIrpt11UZFmKcW+IFvk7J933Hx2zeZhy+Ltgt3yQD6Nsb2ia1oheK1P5NNMzLzzhPpYyt/vCua3M9b3K15999abb8woj6WEFScxf/o/+39D2/d8/v2WKP5PML75AjgAqV8gHZAgeGgG6gA2A9OAzUGfwI5B7YA5uCMwBlUBRkhJrhImL3s5hi5gyEBX4M7fnfl/Xwjjtz+x3/w/+OG/mzFedPx7/+4/w+0XN6zu18zu5pS74rJL+sXf/JrRdEx9rEjzWEz9R7EPr89ZPWx58+UdL/cbZncTT2wJiaKA00nM6o/rI6NJRlk2JHlMtStJZymH1YmrNwvWDxtu3l6x8ZNqWzU4JwS/w/rAaCbEviSLxWR+HFHuasaLnM3Tjjffu+Plw5r53Yzj+ihjyBiasmE0TTmsjqTTjLpoSfPzGE45rI/cfHbF8v2aV9+/Y/lhfTk/OOJMyEbj+YjyUJONE6qTGLRX+5pslrJ73l+e/8wT0OI8QitFXTXk05zj+kQ2TWlOMnaLfUXm22Xxesbq44a7L25YP2wZ3+S0px6MBGafdidGs5zyUItRROmN8Pcl2VXO7nHH7RfXrO+3LF5POSyFNOZQNHVDPs4k2H6a0viXVplDhAw2fzVl/bjm5vNbNmfzkWONiYRFfNoeGc/HEuw9TqiPNck4pjo2ZPOM3eOWuy9uWH7ccPPZgs3zXhjW1onKYSztn88kgD7OYwm3yGNOOyHvre9X/Pn/9Z9j8Wr+tz1//wdZC74t7f46P45LnuJZq2VCQ28lW7A/WayVZHelpNxxLutK/cXjkuZcztL0g0MpQ9f1JErKFwr5rja+FKtAym+fcCJtROOmUXTdQG40DQ6jFL23ubGDu+i9sFY2KyJiY/DaNtuL5qvrelIFg7OgNF3XMzprVbV8R6lPGZBnTaHsDHoCY6jcgHLQ9z2Jcp9KsQMea5E2HKxgkaL7k9Jo3/egpGxqtKbve4KzP7Evt4H3+XVSyjpr6+wgu82uH0ico+9FkzsMg2gaL1iN19Sdta1WvGMDY3z2pLvo3gY7XErwWsvvop9z4o2KaPG0jzfTHjdVWKmwao3rBu90xVkOKFZEg+Pt3/WG+eT/yt3tVzgHV3d/EgINrGUHaVpwLSLCq8SyiNIfpASXgnuURVW9yL8rZPE1Vnac510tCqiQMnEBNgJeZBHlRfAIVggDGFl4o4wgvOHz728xQc93v/xfcOz/Jzh7VrgKVhiEAa6TTN6+73Eq8r7AWqLedCBt7fuQ8eVv5cuSeN/qYbDidWx9V0fwbztYKZX7vFtnhwuWeT6PGwRqaOtWSqHOoZxh6AfB+X2/gU/X7hVHcjwU3WAZBwbb9ziiy9ixPgt1cANDN8j4t1ZgFfz9W3fJ4sSjejjouw6jR5wnC2ut4OecoQGPlhoZQ8bIzlTybyXWbjh7XDsL2uefIqVz7WEMyQQ2dF1HqmPph05Y6NpJVuoZhvjVHN9zm5jA0Lefzp+gsU58dIe+vzwHrbyG2khZ2vlMV+cUGBmzHmIGNF3bCT9isDilxLP6V8BOp7xfcSC/m0DmocQl9NaSaLB9jw6EV6IuHIBf/+db1u6v8aMNjBc5xhjScUYQhiJ7CAPCKCAZJZ+8L/ue2asZXd0xvp3Qtx2TmynODmTjFBMYklFClITEWUiUxeggJJ9nuAHGPuNw/ko8RyfXE6xzjOYZKhCZgAkDojwkikPCKCBKYqyD8VSOMX89o6075q9mdE3P5G6MdZDPcsIoIB0lxGkk/ptZQhiFjGc5ylkmN1NsPzC/mdK3A+OrMX3Xk89z0I5sFBOEmjiLCOOIKItIRikKxWieY3vL9EZKSrNXU7mHmxE4Rz7JCMOAZOzvP42IM/n/fJwy2IHRXLw3Z3dzKZvezrw8JcOEhnwi1xuPE4I4II4D0lGK04rRLMV2g2SNDk7yQpue0TzH4chnGSZQJKNYvptFonWMAtJx5n2Ux/TNwHQx8dch9zCaj0Fr0nEiGa+jBBMZ/xxjn52Y0vcDk5uJXPvNlKGR9sBBPh/xd//HXvHZH/khb7/X8tn3byG88RKVQMhVLkB2lDHCso3kzc1lwvRwiZ+gY8FMSWRlUIH8PEaO9au/VOyPEftJPPScmRSZaSN/TvluPv97+eK3YkwA3/t7KtTpX+TqzRxwjK/GBGEg/SCR3WWSJwSBRMK5fmB67fvw7YTG++b2vSWbpDKGJjkmDkmyiCgMMIERi0Egn+cyhm5837mTY42uJqAU+SwjCAKSUYyJDHEaEucJURSQT3OcHRhfjxm6ntn1mLYR7+eht+QzySLNxjEmCohHMVESoqOAZJQCMJpnDLZneivnX7xaYPtBvGeVIp3mBEFAnMUEcUiYBESpHC8fpzgLk+sJw2CZXo0Z2o7pzZRhGMSb1ijiPEQHAXEaEcYhYRKR5inKGPEAHiyzuym2HZjfzelby+R2LGNommICTTJKMJGcO04jwihkNM1xzs8h/SDzTm+ZXI3FGnGegVaMpilhLPcf5xFhEsoYQuaIYZD77duBxd2CvrHMbibY3pJPM7TWJFlIEAWkWSw61TAgGQmuPbmW889fzRm6gdn1VJ7hYoTWhnySEkS+DcOAKJHx5DSMpimut0xvpnR1z+KV+Fj/xub639iZ/v/0czpUWBzVscLagaao6L0vZFNVoLSUnVBUhwoTKKp9hQ4DTrsTzkF1rBkGS1U0DF0vuGs/4AZLU9Q47WiqBrSiPJaYwFCfWozWVKca65BO5Rxd0zP0A303MLQ9KEVTd6CsaOMCRbmvMKGh3BWA47QtcM5SFw1919GULUPX0w8D1anGOUVXtqAlC1AZTXWo0L6c7XxZuWstTdliB0dXddhGfGqbsgGlqE8NQRhQbAtMGFCfGmm7U4UdHNXJt0PZYvuBru2pa/EabSrBjqtjiQm1/B4E1FWLs466bOj7nvpUYwdH31i6pgHfvmhFU7Y4ZamLGmM0VdGBdZz2Fc5KGw/tQHWsGHqL7XuqQjDjpmpxztLULSbUFIcT2mjKQyl/Xzb0bU9xqLADDM1AV7fYwVKfpHTfVPJGXp4adKAvWFaxK0iH/yXt0QETCP4knPet7uzOgP9zL7vNc4wGPZ/oi2fG2vk7Z8az5UKRlhwP+TlfTRFJjD+X9diocr9yXD7t3IP/JF1r2D5H3H3+Ncf1EoWi3JcM/UCxb7BdT1N3dE2Pc5bqWEv/L2qUg2JfEwRa8HCtKA4VzjmqU4EbBpq6YxiQsVA1KKVpi5rBOspjhdPQHGp0KPm6OMtpW2CHwfe/gbbqsF1P3/dUxxKH8vmVjrJoiaKQ+lhKvmgh56+Llt734b4dsE1H3/bgFG3doFDUxwodGIp9iQo1dVnJGD5U2L6X6+stbdMzdD12sJ534GhqgVDKY40ODPWxAq0pD5XfsYrzUVc2DL2lbzr6tgMLdVHhgLqsUaGh2Be+/1VYFNWxxPaWumyxdpAot87St3J+hxxDKUVzEhy6KZpLRrFzjvIkfbg+lvStzB9d3aGUozk1WCt5skFgOO0KTGQ4HSqUUVT7EqyjLjuGbqCpZAwP7UBf92gNbdlgraU8VJhAUxcyP5a7CoC6kLHbFA3DYGnLlq6TslVdyBzSFI08s1Ptfbd/M59vF9Jf4yfOE+I4JB8nhElIPs3RQcDi1QzbD7z68o6+kTdPbTTZKCb0O650nBLHEfksJ0ojxtOMODRMr2Xnd/NmTt9JcoKzivE8xwQBSRbJm35kiP0uaDxNiZNYkkvQzP1b89XnV/RtJ0kOSpNPcqIkIk5D8mkq6RGzlDiLyKeSpjFdTFHKsXg9o697rj+7xiHuQFpr4iQkyWKiKCSbpCRZzGSWE8Qh0+sR2mhmNxO6vmfxdsHQD0yvZzi0T50xRGlMkscEoWFyNSZOYvJZJjvguexS53czhnbg+s2CobNMryfoICDN5Z6NMWTTlMBoUr8bHc9HGGOY304ZBsv12yv6ruPui2tQitEkFSwuieQ7oWa0yEmziHw+IowjJlcjdGBYvJrStZZXX15jh4HJfCS7/DQkjEJpu2lGlISMpilBFDFa5IRRyOJGdq3Xny3oWkmwMEYSM0xkSOKQZBwTBAGjqwmjaUmc/URKzfx9HsNESEbKCmFI+RonCLtWne3oWmR3WSPelLUwcVXjF0O/KLrBE5O8npTBs3fPx1BA6xfbThZh5X/O8encDNy8njK7tsxve/Lg/4DDSQzYIJFy05sp1g7cvL2ia3pefXkLSjGejQjjgDSPSPKUKNSkk5Qkjcl8fxzPRiijmd1JYtGrL24Y+o7p7YzQyK4lzaRykI2lkpLPRiR5Su6PP72eYh1cvbmi7yy3X9zgnJX2jyMSXy0IooB0khInEaOpjI2J78Pn9KHrz6+wQ8fsZi59eCLJJUkako0StArI5/Ld0SwnikIm1yOwjqs3c7p64O7LW5xVTHz/TPJYXJXikHwilZfxLCMIAyZXI1QQyM6367n67Iqu7ZnfLXBKDCKiSJNmCckoJgwDRrOMJBUjjyAMmMxkh3f1WqpXd19eAzC7mV52rVEcEcayWw/i0Ke5hIxmOdoYZuf0pc+vGHrL1ZsFSmnSUYoOFUkak6TRZR6Is+hS2ZpeSwrT1eu5P8Y1tneM5hI0n+R+1x5HjOaSAJONY8IoYjzLMaFhcSvP8ObNgr61XL9ZYFGkkxQTelVA8Jtb3r5dSH+Nn+pYU5Ytp21FW7YcVmKSvXrYgDE8ff2MCcXo3dlBDJjrntPuRLUvqcuW0+ZIdao5bE6UZcv2ZYsDnt6JsfrTV0uM8ebcfc9hc6I61XLuXUl5qtivTpTHUsy3204MtpXm6asXgihk9XENzrFbHrzBfUF1qKmLhmJb0JQSwl0cKnbrHbZ3LO+3hEnA0zcvGGPY+RDu40YCxKtTTbEvqU6VBJif6otJ++Zpi9GGx18uMYFhfb9GYcVEvu4pdgVVIec/ro9Ux4rj5khT1GyXe+xgvbG14fGrZzG8f9gw9AO7tYQ1l6ea064Ug/tdSV20HFdioL9+2KEUcv9hwMNXLzjr2DztJUB6W1AdKqqjGPuXRwkhboqGzcueobesPmwII8PjL1/QgWH9sMNay2lzoqs7il3l77/muK2oTzWnTUFTNay8GfrLNyuixPD8zRJwbJ93DL3l5M35q1NFnAT8sT/+f2cyq7h+E0Nw61m2UyACNQWVgBqDyuUXI6T8OgKVeuKQkd+1BiZI+Xbij+F/To0ESyWX/z8fgxDsxJeQZ4JZXM4/82XkkfyZlGTyD/DFbzWkGfyR/8gLyr14Ja8Ca8Wk3Tme3z2L8cLXLyiFv/+Bw6agOlWUx4ZqX1Geao6bE1XRSNBD07K+X6G04vFr34ffr3EK9qsjTdVQ7ivKfUF5rNmvjr79T5SHmt3zDucsz+9eCELD89cvmNCwfRKD++OmoDrVlMeK8lBRnnw/PNXsX/Z0Xc/mYYc2hqdfvhCEsQ9Hd+xWB9qu57grqQ41TdVwWB+pCt8fy5bN8x7rnARYx5rHXz6hNZc+fNqIOX11lDaoy5bD5kRd1OxXB4a2Z/u0Q2npO1ESsPq4QivHwYfQn7YFbdlSl/8f9v4sVLttze/DfqOZ/duttb5un12nTtUpW0aqY+lCimUrDkpwyU4sXwnnxjJB2MEQ60ImFyKSE4JCcMWCCKHIEErGQcQ2JjjowgQSKYSUY0xCuaSyqlHVqdqn2fvrVvP2s59zjJGLZ7zv9x0pThyn9hal7Akf77fWeuccsxnNfJ7n3/Q0+5qu6TkfGsa2Z/90ws0ujiHN29+6RynF0+stPgSOTyfGfqQ+NDRHmU+OT+er0P08Ofbv9milefvZPcbEPqzEBHwcJppjQ98M9G0fjQoGTgeZG3YPe4LzPHzxRJoZ3vzmO9Ca3fsDznlO2xrXzzTHljrOYeeDGKKf92emfmb7bk8Invc/eMAmmocfPKKVzGHTELNGzvNVbV8vpF/i5l1gtakE8brIsYmmXBRSqyksaZahjaJY5QQP6+dLhm7k5tUN0zCzvK1AaRabCpOKT6dN5G05zSxJmkiNLnjKdck8Om5e3DAO4u3onHiQaquo1hXKKsqVvNmmZUZeZBIJr0uU86yfLRnbgdtPNoz9yOKuIngoVxk2SVjeLjBJQr4sSKzGWnl7JiC6qbNn82LN1E+sX65xk2NxW109RsVjMMcmlqxIyCvRpRWvx8DybhFpKTfM3cTibkEIisWmxFhDsSqlVrssSFKDTRKKpehzVpsK7zx3L2/kHr6M/pTPFxijpUaUGoqlROv5IicrM4xNqFYlCiXt9yM3LzdMo9S7CLDYSI2oXBWkmUTcSWbRiSVb5KhYg5snx+b5imGYuHm1Zhocy7sFyiiqTXF9Dkl8S0/LFKU15aogOC9es+Mk595PrJ+vuLn7Ht/4ds1yo/j0J/8Q8BgjwB1Cdzkg1JVa9HNDK/q5jMBRosywjwChnUSj4VFSv+yR6PKE8E5bBGQ0yPHUjCCCA6h9jGQfRKAh7BFU2EfthxHo4zG+yfNPJ/7h39vxY5/+O9J3rGZ5u5T7vyxIcql15WUqXrabSqKrFyvGfrz24dXNAm0sZcwYlOsSmyZkZUpWSP22vKnkHt7FOvvLNWM/iT9ovP8m0RKVZVZq1nlKmtqrxvPitsJN4rF5qbNPw8xiU6CN+PSa1MoYTo3gBcoEDFTrguA9i5uSqRu4ebFmHEaWdxVaK6p1EcdfThKlBW1uZSwsCrSCxUY0nzfP14ydPH8XLRilRijt58scmxiyKrtqaxeLnOAC67sFU++4ebVmbEeWt0vRs16Ln3EZo8J8kccxZMmXEatwW+FGx92rG8Zu4uaTW+bJSSYnsSxuSrSVMWziHJIV4vFarivwntXdgnmcr/fuUiNe3lXXcZik4hObpAk2jb6/RlGtS/w0c/NS7OluP5Fa6erZEqPFJ1gbQ7ks4lxSxDqr9Cd8YHW7Yp5mbj+5YWjHr2yu/3oh/RI3peG4O+N9oD2KdVpz7uianmFwNKcWPJy2Z7Q1PL3dk1eZWAGVCfv7Q4xUz2Kjdmzo24Gxn+nqXqKnQ43WhsP9gSxPeXz9RF5kbN/usFZzfDqiHLSnVmp0R7GRGoeR5tQQZs/x8YROLNt30u7FTulwfwKjqPcN8zRH+7GBsbtcw0xz6AhoDg8nkizh6c2WrErZvt5hE8Px8YybZupDw9hPtOeeoR+Zhon23OKc47ytxfrt3ZaktDx98URSCE9VG0VzFMuy5tQxdCNDO9A1PdM00x5bAI4PR9Ii4fH1E1mV8fT2CZsZjg/na5Q5jnO0v+rp25760IjF2+6MTgzH+yNpmbF9K1ZQ+/cHlIH6UOMmR31sxcaql2jZjzP1sUF5z+HxRJJZHl/vyIvkaud0fBCrvPogdaW+7hj68Ro1+Tlw3jfYxLB9uycrUh6/eCQtM/b3RxbVL/H2BxalXoBVwuFUgpSWhUzJpyKipWPHUw4Z3k5+zxSBRV4iSmH4x32jyILIxnBVNgrxbxfzUuVj+y7OHD7WWWMbYsEjf0t+Nw+vLT/4bor2e/aPJ8Z+5rQ9yzOsB9pTi5sczaEGI7ZpSZbw+Frs9PZvdyijOG6P+HmiOTSM3Uh3Ghi6kTmOieA8x4ej9OG3e7Iy4+nNjrxIOT6eCAFOu1r60KGhb0eGeqKrW4Ze+oZGsX9/JM0tD58/kpWZ9MdUU+9a5nmm3te4caY7dwz9wNgPtMdWxtDTmSRJONwfScuUpzc70lx+Rinpa73012mYGVu5B9M0cz40eGWkD2cpj3EM7d7uMYkROUgvUebUj3Snlq4dmLohRl4yR+hE8/RuT1olPHyxJSlS9vdHtFGcnmrc5GmPLUMvkWLfDkyTo97XBCW2jWlhZQwVKdvXkvU6PdWSbdrXzIPUeYd+YOrlGc6z4/h0jFH9gaxIxVYwT9m9O4BSnLZn/Oyj/eDE0IwMTS9z0r5BBTg8Hkkyy9PrPXmR8vjFEzbRYuM2O877hnmSaHMYJoaul/r55KUmmyVs3+1kDH3+SLnKv7K5/uuF9EvcQpQ4U0Q7oigbZq0W82ujRfZNX+To1AcFIwS2boyJyipio2S1sPONuRDdQaSyNC74q21ZxL0LEV5E24R+ooSGcFHYUTpKfl3sobyKlJeLHCFc7a70xUpKR3UeorxZlPmKNmfBe2knSpGZiyzeVfrsYjcV2zUXqUDDRYoMJbU35zwXprO+WiZFeysfQTMKcRuJzI2L/ZK+qKAosZFSIVIAjIUgVARrNEZF+y2CQP9RV2k0Ff8mdl0Cpw9OoaKlk9WiuHNRKrx8X10lF7mqzxBLklzWnigFKRZ3lzVL7svq2YrN8xWr5fdJrQfukNSpRpSLlPwcNISIug1ROQD74XdEVK4q4t+yeIxE0LY6HiskonwUdPz5IicYv3v5DB+1S/Kjn8HEf9KmsYDXpDkkek9Xy6R/kYS0F9UtVLRBu7wHKLjSLuAiz3iRrQtKFIPcReFGi7KP8hersY8uIYSrbCVKaC9aKUIQqgtKng+GqBomI+9CPwpK4byLVmz6A74LoZFoK4o9Oo5RUCgv4+uDTVy4qgBd2vRB6GrKKwwQgqiA+aiGFHy4HE2UicIF2iVHtEYLw+kiQxhV0+T7xGsUmzF/sUPzQoeJop5xTBAt5USlLFxoPHH+EBaej/KM8f4HcVXyTizyjDZyD8OVpxSvP6CVvFxdbPS0Vh/GwmUO0xoXxwlezs1fKIPIdYj8Zrz/UTTUOVGJuzTrnY+KV1yf1Ve1/Y4VZPjZn/1Z/uyf/bP8qT/1p/iLf/EvAhBC4M/9uT/Hz/3cz7Hf7/mDf/AP8m/9W/8WP/3TP/1f+ri/vcpG/yFdLai9rMwYmp4ks0zDzDQ6bl6suP/iiVc/8Zx3v3XPzScburoXWS0nnccHkcqb+om8yqiPLdYasjLltK15/mO3vP3N9zz/1jO27w8sN5VIhWWWeYx8MB/IipS+6a/KOt45ls8WbL/Y8uJbL3j32QObT1YMZ3Hd8DEYCSGgrUj45VVOc2gwicGmhvO+5dmnN7z73gMvf+I5j19sWd8tmSbhmPmLV2QIpHnK2I0kuaVvB4ILrJ4tefpiy4ufeMa7zx55/s1bztuGrEzjgqKuEw5erJPqY0uSWrTWNKeW59+44d33Hnn5k894/GLH8q7CDeJcE5wIkl3aH1px1OnbERUC1U3F9s2OVz/5QpSdPr3hvGsoFsKtE25jkBcP58nKlObQiqWdEiTmsx+74f33Hnnxk895/MET6xdLhnYiyawcQ8mkbFPD2E5kVUJ7HtAKylXB/v2R5z9+x/vvP/L8m3fs70+Ui4xPfuoVz77hSIc/jbbwnX/in4k0whRJnWbRCi2KKpgS5j6uPKmkWimBBnF1cbKvmiDkso/agD/EY5z4wCP1cvxQS/2VQY4JyMLcy7H9Gczmg2KSq2M0XMjx598Evstv/krGw9tv8xu/9s9ji5T+2KKsuP+cn2qe/dgt7753z8tvPWf//ki5ypnnQJJp5iHqqUYpy7EdSLKUeZ6YesftJ2vufyDqWG8/u+fm1ZquHkizyMe+6FBfZChLES+xqSXNExEh+bFb3n92z6ufesHj6z2ruyqqgkVedlyskiyRMVyk9I304c3zJQ9fbHn17Ze8/e57bj5Z09U9xSJnHi+qVB5jE/zsSPKE9tSRpBZlNE0cQ/c/fOTZj9+xe7uniraCJjXCT42c8iS6QKVVwtRPeAfVpmD3dsfLn3jJm996z92nG7qjtD8OU3whVGgLbnRkZUZ77sTezSiaY8eLH7vl3WcPvPzJ5zz8cMvqWcU0Ck8zBISTqxVpZhm7ibRM6esOkJT17u2eFz/xnLef3fPim3ccn2q5/lmUxeZJJEVxnqTM6E7tVeGtr3vuPr3j7Wf3vPzWMx4+37F+thAFo9Tg/OX+iSXb0A5ki5TuJGj5alWwfXfg5bee8e579zz/9I7944limfHP/ks/w6f/0Cf/lefvf+DdX37hF36Bn/u5n+P3/t7f+yO///N//s/zF/7CX+Av/+W/zC/8wi/w6tUr/sgf+SOcz+e/L+fZNz3HxxPNueX0dGT3/kB37nl8vSUQ+MGvfYGxiu//yuckmeXtZ/dorbj/4SNunLl/vaM79+zfHTgfWs77hv29ON1//hvv0Ebx/V/+nKRMePOb70isgF/cNPP+e0+M/cj+4SBAo905gi4Gnl4/Ebzn8199g0qstJ9b3n/2AAoefviEczPbdzu6ZmD//shpe+b0dGL7bsfQjbz9rXusVvzwV9+QZglf/J032ETz5rN7CPD4esvYj+zu97THjsPjid39kebYsnt7ABDXl8Twg199g0nEOUJdrn/2PL3bMzQjx4cTx+2J067m8P7A0E/c//ARazU/+NXX2MLy+a+/u4KvgtI8fL5l6Cd2b/e0547D/YHT45m27ti/3eGc5/O/84YkTcS5JjG8/u67CGB5ZJ4cj2929PXA4d1B3F+2NYdHAWLcf/8RbQ3f+9vi+vHDX3uDSQW4Ebzn/vMnpmFi+25He+o4PJw4bQWwtXu3x8+BN7/5Dp1qcaywmi9+/S3GKB4+3+Jmx7T9c3zzHxr51u/qUWGM9c5eapFhijXMAZjEa5RJfs+EoGmd/N91EZXbxWO08Tu1fE8NCFL39ipJLAABAABJREFUgtp1YGLK+ILkvRwrjPK9MEr7YUDqsUKhknRzbE//bgCsDeC+YP9wpH46s70/4KZJ+ntq+OHfeUOaJ3z+G29Q1vD+B49473j8fMs0zRweTrSHlvoQnVOajvvvP0FwfP+XP8dYxff+9g9JUsvb796DDzx+vmWeZrZv9gztwHF75rQ705wa9o9HpmHkzW++Ryeaz//OG2yR8oNfeYM28OY33kkf/nzH2A8cHg6cDw3HpxOH+xP9uWP3dk8IIboeGb7/yz8kyQzvPrtHgTinjBOPX+zozyP793tO2zP1vmH3fs/QjfJdA5//+htsbnn9G28xRvP+B4+EEHj6YsvUj+zf7WlOHacnGQfDaeDpiy1unnnz3fekecL3f/lz0szy5rvihvLmu28J3rO/3zPUHYf7I+25ozk27N/tGbqJ9589YDT84Fe+IMmtOOikhvfff8B7x9PrHWM/cdye6I4tx8cTh8cjzbHh6YsdbnJ88RtvMYnlB7/2hiS6zhituP/BA94FHj/fMXUDh3sZv8eHE9u3B/p64P33HwlB8f2//Tk2lfZtonj/vXsgcP/FjqkfOT4eaY8dx8cTp21Nc5D772dpP0mszCXW8MVvvAUF9997jIv1V7P9jltI67rmj//xP85f+St/hZubm+vvQwj8xb/4F/nX//V/nT/2x/4Y3/nOd/irf/Wv0rYt//6//+//fTlXP3umYcLPIVL7Al6Bm0VFxLlA8MibqxYOVAhBJPG0wk/umu7zTjh9fo7O79FZYXae4BENXg3TMGGNYRxGVFC4weM9+CmI0koQlaLZiaoS3sf2uXJRh04UcsZulpRQ8FdloxCBcN555ngdwQeGZsQYiZxDCKK3q5Vw1VykPkQU3TzNTIPs52YnuqpGMQ4jAR85YYG5m9D2g4tE8EEiVe+Zpxk3BlE9AoamF3/JbiS4C68spoadpGxdPIaki0UOxzkv7SsYu1FUm4bx6veqjaRwL6xJF49z4ZEGL9orUzNilGHoJkyiGaPOq5vEeNvPsp/3AT85XPDMk4c5xPuvRYpQC69WacU8DGSlw9hLZJkC0YA7tJJCVXPMh3qhvegLpUWJ2HxIgFE0dEMN4WKnliG2aZc6KVLfVJN8+gHJ7Q1Iqvgo0Wk4yb4hCtozxSh0jv9inVQhiklo5lHhvKT+ldH46dInhYvophnvYWzEum3oJkDRdyNaBxkvPuBGLwL48Z7PTgB93gvHUlnhc2or+yptmCNX2c8O7+QYYfai0uXl/25y4ANjL9zrcZhRSsnPxghn1Inhwzw7fAjXMRy89K1pmIVz2QonfBomlDa4ISrteNnHuyD9Mci54+WYOBiaEaU00zAR8AzdiFKKefZ4H9ubPR4ZwyF64k6j8MK11kz9gE008+TwQTivQSsZ85OPc44MZDlmuP5uqAe0ES64NjKWlFbCuUXGnvOSY5b/y9jyXsawNibySpE5JN5TpUWJKES6slQf5JyIimPgmfpRxkE7ypiK+06ju16/j2PIOZkLfRxforRkGNqRJBE97SQ1X9bU/vdsv+MW0j/5J/8kf/SP/lF+5md+5kd+//3vf5/379/zT//T//T1d1mW8Yf/8B/mP/1P/9P/wuMNw8DpdPqRf79tm9boxCLFi3B1egCpD8UqkEhr+UBWSg3qkvawiZXFR0lq6SoRdnFUURqjNcFL2il4RVYkcqwixQUnnCoCykptIsS6h422ViGei3eBNL24TqR4P1+NxS9WbTFLFOtBl3qTFLaSPME7R5LJOYuDhtR/dbQX00bF2q7CJNGBxSiSROTQbJoQgmj6ehewmWUancgDRssxUNd6kLixSPrVpgYfPElmCBpJD88fLKKU1VISvNRwxbcLZZDrB2xMBxpr5R7mCS5KEcojDOhLTS3KtulYE7WZYfYiiu5mLw4ag491N9BWzlvs6sQKSw6rpc7tPWkubh9pljAPI6ubGT8ZqmqW1KqPDwAjUnpXD6k0/v5S/9Sxr9i4qCUf9lMqLoBwVSXyIEAkhSgehfi3IGlhBZL2VR+OpTRXs3AV69NcziMRqoyywCcMrWLstNzvCIrS5oIXiPZqCnl28R6GEO/h5NE6iFuKUXIfjaT8rf1QH7RWiflzkYIPMbUrfcrNTmqDGpEVVOJAc6kPXvQszMXgIBfnJJtY6cNWoZW4J11cj4CPeIoyPmbnSLIUCCSZFaH1XI4hdoQKY1X0AZDxdLGHQwWSxBKCF9cjlLgweY/NrOARjBELv0v9PrZvrMFahfdO+p8LJGkitdQsJcS69OVRYUTmjxAwUbQgBOnDbnY/0g+9c5j0Qy3TIHXOD/NAkLR7XCxtanAhziV40iLBTeHaZdARlxat5659OGIWvI/ONYHohiVp+Yvkn9IKa1TsvvHZxfHkvTj4+NiHxmH+LzVN/3Zsv6MW0v/gP/gP+Jt/82/ysz/7s3/P396/fw/Ay5c/qvb/8uXL69/+X20/+7M/y3q9vv775je/+dt2vsE78jJDo8jLTIBDVpNmFq0M+aIQSPqywk+OvCoYh5FyWTD1M8UyxzsoFnkULRfKizGGJM8IRovVVPDkVcY0jGLjNUktxEfXGTwkqcVYTZJYUfwIkOYpOiiKRck8zeSrgmlyFFWGmzxpKZZkeSE0jTRPsdaijSYtRIg+q6Sem1UZ4+CoFgXTOFOuCtzsyRcZKnAVzlcmXr8W4QWFJi0L3OSpVnIeWZExjTN5lUl9OU9RyEuCsUK0zssMY4UC4JynWldM/USxKJi6kbzKZUGP51mUOVrpq1iCQpPkMulmZc7sfLzvE4tNxTxOMihDoFgI+s/mqbw8WEOWp2CU3IcQyBcF8zCRL1PcOJMvcpybKVdCIcqKDKNlsjCJRSlDVuYYDcWyECm8tdB8nv/EM/x8YvPcCaDksjipAeF+jkAR650J+FEWxDB+AHx4E9G20RqNCeGHjqAr2ZdM9tFWUsPKIGnbBEnRavnAxVrphPBFL+0PQCr76mjDFrR8ehX3Ldk+WLQKJIlYBdrEoFAkWUpQgazIcLMjX5S4yUm/n+Rn7+T54KQPiQ2aIctSlNJkZS6wqyLHTzNJljIOE+UyZxonEVv3UC5zQJFmMn4UglsIWpMVOX521+deLnLmSX52zpOVIomYVbksTtaSZgnaWPIqEwnAZYkbPeU69v+F0NGyMsNPXkTnkZdka8RGLynEkzXNRau3XJcMfWy/n1ncinSmvBTIAq+1wiZGrkMbGf+zJy8LuXeLgnmcKVYF0+goqhQfX061kmOIBZoiK6RfZ0WG845yVV6t4OZhJq8K/OQpShGMT4tEXlpSS5omGKNIsgyCCCEIVUboR+VSfs7LHO9lTgnxnsuCqmT+MVqkSr2P7TuqZcHcTxRVjpu9jL8QKFcFWmtsZq/PMStzmV+KXM49zl15mTFPXy+kf8/2xRdf8Kf+1J/i3/13/13y/L8Y1vx3CxWHKFj9X7T9mT/zZzgej9d/X3zxxW/bORfLAjfOlGvR0kzLDO8gXxaM4xR5Y/LWZjILIbBYlwz9eOXDLW4XeOfIF7KoZlXKOE4sbxa4bqDclODlrTQrc1yIg7mfWN0smCZHtsrx3lMsMpgD1VoWrOVtxexmsiqRt2EfWKwyxmmSv41OuF0ukMUoMasy3Owp17lw3G4qlEJ0dItE9t1UjN0gvLTZiS3a7ChKGTDZImfsB6obOY9ikUVgg6eoZAJcbqqr3q3Y0Im/pyz6cl7TMLHYlBLhWU1epFEbtWDsRpa3Fd7NFKsc51yMdD3ZQizmVrcL3BwolplE9kCxzIT/d7tgGj9MZkWVE7ynWBS4aaa6Eau11e2CoBRpZkjLhHl0lKuKsR+iVukU+XGefJETgoCMxn6gWsuLS77IxXA8BD75yZfcfXLLi08fef1ZRl554DZ27hQJ/S7m3BGVG1T8d0HOxg6oL5q5QRZHFRCELTEtDNdINRBRu5IxkWjSfrQQE/d18WfzUWQb94EPbV8oNaxZbmYCgXzR4qZ4D2cndn39LHrQSqK1tMiZxjlySkfWtwvpu+s8PoeM4ANFfP7VWo6VVxkmS4SzuywY+pnVzZJxmFndLQjORb6ov77klauCuZuoNsU1MMqqnGmaWW5Khm5gdSsavuVKuM75Ir+2Pw4ji5sFzs1RjUjsxqplzjRNLG5Lxn6iWBfX6/ZeXrrc7FisK6ZhZLEpI6hPyeLhPdVtRd8OLG8Wct2rHO8CxUI8g8tNIXrAtwJMypeiBBYI5Jc+vIn3KHJs8yrHz4G0LJido1gXjN3E8qZEaXFmyTLJQpVr6aPLuwXzPFGuRFP6ch7ZIr9y3d3syapcMjlOFuRhGFndimZxdbuQeXCR42ZHGfWpq03F0I6UKxkXxhqSPGV2jmpTCZf2bsE8yTVMo8xVfvIUS7GarOKLS3VTiG+p+pBRyMrst20u//+0/Y5ZSH/xF3+Rh4cHfv/v//1Ya7HW8vM///P8pb/0l7DWXiPRvzv6fHh4+Hui1I+3LMtYrVY/8u+3axt70YIU776BsRuZpon+3KF0YP94AgXnfS11zlq4mXM/CU9unBibnqGbor7nRN/0EOC8O6Os4fxUo6yirzucm5nakbmfmEbRM51Hx9yNwv9qRqZZuI8hBE67WjhmuxofYGxGhsEx9TNDN+FGOY9xmJjakWkYGdoe7x3dscckoqgUCPS1oBjnYWYeZ2l3GBkH0eMch0k8BCfHcO5RWgl/zGjO+4aAoj8PUlMdZsZR9ISHphfeWTfhhpm+6fDOc97XKAXHxyPKiz6p84j+Zi811HGcRN+3HhiakbEbmeeZoRlBweHxhNKK876G4Olr0QMeu4mxG/GTk/36iSHqqrZRZ7fetygFh6cThEB76giz1KHHUXiyYy/PcmwHxnFiiPzd7twRguK8b1BaeLraSF13HEfR552/i7WBeVKIQlGUBaSOi10deRhdBB2NoFz8N8oCqHpZHLlICrbys6rjYtpK1MoA2vFB8i8ClsIsx/IGMfkOcoxwOUaQfVWI4KMoVagiQMnMQMly48nygHL3zJPcw3kWFShtNKet9IO27gluFg3ZfmLqJuEL9xNTK9q8fTvJMfYNSsE5HqM+1IRZnuE4OuYhjpmoENS3I9MwX7nczgXqQwNaeNwozVD3MubakbGTftw1A+Mwx34g/X8aJ9qDtH96OqOV5rQ74wO0545xEi3fcZjxk8fFMdF3QxwHPSF4zrsz2mpOu4agEF1cL/3VRS1b4avKeJyGUfrINFNvW7RWnLY1yqh4DYq+GXGjj8wAGYdTNzANo4yNUfiXava0hxaUcGB1UDSHFo/0/6kXTdyxG5h6R9/0jN1Ef+6ZxpGh7gkEzocGZeC0OwPhOsdN48zQDfjJyf0cXZyPJtHOnh2npxNaBepji2het8xxvnSj9IOuHUSp6NTJPNJNjFGzWhlFc5L7cHg4oYC+HnDOXbW3v6rtd8xC+k/9U/8Uv/zLv8wv/dIvXf/9gT/wB/jjf/yP80u/9Et8+9vf5tWrV/yNv/E3rvuM48jP//zP84f+0B/6+3PSXknEApQbUfhZrERhJ80SioVQChY3lSh6fOOGoenlsxtYPlsyuxD1LSV9YpOoxZmJKki+TFHBs7hbMnYjdz92S9/0ok40zCzuSkBRriuS1JAvxPEhK3PyMkFFxRQ3OTafrBmbnrtv3DC2I6sXa0J0UFFGSeoxMeRFhkkMxlqKVY5RmuXdkmEcuf3khr7u2XxyI1HBndhCLTYLbCaKPiY6zyR5grGWcpkzTzM339gwNMO1/eXtgjB7uX6LuLBcVFmyBJsl4qBjFYu1RMG3n27o257blzeMzcTqrkJpRXVboY24sIj7Ry5RjFWUS4kUbl6uGduBu09FFWX9YhUdZKorXSXJEopldm2/qFI0UG5Kpmnm5uWGrhm4+/QZQ9Ozer4iBCUaofai7CRuNGmRXNWh3Oy5ebGmO/V88u2X1DvNT/6ejnlUiNeoRxSEPILSjYvYheTqLwvhHKPGKF6vBPSBivuoIS6eFyPvCzL3owVUefmddnEy6j+0G6KOryf+HNG8Pn4yS6o5DPF3iqf7WOuKylppbqlWhfj0WnH/CFFZa+ilD7XtIHq2oxN1HoVoJ1tR8TGZJclE5UspWMTI7eaTNX0jlIq+71m9WOG9jDGtFcVaVLHKpejx2kT6X/Ce5bMl0yj6tX3bRwcfJ/q2iPJQkiUUVX5Nb6ZFgjKaxVqyL7ef3DDWPXef3jI2I8uXK5yX6FtpRbnIY2lCXJC0ljFptGL1bMnYTdx+ekN37qI6k7ggqaiwZdLLvbNRFzqJymGSSl4/XzA0A8++cUvfDKyfr5gHifCUhnJZSOS5KrBZQpan5EtRh1reLa9m4V07cPNq86F9rVjcLqLjUYHJLEVZxPYV1arAOcfy2YqxHXn26S1DO7J6vsLHDJOUsWQOKVclWZWRVRl5lZKkRhxkppm7Tzc0dX91o1o9k+uvbkqMEe3gJBNFLJvGZ7gqRRXq5Yq+Gbn79DaaPnw12++YhXS5XPKd73znR/5VVcXd3R3f+c53UErxr/1r/xr/xr/xb/DX/tpf41d+5Vf4E3/iT1CWJf/Cv/Av/P05aRU4b+VNrTu0uGmmj2+20+joTkOMSGpsotm+3VFsSnZv92RlyvnxjNHQ7BtxPTmLEsg4TFEdaJRICM3p8Ui2yHl6vSNfFuze7UkSxflRoo/21DL2M2Mrb7bzPNGcBoL31IcOk2i2b3bky5ynNzuyRcbh/R6dGs67Vto/9cz9zDBM9N0ob6aNuL6cHk/kUdGlWOXs3u1IUsvp8Yz3TpRdhpHu3Me39YmhGfDjRH0Qbuj27Y5imfEYFZ5Oj2dMYmkOEgW2p14ivGG6uql07QBBcXw6klzaX5Y83e+xmeX4IFFne2iYppmuHmJkOl0dMJpjh7GG3fsdRbz+fJmJKXtqRFFllu/Ng0SnfdPhJifOMQbOu4YkMzy92VItc1F4KhOO2xNKS9ZhnmeGVp5d3/YMzSAZilrcZ57e7SlXBV/82mtM8RP81i+XZEUAzogXKML5VAHMStKvZiEpX1MBqYCDdMlVO1dZUGXsjwvJwOobSb3qBZK+jcfQCxFoUJn8P2SIsbeCsEJQvhtZsPVKjmGWH9pXOehCarA6l08zMbSKp/cJQ7tgOHcS2V2f4STuJgp290fyMufx9ZaiytjeH7Cp4bSVjEF77JjnmTFmSeZJ3HwCgWZfYzPN/t2eYlXw9HpLscg5Ph6xiaY5Sh/qzz1jPzH1kmmYZ0db92ijOTwcKRY52zdbypUYbCepoX6o8cgYGgZxXxrHkXGaReHK+chNNWzfbimWBds3O9Iq4XR/QBnLeSdZoKEdJbKKEds8O/rzQCCqc0VlsXKZs327J8msjGGg3rdMk2NsRokUx5G+HXFupt63aKs5PhzJipSH11vyKuNwf8SkhtO2xQWJ2IZWItu+65jGmfbY4bzjcH8gKSy7t3vKRcH23Q6TJpziGGoOomI0NgNDN0g/rnvc6GkOnWh+v9+TFZnMQ1XG4eGATS31QVSJ2nPHPLqorjRETWFxszlta9Ii4en1jsWmYPtuT5olHB6PEn0eWpyXez72I107MMQsTn/u0FqxfXegXORs3+yo1sVXNtX/A2Xs/af/9J+m6zr+1X/1X70KMvz1v/7XWS6Xf1/OR2kVTXsvxPAPAgmid+KvCibEGpmYFkeDaTzKGLCKi26GHCIqA13Qe+ainQLeO7SxeC+UCpTiopGiI0rOhYDy0XQ6KFBROEDJzz74D2mRqLwjSi/hipBTgNaGee5JQ4IPnhAU3jkx4L2YAyPnqyLSzyYGpcGaaL6tjSBoY41NaAHR8PfCtSEQvJIgSH1AD1/MyH2UqLsoD13Mu3VUVBJUqkajsPGemajQpI08B60+qA955zFBy/VCdF0RkGDUqAEthuueaEAO1/1DELqD0lIzw8dnNYuBu0ZhrL0aJ8v5Z3KPAtJnzB2EEJ9dFRerb4C7B/OpRHw6Lnh4UGvpQ6SxFjrL30MFvgN9F/f9BNwT6FcCLlIG1G2MVhdAjkArLz6lEegUjqA/Af8ezDfBt8ArWVAB1F3sS7kssGEGDLgtSebISss8rzG5JmpnfRA7ICpgIbuEKIZxMeQOKirymDiUtIlKSEZoFS5EWoaWTyUI1os6l3fhOn5QouwT0FFd60NfVbFNoSkJ1QmtcCqihonnpAXlbpSC4CM1KvYhwcjjrv2P+JtIe4lyi4oPCmDe+6sSkhyDqEYWxUBi+VkZBYPHBVEXMpf74FVsR9D/gsj9cF5KKeka3gNRIS0xwpiKql9aK7TVKCVm3RfanbVa1J58nAycE+RwEKRuiKjdoGRkBCWKXc7PV0EXmQguyF0Z60opofAFAB8FkeR+yCCK86SJikoiVibG5YE4dpQYihtD7wcZ4xEV75xQZr6q7XesstGXtf12Khv923/234s80pl8WXLenVneVJy2TQQNeObJkZYp9b5luano6o68ypnHGZsa5tmTpMLPKjcVh/sji7UAEYyVQTC2I8Uq4/xUU91KijdfZoztiE0t8zBRrEqaXU11W3KKyiNulkkoKS31rmX1bEm9qwWBOk0kqWWePElmGbuRalVyeDqx2FTi2WkNJtH0TU+5LDntagEJNAPZomQeRkyi8LOAJOpDS7UpOW1rQQZHbmVWJDTHjmpd0hw7QVxGdSI/zZjUCrBoXbC/P7O6XVKfapIsEZ5ZJyjN07ahuqkY2p5iWTC2IybVVxRfe+5YbEoOD2cBj3gvoIQ85bxvWN5UnA8NVUQxp4UgQBNrBBS1LjncH1ltlrSN+L6iYBpG8kVJvTuzuFnQtyNFJchHnSj8FMiqlK7uKDcV+3dHljcV0yBekjY3tMee6qYiy1O+9Xs+Zfv2nn/sn/ifsFwG1ndrSP+ZD4hZZRDA0QnUK3DvxBVm3kW6io0LXRVrmSb+bgRTSD0TB6qKykafgHsPesO1nmpKcAf5DmNE5i7iAh5BRqEF9SIu0M/BbeX7GuGhqhL6v8mv/c2/jZsM//Hf+B+wuF2yf39icVMxtgMYmdS7U0+5LmkONeValIWyImXqJ2wqvMhiVXLenlluKk77JtLFYB6lD9WHlmpd0nc9RVXQtwN5mTF2I2khilbLm4rD/YnV7YKu7tDGYFJNXw+Um4Lz45lyXTEPE0mZMXcjNktwkyNfZjT75tqH8yoXjvXkSfKE5tiwuF3SHRryZck8TNjM4iYnY3kSIM7+nSiQdU0fSySavu2pViXHp5pqXTIOE3mRSf9LTWy/oN6dWd4uODyeY0lCeLBZkXDe1yxuV7SHlnxZ4EbhNM+TJ00t0+wolzmHhxOrTUXbiO+pMTD2M8UilTG0FvOGfJkzdSMqMYSIPG6OHcubiv3DKaaTZwJCWWlPHYt1xflQs1iVTONEkqVMw0SSJYz9SLUqOD7VrG5lrNmI/h37iXJVcHyMfaObyMo0jiHh8uaVKBot7hYc3h2pbqQNHCRlQnNoWd4uOO3OlIuCf+5f+SN88x/59L/y/P0PvLLR75StjOjUJE/lM02YB1kgh34mLdOoD6nJCpGwW9yVnPY1y9uK5iRygUM3YlLpiMJTnEkzy9TPpFlKMIpp9OSrnPOuZhEXy+XtgqHpyYqMvh3QacI8OCEs99K551ne3JM0oTt30u6xYbEp6c49xTJj6EeSImWaJuF6zY4ktVcSenCKeZqpViX9qWP5bEm9O7FYFwz1QJJZ+nbEWMM0zBgrpHPhmAlP01rD0A5Uq5z60LC4rWjPHfkiY2wHsixlHGTCmMaJLE+Z+pkkiZPpJIjK7tyyultwejyxuJFrSMqMoRPT8HF0wvkc5TzmUbw1k8TS1T3VuqA5N1Q3JfWhoViIHJrNUsZuiBOSkM/nyZEWwp1UQF6VcaIpqXfxHtYDaZVFkrsVWH+RMo8TSWKZpxllDCYxjL3UhY8PZ+4+/YTv/VqONgFHL2IM6sLPvPyLWriXhVVFNK0IxyIJJyXfIY37xuOoiwZv/J4i/v9jQfsLJ1XHxfPyvTT+/yPOqjLxuOrD34IF7vmxb0/cvAwkRc44inziPE2YzDB1IiOnowBJXhXUh5ab5yuaQ0u1LoRkn6VRHjCRl0xrmHon/d95oVFkCWM3sthUnLYnljcVzaGhXOeM/UheCCUiySzDMJEUWewHcr5jKy+cXd2xuFvQHpo4hjpsbhnaEZsKMtvG80iyVMQgtCFJZAwtLmPotqI7dWSLlKGfsNbGRT3yJYs4HrME5TVDN1FuSrpzx+puQb1vWaxy2nMn8oDtQJpl8pKZyrFsmjBNjqAVaZYydAPlJqc51CxuK4ZmpFrmDP2INZqhHTGpZZ4cJjHMw0wS+ePzFCgXBX3bs7yrOD2dhUVw7rFxHkpSyzROpJmRcVgI3UtphdaGvu1ZbErOh5bl3ZL60FAuC5EnTRPGfr7OA2mW4qYZm0gNfeonsqqgOfcsNpXsuy7pz73Q6/opPuNBFtdhJMtFLhJE/7treqp1SXtur7S1r2L7eiH9EreuGejqUdCgvaM5NTgfOO9qjILt6z2JTdi92WGM4vB4wo2B7iy1C3FHmJgHR3/ucYMXdKAP7B+P6ETz+PoJo7XUAtG0pwY/ebpzR1d3cg5tj4sefd6LE0bQmsPDAWMM+zd7tFEcn85Sizy2zJPUZMd2ZGpH+pPUNppDg3NBkH5Ws3t3xKaGw8MZ7wLHrXgddrXUooZulFpIP31AvO4aQLF7dyBJLYf7Y0QvChK3Pja4caY/d8yDF4/SWlB7532ND5794wmTaPbv92hr2D8cgOhlOHvapmcandTD2oF5dHR1S4ieqYHA/v6IsQm793u0lVo1LtDsWvws93AePOPoaM8Nc+9ozh3BS+1baxUdOjTbt3tQnmZf4+dAW3eMvdQ/x2YQb8i6w8+e41bu1f4p3rt30v7p6QTec3w6SS22ydAmcHyIOXKSCDKKwgchLoQhLpzXHOBHzPfLonb9u4mfNtY+1UeLXhS+vwg1qEizuYrWX6g1Mbce7EcLZ8y7Xtq6sv8/p6g8d88HQaWOXtxGAhwfz+hUs32zRydWfDqVot6dGXpBN4/DTN/Feuog/c9/hDjfvT+gjdSmjVHsn07S/08ikN/VvSDPu1lQoYOj3jfgxf9VW80+PsPT0xm89CE/i9tP30/03RTdfsRtZp49p8cTIQR2b3fYRLN/vwMtx/AuiKfoOIvbUT0wdZM4pQzid+qcjxgAxdPrHSYV5C+z57yX/t+cG+aovNW3gg+oTw1+DtR7uf792y1JYtm/OaC04vBeUOz1scHN4jA1DoLC7ZsePzu6fYPzntP2hLGa3fsjNrMcHo5A4Ph4ZB6lnjmOs6DN24G5n8WxJ54jBLbv9yRZwuHdAasjejgo6v2ZsZPa5dRNjP0k89A4054anHMctye0iWPYaA6PJ4yGeleLt+++ZRpnmT8awTY0547goDu1eA/b9wdsknB4v0NrOD2eBNX/VF9LX1/F9vVC+iVu8+hYbEq8F56bQiJPrYRUrBNDUF4ilm5i9WxJe2q5fbmhObasnq8YuolikeODI1skVwK3NoYksaRFinOOYlkwtD2bFxvO+5qbl2uGZqBal5HU/EFxRWlNmhm0sWgDaSUCCMvbivbcs3m5oT02rF6s6NtB/EKDiLZrq0lzEY23UXg8OIkGBS27od633L5c0zYD5aYiXIQZlBIPUq2FXG4NSgkh202O1aaiOXXcvtjQnDpWL9d0rUTFeMiqDK31ldRuUivi9ATyZS4+pM/X1IeWu5c3NMeWxWbBPExklTinXEjgSZZG5wot93ASUYeuHti8WlPvatYvN/RNR7EqwCuyhdQxk0xEKWwiiEG8Jl/kTN3E+sWa+tBw+2JDe+5YPVsxjZNYOimu9zCvUhEGMIok8l8Xq5L62PJj//AnAvwof4bXv2WYhj7WPS+2aV7Qs+GibetjHTjWtv0c/85Hte64/+XTx+9e/uE+IIAvxw4hHsN91Fb4cNyAnE9wkWYTj+Xjd10PwPd+LedXf/GbKBVIS4mM0zSR55AkJEVKmB3lqmCoW25ebmiOHesXK7pzR7WWFKb0IS1obxOfpdUoJbzGYZy5uVvRHFtuXt3QHDtWz1eM3Sxp0OBJywSlIS0EKWutweQJfopjqJ+4ebnhvK25/eSW/txdywBZJaIiWWFFDKBI0YlFaSXiHbNjfbug2TfcvNpQH2QMTcMcBQmE42msjuNQauU2SyK/uKTvBjYvVtKHP7mRlP9mIYL7lSCU01LmkDRLMKnMCVkl0fX62ZL23HH7SgwYVs/X9O1IvihEmGGRoxPp81obbJ5gI4e8WBYM3cTtiw31ZRyeexaRB3pB94q4ClGUQdL8aZEyO89qs6A9tty9uqU9tjKG2p5yWYjxRJWjrZH2VRxDaYJWmmJRMHQjm2cr6l3Ds1c3ki6+XTJHkRMI8gyNIitSjBGsQlqkOA+L2wXDeWT1XObSr2r7eiH9EjdjFfWuIQD1Qbw3u3PPEPmVYzvgvac5NCSZZf9+f0XrFVUmHotaU2+FZ9qd+w/cylY4oe25Fx7b9kBSpOze7ihXuUR7eS5cxRCoDy3B+YiUdBLltj0+olFtaji8P5IvUnb3B/Iq5/D+QJIlnA81wUukPMcob+jGa+SJkTfkfJEJ8nSZsn23J8usvOVrRX0U78n+1AvPspc33XmaqQ+tvBnfH8iqjN07af/4/kAaEX9BBbpaUJvTMAlqcZAoF++ptw1plrB9L/fu6c2WLE84Pp3Q2tDsG+ZZUNPzOOMmQQ3Ps7xlK6PYPxzJq5zt651c/7ud1L72sf1TxzzM9J3wCcdhou9Ek7Y51Njcsnu3p9rkPL0TT8fj4wllNPW+wc2e5tjGt/NR2h+FI2et4vB4prop+eI3XrO8W/L69T/K033Jb/5ygR8bRLD+IhQfEApLXASV40c1cy90lih2Tx8j0Q4BJ0X6i4pi91fB+UihuRyPSJUBOd6FDoND6Dfxu2qK+1zE9D1MvwjA/tHyxef/Ddz0Afncd4IeHYeJ7tyjjOa0PVNUBbv3B/JFyvb9njRPqZ8Eed4cWryb6c8SnYydZHucdzT7FpsYdu/3FKucxzc7yirn9HjCxDHk5yAI1ckzdAN9O+KdeMQqJRmBrMjYvd9TrsVVJckTzjvhzJ73gloduplxHBn6mbHtCfG4xih2D0fylVxDWWWc7o+Y1NIcWoILNHvxIx3agb7pcdMHXunp8URW5Oze7ikWBU9v96S55fR0QilNe+gk2m5GmUP6GKlPgnw3acLh/kBaZfEYOccHQT6fI8+zOYov7tj1jN3APIx0TYdHOLlZkbK9P7BY5uwexBf09HRCa0W9a/HeyxiafOTIy5zUHDu00eweDjIPvNmSLwr29weSPIlZCJnr5lHG79APTN0sDlkKzodakM8X5PX9jqLKOW9PaKtpDy3eCfL6yk1vBtwkY9hoONwfyauUeteSV18LMvwDsQVE/1GFqBMbM1/66q0XAB09LIPMbwha1EfUmlZBnDiiWHSIQNsQAioETFSEu/iISnZNkH8EF70JI3o3+hGGIOg9fBD51ijgLiet8NMcfRm5egIK5E5dtVIJXtpwHq1Eci24eA1KEJEXn07CFWQbtX5/FLGstfxOAJfqitb1PqItvRgA+DnEYEnuj4aI5otYSa2vSFgp+Ykmb1AhQnk9IThUkLYECRqRlVqiYxWRhdqaKIgevxiDOaXU1ZtRxWAsBBcDwA/qPt7FEwyI33X0frx0hPiErt6TIr3vISjcLM+JAOf9K87HBOV+TeqkBKlFBi91ThVTs/H5oC7YQSvXHGxcMFNkgbxI+VlkMYwOGZfjXFO68RiCPJJFVEdjcJXGaPRSJ43f/1h/F03f/edMUddhcj+NoDXj/VUanGgXh+g5K0jnEPuF9PmAir6i0qT3l3NVsY+HiOr0Vy1pAI0gZN3so+iTXJ/4lYrmrxbgKMHHMWkiUtv5K0pdXzReQ/SXjahugrThRZdfvD+jJ65WcbxqI16gQIh2epf2uY6DD6hy6TruilDGhev1yEVF9LzzcTypq83fJYvpCRilcV70dUMIEWGvcXO4pv99UAQv4zp4MBFi7yK6GNQHgwyiT6uO5+RcHP8fvito5o+SGkGu9cO8InOU+ric4FVkMyBoZh9Qse9dUN0+hIi65qN7Eb1TAxFJLWhl+VkQzG6a0farE63/GrX7d22/najdv/I/+t+KG8nsSaucZn9mcbfkcH9kfbekPYs6EKhY9LfMs+iRzrMjTUV4OcsThm5gcbNg927H+tk6AmFycXlBBNHnIQI5ZkdaZMyjgIPmUXR7613N8tmS/dsDq+cr+noQQeoQmIYZm4rEV5pYJucEDDM6sjKhbweqVcX+4cjNsxWHp5PIuA0SrWhjGLpRJMa8J0kiWjETJ4aiyqj3HctnFbu3B25erjnvW/Iywc2BeZqiwPhElmdM03wFNCWZYexnFmtpf/V8wempYbkp6Rpx+1BKHFeyPMW5WUApg8PmAizKq5zmKKi+/f2R1W1Fc+zJyzS6cgjoRNCSKdM8k+a5AIyKhLmfKdY5p4cTy+dLjo9nluuSvp0wCYSgBUCRWmk/lWdoU4sbZkE81j3r2wXbdwdWdxXNaSAvEubZE7zDWMv6bsmnv+sT9vdHbl9tOL/7j/jxb/0NvvOPK0z1L4I/CofUO1A96GfgHuTT70FlsebZg6ogNFFVsIT5BMkG3BlZaKObi3ohtBZ1CzRSJzVZ/F4p0asbwN4KktcsBZXLJDQd9wj6BfgtosmrIJz44d/+34OBz7+74H77Z3j7vQcWt+IBu34mKdg8lhXE+0AzTwI+uugku2FCJxo3OopVTr2tWd6tONwfWNwu6OuBJLX4EJiGUQAsUZ92nAWU5F3ApuJlubyt2L7ds36+5ryrqZbi24lRGDRTP2Iz6UNZEYE9mWXuZ/JlTr2XMXR4d2D1bEl3ljEUoquPySxumkkzAQGlWcrQj2SFgNUWNxX790dWdytBly4FoR8UGC1jKM0SnJ9lHAwCjnLjTLbIaI8d1U3J/v2B1e2S7txHswWi/6fFzZOAkubLGJ5JCvESrdYFx/sTqxdLjo811UqkDlFCK5r6kTQVOpsAq+YIznPkZUp76lncxvbvljSnLur9OmbnsFaAZFmeMo6zfF7mpd5RrgtOTyeWdxXHx5pyUzD3s4jOB3HNSfNEUPO5pMtN9GPOFhn9uZc+9HbP+vmS5tiRFynzdDEmEPMAheaf/x/+Ub75u75G7f6O3y51Q5NbpmHEZOJEYeOELfVFqTsluaUfBhabJcen8xW1V64uiNNEROkjalBbzTzKoA8B0bhcF7E+tOL8dGZ1JwMtW8iANEmCmzwml2PZXMyOQ3RPGXqpqZ72NTfPZZBUt7lMVhFhmmWC2rOZkWsyAkAJzlOtMppjw/r5gvrQsny2pDn3grztLwPSY3PLOMzkpUw2yiiS1DL2I+VqweHpLFScSJcZ2pGsTOXeZQY/Q5IaQUKmRhi03lMuM9pTy/r5ivO2YflsQXfqyUpB/iZpdPNING5yJLlhnl1EHGrGqA96OtRsXqxkwN+W9HUfJzOHThP86CMCeCbNbbShEoHwthZFnPOxZf18TXfuyNe5fDexTKPQidwsbiZjRKBqa0Qf+JkstLefbNi+O1C9+u9w3GdADf1/hkSQk7yyc6mFuo9qqDHbwKU2Osa/DTElMCNAoCjoHS6fMZX7cX2UwAdOqokpZcMHCs78oYaqLv6n0Upt+AW2D5bXn6XUw8+QVmIycEGei/m8TNA2MYQg9nrFMqM5tmxerDhvhWLRn3uSXMysbZ7i5gltNW6Sl043TygtNbO+HVjeVRy2JzbPlnTdIP2vk+c/D/O1nmlTLfc/s6gA8yz6s/WpZv1iwWl/Znm3oD93ZIssLipChTGJFauuPCE4jzEakxr6emCxKTluz6yfLTjtTyw3RUTvy9g1icHNYvM1T+L9qnwQDedVTntquH25jgvOQozAy5SxH9FGyzGsjRQteXHVVkea3Ei5rjhuT2yeV9SHmnKTX9HzLqJ1p0FclaZRaG5aKdw0Xfvw6tmC87Zm9WxBc2rJLu1bzTxL+x+/fGutSawseMvbpeA0XmyETrYuZA7JZL7RVn9w2RnlXopLZCCvUtpDy+bZZQyvaE8t+SqPKGV5MbCJwY3imDTNXowojGKaZ6pVwTxPX6d2/0HZ3OSi1qaXN7YYnY7DCEjND2MY+pFAEF5dcPjo3zlPE8F55tnhnCx40+hAi6YlKPpTh9KKoR3F/3R0zKO/1hJnJ16BU1SCcZNj7keI/pdozTTOGK2Z+gmcRKfj4EXvsnfM08w8z7hZND99CIz9jFKaoR9QWtPWHd7BNDnc6JmnkXma8ZNo986jaH/ixaM1eE8X/TenbsQrGDuRvPOzI8xBPCRnSc+N/cgYEczezeJZGAJjPxGAvh3wPghCcZJ/fnJy3pNcwzg40SPuJ/luN3H1YTWKoR3wLp7vIJ6l8yjnMEb90GmcccA0zoQg6Fyltejqzp5xGBi6kakXbeR5jvdjmMUj0s3yrLyTN3EteqEEor7xHJWXxGNyHuDx/Xdi6u5XouH2RynVEOknRCrMBV1LTKFdEbdpBNsaSfli4758SLVd6DPX4ymuwvhKSVrYxGOBfP/iNnOl0iQiAMFnhKB4eltR1/81uedRaGTsJ6m51z3KqCjlFu//HERrd54lteeDeFBO4j85tmP01hRv3b4ZUMYydD0BxdiNuMnHfw7XTbhJ7r2bZ+lL3YSPPrxa6egDKn7A3jvcJO250clzc+J3OcX+jCdygANt3Ur/P3eAZhonEQ+J5x4cTGPsA/3MNE7Mw0QI0qeVEpEB8eEUzMQ0iPKRcx43zUzzzDxJ35+mGR9/Hzw0dY9S0B5bfIC+Hwhz7Ldj9Cwdha8+T7L/NMwEJz8rJdgLAszDjHcw9D3z6HFOtInDLL7BbnS42aGc9H+P7KOUjD9UEI3wQVC68yj61OLHLPPYOE5xTDm6po/PUNSphk7q+NM0M7l4r/pRxtzkZByPco7zNEMIdKde0Lr7s3jItiN+DvTnXspnX9H29UL6JW5jP1KsSuZ5JitzfAgkpfgEJml6rbdJOsSz2CzkbfyZoPbWz5a09SguFeNMkqeE4MVrUAl69YJazKuMrh1Y3y057xs2dyv6uqdalvKmvcyjA4TUtxIrk+OlNjQOE4t1RXPuuHmxpjnWLO4WdI2gdt3syYqMoBDPxxBEHSW6fBSL/OqWcd7XrO5WtCcRWZjGmXwhdmNJmaAC2Fw4jsYIAjZMnsWNXP/6bkl9qKluF3TnTlDDUdQhhECap6DEr1BrJWjQImNoe0k37TtuXqwkol4vmIeZYlkQgiPLo9drLspCxpqr2XS1WlAfG+EwnhoWN0u5/lWBH8WiCe9JU0NwHpuJvZxRXN+U17eCFty8EOT1MopnFEtx9ciKDFQQC7e4n03Fw7VcF9THjpffesbx/sjzT29oDg35s/8ux+MdXTtD9yt84IeaSHG58Eb5aGH7uG56EXCIC92FBvMjC+BHx7hQZ6LX7If2onPM5djX9i8Lu9TcTu//Bq8/SwVk1//M9SUu+OjTqSDNLeqC2kw0KgRxDWlHNs/X1AfhUjbHhnJVMs+j2J4Fyd4EF0jTNF5qkDE0TixuKppjzeb5kvOupdxU9M0o1mxztAZE/DqDDySpudYt80XG0E5s4hhax4xOuSiYJ09RimVfWsh9SLM0+u2KH/A8TSzWcs7rZ0vOO+Fy9+0ozkNeHFgCRN9ScVwhiLJPXuX0zcj6+Yrm0LG+W9GdexbrinkQ1HLwYlkYAoIeVxqr7VX4YbGsaJuBm+cr6kNDdbu8Cqb42ZMXF/R4Jk80tdGbF2yeMAwjm2drGYfPpPxUrivGTlLb3vs4hwWyLMF7j1H6muWpNqXo5L5Y0xwa1ncLQe2uCtwYXZTiM9RBSyQZ/UyFby9c6nbfXrNiy9uliM4s82hrJ/ffpCbOoTr6sIqzTHtqWWwqmmP35U3uf9f29UL6JW42sTTHBmttRObB2MkbpiDuRtGwrTvSzHB6OpMvM3b3R0Htbs+kqaGJTiND3eMnLw4LvbhhjL2k2epdTV5k7O8PlOuS/dORpMhp9rUQlc9DfOubmGbHGN0gfPC05w6bJ+wfD+RVyu5+T7nIOT+dSDNLfWhBSdQbnDhLzKO83cvbpOa8rSlKUU0pVyWHxyNZkXHanTFW09U9wQVx8RhnXDczjxPOOdq6Q2dR63RZ8BTRu6fHE0mWCqpWXZwd5I3dDfJm3dXyNl3va4qq5PC4Z7Eu5B4uMprosNEc5XtDO8nb9hAj9lH0Wk2iOO5P5IuC7cOBoso4PRxJM0HtqngN3nmmUfSKXeTnuRBoz1Lv3T8eqVYl+/s9eZVy2p6xiaE9doT4rOfZ43rHOM5Ms2fsBkxiOW/PVJuKL379DavbBW8+u6dYFwz9yBdf/DHcqIC/DXNEPv0I/ST+/wJ0uSAffuRTfZT1jcAkH9EhXP4fgWUeiVghIkg+Ppj66Md4wAvUYr7n89888eu/lNOe1wT1e7Cp+O/6EKQPz04yJzFK7OoBtOK8O5NXCdt70UvdPxzIypT60KC1kWcNzP3M7GbGSZCbwSuao6B2948n8kXO7v2RYpVR784kWbz/SMQSnJNnGLV2+3YEpQR3UKTs7o9UNxWHp5OoCZ1alIGuHvCzOALNsyB3x27COXH/SXLD4elAsczYvttRLgtOD0ey3NKehYox1KJvPY/zVXO7bwZCEO5nUWXsH44Uy5zD44msSK8uMe25J3jE1WaeIz90ZPaOvhlJcsNxdyJbJIIeXsoYTrKE5iTI467uxJGll8h4Hhx9NwGK9tBSlBn7hz3FMmP//khWJpy2J2yi6c89wQeGRqLEeRCHqNk7wVtkluPTiXKZy/hbFxyfzthExhBK7pNzkqGZplHmoWHC+UC7b7CZ4fAo++4fj5SrgvPuhEkMzaGTCLYVhxfJwE344OmaHmsNh608s+bYRg/ar2b7eiH9EjeFRJxBexTimam16Lsao7BZcuWyeSd+hGiDMfIdpRXKXv4viEOdalGCsYJ4k/SFSJApozCZjcGExlodI1ZBioqWp7RtokGv9qJ/S5C3dGUVxhjZTxuMTTCJvPWJjiVAwFgN6hKVekxqmL27IuW00WLCbTRKGWnXShpSJwaVxP8Dxsp5mMRItJaYeJ8kWkALmMgHqSsqiOcHSRojjEz8NrUxVx3OoJD7Zw3WajFWNx+ewweD6QSthJertRLjZavRibxp6zTeeyX3XQWJJEXwRxNcEMWnj1DAEukatNEoKxGesRZtpQ1l5PkoH9DWxDq1RV3Qn7GfBC+pyKb/b1HXG2CC6d+Li1uPoGg/or8Ez9XK7OLMcnVwCQJQutRMg0cMvj+ur17oL5FmExSoi8vMhXbz0c8hCKKX2P78f0LrgFKeU/svxYg19mMF4dIfYxR2NayO94ygMInoL2tjxEheqw+yhDFIFmS69C+89F2tdHQjEX6vNhplNMZalJXxFJTcb5vEKC5AkkhWxySGoBQmsYQrXlXQ8Fc9YGsFJZtIvzZGo4NEdioItzoEpN9E/VoRf4rj2XxA7grQUK5fmUu70relMwWUNWhjJGmvFCbRMqa0yIOaRO6rtRpN5JbG8wrxhUrF8XOdfxIZBxgNRsabUgGdaNG7tVau1yqMTSRqNqKja4ycs0mkfystJQCdaHAem+ioJW1iuzLeVJQzleeqCFrmAW0Mxsr8YLNE0NQ23nFjIoDow37aRNS8lmelrYnjMRGueSb9xfNBi/yr2L5eSL/ELQTP4rYieKjWBdoaikVKmibY3JKVKUHB6tkSNzluPrmlO3XcfnpLXw9sXmzw40y5rjA22qhZTZKnpGUqdlxrcaLfvFjT1z03L9e09cCzT27pu4HlzRICLG8rbGLIFjk22j/liwxtNOtnYiJ+82JDdxy5/cYNfSOk5mkcWaxKlIZ8mWMTsS5L8wyTWLGvcoGblxumfuLZN27pmoGbVzeM3cj6bilmyptShAiWKWliSVMrQgcalnclYz9z82LDUA/cvryhbwZuXq2ZZzFZVkas2BJrSKtM2s8SipUYPS/vFnR1z+0nt3SNWHFN3cTqbinGz6sCbZRYsKWWJE9IiwydaKpNwTBOUYBB7KP6Wmy8xj5ev4JinWONIV+IjVqSZeTLHLRieVtdbey6ZuTmk4sV3UqAWOtKrOiWOWliSTJLVmbY1IjB+zSxerGmPrZ8+rs+4fh44pOfeEl76li/WONnx7b+C5z2BW3dw/AfIylXH1O14aNULFyVhdSFwoIsrEGBnz5EmxeOTgxEP9BpkJRwcEha+CP+SYAPBuOxXRzj8H9hmjpsGtgd/hCYFyg8Won4vNaaxaKI9nMFabz+YpkzTdECqx24fbmhPfbcvrqlb0YWNxUEsbOzVvpwliViRbgs0AaWz6prWrI9tdy8WsszfLGWlO+6wlpNuSxkAUoNSW5JM0O5LvEzbJ6v6OJzH5qR22/cMnQ96+cLlFKUG7FAzKuMxCZkhaWI43pxVzF0A7ffuKVvJ+6+Ied+82qDG6ONmVEUy2iFuMjJy4wktxQLsRHcPFswdNKHh37i7pM7hmZgcyfm8dVtiTaarEpIE0OWRxtBpeT625Hl3ZK+7rj9xg3TINaMbnYsbitQUKxLklRjs5QsT7GJJV/lOBe4ebGm70aefSLj7+6TW4ZWULJhnllsFjKHrQps7MPFSsbE4rZinj03r27pmo7bl2uGWsbSNIp5uDaaarPAJoaylGeYpFZ0xwksny0Y21ks4NqRu0+ineTdEucCi5uFWBGuSrGxKyxpkWDiPDhNM+vna/pzx90nd6JU9hVtXy+kX+JmE0NzbMlSS1NLRNDH1M7YinG09yJFZxIhTVfrQoQZNiXHxwNJkVyNsAWkAn3TCcpwFAPh1FrqCEM/3gsRfPdwoKhy6mNDYrQY4apAX8f0SBRUmH2gj+L2x92JvBKpsGpVUG+FoN7Gwr2koKSQ7yOIaewmtNY0h5Y0yowtNpXYOVUpp31Lkhrak6RW+1aAPkM34iYBDozdSFIKaTuLQhQiLn8U7c2DXH9XS81jbEZCECDJNEwC1DgLOvf0eKJY5xzvj+TLjPO+wabmum/fDJJi7EeIQIypH7GJod6eyKuM4+ORYlWwv5f0dHvq0VrRn3tQii5ew9SJ/ZNW+oqKPD2cqVbF1c6r3jUkqaU7x/R02wvgZpA0uZs8YytpsXZfU65LPv87b7h5vubd9+9FoP3pJPXgdM3f+fX/Mfdf5DTn32TsfhVJ0Ubu5kc81esCGeDKOQ1eAEOXRTZEjiiaq8zgNW0bV9YYUcriaQTlq9MP37nUY4dfxXfvef1Zym7/h+mGfxK0wqYJKkkkM4OSNGmQPhd8NKBuR4zWtMdOrOcejxTLjOPjgXyRSOkhNfICgfSXoGAYRtw44ZynPw3YNOG8O1MscilxbApOT2fSIhN5wsvznz1TMxLmwDw46X9WUodZmUp6sso5PBwpVzmnpxprtIByCAzdcAU6zdPM7N1VB/j0dKRcin1Zuco5Pkq5oK97QMXxrxjrHu8CUzczdhPGGJpjR5on0nernMO9pFiPu0bKI+dB7t25x4VwtRJ0zosecZFR7xsRlXh3oFrlnJ+OZGVOf5K+O9S9gHWGER9kDPvRoZWiPbakacL+vYhK7OMYqnctaZbSnkW44nItUz8JIGtyopmcWc7bE3lVxDmk5Ph0Ii+EtqOMoj23qIAYkAcBB86zgwDdsUOnmsPDiWIpJaZ8IfrhSSqi+CHIMfBeLByDABzHbsQkWiwpYx8q1+WXOr9/vH29kH6Jm80SkkQkwLIsJc1TTKJJCokEi1WOQky3RSJLopt8Wcqb4rLAJinaStrHJPIdm1qRWlOwvF2I9Fcpxyw3C6y1pHlKkhhsZjFRBsxmCTY15GWOUppyWQKBrBTpvWpVYJKEtBTj7iSXiOESwdrEkFU5OpVoWhGkswZEPs8YMfrWAmawVvYzsd00F0mvtBCQThUjvawq8B7yRYFODNmqwCQmSoCBjSbO1lqSIkUlRq7fwHKzkGhxVaC0oliXGKVIyxxjDUkqEmQ20XJdqSUrheuYRdm+vCoJQVOuK0DOw1pLXuXYxEr0kqYkmSXJDCZRAnzRUJQikpAvCzCWpBCBg2xZXGUMTSbHSAsxYbZFIlJzlexbrArCLBKI520jFnCJplqXJHlKVqbki4yszCjvfpoh/BGGLuH8+GvQ/+oHygrI4naJGK8qILGOKox6+V3wMcUbP6+SgB/VV4EfkQ28sOsvlBkdU8Lj98H9J/z631ryw89+P4/bfw6bJaR5Gg2wJXpJC0tWSDbFWDFZVyiWtwuU1pSrEqU1SSn3PS0SkjwlycXEPrGGrBSJPZsk6ADFskAZLc8fRbmWLEdaZGj01fw9i+bRWmvypfRVm0m0vrxZ4GJWQxuRe7SpZAx0NF43uUjxCThHyziwmnJRiLH7ukIrRbmqIAJnbGJJ47g01oi0ZqJFajDRZEUCyrO8XQCKciXjMl/mpLklqyR7kpWJlGyszB0mtRSLAhMNrVEIENCLzKFODfmyEBnRPJd0cGoEHJXE/mc0eZmhtJZ7qBTFpkJZTb6WMZwUKYm1pLn0YZsa0stnLqWUfJmLXGCe4ByUqwpttYzDxFz7gM0SyeKkck+M1WR5CsqzWBUoYHW3xKYJ5apEa01R5GRpIn2pSEgymRNkHFqUUpLpQ0zXQa7FWgHwqY/FLL7k7euF9Evc+lqcX9pajIunYQKlmIcJZcWJAQRKPo4DISiafUuaGM6PNUYbmlMrxOh+QqtIFYhUCa2hjRByEMCLVor62FCuCuooPdjXElFNgwOlGToRMejqHo1iGkaGfkRFKb0sSzg+nUWebddgrIA0lIKh6VFB6Ac2sQxtF9VTJMrQWuTwkjzltK9JUstQ95FDKHy/axTZDigQ0NEworWi2TUYozg+SvvNscMmRt7arZIImMDczyiEdhMiHL5vBpF62zVklVheJZkV94okYWgkKh7bAa3l+WijGHuRWYMg1lZWzLzTIqU5NGhr6LtB0M2dIwR5G7fGCh3BC91oaDrSLKXZN+R5xnlfk+aW7jyQWMsY7884TGglwCdlNGM34p0IUBwfT/TNwO7dgc3zlURHi4IxCrcPTc9s/3u8ef2PMw4K/P8Zxv/bRxxRH4PKKAVz8QXFxYjTS8pWXSR5LgAj92E/Zj7UTS/yTJc0bhJrsKJmQ/9LEP7vwEzf/hg//OF/m2kUgfi+HqJxQk/X9EI30ZqhE2nDoZsxVtE0Pc45pmGmrweKMpVMTp7FaNAIncFohlb4sPM0oayhayU6dPPM2ItBdnvqKZa58B8LWYDvPrm9CoS4MQoAOI+OmY7gHUM70J07ksRw3p7JipRm18pYrXtsKn1YorERpaQPhwBDMzAMIwroDi3FsuC4PWOsoT006MQw9TM2CpcoNOMwo7WmbTrcLIICQztiEyv9P0s57WrhndcD1opghDZWomJgaAe00jgnVB1tBDSUZZbTribJLe2+QVuh5hhrmPsZlGbsRAija7pIMRIJzSRLqA8deZly3NbYzNKdxLj7MoaFU2oY2hFlxLvUj0LraY4tSokJRlam1LH9jyPZoALjMGONjVkixOihGVAaml1DUsr1Z4VwS7VRjO2AUoIQ1lrTnnqZS7oBP80opWgPHcubBfWh+SqmeeDrhfTL3RSctieC87SnlqETB4W+HXCz6N9qozncH8jyjN3bHcUy4+HzJ5IyEXf7RIs+5eToanFhmMaZ7tgSvLgtmMSKPu0i5/HtjnyR8vCDB9I84fQgbjHdOWpbRn3OMHvpaCpw2p7Ji5TH11vKVc7j508UVc727Q6bGc77lmly9M0kLhBRH9fNntOToIJ3bw8UZcbT6y35KuPpi0eyMufwcCB4cZQZ+pGpGyNfc6Y+tgSlOD2eSfKEp9c7inXJ9s2eYpHx9GaHtZrzrmaeRrp6ECeK6KoREBcQYzWHmIZ9erOlXOY8fv5IWqTR0QKaYytI536M999THxtCUJy2NUlm2X6xo1jkPL3ZklYpT2+22Pgy4aaZ7tQxjiNhmOnOnThoPJ4ELfj+SLUoeHz9RLnKefjhA2mZcXg4ohGt5XEQhHDfDMwutu8dp11NWspzz1cZj6+3VOucz3/9DXmZ8/RuJy8bs3BvA3Ds/mW67g/FjvYG2r/6If36sVOLihKAZHGhTGVRVJGsri580o8cXoip4h+RCtSg0hiFZvK34a+D/08Y+oSHh3+M/fCvMHbC752H+IIxCvfSR0/OrEgZo8Zxc5S+eX46k6ZSFsiXOQ+fP5GV8hyyMuXwJE4r7akTJ5BuFs5nCDJJozg8nHj26R1+dHzzH/mUuZ/49KdeETxsXq2Z+on1szVFmVOtKjYv16RpQrEuOe8adBLbXxTShxcZj58/idbt4zmWYHrGYRS95brHuSki2onpdxlD2aLg8YePFFXB9t0+juFaEOKtuAHN40R7bAkoTo/ywrl9uyevcp5eP1EsMh5fP5HlKcenI4RAc+xEn7gbBEE+Bc47WSyO9yfSMuHp8y3lopC+VGVs3+ywqaXet4z9QHeWeWgaJulLQVFvG0xq2b4/UixyHn4o7W9fb8mXkuLWStGeOoZ+pG8G4bzOjvO+hqA4PZxJ8pTtmz1Z1PzOK/nZZla0pkdHf5YXq2mY6M+tuODsamxiOD/VpLmM+2Jd8PR6R1pJuUoBzbFnHGUO6iLnt7mMoYczaZHw9GZLsch4+1vvqb7C1K79ylr6/9PNZokgaBPNPIp/J0j9VMfUm80ss/NXs+9yVeBnkeQKs0enMqEJEjQiB5Ug2KyxBOdIM/EJLRc58+gjgMGRluIYYVKNnnTUC1WCBoz1L5sk0n6R4pwnX+S4WdJE3kFaWAiCKlZGY4ykTYzVmNRGTluCi6mlufcUi4Iwz2RVAUpho4yaScwH9GPMJMoxgoCvZuGczpOPrjOKJBferI6I28Qmcj5G3Fu8F2Ph4D1FleE9wlebvfiFqkCaWQYvaGNjxH/VaI3SgjzGB7JFip9ETtCNM0VViNxbnki5MImI0zhqjAGTyA9plBXMy4xp8lQr2TerJOVmo3ScsYKoTBIbOYgWY000Z84Jc4jG7o7FumSexODZzxJpKi1o1uADvf2TvHn/+6iS/zWbuwNM/yFM/ySUv1uiUW1Ez1RdapmXeudHwCSlf/RvXH4XxR605oNwA4Bmar/HeP550rwDFO8f/2Xevv2vo8IZ5zzKCFrzctyLvnKSpZSrCmXkGSpthIebWOFn5gl+lmd4uXfzOF95yya12FGMsAOQlzk3LwK3rzakecpiU1EsJR368ieeY/OEF998hpu8pASLFIP0xWJdsHm1Fu5qM5Ak4ibjvCMrM7wLwt+ePWmZEVAoHVAImjsoSJIUraT2bbIEFRRFKVzjfJEzTRPVSvpwmkkpRhvhLQsyFkHtx/6fFilunqVs4IPwJmdHVhby98TSz+4K3DJWEP+C1jf4WRxq5nkW3mYcw855QehrInJdY41kGrRR6NQSgifLLcyRLzvLNfhRpBJ9kDnE+yCoYQRNa40g0nWiCc5LiScIJzZ4Sf1e2ldGieuVFcQ8KLSN/Tl4TGbxQdqfevkMkyMphb9urWGag9TttRL0tIlMh9TgJk9aZAQlDk0/UqL4krevF9IvcXMuYI0WfKMXMfWgAloJZcJE2kuSJAI71wY3e6y1kQ5j8F6Es0MEdug4+RtjcE7k7mbnsUmKm6Vze+eucoDaxBJYFF9Q8VNkzWRC1sbgvUdb6Yxi3jtjrYjP6zjpKiW0Ga+kfR8F4p2TNK+fxGBZfhb5M3UBqmg5/4tAOBcxhCCD28VU8RQ/53mW85tF/Qel4kuIEr0AayB4MWVGJqh5nrFWdEltZhkvpsFogvdCpYmoVO8dWhuUJ16/Q+s4oSdW7k+cHHSkDyitZfENQmvwF4H+eA/d5EmsIcxyb/3sMMri0YJe1SbSaFSk8sh5GWtxXn6W+2DYvj8IGvrVOtId5D7qqAyutWJoA693f5DN7beZxj/HarMjK/6v0P4/gP8mFAs+iNj/XYulhKvyT30041wXQD7aL37f1TD971B0mAS6bsGbd3+Cx8c/wPFhJ6lDI31YaaHuaK0jXUGJ5Rwh3o0olB773aX/zbNQqJxzJGk0vo90DzktobDcvFizvFmwWBcUywJjk6thwTzJYjgNIlw+jzNaqShoLtQJHWkVNrEx7TsDiqGL6c8ogzc7jzUaQyAYg7GSgjVa40JAWxsz3yL7p1Mrn0ZMIow1+MlH2o48b20M6Lgv8ty985jL+E+ixm0qIgvaKAhKxp0114XUh9in54DWhjl4Gfezx1o5VpJEapWRfi8vOTou4jK/WKPxo0cpwzhPIr83y0vfPDmRAfVe9tfynIwx13upLv3fObkvLsoQxlR+mB3WRjAcCqO0vJAYA0749sEFjBahExP7g02MzAdGbN5Qcs6gsFroR0rHoMJaXBCN76kfWd4uaZv+t3E2/3+/fZ3a/RI3Y5SIqgeFm6JMV5T7897FmoWlrwWtV58a0iKR2lqZUR8b0tQy9TMheHFAcV6k+MYRrVREqwkqtKgSEQIvhIielgn9eSBoqSG62eOcF0caFZinGWU1Uz+QZVKXyhcZ50NLVuacdw1JbkXC0EWZMCeOMvM0gw9SKzJSZ5LaSkNeSX0wLzP6uiWYi/yYk3OYfURsSn1l7EayIuN8bCgWWRSXEIHwJLX03SDtT1E+cRa5MKlVjiKY3/Tkefah/V1NUWZ0xxaUEMAv0nF+FueZaRjxyDUkaUJ3akmKgvOhIc0FAZlG/dbgfZRIm3FejgNS3zVG0587kjThdGhJq5TzoSYpUtpjgzYwDiKxOEeUo5+8SCgGkXtMUk13bq+2bW5yvP7um1jr62iOLU9vdvjwwQFHcEGBpvkGn33+l9hu/wD7bcrQdzTn/yN0Pwf9r3zE9fTyqYKAj5yHMEZKS+Sdhsv/43e9h2nH7ov/A6f7v8px39HVMA4rvvfFX+Z4/CcYu4Hdu73UeoOXINaLG4/7yEnFz1KHdUGe/zyLzOLUj5jU0J068jKh3rekecp5exKh8npAaSVR+qqkWBRsnq8plhnTOKGMYmg6Qbo+niQt+WZHtcqvAgFjL7KA0zhJ/3E+ijmIIMbq2ZI0T7n9xg3Bi2pPvTuRF4mUEZTCj1Febxa0vXIeN04is9kN2CyhOTTYPKM59CSJ5bytsZnUVp3z+Bn8LCpPc0Qcz8NE0Jq+EQH25tgIAv2pJl/kdKcOlYjs4By1sf0s3rTzOMv47keyRMQrskrQ6lkhx0jyhKGPcqOD9GEfArObUSA1+0zGUFHI+E8LwRgI4lnqxG6K43eUeUzkFOVYUz+RRfEUmyc0h5asTOIxUvpGOMkiU3qZCxwgmAVjDEMrmtbnuO9pV1MsUtpzg0nUVcDDx7koROlERWDsBnlmh4a8zNi/O7CI4MGvYvs6Iv0St+CDpEWcuIBMg6RihawsyMPgxallqEeRk6sHVpELtlhXInZeSMrLJFEYALBRHi3NJf2RLXLaemCxqWjrnsXNQsTeFzl+im4so7xdSiQYI4TZk+YpfSdSZM2xY7GpGJqexWYRJ3mRU7PWoiLR2yYJaEWaJuBCNOUdWG4quth+1/TkixI/eBH3bjxJKu1LujcFD0kqA311s6A9DFFWrWdxU0X3G5GGs6kVcrox2ERSUzazkv6qxNh7Edtf3y6v1x8mkSSjG4WUHsnhIrUoiNypF77uUHdUq4IxHmtoR5GVu8oJGqyW9CLwQYC9yhiHgeWmpG8GljcLpnaU1FoUqveTEwRlIuk4m4hBepolTMNMta7om57l3ZKu6VisF3THjmpV0pw6tFZsnq8lersIP+hLlKN5v/vTNIeWb336v6A5fMG3f0+DD3+Lgr8F5MAnkPxjoAtExMF+FJhGBC9CRWgPv4jrv8tycwJmps5yaDK6ZolZ/U95elxSrAq0nkWzPvZ3OZ9L9sFfgcMX6zBiZgaFlAiMJo33v9qUdOeRxaZk6Aaqm4qhGcmrnCSz5AvDzYsb8jLhuKuvEWWYA1mV09U9Ny83tMeWm0+iOfhzkYrMygyR9ROxd5MYSe8bQ1qIqcJis2B2jn/4D3yb/bsDz3/8GWMzxjEsoiNmFJGNi6iGSaSkkOYpYy/jb6h7FpuSsZ9Y3lZMwxSlAMGmQj3ScfypKIyCk3JM1w4s1hVdI05BfTNIirkXkf15lvKMtiJMYpJYWikyicQ2Fd2xZ7mpGNqB6qZkbEfSPBG7tFTOH62wVurnSSrZk2JZ0DcDq5vFdd+pHyiWJfPkSFIpgYghuYiZ2ESkRtMipe9HqvWCoZFn2Dcj1UYkMtMiI+BJUkFMS3nHxHNPmb2PY3iSazj1Mh+ce6plxTR4bGqYh4CJJSa0lEiC9ySZyAtWazFnL1c5QzN8ZXP91wvpl7hlRYpJPtRH8kWONlIrUgrKlQBAimUuKaxEkxcZYztRLkXfMysz+qYnqwQyfqnXlcuMEBTFMsG5QF6mGGOj3mTOME6xTlqTVqnUXBYC2U/LhGCU0A+0wOBRAa1lQpiGiXyZM41yHs25u2py5qW4eGRlCijydQ4+6l9eNEuLjLGbKJcl83Qiq1LcIC8MSkNaid5wuRD6SbnJBCiaxEE1x2voJvIql0itiDSTSsTX80omxnKZEwLkZRLrpYG0SsXSrcrEDq0US7lkkcn15wneB4pVhtBPRMM0NZY0FZeZtEzookZuOHdS47GKvEzBGrJSiPDlMscD1bIQn0ilo+7vRFblTJNYqM3DhEmE/pJlKRq5/0EFskocfEwu9cJ56igXJWN/ZnFT0beCpFTA4mZBklkWtwv87Fi+WnN6PHPzakNzaFneLaj5N+lMy8Pj/5Lh/H2++VNbQujx/vtY8/2IITJMoyYvFFpLavt0VGxuBL2snGboDcUM3m+Y1af44l9k8r8Lk6TcvHSM/Ug3TleLv74TXWZttYgW5AlpLrQFgOAzbJqQ5SkKJdrJBLIqwQepvZmojJWXOVMv9nvTNPPJT71i6saorBPLFLEIZqykc4uFZG8uiN3lRrSTs3VJu2+jVmy4ipmHEOTVYXbky5zuNJBXOUM78PInn1PvG077hnGe5GUq6tyaxJAWopmbLeRa8kUKQaGNjKF5nsmrhKEfRYe6GdGplCfyQqhbWSU0sGKRE/BkNkPF8kdR5oy91OunaSIrJM2dFSnaWrIiB6UoV6KZWyxSSSgYJVQULzXmsR/JFxl9M2ASg7FC3TJGkVeiWVssYg22SCQlj9Dppl7wCuMgc4kbZ5LSCiWoELu+fJHGuU7mJZuaq8tOUV7mgULQ0FF9LK9SlBVhCaVkHvDRvenC4soXkkUoqpzTWIv70+hIq1TazzO571UGSlEsU8E5VJm8XFX5V+pH+nVq90ve3Oixhb1y4xWQZEZqAolYcF2AQ372mCgEbbNE3mTzJFIBNSEISCZIpR/nHcZcBMVB6SACAdrgBrEtc16ANgoiuZ4P9bvomSkDSONcIMm0iHtHEWybWFQQ8+BrjVaBSRTOSU3SRxCKMRY3+asHqc1jzScVgIEyQso30ZTXpAYXnZGDDqACiVVij5WKCHWaW6krx9rOxQjZRA/KJBOJQG0sypqrj6JMOuKnmmby9qxRUag8QaPQNrnWc6XmC8oosbjLE9wsvpLe+asEndYihZZkBjc7tE3i5Aw62mLZ1DCPE2kudaI0S0HL/QkRtEEQ8Jh41WYSyQE6EdCITqXW23cjh/vj1aPzAjiyqZV7Ga/ZWKm/2wtvNk3p9f+MPvm3eXf8D3l6+mfZPXyDx/cbnLMMvQImnt555qkTJ5wAp13GOJTM4RP2p3+Gt4d/h7fH/w277n9OsL/vqtngfaA59uzfHzk+nChWOVop8kp4hTYVMNWFA2zSBBs5iDoVoFtSJDAH0txitYCelFIMnbw4iNVgigoS+YMsRJ4oUj9L/wzIImzzhHmeozfuTFZIpiPNU3xw0bg73ncPaS6Lo03tlT9rrDj5yAulLOQqRGEJdMxEfADPZWmCC0Giay0lHJNYpsGR5JksPlki5xwjMZ2K2YNNjdiYZck1aldaR3yAuDHZTEfrP6mn2igraC4ARG2kVmtkfBHr0lM/k5Zi22azFD+LJKEKco99EJCP8w6bJbFtGWPTJB6o4zBFf1N/tbpT2kTpQ5lLpEYsYD8VxMlGK0nDJkXC7OaIeZD7r5SWiJQ4hr1E+j46d18xFqmkktPcynyUywuDYATiGEJkBX3MkGmlIy5EMfTT9aXsq9i+jki/xG2eRBps6mbyKsUdO3nwoSWJk7wxEt2dHk+sn684Pp64+WTD6enM+vlS/CwXF/RiTntuWWSZmAVniWhq9oHFTcnu/YGbVxvO+5r18xXtoWe5LhmaiazK6OqeLEtofCDLM8ZxIrFG4PnnkfWzFfX2zM0nG45PtRgX1x3FsmTqRtIbSZ8lqaHvhJxuE8PUQbERNZfNyxXHp5rNqw31tmZxUzL189UrMssSmoDUXqOfaV6mnB7PrF+sOF2uf3ti/WxFW/cUi4JpFERyV0stqqt7iYKVMDLKZcru/sTqbilerM9XnHcty5vymh7s244kT2hPvSAEhxGi7uq5rlk/W3O4P/DsGzecns5snouvaLEsmPpRopazx2aWth0oIiI4+EBSyvWvnsd7+I0bjtta/EybgSxG+lmR057AFoa5mSN6OTCOE8vbBcftmdtPbjhvT9y8WvPmN9+TJIb21FEuctpThzGG9ij19N27PUppdu8PKK3EceRmQVd3GGvom4GhUyTpf5+27ljeVPzgb51ZrAqmqSFPvgcLw/375/TNmsUmgf0Z729pzh25y6S2G4FjzbETrvChAS42YtECzXumbkSbgrEfYx1wZk4EZX1xgcHJPRz6EZNJmWOeRtbPl+ze7bn9xobD44nNqw1JavnJ7/wYIFKa0zRTlhl4QTeneco8zrz8yZc8fP7Aj//ub/LFb7zl2//oN3l8u+XTn3pFV7fcvJLaZ7UqIs9UshHWikTfeV/z6tuvePfZO37y9/447z57zzd/z49x//0HvvXT3+T9Z+9JS/HqNIkAfdJcFnujFUlmOO96cX3ZihfnaVuzer6iP/US4Y2OaiV91yaWHkWaSabHORFm2L0/snm+4nRouPlkTb0XJ5N5FER41/SUmaU5ePE1VWAmQc2fto346D5I3zk9nFm9WNKdOoplJubc64IuevP2QJamKC2LWLHI2D8euXm14fB45ubVWnyFbyvGTuaQoRtJUkmnmsQQ8PhZWAld7Vg/W17nsOPTWZxkTj3FshQU8UIifpPYOG4EsawC5IuU/cOJ9fM1p6eam0/WnPex/XaQenkzkOYJzRFUogndKMIrieZcz6xfLDm8P7J5uaY+1Dz/9PYrmeu/jki/xE0nhvP2FCegnmmeGboxevU5mrOIGRwfj6RFyuMb4ZHe//CRxU3B/v1BCP6HjnlytOeeeRgZxzHKBXqaU4dNLPv3B6pVxdMPnyhXhfBKo4OMVtCeOuZxpIs81HmeaU8iNXZ4rLFpwtMXO4pVwcMXT1Trgt3bPSZJOD2dcTi6c8/UD4zDTHcWJ5TTrgEbnVuqnMcfPrG4WbB7vSWvCk7bGmOQcx/Fz3QcpsiF7Qnec4gybtsoq/f4+RPlumT3bkeaioNMiA4T0yQ+h2M/4mdHc2hxSrF7L5KIT188UW0qnl5vKZYlh8cTGKiPLdMoXqBDP+CmmfY8oEF4nKlw0KrbiocvHilWBU9vduSluG94An09Mo6OeXRM7cDsndQujeL0dKJcFezfHahuSp4+fxST9G2Ntorm3DFNIjgwdCPT4EQIIHhxDkkM+/sD1TLn/gcPLDcVj693pKnl+HgkOM9pX+OmWcAVw0RAADjaqOtLmZtEuWiOnyFEX8wQ8E5yIm5y4qHaaUb303z/uz/FNN4xDY5pNDy+keh4nmbxA/UB730UPnAooI18VoIiaCHqYxTjNBG8kza9B08EyAW8i+CSwTH1wifGRz51aoQ/uKp4+METy9uK7RdPvPjWc9pmREc+tZ/FLWgexb2nO3f44Nm922Fzw7vP3pHfpvzg1z8nu0l5/4N7sjzl8HjCOS/9ZRbhge4kvNDm2GJTy/79nuXtkte//obVsxVvfuMtL771TFyPtKI59eIP2s1M3cQ0RecaBadtTZon8RpKnt48Uaxzdu/36NRy3jVRNKQXWbxxYoyOUOd9jUksh/sji3XB09sd1aZi92ZHuSw5bc8oHWhOA37yMob6iXlyNKeGEAKnbU2Wp9JnV8KFrTYFu3d7ATDuGgjChZ0GcX65+O+2B5HvOz7VlMuK7estq7sFj1/IGNrfn0EFmn3DPEzC5R3EX7Y99eA9511Nmlke324pVyWPnz+x2JRs3+7Iq4TmWOOdpz330Vd4ZmoH3CS/U1pxuK8pFjnb11uq24Xw2Zclh4cTxmraY4+bHX3koeJkHgoucN43JFkiHPRlweMXTyxvFl/ZXP91RPolbqenE/PkOe/OmMSIZqjRnKPix/mpxr5Y0hyEjze0I/15wE+O4+OZaZg5PhzF5Ll2LG/gtGvIy5zz0/mqgLJ5tqQ59uiYljkfWuZh4vh0Yh5nTlGrs2k6WRh3Z7Iqpd7VaFNR7zuWlPRNT31ImLuJ867Bec95e8I5R7MfKZcl54MAN+pdQ5rLBLG8rWgOHQrFOM6ct2fcNHPaHRn7idNTjTbmauR83tcR2dtINLyrYS0mvcYapn7i9NTghpn90wE3ec7bhnJT0hw7siy5iijU+zPLmwXtaUAFxdQ76v0ZPzsOj0fc7Dlva4yx9O0gxO+dtH96OmONptm3cFPQ1yNJ1jD1M/W+xU8zx8eziGdsa/JFQXdqyXJp3+ayyK6eiQfqRcv0vG2ZJml3GmbqXS3qK/WAea6o94IsPj7VWCvartWmoj1KFDlNM8enmuAc+4cjQz/zvV/5oaRNUaRlytPbHdpo9g9H8aDd1azuFhweThKZHpqIchZ06up2ye7dDpNonl4/keYJj19sefbpLcenk+z7eIIg/dVaTVv30WLO0p5aAkSRDstv/mefsXmx5OGLHcubklMjoKzu2BG8TLr71NKee0zdkxYC2HKTkwUWoYeBktT4peIZQhQyz3nx48+Yh5k0sfjRSWkkiBPL0E+M6cy5P7OfDmITlnvCoGEI6EzxW+/BdY7furf0p4lv2Jc8t89JQkoChEgnGc8dmc1xk4t1RIOfHGmZMnWiQ/3skxvaZuDzX38tL8gf9aGbFyvOe1nQhnqkyVsRLdnKwn/anXCzZ2h72Ihfb5olHB5rdJZw3rYsbqE5dqigGdqZendmGh3HpyPTMFHvWqw11KcWjOa8E3TqedtiXxjqXYPfQH+WaHPqpQ+5YebwcMLNM8enkXJViv5zllDv6rjItixvxAtXBUXfTJy2DW6cOT4eCPPMeddgtKZrBtCa+tCRLXJOjyd0jFwXq8BQTzSJvDSctg1udhweT4y9Y+xqwVwcOrIs5bRrSHPJRm1erujqFqUDQztSP9XM3nN8POBGx/HphFaGrhXN4NNesB/1oRMFtm1NuSno6gGjRYlNXia/mk2FcDES/HoDOJ1OrNdrjscjq9Xq/6dj/fk/8b+iPXeRHI/k9o2i7yfyPGEchKs1jXNEzgWpLw6OrEiuNTGRQZVaqnNO6kftJGa6swx+N3pMJrXRJNYVlDWi2xp5gSHysIZ+wFp7JdlP40ySJ6I+k8hCli4y5lGcO0LUQNeI+IExiqGfSRLDOMwkhcUNDmN1NACXa0sye42GLgXii1SgsUp4p9frF1SxjcdKyyRGUD5S2BQqqNi+EYmyxETEqkRkMoFICmoaZkwqtWhQhMi5M9owTtK+mwLGKNwcsIl8msQwDxNJmQiANVJMBOCCgGKivKHUcT3GygKeFglTPwlgapjJCqkzewXKiy2VRjHNDmu0RJOJfNr0wqWVumpWJsyDE94fxBpS4Pf/kd/HPMyY1NI3vYhHzLJglsuC875heVNRH1sBcTgf61MGpYPUzrKEqZuwhb2m2Wxi6JqB1e0ilhVWdFHaEQSRe+Heutnz2X/+g1gnvNTmA0WV0Rxa1i9W7O+P3H6ypj22YoCuoFpXrO8W/MYvfsbtyxt27/Ys7iqRUEylFmeiDN63f99PXK3H/OQxqWYKM+3Q8Z53NIeOZGW5f3iPLwJ2sngCVS6oTbNUhB4mNzEHkZM0xvCiek7X9pTLnJfjK+6e3TKfpf8HL5SwvMqu914rIqdb0547fuMXPsNayzRNcdw5tFXMo9Ra/SzI9LEbyZeSzpUbKDgD5SUtbIyS8Z/IczfWSD/IDa6fSYtUsgyplvZjPzXRPnDoxsg3j/0/YhPc4NCpESGDPME7eT4+YhG0kjFkrUgVmojYxYh0YpKKcEhSpHLfE6EwXQyCiIjlsROjh3m89FnZd4oCJlPvRFAjyvYF7yBotCViChRjN0u/nwXNPkd0+zw6ktwwD44kM3EO8QQvdnc2kbKATeRctdH4WZDMfvaY1DIPI//yv/kv8hO/+5v/lefv/2/Wgq9Tu1/mphXTOKOtLCBzBA/N/YzNEoZuIC0Txoh2PEcOVHcWF4ym7iJZW3hrNhWycZIlwv2M6NRikdM3HcUipTm1VOuS5thSlNIWCGF76mMn7wRRWO8asjKidEvZN19lNHVPlotGriyGwnu0qRauV5Ewtj1ZmTJPE2WVCV3hVtrNl4XUMKuUsRMPSx0XjixLGNtYs+zkcxoErt42PdWiEI3UKqM5tgLImr0sMqmRe1YkjMNIVqQM7UBeZgwRYds1PeUyoz13FFUqLitGBAymUQBYQ9NHdLQsRH3dkVUJbdQobk995PF28lLiXBROMAyxRjuPHyKWIqIjs1IcKopVRl93JEVG341oDWiY++n/yd6fxey6rWl52DW6t/26v5ndanbtDbULqly0BtlBOBDFcGz7JJGPiHISGZAQB3YcDkKkmJJsi/gAi6PIIlJAthRikBIRlwOUwYBdxqIKCqjdrb2aOefff+3bv2OMHDzj/9YG24oUsxcqst7S1F97zfl/7XhH8zz3fd3SGzx1FLW89rzMmIYx+eV6ef5TR1Hn0h+ucmbvQUVs7vj0H3whJcVjx2KzoDu2FCmGS3qNMjmbZ2GZ1UmxnXPaiqr3uG2oLiraY8fiYsk8zWdRjzZJzZrKsCHKxq1ve5YXC774zlumfmAaRqpFwdQPFHWZRDsJrJAWf9l/JNGMk02d2GJiKvdKrNuUPpfu2LB5fUEAlhcV29sdq8sF+90BnRt++ebv8SuHX+HT42c8np54HJ9ouo5oQA+Gy4sLuruB65eXxLeKixcXqJ3h5fULYgdVVnFzuGHbP/HUbvl7j7/Cd9rvcHu4RZcS7L26XHD/+ROL6wVP73YsLxaJmZwRAxRVxupSrCVFmdOnn2M/Uq9ELVwscrpmwOYZ/VHuoRiRhaKw0qvPHUM3UpSOsZPvf+wGqmUhuoRVLuNgIVoGH2XBHtpBwCX9TLnIGNIYHjtR53anjuWqoj10FKuC9tQKOcxLid3msoDaQuafonR0zUC9LM6v47jvqBY5x12DqzPGboSUozp1I5lzjP2Eq+T+yip5rHyR0Z16uZcPDVlhaI/tWTAVEkBlaHuyspB7pszltVcF/aknX4iPtloWdMdOFPCNlNaN0fgQsZkIMfMqO1trhq6nWGY0x1b64Eex731lU/1X9kz//3gFSWWYh6R6S9SYmMKbrRXFrSsyxuR96rtRBkgzUtelDNjciTLRGaF5JOUmQdSRc/KaDs1EvSzp24FqVdE1Msj9FBLeLgVPa0QBXMipz1jNNIiYYTiNVHXB1PvkyZJFH52UiSrxWJ+9aOkE5YqM/ii+yfbUUy2lVJqVuexsjYQGBxJ9LqkEfZiTGVtujK6RxWRoZIMwduLBC4mWo7U5k3c0JLJSJCsyutNAUef0TZLcJ5GR9pDlGVorjBEvKkhwcEhosmmMZHVBf+goFzm+mykXYmOxmUuLTArqViT7BWijmGYJNB76mWKRMTYT5bJkaAbKuiRMEp4c4axa9M9MeURFPQ6ecpHTnQaqKj9Pbn3T4zI5HTtnaffdGcYdJfVYQqBR56pF8NLXfP6cwhzS3wmqT6WgaaLiuSAVQyTEAFEnuFFSRz7zdqOczE67hsM+Pf8zgy1IP9Z7SZLxIZ7/TmuVAp3N2XaikZOmMTZZJuRkUSwqtIaf+m2/jmbfsXmzZvd45If8kL/+/q9zH+94Gp9w2uKcYaFrltWCjV1T1AIjWFzX7LdHVi+WjLuBizcr+sPI5WpDJFCVFVfFlaTGOcVpaPjh/Bl/d/crqAq2TweuXq9ptycuP9hw3DbUa/GC2sywvl6xuF6InzoFyIcYzif6PNmmiup5gySBAzZzKb1OoTES3J4Qjc80Jls6utNAVsvYrVZSqqzqAmb5/tEKY8yZdvZMgTLWMLVil2lPYpfrj8M58MA4Q5jn8/f/PP4j4sWcRtlkD/3EYlXQt7IxmJpRxvAYzijPZzSfVAySmyDPmEex64mNKGfqJpbrWsrzRSZKXWNS4HaQ16Fl/gneU1Q5YzMlu85IsShlgaxzeX4rpLEzJS1Vh9CiVh+7mbIuaI4SWnDafZ1H+s/ElRUusVMz+k6M1VM/sbxY0Hd9KkFOOCeYK2M0ee6wWoJ/Y4xUS2Fm5qWcfqo0uWZVztAP5LmUd2zmsIlBKibtQFkXkLiX8zBTryqG0yA/e7nZ/Sz2AJXKri4Tq0xeOfHXVRn4SJ7Lrrtal8z9SL2qpOeYy7+zLi0yGopkKyhqAS7ki4J5mqhXFfM4Uy0LpnairEu5yUoHBlxmRQk4J19qhGpZprJlwTzOlMucoemp1zXdKGXceZ6wmcVZi9EGkwu7s6hywfXlohCuFoXs+lcyuchJUkp5AC63mEy+i6x0aK0ol8I9NZmVU9iqZOqmVL4ayauC6D1FXUpsXSZRURHx9sYorNZ5DvL+++n8OpabmqkXs7xgziR2DaUoyxyiIq8Log+4Uk4GZfLkzbPn7tN7Ll9s6NpB2L6zfMcxBvJKNg4oCWSf+kkUxbuGy1eiin71jSuaXSPgj16AIH6STZGxhiyX0OTgJTf09rN7qlWCRlwsaI+DGO77ibwqhI+bi03BWoNKGamucIRZTrZaKUwpJX9TWLQVLqpEbYk/cRxGylXJ9x9/wK9O/4Db/o7b+Y5IZF2sucwvya1EndW6ZlHU+Clwsbyg9wOb5YbTeKJeLBjaifVqKaV1DQ5LMJ7aleig8CoQdWB0A7/89Pf4PHzKMEzkC9nElssCH74sOdYXAk2p6oKhl0rSNM1Ya9AaMutwTlCQYtkR/3acPUWRMY0T9UXN1A1US7mHioX4W601WKvlcQpH9Il7m7jD0zBRLUqGdqRcyomuTJ+7RBOSvOZSkRDvaaSqc0KI1OuaeZqpFgJaqBfyHrLSEbyX8WusgBaKFAdYZcmT6s7Ah6EbKBcFUyMnaD9NZGnMOyvxdMpoXCWe7LzIxMpWOsZB5p+pl/lg7EaxGs2z8MCN8INdljynpTB7q/Q5V8uCsZENwtRPFIuSqZ2xieGtrZZNaxQf/1d1fb2Q/hgvHwNRR6YEQD/tTud4n2ohpZu8FFC2sYppmjFWM0wTSinGaRYGqzP0TU+5kvLv8mx+zxlTb+I5VmqePSaTU6KcPCPTLP2K/dORYi19tGopMnhbyGRvMydRYkYzzjMxPb/0YKDresqVhOwWq4L20EovafIC+548xonSU3pGHpLRP0xzCghvqVYlx62UnYZuIK9y/OxxqVdqnWFKveFpmuTE7DRd20vI7+5EdVHT7BqqKpOFKMvkeZ1iHCeskVKSMnJaCD6IMGonz9/sG8qVWBmKZPR2ybfnEqMXpQSNmIg80yg75OPuRJnoSXktNiTjHPMkqMQpRVnNvQSez16whi63NPsT5UXJad+yWNWcUhnQh4C1Gt9POCs+VoxiGkfx9iiYh4liWXJI4qYf/r3PUU7x+Xe+AOKZ3RtiRKX3D6BSbNniouJwf+DFx1fcvXvi8s0F9++eWF4thevq5HSOSfzd9Lz7xwP9seP203tCDBy3Ry6u1+yfjiyvavpWym/P7ORATCctJeAHA2EUaL9SoDOLUUayQZUijCIuihEy59BGc7u95fP+cz65/5TP+89xg2PllmShII8FucoYp4ncZ/TzyBxm8lAQ7Ew1VHjjyfsCbyZUD8ZawhQFb+k18xQoTInBME4jsYOgItvjlrvxju/ff8IpHunbQXr6zZCY1Jqnd1up+jTPbYEel2eEKJ7KYZbxIPoH6aWGGFFW0zUdZV1yeBJxmXz/Uh61iZH7LDYz6ZSorU7q7Jm8KmiOLYuLimPCebZNmypLwhWephltLOMovs15nogEtJWYMumjHylXFad9Q1mKX9bmAkJRVok/VyMnWS3ajeCV3H/7huWmotk1lKtKYC1pIdRG40NAW4kKBJnTxH+qzpuG4/ZEtao5Hlpp7cziV50nj8nsl9qRQR5zDp5pnsmLjObQsbis5bWvBBaTVY75me87TOJxH6dzQMhXcX0tNvrHrn+SYqN/73/9H4rUfPQp4SGcs/RQIQlfnkU7cuoc+5Esk1NeVjr6bkrg+4Ax9txX0kadFx7Z7Wf0TSenn0F2qGM67U7jiHWZwM6NTotsxCgBB8jEO1OURSpLFYzjQFGUDMOAeYZqWynn4iV/0M8zLsvEj5qL0CerchH8pN23zWUna539spybxAtGy8JjC8fYp15nM+JKef+C/ZrIciNiCqsJEfkco2KcZ3LnEgRB0bczZZ2JCT+XRBvnTHp+RyBgjYCwI1IWEii3FgJSnsRCRZZSX+T7MKm0LEb+gELwd5OX3fbYjZL72k7y/AkGMKWSuwgzXIICmIRqlPL6PIthXTym+XmCHoeJosySsVxCDpRWLC9rEbvMPpVDC4wxlMuS9XUt4cq1EGVcJQKaZ8AByb7ikpp2fb1ke7tneblg6IR3+pyPioLu2HN8EvV4SAsJqS3hpzkRgUr64yDoQyOq8bKSyXLzYk2b/KzGalZXK+pNxQ/+zqcsNzXNqcc6KW3mdU5eOKKJ/B3zS/S3I9V1zmnfslqscNFQZCXH7shiVeF3oJcwNyKI2U8HqrlkqkfYGrIXmvFpRi819JFgYWlrgg3QgV0Y7h4e2WzWqEnRuY5T3zAfPOYS7N7xL//U/5zxJK2W4CNjP7C/PxIVNLsGYqTZdYyjnMiGNvUp21ESTM6b3Fm8p7NsNnzqP0eQezezjIMkOA39eL538rJgHie01WmzI/eQiGu8hGI4ncRnIvwrUlsoLzOmaSIrhEcsQRUSkBFiIEZkkzn7LyH5uWHoZAz33UxROOZJ3sMwzjiTKl5GMU0htZb0WTQ19ZNAMNqJYiELdFbIPPRcvs+cY5wnjJa5bJpnOamn9zC0I2XSTbjcMY1S/Rn7CasNQZHEVbJhVVEnMIdmnAJFaRmO8p39L/63/yq/7jf9xFeyFnx9Iv0xXlrLpKTSwB+6AWVkZ2ato+8HXG7pTj1FnXF4OlKuCnZPB4p1maDpwpKV1JQU/JsZTvtGwAhNj8ks+4c92SJn93BIsO5jghD0iYoUGEcJ7x7TwtY1Pbaw0uyvc3aPR+p1yfZ+y3Kz5LA9kqWbKaa0jO7YY9Lz2tzRNr3g9I49xUKk7PWqZP94SH2aDuPE4jCmXaL8N3l+V1i6Y0dVFezuT5TrksPDkaIuOW1PIljqJ1E9qiS2yCzNqSPLHF3Xk5WG9jBQLcVSUq1KDtsTRZHRJZ9tSNB5tJLYrMwxdNNZ9FXVAjsolgX7+z3lqpBg5KTEDUiPse8llL3relzuzpDu076lWsrnXl1U7J8OIv7aNinlx5+pL+MwgDF0nQS/981AsZTTdn1RsX/Ys7is2T8dz8KqEKQ3NE+J65vKikM7MA4jh6cjh8eG7c0WFIzjxDTM54AA5wzNoaOsJYygXBbs7o6Uy4Lj01Hey1ECnp9utuxu9zy+fSKicJmkcjyXwp9V0cVC+sCCfpO0tZgU1toKrcZaCQS3KeZOKdk8zH5mGkZikHDqosi4i/f8/fD3uf30nmZ1wN/B9YcXmM6QLZI4L8+ZxsDIwDhNqIuIyTQXV2vqq5JSlSw/LFGtof5mySLUmCuNGx2TG2n6Fm887dSzyhcSRzf1VFnFYlrw8uU17e2AvtL8tX/w13mo7lKftMTPot7NMku5KJPIZSBL90G1rjhuGxbrku39jnJd0uxaTO6YBs8MoBCBTO4Ymg6bSV80r62cUKuM/eORalmyv9/L/XHqZRM5C+hfa0V7knunbRKg5DjIBuapoVyW7O73FOuK09MpYSdnAtLX7hoJKe/T8/fdgC2fx0fO/v7EYl1KqHYtp0BrwPvANEoo+NAMmFzsODazDI0ooZt9J2Pr/kC1qTg+iU1t7EZCAB+jOAyslqpOmdE2PTa39EcBR+wfDpTLnN3DXnCPx07UzV42j1rrFGJuv5xDm4G6zjhtW8pNyfb+wOLiq4PWf72Q/hiv4AXtNY8TrnRED3khzEyXC2wbFM7JYlVW0sus0s+scMzJzjInbF4ISdY+C2JQ68QmXVT4Xk6V4yAnonlICt+k5AxeC7ZrFtl59JJLqa1lngNlnYDPtZBpijJLIgt5fTaXEu6XEU2ZiFvmiLWaqfNS7h2l7yhxZk7UipnDDz6VwRRZYUSjogUiP8+Bel2dIeFGKxbrmuE0yClpkHKXn2YRbvgvkWdhFlTYOAib108iXJjmWYDk6f2fy9AhnPNbRXijGScvu/fUh/JTynTtU+BAN4qwY5Cesh+9xK0FhNOby+KW1yVzN5KXwkouqoyxn9GpVGczd5b5h9GniDZJwMnyjKGVU/2cOKtxDuSFS6/Zncky87PdaApngtDh4Uh37DlsG4ZmwM+eoR3oTyN+jgxNDxrZ0GnF4fGAUuJf1Gly3N7t6Ztekkq8R4VIiOC9P58E8jI7Wxfm0ac0GZXS2ESRG33yis6eGMRG4hPUXuvEm9YK6zQmN4zjxEN1zxfbd6w+XOBCRn7tsIMlFl4Sd6zncrkhuJl8mbG4WlCtCy5/0xpXOzbfXrP+yRUvv/mC5W+qef3yFeonFSu1xiw0wcBqucRHT+lygiahCi39aaC8FM719YdX5FPGbXHDP3j8LvlC2g9Z4egb2cg935/TIO/fIOXMvCwY+pGqLsUCskj3gTPEUe6lmNo10atzlKCfRIcw9yL6m2e5l8IcpVLTSzSgKH8F+WedkTlEc7ag5FXBOIgK1qfHCpOXKtcwo50EvosWQXQJKog9K89lbigXOdMwpnvZp41TwGSpl1oIGznLJf5MW0ELDr0IA8d+pihls5WXGT5hIAkSXiGnTZv6so4YFD7FCU6DF5LZMJ95y3nmmEaPLTJCkN7nlOxucyebc2ssQ/eltataFJI48xVdXy+kP8YrK4RhWdYCra4vagGLb2qxeFQ58yQDQSHCEK3EmK6TMi1LzMtikdMeehaXC067ltXVgv40nBdVncRCz6cBrQ02FxN8uSylZLPMaLYnqrWADcpVKQulTQxOTfINiucRFYU5O4kKtj+0LK+X0qe4qOmaRsRIIWIy92VPQgFB+mGEKFL/tmd1vaDdC7av2bVUy5ypG1Mea/ySg2sUq6slxaKgXEioc70q6U+9wA92LdVKRAeulEBxEWvZL+M0I2TOAgL6nvqJxUXFaddQr+VnmYRDrpCyt3pOU4kqqYEFQB7mwGJTS9zWixXtrqHeLGgOHdWqSFmaUtrUSRmtkI1OiFAuc/wwyWd2FORZt2+pLyuGdsSVkoihjRbRikqm4xhRxsgmp8romo71iyW7+z3La4Ew1OuSeZIMz0hkGmaapxP7xwPHxxO7uz3tqePtd99x9cElh4cT1x9d8fR+j8st3/tvP0FbxSd/91OmaaLbt/Ttc29YAuDnyYsaci+vfXezY/VywfFJTmrTMKWwZ4XWNmXmaqx5TvkxtMeep3c7Ht49SYUkBEKIeB958ju+O3+Ptumw1lDPNa/zl+hosDFDRcNKLwl4zCvF6qMl9cuK7LVm82pDtJHLFxtmO5EvHL0VnNxsJ4plRvaBpXxT8OG3XmOujfRtYyD4GasscYrk1uGHgHWWOpb088g4zpzGI//Nwy/y3eP36duBFx9dCfru1ZrTtmFxWTGOHlskto3m7NG2VgZilhaNclEyHHvqC4FvlKuSsR3Jk6AN5MSrtEAnQhQ6mveBYpEzdBP1puK0bVhey2NUy4Kpm9KmWu49Z4WHa52MCUkoCiKya0bqTUW770QodurIammD6HTvPzN1Y5D+ssDgM+ZeRGDtrqVelzIPrCvGVsqvwuC1ssFVWjJIFWTPHtHC0R86lldLQR9eLmmPrXjm54B2wlyW8rWwi5/753khC2RZZwJ/uKxoDy3LqyV9ahHAl8HpEb7SHunXC+mP8eqbkbEd6Q4tKHh8t6UoMx7ebcnrgt3dAZcL2cY4y/HxiFKa01b+fXPsGAcx258eJNfw8e2WelVw//aJrMrY3e2xmWH/eEBbS7M9oU3kuDsJkuw00J86lIbd3Y6szHh6t6eoC7Y3O1zh2D8eME5zeDiiIhx3J/zkOe06hnZiTnQgmzsev3ikXGRs03vY3u5TafmAsprj05GoNcftiTB5+naQ0qyG7c2erHI8fPFEUZU8vpfXc3g8op3icL+n3JSpp6I5bY/0jfz+cXvE5paHL7aSN/l+hysztjc7rNOcdkdUZjg8HokamkPLNAtWcWhGQLG7PZBXGdv3O4q64OGLR1xhOdzvMdZweDiiteG0OxGip923zNPENE6JAqV5ShjHp3c7ymXO9mZPnt6DzeUnwGkrn3936iULM0b2dztsYXl8v6VYVDx+viUvHYe7A86a9LuR49OJCJx2LX6aGLqJU6I+3X/2xOpqyf2n94JCfCsIuDaRdZpDQ3vs2d0dOT6d2D8c2d3uGcaJf/hffZdpGPnlv/r3idHz/V/6FJs7vvjV93gfuf3hA9M40x975n4UTm8jGMPTrhUa0meCr7v7oaAYH9/Jd3h8aiAEmt1JTsLdKCi5STBu2mra3YkYA1M/Emcvp/DMcuLA1j5h9xkv1lcMtxNVWdG8a9C5ptk25N9wLK8XZOuMaAPVtah2VafwBFn8s0h/P6FymJ4m1FIzbz3uylBkOcNiZLGsWL1ZYa4NYzMxe0+z7Qgqsr85kpeW4/uGdb3A7SyLYskX79/xyeEHKAVffPc91ari7ffesViXPL7bkiXSlXOGw/0BlOL41BBC4LhtzkjM0+MJnRue3j6R1xmP77a4QrN9v8dmcu8IVvRENIp23+InQeINTS/ir9s9RZVx//mWos55utmRVRmHhwPaGg4PB6GHJZxis2/xs2dOY9jkhsd3O/JFzuPbx3QP7ckyx/7hIBmq2xNKw2nf4P1Me2jkHlKwuzngSsvD2y1FlfPwfA/fHdDp/Wsj72WeA6ddwzDMTNNEs2vQTvP49om8znn44omszNjfH8nLTOY/pzltT6Dh9HjCz4G26ZiGiagiu/sDJjM8vdtRrSoe3j6SVzn7+yPGyTykjZJM16Q8/iqurxfSH+MVVaRaFpJh6YyQZmKgXOaEWXaZfpwpl1JKrZO0fH29pDv2rDZ1IvZkuFJKYUVdioR+WZzjxqZhYrGqGVrJAW12PcuLlZQ4liUqCtGorCo53S1zoheAtJ988pqNVGvJgVxdLhg7gaj7WdJLTNpxV8tKyk2LEj96qlpgAPWilBPb1ZLh2LG6WjF2ojSV0q8lK+X0Wi1LfJhTzJpYbKZuplwVxMnz6idesH88sX6xBjT1spISdrIDhTlQn3+K9aEqS8amY3mxYDgOrDYLpl7ek2SZSjhADFCu0mteVQQv9oR5lNJy30oe6ngaWV+tUhJMhs4MRmmKusR7+V6nUcQ+YztRL8SWtL4SRfXmxYqxHamTpcQ6TV4WaKUpq4Iwe7HDTOIfHYdZvsNuSmEBPatLgbQXdY6xCq0keq079TJmuhSvNUnZVSspsRkrXmPrxMrkEjUpBNjeHdNE31Im8pHNJFlEpxgzpZXYgLQRxauPaKek7JZsF1WK2cvLjHkOKAtYk05UGuJz+VLK/n6cyepChHJagzFkzpKtHNdvLoghUF3m5MeK1Tdr2oeO5bcW5FnGT/zOj1ClovhmgTee5WKJK6zYvJaBaR5ZvChp7zuuf+Oa07uWy5/ZcPz0xOonFwwPE/pKMc8T1aqi+Mhx8eGaFz91Tf7KUS5zrHesXy04PLYsPqoZt54Pv/WG7OBwLywMmlN2oroomCfP+nLNNHpefHgl30uVM/aT3MPNwOpqIT8vl5KwVOTo3KJRVMtK7oNFSYhK8kbHIK2MdmB5tWQ4dKwulwn0IL0+5wx5lRNipF7KXFIt5PVIsMLEYl1Lpujlgq4dZAx3qV3i5PnLOidOgXJZgo/Uy0o+m0WZrE1i8VlfLmQMb5aEKKfTciHxafWyJHhPvRD7TbEqmUefQiIGVtcrhtPAOr3/PM8lBUqpNCdJlSnMgWqR44f5bAt7zuXdvFwx9COL9SK1yXQS1+lU/hVsafBRbErTSL2WkIrFesHh6Wsf6T8TV70qQSvKZYnLLHmdU5Q5RZWTVzlZ7s6hxaurJQCXby4Yu4GXH1/hfWR9VWMzS7UoyQpHWTnyssAVGUXlsNZSrUqUgfWrNfPouf74Cj9PXLxZn9FsLrfkdYYrMnnuMsMWVrIJc8vyaokCrj66ZOonrt5s8LNn9WIpfr26wBWyGLrC4UpHlmfY0lEvCrSTMts0eq6/ccU8zWxer1FKsbyosJmlWOTYwpFXOWVVyPupZZOwerEiL3NefvMF/Wngo29/gJ89v+63foPV1ULUqpmTjMsyI6tyXG5xhaVe5uhMs3mxxvuZFx9dMY4Tm1drNFCvKkwm77WoMvkOann+osyxuWO5KUHB9QcXzOPM1YeXTNPM5sWSLHfUiwqbW/Iqw2UWVzqqupC/W0pG5eblmmn2XH14ydhPXH64gRhYrmtslsl7zS1FnZNVDpc+f1dkLDY1GLh8vWbsRl5//IJ5mthcr6XcuaolquoZ6KGeAQycwQuo55ZATLF9ItCKSPyUlspdQrYJ4CIkJTUKsVrEcI6q00oe3xqFVqltkMplSmuYpRxJiFKODvJaJGotAStSPJxSJvnoxUZR1gVd1fFL+d/l4E5cf3BNR8f619XEVvMT/9OPyS8dL/+lC7IPHPVHJdWqoLooWVxXuLXDrg3FOqd8VaAKxeqnF4ztzNXvuGB4GLj8HRvoI5vfuCIrDOsPloRqxq0tq+sVL37rBVc/s+bi2xsWP1kSDVz85IqhGbj+jWv0aLn+6QuqvMZ9S/O9q+/w8M17FquSal2webXm1TdfcPHmApMZllcLIHD5wYapn3jxjSuIkfXVEptpqoWMuTzdQ1mdkZcOW1jqdYWymotXGxl/H18wjRMXr1agYLGusc6SVdmXj5FnuCqjrCSreHlVg45cvZF7+NU3rpnSPWyMoVrKXJNXGVnpKKocl+aBalFirNzDYQ5cf3TBOExcfnABSrFYlWm+EnW13EslrpDHMc6w3FREBRdv1gzdwPWHl3gfWF8vsZmhXFa43Mk8VDpckZEVGTa3lMsC7QzrFFz/4oMruYfebIDIYrMgKzKKMpPHqDLyqhC1dy2f5+JyidaKizcbxmni1TdffGVz/dcL6Y/xUsjuCyLLqyV+9CyuZIdWr0tCCnfOCoe1hrzOUUZTrktAUa0KlNEsL2qJWbpaMk2exeWCGGVw6cxQ1AX5okwAgUx2yIsCrQ3VpibGyPrlimn0bF6smCfP6mohi8y6EhCBMymk11CsSow1VKsSo7QoFmNg/WKNnz3r65VEUl3VaK3IylxCzLWhXOQopamWsnNcrEuihtXVknkMXLzcME+TnD6JuFLe4/pywcXrDcYaVtdLjBO7RF7krK5XlMuKVz9xzTx7Fhs5yS2vVhKUXlcSuGwM5ULCyqt1hbWGMr2XzfWSefQsLiSSqr6oiUiourEamznKpQSNFykAvFrmaG0pVyVEWL9Y4aeZ9bXskMu0UcqqAlc4jJbvQitNsSzl9LmSCXJ1vWSaA8urFdPsWW5qQogsNxXKKEwmMAKltQSuW0W1rtFGs1hXBB9YvVjSNT1FVdAmjOTQjWd7VEhEIe/lZ5g84dx7FuB4XjjapiNLatAsFzKWIhKmgPdBWtxBCEXz7IkRsVLllvbQkRXiCXaV2LOyXPImfRDPrp+f02ZSEs2zF7kdBdhR55SrEl95jm5PX3a8Wr9k9XLJ+s2ay9+xpvxmzm/4l389ptbUHxfkq4yrDy/ILx3ZpaG8zimucooXOcU6p3iTUS8rVt9akpeOF9++JKscV9/akK9y1j+xplznFK9y6hc19tKQv8zIXxV8/C99QPkqo7jKZMy+XEClKF4UMv6uai5XVzQvG3Zqy9UHlwztyNUHl/g5sNqUsjG1jmpZSDTbqoQg71UrzWJTE2JkeblgmmYWFzXRB6pVuocK2WgrLQue0ZZyWaYFsCQQWV4vCFPg4uVa7oOrJSpCuSplYc0yGX9aUazk9F8tcrQ2LC6r8zzwfP97H1isSrQxuDIjq+T954sUWr8q0UZTLTK01ayuFkxTYHW1lFPoJicC1arEFQLVkPtQs9hUmCzdB+l+jCGyfiHz0OpS7qF6U6K0Jq8LstJJrOKiEBjDovjyBKtgtVkwz4HNixV++vIxqkWBthqbTuxGKxbL4ivNI/3aR/qPXf8kfaT/5z/2fz0nesyzgLHnQTxl7aFjkURHRVUk9qjQgI5PHZdvNhyfjhRJfWatJgSFcYinyhn6ZmRxIaWcLLdEYGgGllcLyfN7teK0awXu7IVVO/Xyszt1LDcVx11LXhbE4BMNxHHcNpKn+HRksa7pWpHLh1EUetMk6rj20FGtEwowFyJP3wysrr98/ueYt2c/2pT8cEMjMIaulc/n6vUlqEheSCrEi4+veHr3dIangwCpt/dbVNRoqwSftiro+1nCy6N4JqvNgmYrWYin3YmszM+e22fg+9BKefS4PQlpZRCAQpZbjruGy9eSJ7m4XAgv1IqX1GYC3bdW03cT5SKja6ZzePo4CLHluJNMSkkJkZKVTpQgY5QoDEvH0AxUy5KhG2VTkImVZvN6zenhKM9/6LHWpMB38dq53NEdBDDRtxNZlaWFcKJeLjhsD1y83NDsG7GMTKI6nscE/xhmsszSNUJLmsdRWhBG4OyrF5Krubpe0e5abAp6fw4m0FanMVTT7IUN7EPETzPlouTweOTqzYW8/0XBMIxYY6gWwuXdvN7wnc++w7tX77io17y6esOp3vPqxUvClefSXnDwR5xxDHOPJWOMI4XJGcOEw+JVxABTnNAYpjhT2pzT3LB2aw7TkZVb0vsBZwwExRy9+ImFk8fsA6Ut2N4eGHcTbCPdrmdeeMankc3rFU+POygjN9xw2V3y25p/ntX1kt3tnuWm5v2nd4zNIBuJIGO42bdsXiw5PImlaWhHYcXOghWcZ1Hhd0f5DLujWEDEnjWyuKw5Ph65eLmmOXTiB59m8WOO4rnsmmTbOnUps1dALlnuOG0bLl5tEvxA/OFGa4IHm2vGTrzWwncWJGBWCopyGkaqTc3x6cTFizWnXSMOglk4ysK9FhZ3sRS+cLWUVk8AitJx3LZcvl6zf5D3Lza0FFpvDfOU5rCTMLKHXuZHFQLDMFGvao5PRy5fXXDYHgW1Os7pd2ec1XTdRLnIaQ4NZV0yDTK2XSZpRf+bP/m/olqUX8la8GvmRPpzP/dz/M7f+TtZLpe8fPmSf+Vf+Vf41V/91X/k38QY+eN//I/zwQcfUJYlv/f3/l5+5Vd+5Z/SKxZLg84SWWZTc3g4ySJzf6LeLM43j/eBqAEiUSkiHj9NAokeZbB03cjiQjyWy6tF4srKTaS1sHJjiOcoKvVMJsnMuZdwempZXy84Pp5YbiQhxBaZJDMk6IKfQyoLhpSyIIt0u2upNwKlX2yW7O/EJzp1sjGY0+8pxTkTc+hGlFLC7VyU7B6PLC9q9o+yQWgPLeurJR//1EdAJEvWAGNFoq+tsH0FPahYXS+plzXXH15y3DViHG8HjAY/TfL+QwQfiMA0TgmSPZCXjtNWPv/j45HFxYLD0/GMEVRGkm1mHwCBXcQoGxPrLP1eFq39g/jTTgdBLA7tjM2EHQsCqgjeE70sKtYZuqNQkLqj9HAPjw2Li4rh2cc7TCij8JNMxESI0zPQXaxMfVr4z2Po4UCxqiTBwwr5RmlFDNILFIDAlMhGEmPW7IRKc9w2LC6WdN2IqzLmIVl7ZiFZRZDSboKU21wCwoUKJYrx49ORerWg2XcYJ5APlVJ+nsvGfpbe7TRMFIWEEBSVYzQTf0f/EqdFw8ZsmJ3HXml++rd8m+yFw2rLjGcMAyZopujTqTtinlXB1jDGnmfir9WGTDu0MlhlsRg0GofUs30qP3tmrDJfqmK1IhBxV5qXv/ES98rivmExSpHlOVFBUZS0bQcnxTzM7L/5xNvbL1hfLdje7ZIq1qMUxLQhDuHLoImxkY1Pe+pZXdS0x5bF5YJm15DXErSAFbAAIc0DXs43Qy/zQN8Je/m0bVhdLdk/nFhtavFYJhiKUgJ4mMYZ78PZ/z20E3me0bej3H/36T58OFIuhe9srHgznysIMUFTpmEUsthpoKwyjrsTq8ua7e1OCGP7liwXYEJUkkE7TfLe52FGqXj2vnen4UznWlwuOG5bylWVSEbSR4cUajDPEvoxpY13N5LXGe2hYXUpc8hyU3N6aijLQhZoI3OPn71AX77C69fMQvoLv/AL/ME/+Af5W3/rb/HzP//zzPPM7//9v5+mac7/5t/9d/9d/uSf/JP8qT/1p/jFX/xFXr9+ze/7fb+P4/H4T+U1C7vWYJxO9hTRpxtnsE5+amXIMgM+4socvEi9deLeipVAYbXCOI3LHdZorJNYrzx3RPyZF5sXGdMccc6inRG/WFTJjiFCEGU0GAFOK8BmYvF4LstmdS4ACKtEcOKsSOO1giRrz0opiarMElECep89rrBnzqjNnPAzo0x2mRNpunOGvMhYXq/IipzFRUkIkeqiIkQo6kxOZ7mTsnfmyAuHsVLutrmIYFSy+CjA5Q7vo3gvVeL2WoPONMZJ6VppITOZzKK1Ii9yIgptFTGJv0CJKCKV27SRkpHJHMZqjLFic9GA0aIcjQqtZCGuVpVADAqHsjLh28xgMnPeFLjCYo1BWYPRwuclRrHSeLEJxDROlBbR2pnDajVKCQdXa41xDoWiKAUTl5UWbYSzatP3r41kbGojr8VlTsDjWuOMPkdmFXVFRMZUiJKyoY08BoidwGQyFoxzaAu2cGgj/e85eQxjlJM9WsuYD5JxYKxGGUvA8674gtvVDYXK+eBnPkCj2U9Hcl0wh1k2d9LQxUePUxlGabyfmPyIQYt3Vck9NMeAJzAHL6dOBT5ORK1kU6gMRgnj1ynHFGbp6yqFQ9jMTjkW36x58ZNXuLXDlQadK+oqp7YVdVFjVppPlj+g2wjes1pKS8UVWRKuCd/VZS4RyPT58zf6WYilMEq+S2NlnAPkdU6Igax2oBR54bCZxRQ2jV3591ELXejZ4qGQSkbwkawsUEBZ5ygjY9g4gzJirVNpXJvMkJcOpTR5lfjOy4LZB7HtIfONzRzamfP9b50Fo4XPrYUypLQmy8XbmhXC5na5A6dxWQqLcFLtyHJLUTissbjcnOdJIDGpPWVVooz+koZmtPiPjQD7MRqb52ijyNJjaGuIIQqbWiEb5K+w2PprZiH9S3/pL/EH/sAf4J/75/45fstv+S38R//Rf8Rnn33G3/7bfxuQ0+h/8B/8B/yxP/bH+Nf+tX+Nn/3Zn+XP/Jk/Q9u2/Nk/+2f/qbxmmxmm5LE67XuWlzWH+wOr6yXHJ2FlTt2QUhgkpcMHj6RNCfPSZZaxG8jrnMPDiWpTsXtoKFc13UlCbaMX3BwIfcQm5qpWijBM5LUkowjx5MD6uqZ5alisK3w3YRwoFZknEZfMXeJmzgIuGNqBxbqi3besrmr2d3uqTUG778gyTZj8mWijopadvxcVqB895UpA2/Wm5vBwpFqV0p9cSE9wfy+2n2bbEUOgbwbm2TONI2M/4eeZoRuZhpmhm2j2wttsjy1ZJmxcrQXU7aeAIuKniDYSXWczQ3voqC9lN15thNpSLgSiYDOZuPwU0MSUlyjQiawU/1peScl5cVlxeDqxuKjody2uEK6xMqKYnQcBVoT0HUYfyMpMfHuXNYdH4ZzuH4+ilm4HrNPEAD4gHrgQJS0nBOH4DnOKdWvkM3w8Um5q2n1LVlrmeQZkkg4zEFMJMX3+Lre0x456XbF/EKrR4f5ItZBe63Myj5wkxT9rtD6X8Pwwp0BmoTdtb3asLhactm2CEowQwRpZqJRCsjOVwnsJQOgTpPz+iwf6dmTsZuIQqVY1fpxYf2vB6CecFnW4Sn5ClBK4PJKrq5V4NA2GKMc3RM4kyMsQvYSE+4BWkmWpYsTHkHJJFUYZPB6jFMTIFGc8gahgDhPRRnzwWGPpx4F+HmEGMxiKouQwH5lfTzze7rj84FIwl1buvznRq4Az8N/mqZWwyDk8nVi9XAkBayV+am0EASmlAMU0yBie5nQP95NYnA5CTzo8nFheLjjthOI1tRMmU+dEGuH1ehmPqRw8DbLZPjyeqFc1+7sfDaovCPNM9LJ51tqkdCOdOM+iLO+bgTpVRaqLiubxRL2phd6W/K8hRPGgR4E8TAngMQ1zIq8dKVZC7yqWFd2xS4EAs1Q0jGQsA2eQRJg9rnyOKCxpnhrqTcnx6USewP9ZLklaMQg+VCpkXy+k/1+v/X4PwOXlJQCffPIJNzc3/P7f//vP/ybPc37P7/k9/I2/8Tf+Bx9nGAYOh8M/8uef1NXsO8ZhZnd/xDrN7ScPlKuSt7/6nmpV8v77d2RVzv0Xj2il2N8diN7T7Br6U0936DltG7wPbN/vyEvH7ffvKBc5779zQ1EV3PzwHpNZnt49EefA6enENIw024720NM1k3i8NNz/8IFqUfDuu7eUq4r337slqzPuP92ilWF/t2ceJppDy9AM6flbgo/i+Soc779/R7EqefedW8q64O6Hj9hcnh8F+4cj4zDR7FraXcvQTuzujyijuP/0Ufq3jw3VRjITlYLj9nT2nmlr6A4dfvb0x55pnOibgamfmCfBLNabit3NnuXVktsf3pPnGY9vnwghcng8MA2e9tDS7Bv6dub41KCU4vFTef8337mlXJS8/+4tRV1y++kDxmh2N3umKdLuGvp+lPf/2DJPnqfbHVluufvhPUWd8+67txSrgrtPHsiKjKe3W/GK3h8Yh5Hu0NAde/pm4PB4RGnFw6cP5FXG7fduKZclb7/znqxy3H/2iHGG7bstYZ45bRv6fqA99XSHhnkKbO92WGe5++SOalnw7rs3lKuC99+/xxU5D2/l8z88HpjGkWbf0J06umbgtGtRKO4/fySvMm6+f0e9zHn3/VuKOufu0wdM5ti92zLPM6dty9CNtIeOZt8w9J7dnQAcbj+5p17XvP3ue+pVxe0P7smKjPsvHgkxcnw4Mo8j7b6lb3u6pue4a4kxcv/5I0Vd8Pbde5w3jMcJFSKbb6xl0xMnfEytBXUWAcvfhflHFj9NQlYQYkDrhIAMAR3llBkSEA8ApTFKSTB9+j+DwWCZ8OnvLRkWhaY0GTZo+sOAnhWxiYynGTtZmseWQODm4ZblxYLv/9IPyauc+8/k89/dHplnuYe7U0936Gh2DWEOyXNref/dG6p0/5WLkrvPHrFOs323hRjptuK97PYd3amnbyeO90eUgofPnqjqknffu6VaLbj53q3MIZ89oYHd7Y5pnOj2HVM30B0GTtuGefLsbvfkpePmB3cUi5x337ulWJa8/8Ed1loe3z5BgMP9QbzTu5bu2DN2o3icIzx8/ki5yLn93h3Vuubdd27J64LHz57QWrG73RGmSLNrGDvx0Dc78cNu32/Jy4zbT+R3br53S7kouP3kAZc5Ht9uIUT2D+kePva0h56hHTk+nlDacP/5I1nh5HdXJe+/d0NR5tz+8P58D4cQaLbNl2r2r+D6NbmQxhj5o3/0j/K7f/fv5md/9mcBuLm5AeDVq1f/yL999erV+e/++66f+7mfY71en/98/PH/74nq//glZTVhlT77RsMcKJYSq/QcleSc7Ka0VShnU2blc+lHE4Mg1aYxUCwqwuTPJYy8yFBIRqDJU5SQMWgrsWBSdnLEqCjXVSrhlnjvcWWGj+IzJGWcmtxhjDzvM2w8RATkPor3NPoo4pJUBiKSyDxKEuytEd+j1RitRCg1CVJOxQReTz1JEoWImDIzo/A4zZlK8px7KKeHGCXTcHlRY6xOUWWkMmcq/2TPGDqLMyp9hoG8LpPaVmhEWZURvZz6STYQlz5Da+Q7EEqLfIZ+8hJv54OUkD0JaC5Ae62RcpeWvEmbCWlJTqiBvCqY0wk9Bp8i8jhD6b/0cT5X0YVSpYgJI+kFgTh7yioHHylr8ZFKbJl8DtaluDJnJbvSKhGyVdJLqlYSDSYIuiD0mCBjyCUPqrbPhCwt6upC0jmKZYkfBd82TxK04L3HWRlrkZD8gkj2q5Zytp8CeSmBBlVVsgwryrnCx5iGQJATJRLCPvuRXGVYJWkxXkUy5TDa4pETpFZS/ZiD9NM8IraBKOEQMeLVLBSjGOR9KINTliEMRAUmamKc05yr5XNTjuqjBa9/+iVRyanYOikvGm9RE1gl40G+Q9EJaG3OcYSkMr42Jp34U/l3lHjDkAIHoo+pDC7lSe3kFOicRlsZG9pobPEcbygw+nJRMM/CPQ5IHqc0UBTWpexTo1GJuEUEmwhCxY/cw8EnTKCWFsYzFcgYjTFy3z1brEIQzrOffHp+EUf6ccYWct8YK+MNBcqqL0lDAYnaG2eKuiSk8RejhKWHIJm+1mqUUdgUqYaJaV6S0m1Rpjm0Fi98UeZ4JaXkqKSS8Tx3POsWvorr1+RC+of+0B/il3/5l/lzf+7P/Xf+Tv1ju5DnsOP/oevf/rf/bfb7/fnP559//k/sdSqlpMSppcRiMsv4HBU2+BTKG1JIt6j5dEDipyTFKuHUIjaxYbNcM81JPTl4lFbMowQL+1F+SSPlmRgFdK5TKoc2+gyO93N6/mE+x27JDSePkTQvKCu7f5uJatBkhnEcZYGdvywBG6uJUzzfiFEpiTFD/InTHGQSnr2E8aqISd5DbWSylp9B+iBRJgIStk/ej5xOQpR/s1gvuP7oShar3EhtFCkrkTySz5NCCBFjFcMw4qyUK40ziVkrgHXjZMHluUQl4EZZdJ2Iwow1DEPizEoNHu9lIgUtC5d+9mrGhH6UD9Q6ncqAhnmMKUVlkgitKErY50BurWz6/hVEdebaujyl3eQS0aW1JsSASnFbz5PHM2UQoqD60vv7MolDSoCzF4ZxSONBwsIVChmE2miMIpXrZdM3DBM2NwQvnyFzev4QMVYm6/B8z0X5/hQRkxnmccbllmqqWHxYYa5kog4hIEtdQKeTIUrKseJVDchHozBRI919zn5ZOV9KTzdXhcBLdI4OOpVa5fFIntkYkUUblRbdwBxGxjgTCGQbw+ZbC3wMBOWJVhECZCHD3uaUpyKl+khp3wjVXcZSwv09sypV+lyzzErMXyGJTM5pxnEUweEoC4aahX8tqgbpg8Yoc8SY5hA/SqpTSGjGkGLHghfwiDiBFTHNBcqmkq+Wkq/NDOMw4ArL1A/yv1MKlApB+v8oYsr3fO7X+qS9GAdJJApjmkNm2fwIj1kGnko+YlmIlcxtKXTB5VZaGrlhHEYRpgWPMuZ83z2XZc8bxHQPmUwz9lNi9ga00/h+xhhJwbKZSfe64atbRn8NLqR/+A//Yf7iX/yL/JW/8lf46KOPzv/99evXAP+d0+fd3d1/55T6o1ee56xWq3/kzz+py08zKBiHEVdkojCrc45PDflC+mYuRXehI9OY4NxzUv0l5Z0xmtO+FRTY82NsW7JK5OvGKsZhRqmAnwLeCxJsHj0xhIRiE0l8XmbyWHlGu29xuSjiTAKS++CZZ08Inhi8KOk0dEexOBwfxM5x2rVkVUF77LEpQzMC8ySKuegDYQ4QYgJQS/N/sa7lRo9psdKkm0fSLc4c1ijwc5XyVH1KvSB6tNJi1yESZtkdu9zhUyxZCJ44B+IsCspxmMRWsuspq5zDviFbOOnx1bnYa5LyOQR5zOjFSiJqTEV7GgRj9tRQlJnYOpIFyCXYPMj3NafXG7yUG6dpxuXyfEWdc9g2uNKK4rHM6ZoeYy3zIMrjMHm8T8rLcSYq6E8DxSLn8HDE5Zbj04msKDgdOrEV9RM6wevFShXT6/D0/YQ2hvbQU5SOw2OTHqOhqEpJF8kkys2HSBg9IcySWDNKakjfDuffqZYFx+extGuxKXRegSg/lTqP3ehT6lB6/rDwPDZb8piLuX+VMYTxDHCIUfqDqMgUQuIo6xTOEKWEq9IJM8gELqdWLafBmEocQTawQSFKXiNioylMwkZWGoIi4AEtQqZ0cn1eBKc4MXQDvhcFamlypnZkERfEB0O1qtjdHSgXBUM3ETVJKesJITKNkySWpLSTZt9RLgoOjyexCCW6VLPvRF2fUoaC94x+Tn1L6RdOvVjOjltR+h62J+mb71rypF5XWhTScfbMwRNnL5qLUe6dvunJKhnDZV1yfJCkmCaNoXGcmD3Mc2DyM36c8JM/R/HldSZ2uSrnuGtxtYzpvMromwltpNfpZ2QOmWUO8ONMjFF6mWUm739ZcnxsKKvnMZwxDSMhROYp/e7kRYUbYurDKtq99JqPjyfyytHsWvJFTtcOaCvJVsTINM9fi43++64YI3/oD/0h/vyf//P85b/8l/nWt771j/z9t771LV6/fs3P//zPn//bOI78wi/8Ar/rd/2ur/rlApzzK10ugoxqVYjoZl0IemslWC+bC5jZWGnwPyvhIlF2oEFKeUMzUK9L8ZltSvp2oFxkRB9/RBEsdUFltDxuQDJBx4l6VTAl4cjcT9SrknmSFAuIUlZCSiPWPCvqrJSSyywJhgR8vbioJGx8keFTHqAy6flBTpLpdOqSrWVztcTlFgKpDANfnvukHMczLF0L8u55gl29WFFvakKyBUQlJwu0pqgLVhcLeQwt/TASgD8iqLxpFGj/0AhecWomqnXB2PRkpZTYtdHnUqRO4G2T/JtZYelb+fzHfqBaVXTtQLkqJO81l/dtnJRDjZaSnlLgrKVvR6pNyTzOAtzvRnn+bqCoHHiPdsnq86yuVkrSQhI8f0z94XkQoMfYSXTVmE7IQPoO5bO1yTaUZRY/B/LKMY5evvdhkrHUdikRSIRFVit0Js+tlMZkSQ1ZOcZuotoUDKeeeiXjsFpLyogrHFHJiSEqUZWaJECxz2XpyrHr9uiNohlbghGLTqZyKcUrUZFO0aeigpzInBIrS4jS31TIaTIqZAMWg4ylNKhCBLT0T4nJBhEgBJ/CGaQigo4McYYQsNoRlQhUVEzjEAVlxJVOwup9wFUZcQ7UC9mAbV6u6U+dKFAjmMycxTp5KpkaK3aqvHYi3NuUdO3A4qI6RxjOo5zySadAg5SFtU6CpXSar1cFfScoPBlDpUS5FTKHaGvQRsrsRptziT+kdsTQ9PK9dyP1RcnQ9OfEJmulnGudxmklqv80Dl0myTfVMj/PZYLzk8fKK0ucvcw7Rokq3UnL6Fl0JTaZMY1dEZ/1rXjB/TRhnMEoKeuiZA5TRiXMpSRPlauCrv3y+atVmfJXHTH5m+X+0ykI4Ku57Ff2TP8jrz/4B/8gf/bP/ln+wl/4CyyXy/PJc71eU5YlSin+yB/5I/yJP/En+Pa3v823v/1t/sSf+BNUVcW//q//6/9UXrMy+hwjlJdiWLeZEem4NWR1JuKGlRA8yoT6y6scYw1FJXQOmywERZ2nWDNB9WnjKGopG9WbBTpCvsgkKLlMP6tM4sNyl6KKxH6h0/NEIK8zSSlZlGgtiS8oeX6tFabMGFNY+DSICtA6i7E29fDkd0OM8tqNJiuFqFLUGdcfXmKspT/1uMxSVFn6HaGd1OuKsZeJxT+TShB7ijHyHn79b/kmLrPcfHqHtZqizlEB6mXJNM8sr5YcUypMCOCKZCGoxI5gnXxOrnTYXmwFWZFhMkOZmUShyqWsV+Uopcgrl/pdosZ0xZeB43kh5a1yUYL31GtZ5J9tSFkpFpOsLCBKnN7YD4IXzDNh/5YZ2mgyJxuZalXJZ1hkKCU2IGVVCmkWXqufPTZ3KQPUUtRSys6rjKhVsmMgpJ30WUeEnBSJ5IVlLBzGGRlDWlEuc1SMwn6OnAk7xSLHaEtWij8vy53YRMoc242pR50T0GRVEuosC1SUz18n0oxOvbZJQ3N9QpUBlwnnOSrpkZLa5YGEG0TsOQGP4kdSfVK9TiuNRk6RU5iwyjLFgdw7PCM+WAEk6ICPnikqnBXbhYrpgUIkV042LVFhsJgUS5gZiQjMP8y4zi44/p0jVmJjCJnGZJpDueeyu6LdN+TLIt1LOSi5t5R5/o4NmREIQVZk57ixZwtTuSyEAb0oCF7uIaVI84Qmr3K8l8/UE8lyQ58nC0uVgRK6mIJE54oUlRC+XJmlPqtj6kaZB1KMYlY4lJF7KQaEKBTEQoYWi5rJLHmQCkdW5AwtZFmGzSaMcWS1pCbldQFE6lWOfx7/Su5dbQ2ZFpCDzIce4wyudOcxFIOgPANQripApbGj5XVqGcP+2JGXjrGTe+eZfmQWGSEIvzcCxbI876G+iuvXzIn0T//pP81+v+f3/t7fy5s3b85//uP/+D8+/5t/89/8N/kjf+SP8G/8G/8Gv+N3/A7evn3Lf/af/Wcsl8t/Oi869flmL1mCsnPMGLpRSCHdjDGyqxZqjFgdtJJTgJTIPDaX3oYrJITX5JaxHXGZ9CelHyHlDJP8VCr1FK3VyZuWSwzRQk7FrsgZO6GLPPfztDHMY8BklhAkZ/H5VDwmCf7QDuS1Y+qltxMmKccaZwijxyVQudaKal2RVwVZIRsDU1iUFS+s1pqyztAa2ZH6QJ3QiLLQG2yh2bxcs7paSu9Fw9WbSxabWgRSGqpNgVIyGRWLnMtXa0IAaySaTWspFVvnJOu0yuib8UtCTFIIhSALREg785gsMBBxucVPE3npxNxeOiHVOMPYD6CFeytxaskCYgVwIQ6LiMu1RGZVGUM7SDm4G3FWPIQCBTeEWXqIpD63CtJ3ntN/75pBem0pFs+P0qe2mT334aUvL2MmJoO/dUaeN3MSqJ475n7EukwWrqhwzuJHES7F1JOMOmKMjMO8zunT+5/aCVtlEhJvwLlMxmoaf865lEkaE5FJWgjHnzhw/PjAxZslMxPaao67Rk6DyY5i0+euovhClUp1C6UxJJhCCFgtPkPpI0aIkaADCiUCJES4BmLv8sHLSVNDiLNUPKK0GXyYZVFPK/Y0zIy92GWikXKry60QmjLLF+4tny0+54vprUQIokQ4lGUpdFrGnfRnAy43Up4tHWMrC1rfjJJTO4nYyWV5qn641PZINhqridFTlBnDacCVGWM3igCxm8gyK/nGKUj9Wfz03DqJMZ57mfkyZ+wS5KORcr2fpaJlrWWapM8ZvE9CQ2mhxCCitKEZJey+G8hKS38asdZKDz2C0pY4eYlQTGVppQLGGbHApPdfVJnMP5llHgXcgZZ7RqAeUqF61jaEKWCt2MuKKmdoB7I62ccyy/NSZpzFp3bMV3n9mllIY4z/vX/+wB/4A+d/o5Tij//xP8779+/p+55f+IVfOKt6/2lcxhrmfiZz0ktbrCqaXUexyOkOHeVaQoCVErWlH6WX5lMQtZ9nsiKjP4mP8fTUsL5c0u+7hA5M6L454L002EX9iWQtOmnM57mj2TZUa/FeLTZCqMlrKRfqVL6J3gsKbxJRjfcRVwjGrqxzTk+NeGET9qzbN+RVhvdTCvo2+CmCkUDn1WUtyS7TzDxMzMPMPHrGfsT7SNcMhADNvsVoxWnfgFZfekdbgVZfvNwkO1DHxcs1q+s1Yz8T58hp26FUlGzMVSVlLavOCLJ5EqxYd+wo1iWnpxPLC8kyzMuMvutJ5x/85NHOEmYpEc9p5zy0I3mZ0R166nXqca0lYzYrcuZJJm+llYh29PONb1PJTibNYlmwfxQyTLtrqVclXdudlabz6EV4NHq0TsIga5mGmbLIaXaN0IUOLdVGciHzWvCHfpbStO9noST5JEDzXqoBx45qVXLaNayvlzT7lnJd0jVdEuxIr9o6mdiMMcTZY41MgM5Zml3DYl0KmSllWpZ1zjzMeO+JKPFRuiRusyJqc87RH6WEaE6J2TrObN6sOB2OGJV8f0olP2tEY+QsqtT51KmevbLJ8iJqXTnBRgIqJQTlqkAri9UGkwRXKonQYpSSr0KjlCjkY+q5huCTNzXSHlum40ie5aig0NHQ7wYy5Rj2A3nI2flHxn6kP7Ukld+XodWTfIfT5DGZpW8GiipPOZw1x11DtS7EC+4cIUgv2RrN2EvVR3CSaQHKM06HRu7dbctyI77ualnSt71sCFDn8R7mgDHgJ1kAp24kr3KaR/FgnrYd1VosaC7TZy6ySRtAk3JojZbHckVGd+wpV0JXqjcl7a5huZHSslTLU5CCE2+5SSIna2Xhz0pHs21ZXNQctw31qqA7tJR1nohqsgEnKchDUoNPCYnYpjF02p5Yv1hILvC6lBxbI8Hy85g+u0Sa+qquXzML6a/FK8wetHy5LjMCHK/dmXN52rY45xg6UcxNwySYq4QZi0DfDWAUYz8noZDwLYd+Ii9y5l4mrHkUHNw0yC56HkU0BDB0k7BZT4KKaw89eZVLiSmX16O0JNwr84zHE7HP1MprGwY5iZx2LWVV0GxbwfydOulrTRNRKaZBRCfBS0jx/AxBVwnfl8RFOp0QtBXFZlQyCTsnC9qcaf6a3fK/+6s/z//xl/5LhmkSbKCR029ZF7KJ+JFTj1Iidnr5jWtWLyT6CRBVc24Z2lGwiseebCF8UZc5+n5EWegb4ZGO45SETIFxkJPNNMxoK2zaoi6kL1PlZxFE1/Y4p8+ovnmak3pSUI3aaIbmOZi4I1/kNIcBV7nEEJXvTmsYR0+IHiKMo5xWmqbHVjljL7Fq7aHHFY7mIIi+eRCM3jjMAqYYZxF7xXieXIZ2IiuLFKFW0uzkMYZBRHHdsccm0VlUUs4bxwmQ1+EKd57MhBGd0zUzWEEZaqsZ2wmtEO6qF7jFkBCEYz+x2W3IdyUsYGpHbObYbve0x4793Z6gorBwtZw9SR10cYEqVIw448QXqlJfNf3tc39zYkYn8fazJQQEB+gTsMFqeQwfhaBklQG0eFHRdH3P0I0M44iNRjY3UROGSG5zuFO8+OIN/Y14Hcd+RCu5d9CyMfA+Af87ua/nFDvXHXqJLDuNVFXBOEzoJFTSTjbSMSRh1TwLqq+XapOMv5zm0JNVjuO+w7osCeZk7iAqxm4iai2IwF5sQdM4CSoyCXb600Bel/TdBFrRtSPWaqbB4+fANEgWcQiBvulRaR4qqzSHLESolDlH244opxj64QzzCAnyMg4yhkQP4miOPXmZ0R6Ft306dGgrKFHjjIxhJxvZOTHAp8njMkER5lUhQqVFwXHXCsL0NKCsRP3FOTK107OL+Cu5vl5If4zXPAfwomATRZ0oGsduhOdJ16qkbvOEGJhGL7YVH4QW5IPc8MMkVothJATP2IoPbuhH6fnEmJSiUW4mJX2tGOV0iBZFpbGiDtRWMzQDMaZJP1lHwiw70+gDMZVYIOKHOS2UssiMo7yXuR/FqjAFUXwGSU959ihqrVI1LYmHoni9MDI9Rp+mwSRuCbM0Nv5v+0/5Jd3wqZt4V838h//Nf8VtI2AFYxTLqyWXH1ykXaeIIp7ZrsYYkcN7L77UWRajeZhECTtMaKUEFK8TmcnLhDuPXlSjaf6NXk48U7q5p36QzUYvk8/Ujzit0RHGQVSWPpXlhTmskuJYM09pszNOQp0ZRzSKeRzTohekzPUjSS4xyPcSQ8RoJd97gLEf0EYzD1MqzXumWcqgc9qEhSAbqecTrqg3hUEcCcyTqHnDMKKRhWYcZ+kD+lQq9dI6mCcpl82DKECnfhJFetsnYcezihamSb7DMAd0JH22kbmf0E1GaAIuWHwvto5IxA+e9tihsecTslEiVtMk8QiiQg0xEhQYZZMoSfCLRpsUDSfv+1m4ppVGaUEJFrbAaPcjC6ycgsNzJN0gGwqlFSoTX2wgUL0qWP2E0JdmAg+Pj9zcvqf/TDaaYfYEuXUS6Uu+N5WsO1pphl7CsYd+lHu3k7bA1I0QNfjIPCZmdOIW+3RSD2kMTf1EjFHuYWOYx2SBCbJhjXNM9zCEKRB9TGp4CbtAy2bXhygcXROZ+lE+uygb0RikvKq1EKJE0BVTdWSEZ2KSlfEnlTAPXk6l4yAVKmn7yFiS+1PaRvIYimEYiErLuIhSTRNKVjg7Dp6paX5K424QpvA0yQZ3Tot09FEIHjGAEu6u/tpH+s/GlZdiEq6WJX1KZWkPnQQ3HzqWl7Xg30qLMoYsc4ljatDOAIF8UTJNM/VFRXvsWL5Y0p0GNi+XjO0kocAxiN8qmaGNc2gjIoUYI1VC9K1erjjuGi5er2n2LcurmmmSXbLSX5q/tRU+LUTyZY4fPfVaEhxWL1fyWNdLhtNIsSjwQcpXxoB1mtXFkiqJL2Rwy830HLMVvJSiwywL/tgPMnnOntlH/rp+4h+OB1ob+MlvvubycsMPTM+//8P/lil5N5eXC2xSI8piJIuTT5L5MHvyUkKQJTB4YnW5YGgk2aQ9tKxeLBmGmaywyaupcVlS3abecV45Zu+pViXdseXi9QXNtmX9YkF/6qg3NfMkqSzWWrSzWKMxWvi/EWEYT8PI6nohoP7rJe3hxOrFSvrlSSjicitq4TNnWUQkwXuqRU577Ni8XtPuGy7fXNA1UiZ7xgBqJWpjoyUdxxUiRCmWuQQnXFY0+46L12u6w8BiUzH2I/mykF6UEyawySw2hXQXlYA3qmVBf+rZvFrRHlvWr9f0x57l1YJxkNOqflacWmG7usIRVKSoMuZx5vWve0kgsAxLhvsZdyXVkHpREQlUy0oWHq0Y/YBCk5ucOc7is1UCpY9RNp1znFGR5LaUhdUoQ4bDKUtuciEWKXcG6o9hJIaADzMheqwWUdocPU455naWwHSXYY0lyzKMtlz9+kvKVwXloqDtG/KrHN9F1lcrpiHdQypicxk/2gqzGaXIFwLiWKxrUfq+WtEeOtYvl/SnnmpTCZIwl7bEMwxFuLgO72fp7bc96xdL2uMgP/cdF6/SGMoz8Wy7dP9mWuYQHSkWGX5OwfXHns2rNf2pZ/1iTXcUJfiUBEjKChvcOpvi1dIYXpYMrQSGN/uGzcs1+6cTy+sVXS+9/xAl6MJmVu6H3CXhVbqHNiXdoWHzckV/7Lh4saZvBPfpw0xWGKxOLOfElc6S8K5aFAzdyPJyIck6L1ecdieWVyvmUVT1MchCjVaoJC78qq6vF9If49WfBoIPya/pOD0m793TibIqODwIEq/ZtUCgawbiLDfy0I74OdAeOrRSnHYnXG7ZPxzJi4zt3QFXaI7bBmcMp0NH9IGpnxgHYdQOJ4l2avYtxmr2tweKKufx5kBRSs/VOUtzaAFJOpmmmXGYmcaJ4APNoUOhpBxaZBwfJdLo8HgkK614Ya0knAAMw8g0+fMpdx6nlMYgCxwR5ueT4jgTQ0j9scgwjvy/wi1/u+wJK8dv+/Y3+fWbS/6FDz8ie7Pk0QX+1H/9N7lvTigUi4sFq6slyxc1Yz9Jb8inHE0fyAsJIm6OPdpqdo8n8rpkf38UL+ijeDK70wA60h97xikwjRNjOzCPE30zokKgO3Rkecb2/Y5yUQgztMw4bhu0s5wOPSpGxn5kHEeGfmbsRuYpyOMrxe7+hC0zDg/yGe5v97hC+uVKK5pjR5wlNWjoJqbB0zc90cs4cM6wvz1Qrkqe3u7Iy5LjU4PJDc2uA63ojyPT7JmHWZjF40x/6kHB8fFEVjp2twfyynHadtjMcHpqJBatHYg+SEmzGxn7mfbYE4JPTFTH9maPzRz72wNZmXHcnsgK8cTGCF0zME8T4+gZ2gE/eZqTjGFrLZcfrdh/fsRaTXdomf3M46c7uqeeYRhotg2n+0Z6c+p8qASinBxVlAUz2V7mODNHoRdNfiQSGFU6LQc5AU5R/JnC2gVPwGCTSthj0czdzO5mzxBGurZjCjOzn/GjR6Gkl22h7TpGMzLsB5bLBYftCZsbmn2LUoru0DH5mXGYGJqBeRhpD9LDlL58zj55sff3R1xhOT42GP38GUaGfmToBsZ2ZGhHiBIZaK2RsVtl8rPO2L7fY3NDe+xQwHDqxffZz3LynDxDI97KZtdiMsv+/kBR5+xu9mSFaB+ssZz2LaQxPA8TYzcynnrmycs8ZDT7R/Gvbt/vqRY5+/sDmbM02xajFO2xJU7i+xzbET96upMwtE+PJ4xz7O6O5HXO/u6QPOkntDWc9h2ByNAOzKPMF33TM8+B5tijFBweTmRFzvZmT1lLkowrpLStraU/dYQxMnXj2Sr3VVxfL6Q/xks7fbYBiIRb/jfaYDJ1RrlVq4o5+ftiUNL/c5Ysz3DJpmCMo1qWGK3PtgVtpFfoQ2B1uUhBwRIkLmkpmixzWJdS7K2RRImUOKFSKkW1EnRgtZEA62pRpBOSw1qNK53I8ctnX5xYcowzZFWBDxIQPk+ealFhnKZeVeSFo1yUFFVOXspuPisdZZ1jM0O9qdFKc/l6jffwt14N/EqzJVrDB4sFH69WeAVT9Py2N2+4LAveLj0/96u/yOJ6QVY4fuZ/8lMYY7h4c0nwM6vLGq1hualYv1ixul5h0+n8OX1CKZXSXJLfL8nvq3UNIVAsSpQWm5IxWuwwJn3uVnCNWhmUEyuLIlItSiYfqJa1qIgXybpTZpKWU2QYoyiK7OwPNc6erRIxRBarmhB9CmUX6461WsKSnaWsJXDZOIt18h24XBCN9YWgI6t1iYrynqw1Mv6sIS9ylDUUldiiXOEkTcg6qmUl1oFlmexHMs6KOsNmmrzMxcJQynjNkm3HZQbnMrFuLAU7udjUqABlmcl4q3LyzJFXYt1a2w3Z5HhQj+zYo6Jm+GIiDgjkfJiZmgk/BPquZYqj2HcQfGA8r6wqlX4jTjvm4LHaMvkZg2FKPWYdpXRslMGkErBNdCOFqGHDFOi6nv3TUYhJOuLxUviNiiY06XEgFoFYBnRh0v3pUCDw/SA2NBXl8zBWk1VCWbKFTWPKoZVUboyRdJVnu8vyQoK7q0Ul4fB1LvNAGkPPp/4sk59y+nMYrSiXEv5ebeoUdl2itFinjFFi+7KashKVtiQ6aYwVqxTRs9osCAHKWqxsRZ2hz89vvgz+Tpaac6qSgaIq8PHLMZxXEmyfpXnI5fJTlPqKLBdrj9YKm8k9tEg+8Wq9EJtVkWEzR5aL3a6sJXEqL+XetbmVkn9M+EvvqVc1kUCxrL4+kf6zchV1ISentQT7Xrxe0R5aLl6t6Q4jF6+XYrJei180S9FX2gnbVRtNuSoJ88zisuS0a7n8YEOz77j68FLUtEsp38piK5zVPHfidVzkKZ2+pG9H1i+WnA4dVx9f0h07Ll+tGbpBJj+DLLqZ8FmzUhaCellBhNXlkr4ZuXi1oW/6pKQdWV8viGGmXMri73KHiiIoCiEKqSWIICimEm9I/cgQA2gYppm/WD7yi2FHfFHyU5cX/PSbN2LriZBpi9Wa3/rmA9SqYGtn/p1f+MvcHY4EH1ldLbn+4EI2FV76UWGWvlcMkWJVMg1TChrvuf7wkv7UcfnmgqEdWV7WoGLyeDpc5qS0ag3lsiDESL2p6Rv5ne7QcvXRBcOpZ3VdMQ8zy4vqHJHmrEUbmYAA2ShNntWVlJSvPrxkOPVcvl4zJ/9sCJF8kWOsxbr0/EYJS9VLeb499Vx+sJHX/sHFuV0QxkBeFyijyAuZdI01Zy9xuSjw88z6akFz6Ln6cEO776TEduqoL6oEXSiwNpXmCuHkFpWwhZebmqEZufzwgv7YcfVmQ3vqWL1YME+exbqSBTpz5/Kwy2XCL5YF8zRz+WZDeazIVjn33RNqBWGcubhaAZG6rMlNIdWa/VESi0yBjzNT9BgtBCMTNU7bFOgtFg2TevFGGzwBp6yA61NfXohF0sf3PlLojExLAHWz75mZWVzVRC0+yUxJaTfPJY5ssVhyGI6UdcHJNxSvMr6tf5KLl0vGXiAbSgn8wjqLNfa8UV6sKxTCmG728v33p4GLNxv6pmN1XeOj+Je1NZhUFpWNqkMRKDcV0zjLHNJ0XHy4oTv1rF8u6LuJxbpMpWDxfiqt0hgyFIuS6KHe1HTNyMUHG7pjx4uPrxiakdXVknkOZHWGsbJRsrnDZI6sFPZ2me6hzYsV7aHn4s2a4TRwkdoT6xeygciXxZeLXyULbbWqIUoFqT31XH14Qdf0XL7Z0HeDtLgmT7XMMU4Y2Vme4TInGz+jWawKhnFm/WpFe+q5eLOhO/RcfrBmHiYWlzXEKBFxiRH9VV5fL6Q/xqs5tAz9wOH+SAiRhy+2WGd5fPtIVjoe3m6xueXhc0lOeHq/Y/Ke07ajbzr6tmd/f6TvJ3Z3R7SC+8+eyHPD/WeSgrC92WOs5vGLJ6KC/cOeoR9pdieaQ0vfDRyfTsQQz/9WEjsc958/4pzl5of3KDSPNzvCOHPcnuianvbUc9yeGIeJ7f0epSJP77Y4p7n//BGba25/KMkht58+EGJke7vj8d0j7z+5ZRpnuqZnGmeGbmBoR6ZUtvKTJGQQ4f+5/ZTv5g1Bw898+Jrf9ht+Aq0Vq1yIN4U1ZNrgjOV/9tM/xcViwQ8XM//Od/5rPv/hDeWixDpZ/E+7hhCClCRHKUken074yfPwxRZtFXefPuAKx+0P7nGZ5f7TR6wx7O8PzPPM/mHP2E+0x5bjU8PQS/pFjJqHLx7RmeXuk3tc7nj4bIvJLbefP2JQ7G52TNNMs29ojj19O7B/POKnmcP9CWsdD1884YqMu88ecXnG/edPWGt4+OIJQuDwdGRMcXHNvmUYRg4PR0Dx+HaHzRz3n6XUmXc7VKZ5evuEUTKG5tnT7lvaRtJnjk9H5smzvT1grD4n9jx89oTNHfefPqCV4uGLRyBweDwwNvL8x33LOEw83eyIMfL4dovNHXefP5LlmSTXWM3NZw9oo9ne7vCTp902NIeW5tRzeDgxT4HjtmW9WtE/DrhSE9uIzwJ3+h6MYjfsmf1IO3UM7cg8zjze7Zh3nvFppD02zGEmMzlGKZzKKF2OQmOwApiPMIUJAoxBFlrZtgng3imZZNuu5/72kWme2D3sKCkY9oOwnweD9zOjnxj7iRAD2+OWQfU8fPrEMI7c/PCWeZy5++yRLLPcffqI1vB0u2MOkmg09AN9O6QEnZHd/R7jNA+fP2Kdkc8/c9x/+oRWivvPHoDI/u4oCT67luO2pWsGjo9Hoo88vd9jnOXxiyfywnH/xRaXSYIQaEmBmmaa7Ymxm+lOPcenhmmc2D8cUTry+PkWm1luvn+HK79MH3r4/AkfIk83O/w0c9qeJMGolfEXpsDj+x020zx88YQtHI/vdrjccfPJA0pr7j9/IPjA8enE2Ay0h47Dw5GhH9k/SILM/Q8fcM5w//kTeZ7z9G6HNkYSdKJmfyv30Gl74nRo6U4924cjfpzTv5X3Ka99i8sddz98QFnN0+2BGCLN7vSVzvVfL6Q/xkuJU1xoLckXpRCJvNaRoRPFmU/iG/kdUUvGyFn1Kicsf4bNqySVRye5fRTkXvSi0hO8YHr+IMb2M1Raq2StEVuETkBzEA1jfPZxpUnp+e+8l7gpP83CpZ1mtJMJh0SdeTbgzzPpdSixzydD1/NPLXU1AvCfPn7C3/Fyg3375Ss+2lyw7aSntOt7Yozs+55+nunHiWH2/PbXbyg3NQ0z/6e/+V9y354IIbK6XHD56kJoRAm+r41Og1xOwCpG/CwIunlO8O/gBZoeQlJMioDljC48K3/lNKNV+iytqBdF7phUy8+AAJ/wdCnRRimN919aY1CReZowCoL3CCJW+rsxRvnfxAS+F6CAsaL8jSGcH2MaJnSCQYTw/DtyAouzT2pUWURiEmqFKONgnKaz51TyVMH79P7NM7M2nFFrygjLmBiZpy/fi3Op35isEmiVItDk+44xohVnxSVdZJhGxjAyxolhHpmNqIVBY2MSblnNsBtop47H+yf6ZmDsRtrQ0fuBypTSX0eCGXLl0NqQaYczDqctzrizn7BrBjKd0+w7pnFiu91hSDhHLFHLdz4wEGLkOl7hsPJdDsjJuBN17LT1NPvu/DmI/1XyMIOX9/IM6SB8Cf1Hpe8/eT5FICfKX21UUvvKDS2oRdH+hvS9zLM89jx5glKC1kvpPj9q+IlJ6fdsCyON2RgV8zzJfRpmlDaiiDWCTdTpvnm+X1WQOUQrkgbBJ7+qPwsFbSqvKkT5HEIQtXMQX6k2nJXF1hl8CMSo8eN05gPrBH8JiaEdSQ3yVJ1ViNc+en+26CmEY26ex3QK+Hj+FGQMfzXX1wvpj/Eq6hxBzwljdXW9pG8HLl6t6RsptU3DRL2u0ApcYTDWYpyU1KwzErkWA8uLJUM3cfXBhvY0sr5eMvWzhHOHSLnI0daRl9m5vJRXEpxdLErGYWT94kcUt/3E6sXyzL6MkPpmEuWUFZn0FuuSGCLrS3m+zas13Wlg/WLF1Mlr94N4G40xqTQqvVfSoA7PiwPP/a0IKvKXnj7nh74Fo/hNm5dc1xVGQTtLqskUxOQ/pRKdj5GoAkMI/LY3H1IVJbeV50//yt+mmSdWV0ve/PrX597j84SS1wXee9ZXotK9+mDD1IysXqzp2kF6oyiK5E21zuBKKa2WiwKiZrFZMI+ei1cbhq5n82JF3wwsLmtRCC++LK1mmcPmzz0dS7ksiSGwvKxFeXm9ZGgG1tcrKQuuK0DQcM5aXGZTb9VQLksUmmpd03cjm5cbxm5i83KdlLg1s49UywqMIqsyKW8ZwcdZY1LklWexWUqL4eVa1KMv1kz9xGJdpZg36ck5J6pL4wxFXaCVZrGREvbFyzV9M6a2wMTySsZQVRdoJahC66S3n1cuIQhLfAhcvbmgO3S8+vglENBXhlM8onPF7rRn+7RjnIV2k7uMQudUi4pIZHFREwgM7US37TDKMsYRrzwrtxSgAWJvmsLElBZpkIXIRct4mnj3+Xs8M82+5cWba6Zxproo6empF7UojwtFYQsezSOTmeh8R1cNNFPL4lWJmSzrTN736nrJOEzyHSrB/GUu4fsSHjCvi4SvqxiaUfi83cDm5Zp5mqSvOfvUe7TSmsmkB56XOaQ5JPjA6nLF0A1cvFwztD2rqyVDP1NtyqRjyLGJdJQVMobySqxoy82CeZhkHugn1lcrxranvhCNRlkX0gvPrMSYaU32jCCsMulxX8kctnm5YjgNrF+u6bqJYlmAEZW3s7IRKmqX5qHn8bdgaOX9d03HxesNXTOI8jxKNJrR0k/Nc4d1RvrzSlMuJXptcbmgb4bz/bd5uabrJ+pVTZgkvFw0HIbzjuAruL5eSH+M15ASGYZ+xOWO5tBSrqTXWS4z2qanKHO6tkcZgx+DKBN9ZB5GATK04vHqT50o3R6PIsE/dmSlo0/M064Z0CoyTjPjJGSgcZhRWtTDLrccnk5US0n7qKqC5tBhC0t76CVSbJqfD1GimvOevhvRGk77jqLK0mMUQgoqnSSr5Fb8rFZ2vUM3SjySeT7dJrZp2l36EPm/n77gs4vAuLT85t/86/nWx68prGMOgew5Mk2JGEGTgpl1PPtRrVb889/8iPybl9zpiT/1i3+LOflFF+uSzYvVWe059SMu1zTHlqISulCe6FKudEnxp+nbAZAT1DwK7abvRpSK9G0vn/+DpH2c9p2QkZoB6yQUwBrNNKfUFO/FVxoCYz9inKY9DlSLkubYUS5L2mOHTY8BiqEbRF06e8ZhYvaBoRuIMXDat+SZ5bQ7CaFo31JVBd1pwDlL14iqcRrESxyQNCFUpO8kKqttWqo6Y/94olpXNIeWvCqSEV6+Q2JgnmehFc1BfH0a2pPAGw5PJ6pVwf5JqFbdqUtQi0FQhtOMn2bmEAizFFXFr2jYPR4p1yXFoWKlN8yfe4axpzc9w6nn9P2O0/FI1/WEGJniTDu2UoHpZy7NJduHLcM88Pj+iceHLbubAw8PT9zfPbDpLnh6eiI75hwfGtRO0z/2DHcTp13DcXdEOcX9uwdc6dhvj7zOXzP2E9YYgcBT0Y09p+nEcTjStC1NaBnbgdGOPLx/5PpwzeXdNeVKvsO8EGuK0UoAFkqnMTRDDEz9gDHilyyXhXx3C6FMZaWgIq0zZ3DBeE4QCgLpUEL7spmmO7VUy4rjvqFaSN88K4zARIxhnmciJJW8pDk9xx/27UBR53SnjnpZ0Z168ipj7MWL2iWP8jyFNA8EQQYqxdR7XGE4HgTmcdq35Mucdt9SVpJgpbWi70axxKaqSQghEboM3SElxySq0XOS1dCPWOcY+gltlLzvUT6DaZJkrKER33R37KgWQiYrVyXNvqGospSgZOi7AUVM9jr/lc31Xy+kP85LSblMK/FlkRYBpSB4UV9OkyfLc/w0YwsrnqjcSeCx1mgt6QkYJTmlSHqFQjiUNhOUW5lQcXmREb3C5uKdew7F1tYI7UUhhvu0SMVZRA5zPwlYf5S4JojiR1URZUSZp82z2lFBUMyTMF39FBJjVJB2IXhcIarNrMqxTtTDeZlhneW/vB74pUXL8BMLft1Pf8yHqyVTCNTW4SMssowIZEajYiQzAmzQUcpwMURyK97Pf/Eb36B2jvcv4X//i/8FrHOu3lzyG/6Fb7O8WHL9wZWY8rUDVAoAkNg2bRR4gfSPiToz9QKFj96jtYAejDPp61TpO5UymCKeE36scwzdQF5kKUlFTP/CXE3l9pjKTTHK95lgAFnhiCnoeB7ms2BLOMiijnTOJJ6qqEdVOqHrVDLLSvFqlnUumZfpNWutJejkOSjdCA6SVPLz04zNDT4B1adJkmZCSOMuCuBC2L/PY48vQRvK4GPAZZkkCeW58IKdJXh/zrY0mZWJfQ7oUfEbxm8z/0qg34+4vYOgMKPhdN/wxc07uqHjNDZk3kkU2OzZ+R3eeK655nhoZJOyn9iNW6a95wfHH9DvBnbdntOpYdfu2HV7tt2WYRoIKuKUhF6vWUnPjUdZSLyl8z0HfyT0gXEaOUxHJj/S+4F+7OnnnqmYuThcsKBOwA8pd2f5c7BAJhxqJ8lDxvxIAopKiTbPbRwlJVtjBVbgMsc0CcEsePFmo4R1TUzfB+qcNfvckAlzPMfgZXnG3M+ipo6SfESQNB4ZN8gGJ7VsQuDcCsryDO9nXClYSm1syqdNaT7GpPzWNA8pAavM5+efyXPH3Eu4e5wjxhhUkLaAMvoMSdAJnhETFjBMcg/1/SiIRe9T4LzMNyp5lKX6L9mwpFziMD/jMFPg/OzZXK/P7/GruFT8KjXCvwauw+HAer1mv9//j84m/b/8H/4TukZOO2H0mFxyI7PCcdw3bC5XPN5suf7wkv3dgcVVLd7POVJvSvpTT7ks6NtBuK2Tl1PoqadY5Oxvj1x+sOHp/Y6LNxcctyfyIkMj9JTl5UKyJhMY26bcSpc72v2Ji1cX3H3+yItvXLF7v2NxuaRrO3QUpWl77KhXlZx2U481T56tYlGwfzhy+XrN082OFx9esXs4UNYF0zgxjZ5v/aaPJYNzURC9Zxgm/vPskb973NHW8M2XL/itL99w3x15tVhzdzpyVVU8DR1LmzFK048IWKUY/ERlc0bvCURqa3nsO15WFf/v7/wAfd9QFzn/1m/+F3m1Wglcvh/5m3/hbzPNkkk6j8ItbnYt1aZmd7vjxUfXPL3fiap510hqS+EYm4nFhZjojdaM00y1yIWbusjZ3R+5eLnm8f2WFx9fiU93KWk/fvTUFxX9aSDLZbdtnWaeAlnpaHctq+slj2+fuP74kqf3ey4/vOD4eJRyYCEn5cWmpm+Fh+wnjyutAMuLnOPTkYvXGx7fPvLio2t2t3vKVYEfAtM0plKaoNwEWG8ZO5ko+1PP8qLm8e2W648ueXy35TKNIZuADOMwnr9/azV+iuhMM3XyGR63Yq5/fP/Eq2+84On9lsVGPL3zJFaYvhkSTGDgo29/wNAICGL/cOSvTr/ALtty/dNXuJ3FNo5gAt3c89FPv8Eai8lESLTSSx7HJ66X17SPLRcfbHh6t+Pq1Ya3T++5Ki44+oaFWtCrjkKVNKFhoWtR2VIQTSB0kfzS0t9MLD6seLzdslotaU4toxuYg6f3vYSEI5uFndrSbQf2iy3qv7H8znf/IkWZ0ewbVi/WPLx94vrDSw73cg/3p5FIlNPWqadcV2f85DR68srRJ3D78eHIxQcbHt/tuP7wgv3DibwU7OE4jCw2tXi4y4JpGCRIfJDow2bfsHm14f7zB15+dMX2/YHli5r2JKSqYpHTHTvqBIIwRqc4t4yxncjrjMP9kYs3G57ebXn58RVPtztR+QahJy0vFrSnjrx4HsOGaZQkqHZ/YnW55OH9npcfX/Dwbs/V67V4q420h4a2FxBFO2ASfrCoHf1RTsfbhyOXL9dsb7dcfXDJ7u5ItSqYkxd9cVHTn3ryUpCmxgoRrqgzTtuGxUXN9mbPi4+veHq3Z/N6JZzoGPhf/lv/Ki5zX8la8PWJ9Md4HR6PtPuG/fsd8zDz8Okjxmje/+COLHO8//57nLO8/94tEbj/7JFpnNk/HGgOLcddy/7uQN+MPN1sCcHz/nu3aKt59907bG64/eQObeWnIvL07omu7dk/NRweTzT7lt39Dj96Hj6T57/54S0uz/j8H76VJIvvvAelePjigXmY2d4dOG5P7B9PbO8PdE3H9m5H8JGbT+5QTvP+e7fYzPLuezdoo/niV9/h5yCqvTnQ7BpRb546pn6kb0f+k+5T/sa4Yybys5cv+Wi5JhIkRzKJsmIMInCIz3BxRIQSIzEqQcQlsPgzS1ej+c0fvcG+XvBejfx7/+3f5Lvf+0IUs3dSKrTO8PD5I0pp3n33Bps73n9yh3WGd997jzJw88k90Qf2d0eGdqLdd+zvD/Snnu3DDmLk5gf3GKt5+6vvyXPHzQ9uMdbw7rs3KAWP73aM3cj+8Uiza2n2LfvHA9M08/h2i9aKm+/fklWOz/7BF9jc8v77d2ijePedG8Lk2d1saY+ittw/HWn3LdvbHcF77j99RGnFzQ9uyDLDzXdvsZnj3fduiAoev3hi8hPH7Ynm2HHad+xu5DXdf/YIOnL7yR0uc3z2D9/hCsu7791iMhlDwQee3m/pm5793ZHdw5Hu2LK92zFPM4+fieL0/fdvcLnl5vu3OOf44h++B63SGPYcHw40u4bj05Hd/YFpmNjf7SmWOfdvn6hWJa+Pr8iqnKA9Qxw5VSdmPRHGiJ8Cx+lIvxt47B55f3+L9Zbb+zv6vOfp/Q5TKnY3B9ZuzWF/QgHH5sgUZrpeBEWDHyUhBcfx0FBmBU83B/qy590XN2ir+PT2cw7hyPZpzzROtH1H6APt2OGbmTnMHJ6OsFVkX4hC/PaTOxlD331PlltuP7kDBXefPODHif3tnv7Ycdx17G8P9E3P480TMQbu0ri7+cEdtnDcfP8OoxXvvneLioGn93v6rmf/0HB4amiOHbubJ8Z+4v7zRxlDn9zhcsfnf/+tfP/fvwUDtz98IEwzTzdbmn3LYduwu9vLGL7dAXD7yT3KKN5+5z02N3IPO8Xnv/oeIjy+fWTsRG2+35447Vu2NzumYeLh7ZPMYd+XOeTtd29wmebd9+4wVvHuBzKGtjc7upPMQ9v7A+2h5fHdE8F7br5/h3KKL777HpdZ3v/gFm0M735wSyTy8PaRaZo5PBxpDmkM3+0Zh5HHt08oDW9/9YaszHj3XZmH3qb3//57N1IJMV/bX/7ZuXSSs2olJZDgE3NSoNrTFFApAUglhaZOakltBBGotEYrJNzXWUKQcsbsRTU7TXMitEiZLsSIMTaVHZ8DovU56FgnBqw2KqWbJFWrEsWpNjop7UxKpVFpZx5xmURzGaOZvZeItlQi1E6Ue88CHz/Lv7Na41Xk/zHd8t1iJlj4mZ/+mI9eX3FRFUwh8LJeMPiZN4slgw9c1wuCUqzzEmcMVZZR2IzcGpZFjlWGZV6AgquyYogzrxcLfvs3PubFyw33+cS/d/932Q49UcHlyw3XH1xJKLTR+JCSMjrpZ3kfIChRKivpkTqj8UEYyUm8K+W5EDDWJpV1lP6T1UkVmZJLrODJlFaiQkwq4IjEq/n45UlbaSUq4oR+DSiJVHseB5JeLQpOK5F88vyJWzqPX2oqoihmhb0rpfgYv4wGiyqmVJ9wLgmLwlaUwVGdMUIYZ1NrQbJxpBSumYPwcX2Q8fUMaVdagedZb0mMStJYlEqweembWWuYhxllDa/da16ZF/THgVM4iEhIzehZCE3DfqI3PVnMGNTAo3qi68UO9NDf8zg9cWiP7MKOcZJT4DAPZKOjm1rcZGnHlmmaeAiPnPoTX4xfsB23hDGwn440c8cw9cLnNRKkUPiCqCNTHNm2W05DQzzAT3zxE7y8eynMYe8x6R4StbN8p9ooMMKmxSQ1q0ktHaQ8OaV4vWme0Ujgg7IqlSxFuWqNRMkZIxxnpSV0+zkqTfjdmnkWvnEI0mpAJci/TsHqUcr7Wsu40lbGu7MC6McYuVe1BSPfX0wq8xgC1srjkfChz+Paew9Iug1GC4s53SjPj2GMxvzoPJTe/5xSbaT0nBjZLoV5J9WxTo8kzgfZOCtEEayNFSeE1ngv92j0HqPl/fE83r/CWuvXC+mP8XqmyBQpsHd1uaTrRjYvVozjzPrFkqmbKeuCqCRg21oxFGeFxVknIctKUW8WjJ0o7sZ+YnO5Yu4nFpsF3s9UdX428rvCYu2XQICszAlTYHm5YBhm1lcrhm46qzbLpFrNy6S4c/bcz8zKjKCgWlYM3cTl6zVTP7O+XjJ2I6vrlZScq1xyEZOZXzij0nv5T+MNv1w26IXjZ9+85lW1QAOnfqCyjm3fUmcZj11L5Ry7tkPFSDsN+BiZvKf1gjtsR5Hut8OEM4ZdP1DajPu25aLI+Y1X1xTrmmMe+ff/xl+jHQfW10tUyjL10yyf4TBy8XIlZu7NAh89eVWI8tiKIf75c1BaUS0rpn4WXm8nrNN5CiwulswpkeWZOuUyew43t85SLwtiFHLN2A6sLxZM3cT6coEfZ+p1RSCQV0KfsU6yW401AtUwmsWyZBxm1pdL5m5kfblk7GZWlyvCOFMsC4wW2k6WZaJ8LDKsE0JOiJHFumZ8Hn/dwOpqmVTjovwt6jI9vyUrXPrdFKC8LPGzZ3kppdvVpYAIVldL/DhRLUvQMtaemcFF5TDPwdVKsb5a0jUjL795zdD0fPzNj/iNx5/GtRlYiJvIqGfC0tNvO+JNJPfS863zGjNossuMZmiwFwZ10szXE8f2xJzP7KY9k5l45Ilej+zUji52jG7kNJygjoSjIr/MaPqG7FJyfauLCj1r5nLGWstQysI6q5looG86qrbkZ/hZXr98KerVF2v6fmJ9vWQeRZEdU6/aan0mk1lrKSphKdfrBfM4s7leiQL+Wj7/1fUaPyXVrNES3J5ACK6wqGduto9yD/cjm6sVvp/YXC8ZRymj+xApE9RBGyFzWWfJFzlRc1Zeb16sGHoZS36Q8u04TFRVgdIGl0AMNpP3oI2mrAr8FFhc1KL8frFiGifW1yv8IIr42YtWwzqHyy2udPI6yiy9/wo/JrdCP7O8XDANnuXViqmdqOoURp5JcP2PgmHKRfmP3kNXS/qkAJ6HmXpdM82Smeuc3Adf5fX1QvpjvPzoifE5RijSNx3GKbpmwFjD0I2oFC+llWbsJtklKs7//9SNwp9sBrRRkkHqLP0wiDVkGDHGMgwTIQpjdhqns+JWIWkfykiqhTGiLLSZpW+EwTqd/92cvJCBcRjxPjB2AwrOijrp9Sjp/RpNd+jEqtKNEh0VQuKTQvSe/8Js+VXXg9P89tdv+MZ6IwIYLVD451Dp53MPyf+ltCIzlnmWWDCehUZRBBtKx7NvVcUgQqrw/2HvT2PuyfL7PuxzzqnlVt31Wf5Ld09P9ww5kihRUsCRJQ8dygsDKQxsRYkNB3DkOIoMxIBfRDZgwIbhdzYI+IVlwIC8vbSUxEACJIgFypGjBJFFQbEYRpHI2ae7/+uz3P3WXmfJi9+59z+UDYSh2G057gJ6np6nn3ur6tTZ6vfdwCjFz330MauyZK1HfvGHv8Kpai7kouvn4gyUJIam7tGR6Sf40YgLHucdfT/gnRO9HMizMoq2Fc/TLn72HKI8diNBib7XxQSdsRUWZNcI87eJONWZJdvGBJ+hH8Wpp5fg6aDAtZYQPH074n2gaWJ7N9JnulZYjEMfI/g6i1cwjiN2HIX5246EoOh70av2nVx7U7WYNL2k3/Rtj9LQN52ECgTxOx2thFuDoq+7i+YvyaXPKqXi+c2F8WzHMbK/pd8HAl3do0KQIPNMc9pUpFlCta9ZJHN+z/53k18V2HzEKkkOaZqGamxYv9rSvx6ouhNohT5oITK1gXEyMLaWicmp2xaNoet7rLcSXuAlKKEbekyQYG2bD9DEIPLGi1a1l7d6VWke3SPVWHEYDxz6I7tqT/lqxspeMc2E6ZokRtjKiQStY+QetZb28F5Se8ZBPICHbgDejd2+GzC5oWsGdCZtq5XMB2c9+NBJlKHtbfS/7Qla0VXCTm2bHp0a+rbHKASD1HIvLmqi+0bmgbEbwAW6SlQEbd1Lzm4/oJSOMW6KtulFI+ycRCnGuST4IEk1Brn/TPypjdGSZKWgqVuMVtJf7Yj3ThjkxHtQ0FQtqBj1Z7T0C2DoOkwq4yJEnbdobQNj18coOPELbs9t2ApuXx9qMCqypg3tsb8whr/I48uF9HM+8lLYq8VCtJqTqfjZmsRE8qZ4qtrRyW6rG2QHGzWByoiWSinROXoPSWaECZyl6DQRnemyxI2O6aIkWChmBVoj3p5ak5cZwYvlnLPCkNNGkxjxY/XeM1uWjP1IMSsAxaTMMMYwiW+2k9kEa0XvaJRBZ5J2ooz4BQcrVnLeeZI85X+z/4S/MalRBv7+jz/mvdmCVGsyI9mRE2MYnGVZTOidYzXJGbxnlU+w3pNrQ6I1sywlM4rMaIokIVGaiRHv4qt8gnVwXRT0wfF8Nsf6wC9843fhnpYcF5o/37+g+NqKvh7F/CCIBaOJ2aaTUpi2s4vnsVi6ZWWO0opJkcv9l6LpSybCAFY6Vp20ilpMx/xqGskQYhmXR3/iSZmDlzZEK9JcGLlpmpDmOaN1zK5Kht4ynU4IRL9koyinExJjmJS5xNQVKQqNSaNo3siboxst82WJHS3lPOo6J/JWmM9yVNBkU7mXNDfChDaGPE/Bw+xqFq3aCkLw5BPx/D0ny+Rljh8CaZaKF2omvsXaiA2gt55yKW/Zk6lUYdJM3qzTIqU9dWgtAc1KG077hiRLWBxXfPX4IXonRKbwCCMOY2WD0tIKLJJqTkNNkiQMx4GMjOE0gFaE0Qk2FjTKymLkR4d1I8mY0KmOvM0wJqE79YxaPH298vgm4JVHO4PqBLYYHhx905H5lN/hfwe/y/8uVKIJHrFt9EGIUKnBaCNv/R5mqyl2HMmKHHyQ9BJtLn7V6STFeWm7EBToBJ2IK9NsWeB7z2xV4qwjL8XiU2zvEiZlinOQFgkBj8kkuSZJDPkkw3vPYiX9b74oULFCorQhn8nbbj7NgUA6SVFBy1yiDRgtek7r3/XhmVicZkW0Giwz8JAVKd4Hskxi7JIsYTItLvc/9uK5HYIn/7GqmFaGIlpeZkWKMpokFw9ijKJcTGQeupriXCAvM1CQThI0ism8AKQve494/8YKXl4UeB+YX0vlKMRS+xd1fLmQfo5HQEK9vfMMzSAh3nWPibhAXmQXNx1l4m7fJKI/8wHfO4J32MFijLrozca4g/SjjbFSshPURuOtJSDpC8ErbOxQY2/JCoPthVY+dhK2bM8Yg5I8TW0krxQCbhQcxkWHpTYyMMfBCiY6RIq6k78NUbOKCvyFfMPf0BV98PzO22fMs4zRe3rnsNEBqLUOR+DYi36yGkZUCFRDB95TOYsHdl2PdZ52tPTOMgRH60ZG7zgOPV4HDl2PCoq7qkZpeKhr/tB7HzCdTHg78/xLP/hrfPe45bA5keWptGFioiSDGOgtmYfnLEQXc0rHUdp/7Gxsu1FkRz6Q5QneerpzxmI9ROcVh/dCmkHJ25nJRKsoulNLmieMoycEcboamjE+5xFxvpFc0qEfCR76zpKmRqoDicKPUf4yxMxJrRl6hzHC7JTPCm4+NNI/xnoQBnjMkcT56OEUouTBYDsrmbHRq9hFF6uxG0jyBNtZkRuMjjQ1uMFGdxyFG0bBzM591AvWZa28/Q3dwHQ+wY0j5TTHdo4sT/idd7+b1esrJpOcYTnQ5Q1N3zCkA8Epji9OnD5tcBNJJcomGWGEdt7Q+oYkE6ZrZlKU0mRGNqOJTiGF1Ke0RQc2kEwNfrSoQrC+JDEEGwg6YDC4xNGZluSHE/Juwsfq49hmliSTMZzlKXaMRiFWtN+BwFAPIu04zwBeHH+sdTFPU6RBtrekmUE5kW4QJJRap4IP6+gi5kPAWXFI6jtLXiS4IZCmKS7qM8c4xkOIunOT0MeKxjlP2PbRCagbhWMR+5AbhMuAlQxQZRRjE6scg8WHKJdRUrFKi0wMWMpcggKyJI4Tf/kbk0g/x8u1oxAHplSqbiZNLrpTO8b2H33M7+Uy/9hR+jRxszp2UpXp2/5yDpOK/EUFwVDtGK/pC0x+gS8X0s/1MMZgByEYSahvtMMyImWxQ+w4gyXRIog2qRbxdZrQ9wMmTRl7K+n07TnB3gqhx4tgWUWruCTR9LWUjaz1FxG4UkE8Q32IguVoSxhDc4dmkGtspMRiR4dOJKkeoGtH+UwMru5bCRe2sXyjtKKL8go7WHZ+5P5UYRNH0JqbsmTwcWEJgcE5nAuMXnR4/WhRSlGNEhJeD7KhGGyMv3IOH8B6j0PK19ZLEkhvHcpDE+32ejdKuLCzJInhJ1crdm3HqR/4ZDgxdlbCvWNmqQ/E0HQdJ8gkGigkccOgpLypVTRHCAytlDvPgnmUGAZobRi6gcSIQD3NEln0tGFo42aoG8A7kchEuz2xjtOM/YiJbXg2NzCJlN6SVMrnWqtYVpUNjpg+SRkxiXCBMTJRmVS+y2j5bk9gGMQ1SkqQUsaWLFeZmM6LnVJxwjIiWZDy3hgNRsZoVzdKH/Ewdg5lNN2pI8tSsZ9MdbR/04wR17KjI5lIn87Lybu3txD4lv5Zfq//vdCAm1jG6YB2mtBKQHpXD/jXcPqkZpyP9L5jNVmhBkVIPVNX0iQNqU7odEtucpSHJEmYMhUdroc+7xn8wJPZLUM70E06bHBUaUVfDfR7IS6937zPz41/mOChPTTcv3gUg4FB+rwbrFhhEhjakUTryyazuxgExPZuLDpJsO0g0pYujmFrL31o6GQc2mHEZBKinqSiz0wSHcPUpUSstRB9XNyIj30MjR8dabSSPG++NSrGDCp5tlrmHCBGHFowMLSxPBxNXmz/rv9pJfNE8IGuk8qOmH+IicxwLhO3w2UeSDMTF0zN0Noo6RljuLyQtPwo/Y9oOmFM8g42iSHy55eEvonX0wyyKewc3vp3MIJWslAbTZJ8ca5G8OVC+rkeksfo6eqONEtoDhXpJOX0eCLNDKfNCZOlkqFHwA2jOHqMgmt4FxgaWfiaQyf6022DyYzkQOYp9a6OHVWyL4fe4gaLHS19O+Cdp2+ERHHOlDxuK9KJodrVpHka8wLB9jYOkBHbSY7o0A5AoGt6TGao9g3pJJEMwzSh2p1QSgasc4G+G1mR8cGnPVSWsR34y5/8QOz+1JnRGVD67IgpDMYLYTQKtm3wkYkob8tnZimRUXh2SUIJy+/M9gtKRXkMdKPlr716RfmDI1ffO/GNYUKSJTSHmiSRNkxTQ1M1aOUZBslvHAaL7UfJcmxG8J6+6iV3c9eQlQmn7ZE0TzltK5RJ6JteXGx6i3XiLNV3gvn0tWCj9bEhy1JOuxqTaE6bmixPaPatTFTdgLfiBBNGcbYZ4sTbVT1JruMzM1QbybI8rA+YTDSn3nnGbhBnK+cZ+5HgpDqhjRZsOEvkvrNEsMpJRrVvZLPVDoTRSRatl0mqa3uC9/Rxk1ft5fz1viaf5Jx2FWaS0jXd5e29H0bG0TF2Y+x/A8oYdncH0Q6+3ZMWKevXG4p5wf7hQGIM7aHlq6cP+aj+mJmZ4/vAcVvR70aapkaNnt2rPfVQ8/ZXH6h3LdVdhU0tQz9QqZrRWrowwACd6yBAM7R0WmLSetWJVts4fnD3CaHwNJuG++2ax1/fUFUn8hcTbrfP+Jr5GqqXt6btw5GxHWmPsQ3POO+2IslF2x0Q71k/OsZBxpG3Lm6iA/WxxmSSXZoVKdX2RFIkVLuKJFFi1B9dffwYGEfHEPuQOGjJZ9M84fgoWbrVtibLUtpTi0lks22tpe8tw2Dx1ovrmILm1JHnKfWulf63rUgnCcdNJRunZowcC+mHdrT0TS/9oB7QxtCeGsG5dzVpksg9pDK3aOUZ2lEyjUfB18/fQQi0TUcS5w6TGpmHipTTvhXMtullczdYfPyOcx9qTyJha441+SSj2lUxU1dymutjgyZmqZ7HLV/cW2nyhZ3pv4WH0gp0NKAOAZRIUYIOmIgLKOXxITrVuEAafWId0QUlyIKDjnmIBHG8QYlsJkpsztICELo7OkppNKLR9B6xi480fFSULUhnM4lQ9pXWIqdQUUahIg53ptVHRU8IAZ2I041O5DqFDBRQGv6BJ+9z3Wp+db+jy+Cv/O3v88f/wO/FekOZGjrnWBUFCngynWK94/3pgmoYeDqd0YwDN2VJay2pTlFK0Y0j8yyndTbKUzw35RRH4Pl8TjdaPpjNqIaBItH8xb/2/0INgQ93ij/69Ks0WYOOdoU6SUSaYfSF7u9tQEX89iJduizQ4gKDOpt6K4wWfNKEENtOiYToYokY/YV1FL8EcYVRMUtWGX2R2ygV3VrOW9soRwL5716JAEAZMCYhqmIgygrOsoTwY25H5yDsQHSyCRedDMS+cnaNUUZcY1Rmoj5XTiDSKRWlCepdvzj/u9GoEGMBolNPopPz7UePZZEX1aeGyV5wZ6N1/Hsp3/lY7ifAR/6rPKtu+BuH/yc2sRzdCbNNKBeeIe9RKPrHnpaWdtGRtglu9BTXNQEpzw5uQA0aX1S4PtAnLSSeEXkT70xHdVczTi3tQ40NHrcOjBPHN+vfz3vz59S0l3EcQoiSkx9zdfoxaZQXnUmULol0LCgZf+fp/OzqAyH+uxLZldExblDKnI53oQUSByiyNX9xRNIoo6Q0/2PnCF6sAZWJ7lPx7wLnviTyGrQ4XamIkRsj0hofRO7i/XlXG/uGBoxcj1LiqqaUQkWpibh3EaVkLoZGIOSw2F4u2oViBUpSRpyytI5YvZI2MIkWx67YP8NZNqa59I9w7stKE6Jzm1IKrTXeiUm+tV9safdLZ6O/4/jtdjZqTg3JucSWCVOvnEoCxfSqZH9/4PaDa06bisk0Z7QeN4ySHXhqKeclbd1ijJaFdpLQnnrK+YTjw5HVB1cc3u65em9FvZe3Va01bdWyuF3QHluyImPoBtI8w/YDJj8768yiK9KK4/pEMcsJXjG2A9PrKe2xpVyWFz/VoR/Jiozu1FEuJhwfjyzfu+Jwf2D5ZE5z7ElSGeCnfcNP/cGf5H//7W/zl8s9Zgik7834h7/+E+QmwWhFNY5cFRM2dc2z2ZzHuuZqUnDoeyaJYfQOo2RgZcYweMvEpIxemKWTJOHQtTydzriva56WJeu2pUgMf/lHP4Tv7HjWG/6J1cf03cCkyOh7y6RIaU4txaJg/3Dk+vmKalcxXZb0zUgIjmI2pT3VlMuZ3H8s9eZlRl/35LOMw7ri6tmS3ds9V+8tqXctSW4A8e1d3k5pTz3FdCKswjTB9o5smtIcG6bzgv3DiesPVpzWFdOYG6sU5EVOc+pYXM9oqoYkTbG9I5loxmYkKzOqXcP8phSHpWcrmn0jwfGBizl+dWgpZ4X47aYa1zuyaUZ9iue/P/Hkw2t2dwfmN+JiozxM5hOaqmexmsr5E8PYe/JpSl8NZEXKad+wvJmyfzyxuJ3RHlvyMsNbGPqe+dWC5lRTzgt5o0kEf/6J/87H7B8OrJ4t2b7ZsXyyuLBRkyyjOdXMr2Y8bte8Le/49e23CYl4AJsrhWlSzGDE0/V6ILFC3DErhSoDqcoRXzpFGANmTHHeglMEHGVWsj8dGY8j/Silz2ADHydf46fmv5OyL5ldL6h2FbPllL4beHzxKOX6IsN2A1mZU+0aZtclh4cjq2dLjpsT00XJOFpcPzJbzamPNbMr6UPJGRsthXglY/jE8r0V+4c918+WVHt5W0yyhPYUn+GxpSgz+m4kTQUuSvOU6tgwXZYcH45cvb/itIl9uJXKynQ5pT7VzFczmlP77rOlOAsV8wnHjTy742PF8tlC3nhTIRc1VcfqdkZz7JhMc/q2J80zhnYkL1OaQ0u5nHB4PHH9fMVxWzG/mdIcewnZnhdUp5b5aial7lTsRNNcKjiTac5xc+Lm/SvWr7asnq+odrWQGxV0Vcv8dkF76ijKnLYTaMsOnryQ+1+spmzv99y8d83h8Ui5mjJdiGnG//Cf/wXyyW9dBvOls9HfI0e1r+nbkcPmhA+wfbOnnObcfyp5mA8v1pgsYfNmhx0dp32D7XqaY097bGnrgdOuwjvHYX3CJIrHzzZM5jlvf3hPMklZf7omGMX65ZZhtBzuj/T1QFsPVLuKoR05bSWbb/1iQ5KmrD9bU8wnvP3kkSRLOLw9AtBXPUPX0zYDzaG9ZJl659k/HEkSw+blhmKe8/aHD6STjPVna5RWHB4r7GCp961gqB5O65o/8uwjfl9bohtLNwb+8o9+ACqI1k5rciWswdQYEm3QRmO0CNjzRAgkuUkIBFKVXMTlRmtSLR68RsnbodGadhz4T3/tuwz7jo/yOX/qG7/vYtO3vduT5Sl3n67JphPuP1mTZRn7twe8h+OmZuxHqn1LfWxoamkHbx37xyM60ZIDWuS8/cEjkzLj8bM1SWrYvT1iR0tz6BjbjqEdaI89fTNyXJ9wzrO/25PmCY+frSlmBfefSqbs9tUe74Pkdg6WalfTnhrauqHaV9jecrjfo1Vg83JPErNU8zJl82pPmiQcHg4476l3DV0z0NY99b5l7EZO2xM4z/7+iMkS7j9Zk5cTyaXNMx4+20iW7cMROzjaU0dz7GgPDafdibEbOW4rtNE8frYhLRLuP32kKFLWL7cYY6h3Ld4Fmn3L0I+01UB9ahg7y2lbgwocHk/kk5RX33tLuSh59Z03TMqc+08eCcD+/oAdeslhPTWoRvNx/RHfyv8QT6sn5CbDnjydaWlsw0CP+qHBbQJu57GvA+P3As2mpdn0DC8sw/ccw3dG2h8MHL5/onnT8eY7DzRNS7vuSfOUp+EpfzD/g3y9/QnmfkG9b2mPLX3VcdqeGLuB5tiiU8P2zY6syHj49JHJXNpOJ5rD3ZEQAtWhEaZxM9CcWvoujn8XODwcUanm8bM1k2kmY2iWs3m1xWjD9u1R3MAOLX3V01Ud9b6V5/9wIgTJNDYxQ3gyz3n49BFtDLvXO7z3kqnbj7RVR3Nq6OrxMoYPjydUmrB5uSWf5rz54R1ZkbN7s0dpcYly1lHvGvqmZ2h6umPH0IvbmvewebUhzRLuP3kkm+Y8vNiQZAnb+4O4Yr3Zy/kPHfWpZWh6cTmzlsPjEaUV65cb8jIXd6xJxpsf3JMkhsPDAW8d1a6mq3q6eqA9dvRNzAN2nv3d4XL+yTTnzQ/uSbOUzZsdAai2J4Z2oD40F5+SL+L4ciH9HA/Rcg34QZi3Yz/gbKDrhLTSHnuMUlT7Gh3xJ5QkPHhgaAecFS3hOFjGXpJV/CC4B1rRnFqM1jR1h1ZKMC0dGJoB74UYYuNnRztiYzqLt4Hu2KET0fMZozlsa0JQtFWHMjA0QlCyveBmwyiftaNn6EbQWjw8Ey24RwL1Scph9aGRbFMC//j8Q36uvIUw0vcjv/S97+K8j3pQRap/bDEEJomUBotEtKazJLnoRzWBTBlMNDAxyGKamYR2GPnVt29I1x239yN/4v1vCBFiGGmbjqGLurp+ACe4nzaB06FGG0W9r1Fa0zUdAEPd49xI14i20Y2WPuI+Q9fHAPEWpRXNsUFHXZvWQjZx1tN3/SVN5Yx/9+2AHx1d3YKC6iCYaX1oIplkwHvNUEecth2xo5Cshj5+tusJPtAcG5RRVDspW9enGqNFh+yDpNY4JwSZMeLnQydYaFf3BBWo9w1Ka06HWjYjVSdM43YgONEj+sFjx4GhH2OfFEJOfWpRRnHcntCJ5rSvUYiJAfH81nm6ZsD2UZcaghDPnL+UR7XR4ggUVQtG6cvvr/U1vy/5/Xyr+BYf9x+TmwlmpiGD4elI5zu6fUfXtLTrDt8FXGUZ6oHqWHPMjnSuxZ4s3on0JyPlg9V7fJNv8lP97+bj/GOykBKiOxNKrvFcthz7kbEbBYOzQtpzcdNhEsPpUGFSQ72TPtRW0rZ93ROs6DCHfsAOkuzjHXTtgLdO+kyiqI+NYJnHJpLbBplD2l76bSsaYXfuf72jqwdUoqmOjSS4HDvpw5X8HOLzH7uRcRixw0DXDlg3MnbC5K2PglE2xwatNE3VEoCuFrZ8V3dY67HRQ9s5wf+9dXI+pah2FSYztCfRG3dtJ7hr3b/TtJ6xz+58D4JjtqcOjLr0w/rYiL65ES173w046yJmbLHWShsO0g91oqn30nerfSNwF18kQvolRvq5HtkkFRZZInZbxbxk6AcW13O8dcyvCnwIFPMJKsjfG6NJs4QsTzGJJitShiZQzgr86MRRaIgZkoOjXJZ470V7qqQklKaSaZrlBtspkjwBH0Tj1lumqylulDxSO4xM5jkEcWJKs4Q01Zdg5TRLGLpRjOdHx+JGtK6Lm+jKsyhxo2cyE41lmicsnixQSlFMJaKpmBf8wvzrDMdP+Wvdln4V+KW//W3+0d/30wzecl1OqceRp9Mpu67jqijYNDVlktJasfUrQorSkJuEbrTM0gneOa7KgsE5Cm34C3/r19C15Ruq4H/0/GMmRU7fShnSjdJWY2dZ3CzoupH59ZRxkBKU6OMyTKIxSUIW3ZnyIseNLcksx42exfWUcRhFc2m95JSOgazM0UjqjknE2SgvU4ZWHGac9ZSLAjuKk5EdrLjRjI7pssBZTz7NSVJDkhmyIok/5bPpPMGO4gbjRsfqVpyVzm4xxSzqQ7OEtMhIjOiA+1qyHYfBMp0XWOtY3M4Ze8vsakbwnumqeNeHtMbkkitrUkMyyTC9w0ykLDe/nmF7x+JWfs6WJcE60fzBxREnjS5bSZIwKVL6dhRDfWtZPrnFDqPkk0anJT9aijKPjlwpJpM8yqxIcb2jXEwoVcn14oqf5Ovs0gOb05oxHdkNe+xUGOg+9zgsyTTBV44imWAyAyPki5yFm/Px/GMKN8GUCUlrSK9SnLMU8wlJqmMWrDz/oR1pjg1pTGSZLaeM/cDseiZOTzdThj5qLmMfSlNDmmiyVNoin2X0VU85n4rWOurFV7dzlA8UiwI3OIpZhk5E151mZ2ejlKQdSKN2c7qaMo6SbWytZ34zxVkrebRBNKbKaEyqSXMjc8kkpa8HilmBt4H51RTXexY3M+wwUs7EtSgvxcXInJ2tMkkcStKYaer8RSc6v5J+uLidyfmj0X1WpCSJEVekwpBk0gbOeibTiVz7zYyxt8yv51hrmV1PcVbGkDGKNE/RucEkmryIY6gQ/fvsStyZFtczrLMXt6ZiLnOp5AEb/Be8tH35Rvo5Hs5Kiryzss123kc5gUgRRuvxeGwf9ZrOEQAXRLvnncONTnSAw0hQIp+QtPkARsgFGsStyKgLacN7mVicBzt4AkGo+UbhYmZh34kryjjKeYdBtGcuiFemdx7vPARxKyJKH5JEtIyB6JoU3XnOmtMsNWIdaF3UITqUUvzR9D3+e+oWsx3ptg3/x2//bbrR8vZ0wmjNi+OeXGteHQ4YpXlTnfA4Nm3D4C37rqPqB2o7smtbeue5r2pG7/gLP/gu+V3D7acN/8QHvwPnHNaKRMZFvZ/cP+JkFLMjldYMo8g67OjODJmLb+44isPM2I8icxkku9JZhybQdQNaiaNP0NJmLkgmqB2DPFMfNYadOA356InrnHgTS9tFl6AQg9Cdj9mQDh+iU0uAsR/iW7PICGzU+o5DlOFYcdJxPsS3Byda4uDpx/HCsNZajAdU7FtGSf8IeNFFjp4QpRVBnZ+zivpjkW8oLfmrKmopz56zPgTxEw5SlZH+FfM5leawPsa3u/HikiXSDSvWfIPFO8myFH2maJyNEn3ujbnhg/p9vll+k58Jf4B/4Ppb/OHsv8s/ePMP8Hv0T/EN/Tv44P4rfHP2TX7/5Pfx9+d/kH9w8Yf5mfJn+PuWf4B5vWCWzFGVxpjoEhRUlJUFydEM0ncOmyP79fHiUmad9GU72KjblfFoR4cn5sF6f3FV8taJQUAIjIO8xZ8lSH07iE7Ti7d139nLm7pzVuYBG+VavcVbybg1Zze0c58BhkHyi611okEPYHsnz8M5wDNGtyDRpRthlQM2RqWd+3pAsjy9D5JtG8dwCIG+79H63dzW9yLFGkbpu5cx77xk+kaZWvA+5gUrGTPRScwoE+U10u4oGUPBirTHDtIf7SD6+L4dZKzE/midR6noV6zBRmmdO4/lL+j4ciH9PI8gjDaCF/ec0YqziXWkqWRQGgzpJMFaR14W2FGiygLiggKQ5cKCy4scFzNI3Sj6VBAz6kmZ0/cjk6lEEGUTccdJM41S8qbghpEky0Tbmoo1X9CKNJfswmImfq55LrvvJBfnGnFhCRSz+HaUZ9FEXwvzFCVZmtHRZhiiRtN6KSt2ogPrTh3//Q++zk9XGaaXct9/+p3vXDYDZ/d1WfZjXqeLxMgAKg7ys/haEWjtwF/4m79O8qMTH6uSP/HhT5FYmQjauqXe1ZydXLz1pJOM4AJpLnmmSSJv3857itmEYbDkRU6IBgIafXHwmRQ54+hJJkl0h8rEvlDBpCzwo6dclJe3SxXE4SkEHzMWA8U0xXaOZCL/32gtAQUB8jJniBFVzntMJsL+JJX2z8tUMi/LjODFeF7KkIrJLMePjnJe4kfxfFVBciJB3pS885edfZqnooE0BmMSfFAUM3ljz4sc7z3pJBU2diIs8bxIcS6Q5OKEpePvg0J0jqMjyzOGrifLMrx9dw9ZluJdIC8yHl6sqQ+tlLRTsZtTSjYDbpTJ1w5eyok/Jsm6lPASw3FXoxNDva1YZktUr1npa95T7/HT/e/hG903+Apf5Zl5yrSZU5oSXYuPbb2vSVORAelE0cbyvB1jKLoLFwlZCEH6OTL+7GjJixRvzzmhwmpN8xR8oFzIGMrObRdzaU1q5I2pyPFW3tyCl9/jAyEEJuVE/HrLDGvF/YigZKwq6R/eOrKJVFhMKlm3JjobhUDU5lpx4wriOiTuRJlUnWaS15lMxEglSeT5qADFdCIb4SLOVVkSHayEjZ9NEnnrnMbviLpcpcRy0XlPEc+fFRnBSR8JPsR7ET9xb92lSqSMWH+iFJNC5qZsmmNHF+e/2Ie1VFu8D0yKibRPmsSsX0iMvLEXswnjINaeSn1xKOmXC+nnePj4BuqDvDkmxoCXiVFrWaBstBEjSNJD8AGdGvGNjRRwUDFU20cijpRugpIBElASJByEVq/EZETOnwpRxzmPScVyTmy5pPQTxhADdAMxt1sGLpBlmSxcRqO0vGGlMbA4y4SdmqZJDNaVCTsxMjC1UfKdUU7inCxMSsE/uvoqP2euMbuB/r7hl198yuBE2A+CexKTZM7a0XB+S/byex88p77jb/7aj8gfOp6/6fknnv0kWmmCVxijqTYVTd0TYnqESTQ6xKQSL25G4+gv1mdaq3ch2Ap0KgkcOpEsCh/8u8DsGNOUFZlIT0yUsYiVDypKDnTUC+kkIcll4TGpJHqYRJink6nkteZ5CnjpJwGSVGzlktRc5AhJIu1/bu98kkvCSLQsVPJYLtijSXTcdAibWoUgz13Fv/EyQRICaaoxiWSxBhfEui2c0zvkPkwiUoM0tokxKtrmneGJBIXGZEbSdpS5LDaSzAFKxaQjLY5KSWbimwVRGiN9yJwTakRvJVWAc9tkOi5UGu/i83DyrAIBnSoJ3o6B6oQoY3E+jq9zGHS4/DzLyyQ9J0TVj5KQak2czMVyTxm59jQzhOhO5IIksSiUbH7ipldrGZ8m9n+TqItNqNJKDOmR56KCIk1lUU4ykdGk+btMTW10nEMMaE2WvZsrzveEAhXlLOckIu8D4C8h2NKG0pfTXBZ9ueFo/Xd+CdAKkySoSxtqlJc2M0rJ/StFksl1mSzBe0iTc7qL2EuqREN0KUoSI/aFE9mISmB9iONNxu65DX1MKlKIZCaJKVOJ1mgjfUTGYQwwV2cJ2Fk6+MUcXy6kn+MxXZaEIJiEtYH5zZS2blk+WdBUPfOrGSq+WWR5igKKuXh0TqYiIygWBSFIckffStpEfZJQ6LEdyMsUrWRSys/+rjPx5i3nJd4KNuqtJFS0p47VkwXdqWN+NSMoL29lmSYoLW82Xna2zjqmc3nDmi0FT10+XdBWLfPbJUPbUS4KdCKasPObdLksmC6nLG/nTKY5N+9fkaSG5x8/ZexGvvbTH/IPr97jjy7fR1tP1w38n779HZ7NZwze82Q6RSnFdSExatM8p0xTiixjPsnJE0ORpvyV7/4QdbQ86TT//D/yDzIpMlbPlpSLCdPlTN7wup7pcnpJrmjqjpv3lvSdpMIE68QvNTWgFfmsAAL5rEQFWSDs6CgXpaSd3M5pjh2rZwu6qqeYCjaYGEmtQOuY2KMp5xL1Vs4LbDdeQrKvniyoDy3z6ymuH0kzgzGyaGWleIZOygxnHZNZgXOCRYEHHLAAAQAASURBVEpiz5zu2LB8OqdvR8qleDibVBI/NJqilGufTDOCl5B268WPuWt7SS45dSyezhkGwZC1NuKfmudiXznLCR6KWUnwgXJeSNDz9Zz21LB4uqRve2bX86jzU2R5RghKvJp9kJ9B3tKcDeIl3A6sni1pq4af+P0f09YDX/nJ91Aq8OSDG7IsZXk7p1gWzJYlV0+XTMqcmw+u0cbwwU8+p+8GvvbTH9JXLV/7PV/FDpZnHz3BpIarZ1cUswnz1Yz51YxiXnL9fEk6SXnywTXWOT7+3R9SHzu+9nu/ytCNfOV3vEdQyPknGasnS4bRUR1aJoUEtc8WJWPnKOc5zaHh6umC7tQyu5rGNy4jY1hpJlNZmIr5hOCk7az1zBYz+nZgebugPrasni0keL3M4qZCkcY3xXI2AS/+2sHLXGJHy+JmSlu1LJ8u6I4ts5s51o1kefruzbnMUShJlXKBYi745exqTt8OLG7ndFXH4mZO1w4U81w2Z0Zw3eDPvA35Ducs5VWJjRhpU3Usb2dUh5r59Qw/2pgWJYv2ZJHLz9kEYju40TFbFJIcdDun3jdxPuwpZhn4IItqlqCV+OjiYLqU+a9clLjog93WPcunc+p9JwlavY1JM5qgFcVswvJm8UVWdr9cSD/Poz5KuHW1FUbZ4f4okpGXW8qpBBzrRHFcnxhHR3NqGbqRrunomh47DFTbGm89+/WRNE3YvNkzmeasXwkNf/92T9BKaPfDSHNqsf1I1/Y0pwZnR2FUGsP+4YjJEx5fbJjMCh5ebtAm4bg9EWygq1rGzsbzd4z9QLWvCC6IC5M2bF5vKcqU9cs1+TRn83ZHQHPaSU5kWzV09UBTtRx3NUM7sL07EgI8vHgkLTM+/bVXzK/m/H3Dgj+kluiTo1/X/O9+7W/hPexbcXqq+oHeO9pxoLGjxKmNI+u64S/+F38Lc7J8VGn+p+9/g/2dSIiO2yPtqaM+NdSnBjsInV4pxfHxSDpJeXy1JSsz1q+3JHnC/vGEd47mUDO2Hc2pY6glGLo9tngPp80pylx2lItc2mExYXd/QCkl0iVnaU4NYzvSNx3Nqcf2llMsLx8e5RmuX+/IZjnbN1tMlrK/P+AJNMcW1w+0tcgmbC+yCzt4TpuKJNUi4Slz1q+3ZIXcgwaqXY11gfrYMIw9XTfSnAZcLyHfwXmOmxMmTeKzE+lKOsnY35/wwdMcJbuzq4ThPHYd1b7GjZbTvkEZOX8+yVh/tqGYTti82aE1VNuKYRBiTh/7T3fq8aPluKvAS2C6iRKSybzgb/7ffg3vA69/dA8Btnc7urbjtDvRVx31oeW4rxk6y/Zuj1KKu0/vycuMT//2K6arKS++84Yk0axfbxkHy3F9oGt6qmNDvRcZ0f7xhBssj693JEnCq++9ZnZT8uLbr5lMc97+6AGt4Lg+MLQ9p92JZt+wvdtTVy1udBy3FUrBYX2Sdn+1ZTIteHy1QydJlC45qmODs8J07ZoBO1rqfU2w79p/+2ZPuSxYv9qSl+L05APUh5qhl7HTdwNd20UJ0SDnR7N/OJEWGZvXO4p5webVljRN2D8esVb60Nj0tKeWtumw40i9lznkuDmRZIbt6z35TMZuMcvZvt6DgtO+ZRxtnIcG+q6nPjaMg6Pa1GilOa6PpJOE9asd5aLk8eUWkyTs7o8452mOLUMz0p46xrYX+dW+Ing4bIXZvH27ZzJNWb/eMSlyNm8PoBXVvsFa+ayNrPbm1OMHCVb3AQ7rI0lmWL/ZUSwnPL7akOYJ+7sj3lnaQ0vf9FT7mi+wsvvlQvp5HG3VcvfpAwQxxVYKPJ7ROjQK5yVmK0SSgRjJRLu8WIhDqRjS/a5EIeHfXjBDL1ih95CcyxmA0iFa6xEDeMWNxHshHoiLzDkZQcUyG9gghJCzLZ86B+MqjQ/RXeXsGKLNO6eUgEhRkB1lCAHbDZw2J/SZDKCDEBS8EANCNFRwzvGPvfd1/qHjFAZHe+r5z370PVIjcpjFpADgqihAKWYRm/uVVy/hvuarR80ff/J1JllOUIEQnV+cdZzWJ4wSpxMVCQwuGog7Gy6kLh2dn84uPkFLGVOhhOxCwFsbA9JhtAHvhEAmBIoQafbh4vxDELKHVsQQcXFl8UGej/Veru1cggIJXvc+fk6cg84GLu921kpM7r0YehOEXKa0fJcRs5eIuUm0nAsxbDqSWkw8j4pZsVpLqewMRIvJObGcHh2vvETVnQloxPsJilgCjeVTLeU/aVPEMCGW9z1Sjgcl7e8D+4cj7aGWPq2Rkq46O03Fi4iRZEZLedBG2RRBnHx8DIkmBILyF8lD8EQo4Z1DUyCQJEKIU4F3P52PbSyEs8P6iPMuXlcMjxY0GhsJgd6d2yy2eXy2ikgujHCEGx0BFXF/eSbWu0s/VUQ3rHAOYY9uV15WAR3nATmVvzw7dyYBnkvS8X8EZkikDwcVS/Q6tr18n/MSc2htIDjpI+YcZaRif4xQilZayroq4J2T9lYGF/uzQD8IvJDI5xTRmUkRXZk0zkUikw+RECl9VxzD4tiRHikSKOdACwTivEAkKrp9GSMuZMHHz2ol5zeGgP+vZVX70tno7zh+O5yNPv31l4z9yP/1f/tXhXVnHVmR0x5bFtdzjrsTeZmLL+tgKeY57alnelXSnzqxzsoSQpR+aK3om55iVdIeOqbLgtO+jtFW4jAyu5lR7WqJbfJiZzaZ5XHCBTPRdIeOxc2M464SUlA34vqR6dWUetdQrgraYyclzkkWszYTQDPUHeVVSXdqKRcF9bFFKcn47Oue2XVJve9IJ4JVOOd57+vPLibrxXxCtW9YXE2pT+K21FfidmKt4/98eMkvFy3OwHSR8fM/+Q3AoFUgaIUKgWPX8zd+8Clkip/6VPGPfuMnyVsx/rbOMylSunagq8SMIp9NcKON2I2hqzrmV1OqQ0MxK+i7DjeIhKTaNcxupH2VEfzYDo4kTyFmS07KTNyGrqbsNyfyLAMjrNPZ1Yx6V0kJdHC4YWQyL/FWDNeTTNEcO6ZXU9pTw2RW0J06QlDk05T20DC7ntHsWyGiKIUbI/HHefp+oJjmtKeW+dWc00bejLwX0tbiZk61q5gsClwvWr+syPAxQSPNE5pjy+x6ymldUS4LIdmgmcwzml1DeV1evGRlQZAoK+c9Qy0yqb4ZmK2mF69n7x19M4gD1rGlXE1Fw+zEfcaOQkpDKYZ6YHozpT20FHNxbsrylPnNTFJ1ItGrq3pmy4Km6shjhN3Q9eSzgvbYMlsUVIeGfDYRA/NEWMMSOCCEu+bYUC6nuF4YuFmeUR9qZjfiwFTMCnEdy1PsKIb/drDUp1ayf7XGWTHWd97hbSAtUup9xWI147StKBYFYz8ydJbpqqDZt5RXU7pjKzKiNImRclLybY4t5aqkObXMVyXHnVSq0omhOXRMV1Pxki0LcMLYzaa5sPetJykyhqqjXEypjzXlNKepe7zzTGYT2lPH7Kqkr3qUCpg0jS5ICRDomuFynYvrmfgkp2JV2Vc901VJfWiYRNJRCI4kz8H7C3Gsbwdmy5LqUDOZFrhuoO8FYqh3NfOnS9qdEMK0kQSjvMhiLqoln2V0tcBax82RLM+j3lbc1Jp9I8kyoxOHsQitiJWi5JKW8yn1qaGcTcSn3EK5mlBta6ZXU/I8I80T/vF/4R+L0Yef/1rw5Rvp53CE6PCRpAY7eJJM0kCyIqOte7IskVi1TFhvxsRON1h0Yuh7S5JJWHc2SRkHYcj1p14sAuuebCITgI8kmbEfLx68KouB00mCs1YSPZrhYjtmjGGMKQnOOQnijrFcSSZEB50Z+lbiwuw4kk5SulMn4daNBBWPvUSxKaViYoxGa41JNGMvzi6Pr9fMViUQWN3OGUfL8naO60duPrjGO8/V0yV/7NlP8I+wgqqn3nf8lU8/YZImYragBPv51Rcv0T888vyHPX/id/9e9EE0qijF8nqB0oZyXkpyRWQdulEYtG605KUsBFmeYgeJu/LWYa1FJxJjleTCojSJhAenWSLxaolhaEbyIqOteiZlzhijwzTy6pdNhDkonsdCxJK2Sxg6Sz7NGduRJEkY65E0TyR+LHrWuhgBNQ4SlyaRVJLGkqUJQzMyKXLapicrRaObZClGKbwVj9MQSTtu9LGPSExZ3/QkeUp77OTazykd4ygxVEYTXECbBG8hybJLJNbYyWJgY4xcV7WYxEg6TSTQKaUxMZZOa4nekqg1iR5zo4uC/RZjlIRaK7EMvHp6BV4xXZSiO51PSCYZ+SRjMs1JMiNZlD4wX02xo2P1bIUdRq6er/A2sLyZoxNDuZDnP5lOyMuUdJIwW81QRjG/mf+YFtty9XyF7Ueun64gwPxqRpokgtNpJWkjqYyVNDX0dUdRTuibURbxdkAbYcWqyK51kZkffCSxKdnIdG1PPs3o644sT2gv/XCEoKP3rix+IXhUKiziNBdbybzIcF1PkhmGRjYgQzdemLQmEb/cMPooR4IkS7HWRrzdU0wz+kY04U3Ti042phPJIcQqgpAah3okzTRjNwhj20r/7GsJiB+HgWCk6iPkqYQxhoZb60nyLJIcjWx0ygzfOwlEr3qySX6JjlSaC4kJiAkyAUklGklyiWtLs0S4IXnU6GeJZAy7SGxCoRPNZFZ8oXP+lwvp53AEiFZzDW3Tcdwe8daxfbuTrMwXW9Is4e6TB9LccPfpGqU1u7d7rPVU+5qu7unrnuO2YugGDo9HsWh7uSFJlNi8RSkBWrF9eyD4wO5uh+1HmrNFWNNTbSuClVKa0kpwrURz/9maPM94fLWBoNi+3eGs4EFDNTC0Pc2upm969o8HULB9c8BozfrVljRPePjkHmU0m1d7CIHt213EFjv2j3sOjxX7+wPOeR5eip3Ymx+IveGr773F5CkPnz2CUvycvuVnzIrJdmDXDvzFb3+Hznn2Xcdf/N53GYPj63XK/+Infi93P3ogLTLuPxOLtPXbLdWu4uW3X0n7VT3NsaU9tRzWR+zoBM80mocXG7ROePhsQ1rmPL7cAYrNmy12cOw3grO1p556V4nN3fqED4HHV1tUIs/MZAn3n67RqeHhxRpvA7u3e9xoqfYVbdXQnqTMPQ6W3ds9KHh8vcNkmrsfrUkmhrtP7jFasX6zI3jH8fFI3w50x456X4tF36YihMDDqy1awV20d7z75EHO/3IDwO7NHjd6qm1Ne2jpqo7jpsKNlsPDAaUVDy/XYrP22ZpkkvDwYgNasX61JTjH4fFA34o9Yr2vGduB46bGO8/m9RZlNOsXG4zR3H36SFKkPHz6QADB+8ZAdajo65626jhtK4Zu5LAWK8qH1zu0Vjy+3KJU4Nt//XvUp4bd/ZFx6Kl2Nc2xpa46wXy7gePjKd7/Gp0Z3vzgjixPefP9t6S54fH1Fm8dx/WJoRtk7B072rrjsBHru+3dHpMmvP3kgSwzvPruHVmR8uaH9/TNwA//35/RVA0PLzdY6+mqjuZ8/s0Jbz2bt/LsHj5Zk+QpD5/dk2aG+xcC5WxfC1Z/2FZ0TUtzaC+2gbv7A9oYuW/g8YVYhd59+kCSJDy+3KCDYn8vOtv62NIcW7qu57g9Ya1ndyd44sOLNdoY7n60JssS7j95ABTr11u884Iztx191XFcH+nbnt39AUKQz2rF/WeCL95/9oBJxPYRD9v7I6O1NFVHe+rp2oHD9oQdLfv7PUprNq93aAwPn61Jy4yHz9agZB5yo+O0PtLXvdz/vmboRvZ3B1yAzds92mjuP3skyQxvf3SP1ob7T9cE59i+2clG/FDTVR1d3XPaVTjr2N0fQcHDC7HmXL/YkpYZ9589oBQ8vNoQvOO0r77QOf/LhfRzOi7pBogcxV8q6ErwPCCakeG94+KNFkRQfabgX1JXgmB2KkCIwFnwDpzsQPHn75LdobcBvGBYIYQLRhJAcBMlukx/xqSCmEOg5I36jDn6qO084/Yh+AsOohD7NGEcXrwMolQCEpNgjKKpO+pd807gH6n0wfmYcBOF+4Plf/Lk6/z9dg4jHEfLX3v5Kf/F65fkn9Y82cHPv/dVMi3SBryk2thx5HB/oKs7mfCikYRS0n4XTC0aNKCJkW5yj8G5d2kqKuJKESeW9o+4nBJpg8B3Ebfy7qxMiViVPFkvpYL43+I1nA/vIw4YxDA9gAsiDXD+jKueE4Ni+gaCxemYtqG0JO/4aBxBfL4+InLnXLqzqoEL+i746Rm7NVpHwwjpb+cHeQ6/OSd8II9MriO80/sS3vWNi0yJmDYU4+5UCJdnIclDcj0+BLxWnDaVTNaPBzFgiM8O59/1ZcUFY1Mo6Utn4wylCNa9O288QwiSnnLGWQX38zHdRPpy8IrDw562aam2NWMv+KH3Tt4MI5Z3vj/vRBt9TlUKUYvtnbTtWW4TnLuMt7OeUfpLlCqpd3izPB55ji64iL/+GFbpQ9RTn3kLKs4dccDpKNc5j28Efz1jiJ6IYSt9mU+kL4cLZ4HLYxbsX+sIzqvzWJWxopW+4J86Qi763M6xf6EUnnOy0ruxzo9/JzIPhPN16HN3kc+ogPSFc75iiByLc5sKkCy8j3gOL6CsXJwLX8pf/v/iCCI+VxryabRgmxf4MdpajY7pSjC0claIbKLIMWkqtlyJaPrSPIVIB/fOU15NCc4zXZW4MYhFoBWLuMSIpaAxEm0msgZNXuaRhi5GA9NrsfUrlwVuGCkXBUHF8ydiS5amBp2YaFuoLrjJdDXFOS92b8Mo1+EcWZleNIg66uxMJpo2249s7nbMo63g1bMlzjpWT5fYfmS2KlFKZCNplvLzz7/G7/E5ya5ld6jpP9vzE33On5p/ndtnK+zoWT5dYkfL1dMF1aFhGEa6biAvJ2KRmInNnbrIcoJIOqxnuiixg2DDwTmRKUWLPHPWtxmJgEonKShNNhWDgcksxw6O+dWUcRCbPW9FCK4TxST+NGkiWksFWZ5Gsbx8R7ksxBrwaso4OqarGeCYTDOxFiyyGFEXJSUgRgqjp1wVYvO4LBm6kdlVifeBfDZBGUU+ydFZQpKlpLmRPlSkYgYwzfEuRGs26UPj4JitpijvKGYTlDbxnpXoJpMEhRgIqBAoY5+drgqChWI+wfZOZFBGkZUZOtUkiUFn0aquFDOAc3nwbGs5XRXYxjK7kqQjZ52U/IpULDIzsVc0iWa6LCHEa+9Hrp4tsYPj+vkyXk8ZOQMiw0gS6c9pnpJNxfpwuiqxg5eA8cFx896K7tTinPgN52WKScWWLs0STCpmKWervhA85bwkjJ7ZqmDsrFgERrvJoBRpYcTaME/RSmCPbCJ64HSSiSXeqgQP5arAWy8Wgc6TzyYkiSGPY9gkmjTL0EqLlClKSfwYbT6to1wVDO1IOS/wSvprmidMyglprtGJYVKmaMQy0p3nnSFQLgXPn1/PCO78DM/6TpGEXcxIZhOUlp/BesrVlHEcmF5NsYOlXJYExHBBJ/FzMa4tnaTSN+Lzn11FOdpCbE/LqyneObIiQydiImHSNFpVJmiN4MwoipmYUkyvRFI1XRSM0XYzBC8ymDiHfZHHl2Sjv+P47SAbffbtV/jg+b/8uf/7hd2ptOBBeZHS92KVpVF0Vcvy2ZLd/Z7lzYLm2GDyRMgPoyPJUkIkG6R5Io4fqWEcrUxgywnHxxOLpwtO25rpshCbMusoZgXjIFZ+Yk1oySYZwziilQYV6KqB2argtG1YPZ1T7RqSLJFMSyc4m7NO3JiyRFxb8gQb7eeyIuO0PXH9/IrDw5FiKYtUcEEWnU7sCJWB5c2S/BLpJtijUorgHGmRMdQDxbzgtKuY3075pe9+j7+RN9w28D//yk8xmWSMo2CB1trLW9tpV6GM4rSumK3KaMUnGxlvHSiD0mLFl09SrHVorfDRTHx+M+PweGL1ZEl1qEiicYW42EwudoNZarDOkSYpfdehgsbEgPTVU4nRmi2nEmSMEqLOOGBSIQVZK3mTZzeaYZAA9elVyXFdsXqy4LSrLhsfO1omZRHPb0mMPP+8TOlqMQU3mYm6xhX7xyOz62nEsrXc6+AiezUwdNL/hkHINd5JAHK5Kmn2FfMYHZYXEwgOF8S71I4OlLy9jL1gbkM/olGYTIKp5zdzTpsji9slTdVesHJvpQ8rxKrR5DFSMBFLwGCFKHNaV8xu5lHTnLC4nlHt64sv8TAIPm17SxLxsSRLsNEqzvkgZLNmYLosOe0qZpH4dPaaFs3iRCz5tNgOusHS1h3VtmYZo9DKeYHtJbf0PIa0MYDHjY5sktM1EjTtPHRVx/J2wXF7YnEzpz5I6L2QjUbSXIh73kOaiSVelqcMvQXnyGYTqk3F8umC4/rEbDW9GNYXs4nY43kZQzKH5Az9EI0VFM2pYXm74LA+sXoqz9CkYrrirWNSilPV0MQoxXEknWSMw4jzgTxLqPcNiydziWK7mkpwQ1Dksww/OLQWE4+xk1jAvh0Egx0tQzswv5lxXFdCettXZGWOUsJaFjcnx2gDeWpo255iWjAMI1hPWqactieunl+zfziwuJ7SnQbQ4tg29OOlCjN0whMYB8GnffD0dcfsasoxxgkqJVj/P/kv/TEm5eQLWQu+fCP9HI7gA2++f0dX9RzWR6qtYJ77uz128Dx+ukYRePvDe1RqePnt1ySTjLc/uico2LzcMnQSidYeG+pDzT7iVg+frbHOcffDe3RqePmdtySThDfff4tScPejB+xg2d0daKuW46am3jU0p4793YGxH3j8dE0Igbffv0cbePvDB5LU8OZ7dxA8m1cbxq5n93ZHfaip9zX7hwNt1bF9vcVZx9tP7tFa8fZ7b0mzlFfffYNONA+fPeBGz/5+T1/1HDYn6mNDV/W8/O4bdg87jpsKZQyndUWSJTTHXvyCuxFrHW6wuM7zczcf8L9c/CT/sw9/ir4Z3qWMpIrj4wnwfPbrLxm6kfsf3GFSw/0nD4KlvN3TVj3b+yPV/kS1bzg8HBi7kfsfPeK8F/1gYnj93TckmeH1995GnGvNOIzs7o5Ux5rTtuK0OdG1A48vNlg78vjZBkzg9Q/kObz5/ltMorn75B4fBKse2oHdY0W9q2iOjWBE1nH/6SPWWe5+JLjO6+/cyfm//1aws0/XjO3I/u5Ic2w4bCrqnegJN2+kb6xf7lBa8fb79yRpwsvvvMYkmvsfPgCB3dsdbdOxfzjQHBqqXcvh8cDQDKxfbHDO8faHD2ijePu9O3SS8OYHbyUq7tUjbrTs3kgbHnc1x/WJvunY3u8Ze8v9J4/44OW+s4S3P3yLmaS8+cFbVIDt680l/qs5tpy2Ddv7PUPT8/DiEecc9z96RBF4/b07wYp/dE97anl4uaE6tdhRvGXFZlJ8aKt9gzGG47YiybRs/HIhQAWlJOWkt5KUMjhJW2kHfPAM7YBJNPuHAyYzfPI3X1Dta958/w6TaV595w1KK+4/fcBZz/atjKHD+sRxfaI59WzfHOj7gceXW5wL3P3wHpMZ3vzgDdpo7n5whwI2r7aCiz7IM6wPjWDPzcD65ZZxcNx/8kBQ6l3/+66c/+2P7nHWcbg7yBhaV9SHhq7qONwfsOPI44sNzgZef/8OkyVx/Blefe8tKMXm9QY3WPb3B+pjw2F94rCraNuOzZs9zlruf/SABl7/8K3gzt+LffjTB/CB3d2e7tizfzxx2le0x4b9/ZGu6Xl4sZG+/KPHyxjSRsvzV4rNi0dc79i9PVLtG067mmojnz3c7RmHUXBdBa+++5Y0TXn17diHP5HxsXm9pa2kD9cHmccO96L1ffhsg/eON9+/Qxst3zFJeP39OwKKcRi/0Dn/y4X0czh8xALPGIjoJxVose0KscrvCReLK+0ifhdxv7OvbIi6sbMOThstUU9aiW7OnzEfwV2CF5s0j8gXiBpQFPFpy9+dITtzxjGir6CKmJmKtPgQMVel39nEiexSgBIfztZqRKwzoHXAOdFLXrR2SmHHkaEdOW6OVLsqYjyeEMRX9YINIhgmwCJJyYyJWEtAefGnPWvumkODHUY8Ar2INlS+Q7SJ5/s8I4SgEiX4cdScBSKOp6Vt7BmPUkT9WsTJglQWRP8WICiU9yQmYlcRI9QmYlMhMijPz5/YSAqCFZz64pfrQ3zOMdwg0Sgj5VWjo6Y1BHQUaYbgo9Y0Yo/n6KgIgDkb0ERNYtT6aS3OL/HX0i6pkf8erzWcsag0iZ/1aEK8bC1aZQNoOad1Dq1E+6fOml0v+uYf16cqI38vuJ9QAZRSwvoMPmJbAWst9e5Ed5IJNETNpbrcu3zBWf8s9ndecFUnY04ZYW7ipO/7M24W++lxfeS4qehjFN5lREbLxBACiFtd7M/S33TUeIqVZdR8SlPgnXzEne/Dxf5C7BOxH6FE36oF9Yie19LXlVYXazuxFhXzf6Wkz6jYoc/+sipqz03sq/IMAS/j74yT++hXrZToszm3iVbSpj5qf8/Px79r6zhtRY12xOejJO+iI1Xy72L9LWNIzi/tpNV5rojIroqq3MinCD8+P/nAaB2JESz2PEbgx64xtmNwHo2whTnDuWdt+BlP/oKO3/RCul6vP8/r+G09/uyf/bN87WtfYzKZ8M1vfpO/8lf+yhd6fh0n5MlcYoHKhdTvp8spfhCrPmsdV88WMdasJEQcQuKHMrJpRpIbJtMcFMyWgqfMrspotzbFd4757SzisTnaGPKpxBhlWcJklmEyQzkvUCHGJ42O+c0s4jszxkG+E63Jyowk0aRFSp4kmMRQlDkYJTZfTqKXnPXMbqYMg8RJBe8pphPSLKGcFYLzTpIL5lcuolXeshTD/MRw2lY8/fAG23spxxjFbFnIPZc5RTkhLyeUyxKTGYlNsp7r969ElzrLpfR3VUbsqEAnmnJWkKRiNJ+XE3SaUMwmBJC4MOulHWKcmG0t86sZHsF3BKNKSPOELJP2P1+bd4H5VSlteD3HDpb5zVykBfMJSsUoNi3YWp5PMKlIMtBK4qJGx+rJHOcD8+sZ4+gol4VgxLMckxom0wydp5jEMClylFYSV+Zgdi12j4vbOW4YJArPOopFgTExfi1PyEojtm1ZwmQq5a1yPhH5x80M5wKL2zl9LC2LnjXDJIpimkctbUJeTCTGLsZUnfvO8nrG2I9cPVnSDz3lQnD+rMgk73OSMiknmEw+q1Q8v/Wsni9xwTO7LmP/m+IjFKATLWX+wUo+pjb0TU9eitzk6tmScXDcfuWWsbfcfHCFHwPLp0uUVpTLkiwTjHWyyGMkmqFvRTJUbSQ387iuWNxKnNfyZi448zQjyQz5JJcYuDyhmOXoRAkGh2V6Vco9PF0y9lLSdL1jMs8JWuz5kiylmGbkRU6SG4ppARHnddaJNeToWUSbx/n1DBc5FFob8lL6TZqnEj6QvLObnC4L7OBYPVlgR8fydsEwjEyXJV6LBEtn+vLsk8xQTDPpwyvB05dPBVee38wYx5H57QzrJOYvTWX+MakhySUCThklz1chOHPnmN/OCc7LZ2MkYICIUSdMZjkmlfPn0xyliX1Y+r2Pc4gdHVeR7zApJxHTzdGp4KNpIfaJxawgoKLdqcQ5OhfE5rIdBPcNSua8RMb835PORt/61rf44Q9/+Hley2/L8R//x/8xf/pP/2n+1X/1X+VXf/VX+bmf+zl+4Rd+gRcvXnxh16C05sPf9QEKTbmcYrRiMi0wqSGf5RTzScwJzEAFZtdzGRRPFwKcr6bYITCdl6BlIQTxzs0mKVmZUE4LdGpkANkgmrjBsbxdMY5CJAlBEl2MEV1VQHx4szwjn6QyOEKQAd7bi8fo/HrBMEoGpFeK2bwkSw3T+eQy0U+KDJOkkagQWD5d0De95FWOlulyilKa6WqKNqLrM1q8fNOJTHTNsQONBEkHYvC0sHeHYcQO8gYbXBCcJMa4GaPY3h8EX75Z4J1neTuXie1qhrWS2+idZH0qreKibpjMMrJJRlZklOUEbTTlUhbHq6dLxmFkcbsUf925LJ7lTP6umE9IspS8zGTTkSXv2v/ZCms9N+9fY3vLbDXDByeeqQjWE/x5sTBkk4RyXqC1iovDyPJ6JkSmW8nnFAKFEHoCimImG53JVEg0aZYxncvmYHk7Z+hHVk+v5DtWC1zwTOcFWssGQxvZGGSTjDxPyfIMozXLuBlYPV0ytiPzleTlTuYFWskkmmYp+TSLxJOctMhkoi9TVIDl7QI7WG7ev5LN4ZWQ0mbLmWB90wKlzcWHOEtl05VomF/N8SFw/WwVN1ZXYmSwKNk9HKhPLdu7LadtRVsPaCPh82IGMgj+24ygwY1OKh+9lRgv69ndH2gOLZvXW5qmI0kT8jIjzYQYN10IgUrIb47FswXOCykmBBl3ks5SSNLKTDY3WZnLM1KKmw9W2MFz83zF2I0yhm30G9aK2Uye5WR63iynJIlsemdXM4INLK7njP3I6umCcRB/Z1DMZjL+8zJHa+mHKE02kb6olLls0q+fX2E7x+J2AYG4wSFu5uXZncfjZJJjjBGym/XMb+f03SD9YLDMV1OCC0wXMoalLyvKeR6zSg3FTMbX4loW1OvnV4K7L2RemC6n0Su3IBCiLjghL1KZE4yOyTSa5RPZFMhc5pkupoQAs5X4PRezTIhHs8llk5Hkkr179Wwl5MNn0v/sIEYoX9Txm15If/7nf55vfetb/PW//tc/z+v5uz7+rX/r3+JP/ak/xT/7z/6z/NRP/RT/9r/9b/Phhx/y7/67/+4Xdg3ee15+5w19M1BtK+pTS1e1HNcHnPU8vtgSnBdNaJrw+HKNSTWbl1sUmuP6hB169o9H+qbjdGyojjVD27N9e8A7z/rVhhAC6xdbkixl/XKDUrB5I1rA4+OJoRupdpVo0eqOanvCDo7Nm51o8j7boI1oQrXSbN+Ivm3/sBNvznUlPp/HmsO2om8GdncHbG/ZvNlhNDx89ohJDZtXG3Si2bzZ4kPgtD3R14IRv9Nznhh7x+b1Dmc9L379JfW+lnxMhNzjvBMrstFhnY3RVo6hlczOT3/9FZu7PYdH0UTeffqISRMePlujVDy/dREPtRweT7TVIFq0bYUbPJtXO/zoeXi1QSeKxxdrtBZdLUqxv9/jXeC4rehb0SQ2+4a+HdndSftvXu0IPnD/2SNparj/9BGTaNYv13hF9E8eOW4rupPcf3NqGHvL9q18//2LNTrRF03o5s2OoBT7tzuccxzXR9FEbmu6U0vXjdFT1cXv8Nx9tibJRIOnE8X61RrvPftHeU6HbUVXi/fqaVdhB8v61RZrHZu3W7SJmtSoRdWJYXd/wA1iszj0A9WuodpXUU96wo2OzSvBCNevtiSJ4fHlGpUo7j5Zo5Ti8HjE9iP7hwNd3dNUjXhPWy9cgdj/UJrHl2uSRPSUxig2r7aE4Kk30v6nbc1pV1MfW1597zWHhyMvfu0Fx82J6iDEmrbp8F6yPnf3Rx5ePnL32T2vf/iWvu057GrqY4Pt7UUvvX69RRnRVaZZwvrlBjRsX+/wo2P/IPrL46a66BkPj0dc1IR66+W5p5r7TzaYRPP4aoMPIfIhek7rSmRZ+4r6KHrK7ZudYND3O0KAt58+oFPN+tUGpRXrlxt88By3J8am57hvaOueruqpduLpe3iQuWTzaotJYftmK3PJqy1oRE8+Oo6bE1090hwamoNcyy5ilI+v1ijg/tMHTCoe3MooNq+3YuH4eMQNllPE+JtjQ7VrGMfY/6zn8bNHjFHcv3jEJEY04Yni8HjAWisl9Kan2rWia26l7ZwLbF5tCMD61VbGzutN1KgL/in9f+Swqei7gfbUcdpUjL20YbCWzcstQcHbHwpH4vGzR7wC50YpGX9Bx286Rvzf+/f+PT766CN+/ud/nj/35/4cf/yP//HP8bJ+a8cwDPzKr/wK//K//C//ht//kT/yR/jlX/7l/8rP9H1P3/eX/388Hv+ur+OsR+SigQrCegPRP0YdFj4IljmI56YE33IJuFVK8FB9lrEFLjq4AJG9Kr694zCidIF3Lvq3hot2MUTN5/laQDA+77240Thxthn6kRJwo42+odEP2It20Ed8j/g1PgTxK9WKcYyewtZj4IJVKa3EnzM18fSicQzB0TY9fSMTRFYk4j0aGZg+nHE5ICjBykLA9UIikcDnqJ+LDk3aRDxSn51RBdcJTpi7PkjY8lkDqJT4uzrnY4SdvwR8n/HCCMdEWCxiqgGUljY8ay/tKMHDdnRyPdG7WAEhMrTPul7O3xVER+qsRWsl9x8U1jqUkmip8zW8g5vD5RnqRJ6uVlrciYKS9lfSHj56C/uov0MrPGcFolybNuLD7IOEUGsNzllUIvpiwfnDJWgczppASDTR21WuWSsJPA/x+Z9xVBQX31fvLmCiaHkV2F4CxQWHDjhvBQsLIeoUuegSx36kqzv6dqDvBqpNhdaa41YMK6p9TZqlNMeWosxjiLnBaIVTUZsb9Yyi59RYK77F0u5iOYnS79pNRR32GS+P2J06X6MRAxZhWjuUMtETN3IKfIgYcBw+WkSTIbyLstNKXdjkzjuMMRcvbhXbXCXqMgeA4Jg+cgXG8Tx3jGg9vQStS3d5p03V2kS8Po7NOMaVkb5zvg6lZNx63nEfBIf30UtYtJ6iJxXvX63juFcKO4w/xmVQ4vusxC83TkoyFlWIzlrRe1gr3OjQiYmh4C4KYwNEX+qzVll09uIM56xFQbwOgxuGvzcxUoB/5V/5V/j3//1/n3/qn/qn+Hf+nX/n87qm3/KxXq9xzvHs2bPf8Ptnz55xd3f3X/mZX/zFX2S5XF7++fDDD38briQSBmIWZJaLVdc5kmy6kFJisZgQrGgwAyHKTkR/mWZn7ZXkieYxmLlclgTrKWYSpF0uCpw/a7CMWMYliWBNqZhXp3mG8458VuCso1iUuMFTLiaMdmRS5iglUpck1ehUNHQ6EZwNLdhDcIFimuOtYDXeBin/xrBh0a9KnFiSJiRJgg6iY/VOyjreOop5ifdcpCqjdXR1LyWbVEKK0ywlS6X8I9mPitO2Ef2qk2u3g/gJu1HCxo2RfESTJnLtkwxtNPlUQs6LeSEatEWMKpsVYqE2nYBSJLlEMSVpzJvUEoiORuz/bBCczwWKeUmwMSLLO8EXlcFkBmM0iTHkmcTZpZM0nn+C98g9WAkBH6NMyXsJH08SE3V0gNYxX1JHO0Ev5zs/99FTxmeaFgnaGNJJhk60lC/zWIKciBZ5Ukj493w1BSe6WjvK+RWgEzlXkon8SnTBGRLqHWPdphIMXi4L7BhivJcXmAIJTDeJFv1g+k5H6fGXaLhyJs+/jLh7sZDyd5qlmCwhSROyJEElWrybjYqRcNJm3hP107K4VzFlqK3OPrkIPpeL1d9klkOQUHfvPNOZtF2xnGDtyGSREfAX2VeSpSSZkWeRp1FbLBKSLIZrz5Yl3lmmiwI7eiZT4ShkRSL6zSxBpyK7ykvRBWcT8U0WrNpf+nKxmEgUW8wJTrIEoyT7NcnFMi+bZHgEonFW8FQ3uKgFtcJlQHTnJlExVk+8sCdT0YdPCpGPFcuC4LyMh1F07N560QobLfeeJiSpzEPGyPMnlqa9Fe2xO4+h0YqsKIgcKzFaNNyJjnpYIbSlk1SiIefSZ6cLmQ+LlfQhue/4HfEa8jxDKU06ER3tZJqJBnU1i/2gYLCOPI5hnWpMIjGQfIEL6W9JR/pLv/RL/LE/9sf42Z/9Wf7QH/pDfPOb3+RnfuZn+MY3vvF5XONv+njz5g0ffPABv/zLv8y3vvWty+//jX/j3+A/+o/+I77zne/8lz7zX/VG+uGHH/7d6Uh//SXOOf7y//o/Z2h7CdcFxm4gm+SSDI84HA3tyOy6oNq3TJfi4xkC5JOUoR1ksuvHyMYVz8okFU/VvnfkkySapkvWaFak+DEw2pFyXjJ2g2RtouL5M8aYeqG0GFmXCzFQn8wKxraHRBaCsRtloXIiI8jSBI8wWftxRHvQmWGoeiargqEWzZ63gXEcmc1FtG4yg/PiNiRaSBs9fC3j4MlLwUxnyyl5mdMcG8kOPXYSQu6DlI7SqK2NP7335JOM+tAyu53S7hrK5YSxc0LAmeYM8fz4wDCO5Ll4yKZJgguioyzmOW3VUywmDPUohgrGMLSDmNCPFuGsSvpHmib0/YDWsnHoTj3T65L21IpxRe+w3lGWOW09xGxZxxDb0Hl5Q/c+MLY9WZHRVQNZKbq8rEjBK4Z+oFxMsd1ACApMwHajPMPRSQh5ounqjtntgnbfkBYJbhBXnrwUU/e8FK9hO3qyLGF0liRNcD4wNj2TxYR23zK9LulPfQxyF9P8yUwmbCAm0XhSk9D3vbzdoOjbjmJe0DUDk2nO2A94T/z3kSwTLbJ3AZPqy9tqCOB6mYTrfU2+yLGd5MN6FxiHgXJeYnvRimLEnD6NodkhvqZ3TU+xKOjrnumioG9GXPBMyglDLR637uxLnWjxjE0ScdPqLPk0oz62zK+mtMeWfCoL7tCNkuXajajERLZr1GSPoySmKEXX9EyXBV3dk01zXDsKWStNaJs+bvbkzer8xpkk8qyt9aQTGUPTq2k08k9wNmDtKDrWdoj+vTD0PVk+kTfk6OwztOPF1GK6OgcviG/u2A3kUwlvCF5FRrknSVKGriegSNOEpm6l7WrJp3WjfHcxyxni+b0LjONAnonPdBKrWWMvntdt1VHOC9q6FR2tMQxdL0EGtZzrzEAXn29JxMrShKbuma3k/GmeyBzmHbP5hL4VX2prXfQDFx19EkMB7CAZp4dNxfxmRqITkizhf/y/+h9Efslv7fjcdKS73Y5//V//1/mTf/JP8uTJE77yla/wS7/0S/yJP/En+J2/83eyXC5/yxf923Hc3t5ijPkvvX0+PDz8l95Sz0ee5ywWi9/wz9/1oeDhxUZwlWaUjMBhpD40KBXYPRzQRnF4OGCM+KNqrTg+VnjraY8tQz/QVuL3OvQj1aklhMBxU6F1wuPrLWkq+YBJknC4PxACVLsKZy3tsWfoBrp6oD60jP1IvW8IwP5ujzKIsb4xnB6OKEL8rKfZNdh+pK16mlN38a213rO726OMYn+3BwX7uyMkitPDEUKgPXaSaXls6dqBpu6pDw1+dJw2FRA4rI+EENje7dEa6s2J5tDw9pNH9g97ht6KIN06Hl888vbFA/Wxw8VMTa0lF1MbwUST1LB7vRcN7t0B6yz1vhLm56mlPXb03UCzbwkBDo/i17l+vUUnmsP9CaXhtK4I3tPsG9xoBZdqOrq2p97XWC+4lSdwfDyhlGL/cEAncLg7AIp612DHkWbXxExP8aztu5HmWOMD7B8OQIiYmOa4qUALgSZ4ONwdscNIc+joT4Jv10fJlKz2jZz3/iDP8O0eZTS714IrNjvJz6wPLbYbL/joONh4fs/+4QhKsXmxxmTSdjrRnNYVzjm6umPsLdWuZWh6mrqlPjQ4azk8SAn18FChlGJ9v0VrTRUzV0+7GjeKT+1QD9T7hrbuGFrJpfROsDdjzOX+H19tITHU2xrnPPW+wTupUgztwNANtE2PjR6uhMDmzRadGLZ3e5IkuWTOHh6O2NHSn3r6uqOtOpqqp+9tzMUMHNaVcANebtCxL6eZ4bg+EpRk79pBXJaGuqete/Hc7S2nzQml4PBwAqMiV0BzeDhCgCbew2l7YmiHC3TRN+IX651n/3ACBdu3O5JEsb87gNEypkKgOkSXp2MXv2Ok2rcMXU+9byF4tm92GJNweDiSJPJZrbTkcnpPe2ixvaU9DYxNT98N1IcK7wOHhxMBL+2gYf+4J80SjhvxM652DXa0NAfhL8j47yTveNcSEN9ugM3dDpMYdnd7QKRFwQVO6xNjP1AfOtp9Q9cMMq6c5/B4ICjF9u2eLE3Y3O0xOmrDQ5BzjSPtvqGtZP6o9y1jN1Afa1CB4+MRBWwf9ugk4eFTwZd3b/Z4L4SzL/L4TS+kf/pP/2m++tWv8h/+h/8h/9q/9q/xySef8Of//J/nb/2tv8XpdOKv/tW/yi/+4i9+ntf6//XIsoxvfvOb/KW/9Jd+w+//0l/6S/zsz/7sF3YdZw2p5ONJ/h5O3GnFglO0VM55dGLk7ULD0Ak2NY7iJOJ8iJ6jRJwgasDcGHVcga4dCYSLW5IdBJsUL1p+zJM2Zv85wc1ETuaF+dgNmDQRZmyisc7Jm4N3lyxLjejNBBd1nPMDrbUYZSQnk/hdEecUr03xFnVn/9BA9HYNEDQqUfStvHE0VYPSSsrLWoNRjKOlq4foTRretW0ELm3EZq110Y1JNIzWXoSdFw1nCHK9EDGfAGjRt2olsWlKwRixmrOf68VHNJ47+DMCGxi7EaW1JPRoLfevpQ0FbzuDmwqClosO4eInqo0WowCNJMMYjfOgz97KOmJpkYGoYv86+/B652R3P8rPYbDy/wcrer2IzV38ZSN2HpyP+tGIiZ8TWYyk/qRZerludcb3vOD+ogWMmKELqMTQN0N0zxIXoLEfUYk626peMMMoB754zqJCTMAJ9N2IVuJeo43CO9EEex91jEHGTYS+cU6chrRC2Lta8lq10eL8E12ktIhj0ejYf4TQpiRIl7EbwQf6dgTO3yFj55LfGwClcMFfMm51xFFNqhkHSQLq+xGlAtYGiXdz4Z1X8hmz9J4Q+wdEXNvEca80thsueKOOc4j5Mb6Dj/1H9Opg8kQwWq0Y+lESa0aLSUS37gnRXzuO4fg5H4TZOg72wpo3qZYxZTTORZ5G1MGevXHPWPYZXw0a7CDuQ+Pg0EbySok4q9LnTFPkc+c2iOMzOOFq9N2IUsLVMImOfA99GcMKycZ1l0xcJ3psIyQzrfQlkeisPf2ijt802eg/+U/+E/7Mn/kz/DP/zD9Dmv5GH8PJZMK3vvWt31BO/a/r+Bf/xX+Rf/qf/qf5A3/gD/Ctb32L/+A/+A948eIF/9w/9899Ydeg4iKpjExY2mg8srDoSBIIOJSR4G8pc8mkcvF11ioKujVe+SiUP3csBUpjtJIybxTTa/VOQH4hNSARXdKv5bMqiZFZqZGg5NRcTL21igbgUeR/Hr4+kpN0okEL7qHQJInGBlnptUbIIUkiE+hZFJ1ocDHc28XvUAqVQLBCqBDyh5hIVIeKJE85bWvSNMFbzzh48LGsrd4FIJsskUUxDlJCIEkTIbooLROvPgdAy2DURhN0AKPR0fBCZspz8HhcdKIJgEZIGc56wX2NlrxJFWOnkEnSBVl4g1ZRbC7PPQSQOC0hDZlEcC+TCsEpSZN3xgDnlSdVF5OIEIikNC+CfCSgmvhd5+v1ZyKK1qDVJWgdhWTbIs/2bFyepEJoklKqP6v2gbOxwpm4hvRVLyHalzBtLYuos+5inE6QBQSlLpOvjhFtci9OSDJevjP4gMkj0SuSc9Q5pD3IJO19XFCCEgILMjlrJb6sNrg4XhAS1zkUwshCoowm2BA3clIaBjE/UCD9H1AaEhO3LJJWLaYFwvyT0rR6R0rzSBnaRQKh8AulTaQfaFQc74MbZSH20t4kRsZnJPE4ew4dEILPu2izuIE0Ylyv42eSVIuxhokLYKIh+EtQvQ8Q4rVqk0Aco97FqESlSOK403HRgkgw8gLBQHhnohHnBSE+SZuBGEcI4VDHjadHCTtMIgaN9CcXF0Mfx5AYvMjCeCYLJkk0J4l9OKjz81YEI5t4rQCn4vPXmNygMCSZFvJfkDGk4/V8UcdvGiN1Tphk/004/uyf/bP8m//mv8nbt2/56Z/+af7Mn/kz/OE//Id/U5/97fLaddbxV/8P/w+6qiWZZIy9ZDmOneCe1bZhdl2yfb3l+defcv/pmtuv3nJ8OAphw2j6VkzJu0aszYZW8Jyh7plMJxy3FVfPFqxfbrj96Ibd3ZHl7Zz21OGcpZiXDF1PURR0XU+apfTtSDFNqQ4N86sp2zd7bj+8YvN6z9Ov3op9WiqG1WMMLO7OAdyDZAp2VfcbPHbXrzbcfHDD7n7P6smcvh6wTnRwXdUzmeYRK5ZMwbzMaI8N01XJ7vWemw9vWL/e8vSjG/Z3B/J5hkLTtz3lYsrQxPOPniQRr1LxZz2yerbk8bMNT792y/bNnuXTOe2xJyDEoL4eJQeyG0kSeWNP84S2aplezdi+3vLe157x5tMHnn/1Cdv7HcV0Asgbymw1o2s6af9+pJhOIjEqp9pULG7nbF7vePb1pzx+tubqvRXtocN5TznNaeuOcjmlq2OGZPSMbU8txbxgf3/g+v1r1q83vPe1p2zf7JkscoITJmi5LC/WdmMv+OjQDuRlxil6/K5fbXj+tSfcv9xw/WxJtWvRWggifdszmRfiOZvqiE+n9HVPsSzZ3+25+eCG9cs1z78u559eTRm6gbEbWN4sLpjXOEilwg6OLE+pjg3L2xnrVzuefXTL+vWW26/ccHg4keSGNE3pGgmCH7sRlMGNgvvVx4ZiOuGwPnLzlWseP9vw/Ceesnm1oVyVuN4zDmKK3p06yZJtBT8b+5FJOeG0q1lcT9m83fL846c8vNhw896K464mSdNLdursenrRn7reUiwkIDwpUuptzfX7Vzy8WPP+Tz7l8dMNi+dLumOHc0LmGdqBfJLTNT1pnsmYmkuQ9Px2xvrllucf3/LwcsuTr95yvNuTFmJkMLbyDPuqR2cae8aETx35NKXaNly/t+Lhs0eefe0Zm1cbFjdzuqYXg/fljK5pycsJfdvLc+gdkzKhOQo2fXjY8+SrT1i/2nD1/hXVthJyEIq+iWHfzSgs/8GSljlD05NPc47rE8vbOZvXW55/7Snr11uWTxd0pz4anZR0dUteZFJtSA22d2RFQntqma2m0v8/fsLjizVPvnrL7u5ANk3lDbG3FIuSrmmFiWu9eHa3I1mRUu2q2Ie3PP+Jpzx8umb1dEFbDaACxXRCW7VM5oVkCWcJYz+QlRLePl2WbN/uefLVWx5fPvL8a09xvaNcTPmjf/IfYroof0tz+P+va8GXpvV/x/HbsZC++M4r3n7ywK/8xV+lrWUSNJmh3tVcPV/x+GLDzYc3bF5tmF3NpCySioThPMnNVlOqY8N0Jsy+vhfyzmFbcfvBNW8/ueP62RXVvmZSZLKzS7QsNqkQYOY3c/q2j28fmvrYcfVsyeb1jtuvXPHwYsPsei4kpDzBuoAxiuE82A91NBxwDM1IsZxw2tbcvHfNw4tHrp+vxGQ9nj9JDMMoxuj1vmV+O6WrepLI4myqntXtnM3bPbcf3PDw4oHl9ZyuldBx7zwmUbRVz+JqymFXs7yeMg6OcRDiw2lXcfP+ivWLLdfvrdg+HimnmZQB45u2SY2c/2ZGW3XkeYJOFNW+Zflswe7tnpv3b3h88cjq6ZLm1AizegwkuWHoBorphOrQsLyeMw5W2K3znMP6xM17Vzx8tubm/SWHdRWDw72EII+eNNX0zUC5lE1QliWgAm0lhhXHhyPXX7nh4dMHVk8XNFUMau+thIC3lsk8p9rVLK7mDL1MarJ5qbl9f8X9pxtuvrJi//ZIsZhImEEuEqLEiK5ytixpqp5JkRJQtFUr51+fuHn/ivvPHlk9WVEfmyg/krf5oR1koTjULFdT+k7IQ3mZUW1rrp+vWL/ecP2BbMCmywJrA0kq4fRpntJV0ofrU0s5FcLa0I/Mr2Zs3x548pUr7l+suXq6otqdyMrYhpME21uyIqM5tcyvZvRt944UU3VcPVnw+HLD7Veu2bzZCSEojiGcsI/7bmC6KGmOrbCDrWPoxAFnf3/iyVeuuY/Pv97XZEWGHaxsPuqBfBrPv5rTtb0wiFNDfWy5ebaURfvDW9YvHllez+j6UYIArCfJDX1jKeY59VFIPM57xtgnDrH9H19sZAxtT+RlJmHYWSJM8jyjOjQsbuY0p44kk0Sd6thy9WTB9s2W6w9uWL/asLia0bUS+h2Cwhh9Me+vD43c/+gYByEFyRhe8fDikav3rqh2NXme4rzME8550sxQb1sWT2c0p17gFqPp6p7V0xWbV2tuPriWZ3g7p6070iKVt9VES5B9kVEfGxZXMzHJ6CzFvKDaVdKHXm24en7F/vFIMZ9IyHdm4ltzQnNoWd7K/WcTqfy0dcfiZs7+rWzAHz57ZPVkQXNqyTJJ17l+/5ok0fzj/8I/9oUtpF967X4OR3CCnWGk/HGu6YeApJHEsq2UNRRd3ZPGneZFR6qFlehD9OyN2j1nnWBaQUqb55T4vhlIE3Nh6Tpr0Urhx3huzjo+0cQ5J16l2sikjxb2pU60sBTPvqM+/q06aw4D9px1SGDoZKfbVR1ewdAOcs9WWIrOenzMdPRW2LQ+BJyzgq8kmr7pMalmiFitd1Ie1VGrKhiVu+BG3kqbWuewnbCiu5g40tW94G5OtGlETao96yFtiPrIUZjEeEmyyBNJlNCasRsx2kRs2eHdSHAOb6Xs5a2PnsmKsZf7H+pWMLpuAK0ZeyflwNFF7ZuUiqXs5kV3GrGuvu7kvMOAVoqxH9BB9K+SmSk4reCzUuaW/a9iHGXy6WthavZNjzKBcXCgpWR3waSiLtI5hx0lUch7WWCMSRiaHqPDRcd8LvHjQ9T+Cj5qnb/oWr2zmCShbxopYfaSyiM4m9yD8+c29/Hfha0ZYt5k11mS1DD2AwromkEwunNfsWe9bhCjDitt74Jca5JK9SLNUrpuEGZsb1FK+pz4FEv74aVUOVobdbFBxk6WMPYWlGJ0Fp0m79jFTjyeQ8TzrPWxlm8Fb9SKoRnQqST6qMRIYkwi4x/kOkLsCGeM+NwXhn4kyROGtkMBQyPe0S4y08MZ0/RyfhlTguE6K/rKvhnic+iEK9FHHWcsO599n7XROGvjs5f5Svq/oa8bMJq+7kEprJdyb3COs6+zMPhHfBCYxnuPV9C3I0ma0DUDKMXQDjL+nGhBJTdWlAIuZrpaJ31h6AfBtZtexlIjRCEX/beds6JdjuNF7j8wjlbmJuTNX+fS7iqcfavV5z/Zx+M3jZF+efzmD2UEMHHjGA3LNXYcI/AvOAEhCoqRSVbszSwmkiyClUUvRKLGmfQiE1JcXM/4VyQAjdZfIpd8UDG6KRKDnMMT4kIQhe/OiulCEEzMRbKNc4J1nM8fvJMJpHcXPNI7kV/4aBxuL/iZw3uZrMVQX4gV1p9NDQJ+sAQXF1vvIv4rMVs+CHEoxEU0RBMD7wN2cDKZ+R+7tiBkCBcJQNZ7VIgmA6MTqUFIJC89LowiBSAO8kAIiuAEnw0h8rrwcaIQA3DvfbwnmZTefV+IgcwBpc4GGXL/eB8XYrnucyi0j2HEssESEhqAG0MMNpAJNvi4+Fghu8hzAS4ENmmfi+G/k0kmxEnWWxufQVy0ghgGuLgghwAqbo5kw+Rjv3Wxf8qzsHEhdM7GdpdrkskQEfzbeF1WiHPOufhPuCwA+CDXFMCcCWgewUSRc8n1iAm9G6PLVfAoL85XPi5G3jqwQizz3uNd7Cfx/DZuuPzlGUjhzVkbDRJ4R5pT6nKNCsGivXXY8d3ng4dg4zN3Eg/mY/+Xz8tGzY4OnL9ED7rRX8ZI8O5iZnDuCxKIcB7TsoF01r+bF0Js7zgmL0b9TvqEdy6OD1lc3CiLv/eB0Vqsk7YM8ZrGfhQw+GwmQhy/Tv7RCIHPOzEvGeMYMs7F8HkxOzkT/oKNc1MQgp8brWx44kbB+fiMYsC6SLMA/KVPnu/Rn/uZF7mZdw6czD0uiDGMLKgxwCFwuS8XQHkZQ+ESeP/3IEb635bjtwsjVQr+8v/2P2fsrWjXBhezCC2TWc5pXbN6Oufh5Yb3Ikb65MNrdvcH8jIDpfGjJS9zeWNIDG70ZEVCV4te77A5cfV8xeblmmcfPWH9ds/qyYJ636CMYlLm2GEkSTNGO2C0Yejk/PWhYbYq2LzZ8/xrT3n47IEnHz5h93BgUmaXhW4yn8hbp9FSeitS+lo0p8f1UUo0Lzc8+egJ27dblk+WVPsarfVFR5hmSWSTCkaZzzKavWjetm92PP34CfefPfLsoyds7/ZMZ2Jy4KPQfRyskB5GyS7soubz8HDi+vlSMOKv3rB5u+fq6ZJq16CNiMeHdiArcnlDOGfClintqWe6Ktm8EXzt/rNHnn50y/b1jnIlpULnAuWsZIhvqn4Q44OhGclmOdXmyPKZlOqff/yUh5drnn54w/7uiMk0WZ4yjo6sSBkHi1FKxPvznHrXUK4Kdm8PPP3ohrsfPfD868/YvN4xvy7pG0sITrS9vbxt2MGSTFLGtmdS5Bw2FaunUuZ89tEt67c7bt+74rA+keQJacS1J2UuuldEB5uXOe2xo1xM2N0fefLhdcTonrJ+vWdxXdI3A94HpvNCmMhZgu0Hwdm7Ucr3h47FzZTN6y1PP3oi5dYPr9nfH8WEwEi/z8sJdpA3FTs48mkuuuV5zvHhyNV7Kzavtzz56Cmb1xuWTxZ0VU8Insl0culDYy/Vl7EfmUwn1PuWcjVh93rP049ueHy14+aDKw6PRzEo0fJWW0zzCyPYOTEe6E69nH994ub9ax4+e+DpR0/YvN5JuffYCM5cSv9LUxPZpCZmwmY0h4b59ZzHl2ve/4lnUu7/4Jrtw4FyNpHNySiB3Wenn3GQsnXXCHdg/3AUqODlhucf3bK527G6XVIdajETKWQMp5NMKhVaMOrJfEK9byjmOfu7A08+upVx8ME1u8cj09lEIglHyXu1o5U+PEof7uqBYjHh+HBi9WzO48sd7/3EUx5fblg9W1FtThdDlqEbZCxFv2s7yjNsDw3lqmQTeQZ3nz3y5Cs37O8Pgi13on+fLcpYKRD4Ks0FPsjnuWSIPl/y8Nma5197xuOrWO7eVCSZIcsT+n6MfUi0u6NzTMo0au8jRvqVax5fbnn+9SeMEZr6hT/188yW0y9kLfhyIf07jt+OhfTV997w+vt3/Mp/9jc57WqyPBF5QTWwuJ6yeziyejZn+2bH4nohOM6ioD11MeT5FEN2a2bXU2w/XtxD6kPL/HbO7vWO5ZMF1b4SMfypY7oqhUS0mnJ4PLJ4tqI+NOSZZDb1nWW+KjluKxZP5+xe7ZndzGgOLbNVSVN3TOcFh3XF6tmC46ZifiVB1SEEsjylrXpWTxesX21YPl1y2pyYzosoqC4F17uZs388xOtrKWY5wQpGVi5L2UQ8X7B5tWV2Xcqitox41qqI2OCM4+bE/GZB14hhRjZJaE8dq2dL1i82rJ6vOD4emF5NaY8dk0VBd2yZXcn9r54tqXY1k1mB946xHSkWE6pdw+rZgvXLLcsncyF+XRWCZ61Kqk3N/HbKaV2xfLKkqTq0VphM0x56Vk/nrN/suH6+5PBwolwVNMdO2nDfML2Zcno8Mb9dUO1qcSFyDtuNTOYF9fbE4umS7esdyydL6l1FuZrSHmrK6ymnTc3yyZzDw5Gr5yvaUwc6YJKE7tQxv5lyeDzFvzmJecWppVzkNKeB2bJk/3hk9WzBaRPPPzrsYOME3LJ8MmP7dsfyVsLcZ8tSjC2uphKsfjNjf39k9XwZg8LVxXxicT3luDmxuF2wvz8wuyppTx3lsqTaNZfrWz1dctpWTBcFw2Dx1lLMSqq93N/21Y7l0wX1oWayKOnizyYS4Q6PJ1bx/k0q7PO+GphflfLfni3Y3R2YXs3oTi3FYkIXr+O0ObF4suC4rphfTxm6URbV2YRq37C4nbO/k/Y/bU4Uq4Lu0FGuBFecXskzXDxZ0hwb8kkGeLp2lDG0qVg+W7B5tWN+M6fZ1/Icqo7ZquC4lnFw3ByZ38zom4HgAnkpYQ2LJwt2r7csny45bo5MV9PL+K+3DdN4j1fPZQzlk5QzAW66Kjk8VqyezTncHymvSrpjR7kqaI895UK4DIsnM46PJ1ZPFrRNL+5FeSo44+2C7esNq2dXMoaXE+pDx/R6Sr2vmV/NZB54vqDeSlB3iOYL5VKC6K+eL9i83rO4nVHtaqarkr4aKFcxqP12xumxYvlkTld3gCbNDG3TMb+O9//ekv3dkcX1jPrUyBg6tJRXU473B67eu+K4rSmiqcXYDRSL4kJS2r3ZM7uZ054apouC06HhvZ98Dg7+yX/pj32Jkf43+XDOCxbohZZvrY2ZhYKb2XGUuv4g9Pm+Ew3cMI4Xz1V9zumLWFiIJaRxsKJTHB061bS14IvjaAmIBg8lOJYKohkVTaOU7AKiNdNohtGSZIJNKg1jK0kazo5C+XeeEP03XdRpjv1IQHbaxkDfCBtx7EZA9FwhSFnu7GlrB9Fa2tEJBjgIjtoPI1me0rWSAjOOo+g42xFiydF70Qk6J360Y28jTuUIWtG18rY2dD3GwNCPF11piH6zdhSdoB1FazsOI84J+cIkRsg8CKNVKxWvQ6QKzkf/06jxc1bKtG4UGUfX9KSpEIXQimG0qCDPluhs66xFBSnBaq2wNsR+4dAJslvPEkYrmJQdLOcM1DMu60aRNlgr7PkxtmnfDegkYlLq/HwEXzvLXLw/l+zls3aQ+xs7i05NbH/RXgZ11uRF3WDEZr2TZ3fWVnbdSFCerutJUtGRnjWpBPFEllxIKd+ZqKlVKsj9IRphUjGiMFox9I4k9mWMxsUStzxDi+adD648I7n/JJXnoBOp+CiFaILhAlEoJW1C5CAojfytUbSRDTsMFm0kYN4oJc9LyT04J1URN8j5h26AIB7XSXrud+Hye3mG8f59lH54KZ2Po/jCWuvQqYrPX1jhIQQhCEYHpHCGDqwjqFiOVhrnBMfuWuFXdE1PAIauB+S6zppLG12VfJSejYOVMvOZ3Nd0kJ05AuJ9rKI2lIiHn32wzz7U1lrBmgfRnvfdgFZaxpJX0ocQj2xrz99hUUYLFh3nJa01fT+gEmQeUlr0pBA/Fx2cog+5i/K+s8f3EF3S2rqX9hnPunkZe1/U8eVC+jkc+qzFI4qKlRGsKGJyBBGqaxXDo7WKYb+i64SIvUQdpvcRG3ThgnmhBRPQUW8luj3Rd/qg4mcFPzQ6EXF+CO80XiBBuHGQi1hf4b1oVJ130eA9GuC/EyoKHhXxGqUE4xM/XCMi9XPodMRAtDaRNCQm/SFyADQaa+UetI762CCsv2AjDng2Dw+amPHMuYZigmhQJejYyFXGBUhB1PFF7R0/RjwI0WAiqKh702h9xlxBaYMK4u97JsmoqJOUpo3nceGyyTh/vTobKZjzPQXRC56/PHAJsj77dyujUcHFHNuATt8t2CiZECQ8OUTSiTw3zsJ04vOOjSPaQX3BqFVQWO+F9uJcXFyjob0NaAxBOzFQQLS2Lk5EZ9P5s770vKHTKIxKMUo2PCoGhutEmKMkYijineg3zxb+IXBZYJRS0s5Rb3vWzEq4u/Q5HTW+l1DvEO9U/AqjyYNots8MqLP5yJnkRdSiKqPE/DzId1+CoFGXZ4yXseguIeXuYsDh4r1c3NpV/I6zNllJ63kvl+fx7zBcabgz94hLbEA0rJfFXhi3Ovv/sPfnvrYk274e9kVERvazWWvtpppzeXmbRzp0+D9QfAQeSJoyaRAUCAigRcilSefReo4IAqIM2rTk6AmQZBCgRUgQ7z1Nneprr37NfmafESFjxJx1HiUaEnkKuFIlULVq71pzZkbEiMjMGL/x/aSuW110Agg4RfLyUTQXFEZp6asrUF7GRmpiNYmKcHyipiH2H8iacxEwKaVQzktRahxrf6n7lZmE0RITF4Gc1AwjgIf4sB2ZLdIyFU06QjQTVzKukp9X12vxk5gsEGS+uBBrdGOt7kUTcTFXlzbK916MLbyXGzJaczFbF+DDLyc2+nVr939w/M9T/nKP0vB/+N/+n6L4JpBkCe2xY3lbc9w2LG5KTttGwPRlRn/oKG9rulMr0HktE9emsi08nAeqRcHp0LF8V7J/OlKtC6ZBBASXrdFiUUTlnibNEnFs8QGT2Z/PvzlT39actoJqs5mlbzrq2wXdviXJBOIdvJwfDWMzyrbYsWP1rmb/eqRcFIz9iBsFRN+eWsplwdgOBKVJ00TKy4MisYr2OLK6qzluz9S3FafNGZsZMW/uR6plRXtoSHKLUeIok2ZW3vT6kaISru7idsH+9Ui9Khj6CTfNlMuft7W7c4fSBmsjEAIlT61Hqak7bhuWd9IPSZqI2rQTJmh/bEmKVIQRsxfweXwDKepU8oLvFhxeDpRr2dKEQF7ldMeOcl0xHHtIZBvr8gZnraE791SritO+ZXEjW+hpbkFr5nakWFW0x7PwbQfZtbB5IkrOYSIvU86HPo7hiWot27FaQ1ZkdKdOSm7OPSox2MREOo7GJLJ7UcYazuW7mv3LMXpBCge6XFV0x1ZyesOEd4G0tPI2P7vIQe5Z3JQcdw11nXM+dRijsVnK0HYUq5r+0F6h6c57EmNQiaY/99SritNe6j8Pb6fIoQ3Mw0h1U3PeNxSLQvjCgLVSu+5cIM0TmuNla/kobNpDh1KQFhn9qaO6XdAdGkxqRbXrg3yH0gxtT1mXNMeWxW3F/u0kW4ajKEerpcROXhdM/QBKk2bCkyWAzaR2cxH7v74taXbtFXQ/NL2kGU4tNsuuorQkNfL21I5Ui4LjvmH5ruL4diYvU6ZBhEnlUtILl3kFSAzFh64kT2j2nWwZb8/UNyXnbYdJ5YFjGmMbTjKHdYDJO2yaopVwtYs6kzhcV5y2Z4oyZxhGwuzJ64Lu3FIuK7pG1hCbGvCeoGQODeeear3guD2xvKk4bmMMqziHVjXt4RxNDETxbzPZlp76iaLOOO87lndL9i8HFrcF3XnEezFkaA8t5bqiPXcYrUmyBGY5f5qZmAYqOO5alnfVNYZlDgsbW9ZMzf/yf/Pv/mI50l/fSP8Mh1Lw6fcPlMuCIQojpn6mXJT0zUC5yOnbkazKZKt3mMhXJcNJav+mXibcPEyUcVEr6pyhHanXBf1pvN5ETaLJylT+36qUGtSbOoKkRSiU1yLYKOucvukplxlD05IXmZSUeHGVaY9Sezl0PYt1wTRMEZovubVxnKlvStrTIDDtcSKxRsQ0w8hiXTE0I8W6ZuzHWIg/U1Q50+io1wVd01Msc4YIE/dxGyYvU/qup76tGDu59nmcKRf5tR/6dqJalvRNL3VnEYeXZElsf0F76lje1WKuvKyjuCsXkdUij4D/ku7ckZbptaSjWOSMnQiQxmakWoq4ol5IO8tFwdDNFKuc7tTHxX7C5gkmkdKJ6qaiP/dUt7IQXvq/qPIYBwI2L+qc9jxI7lhk0aSV3IgWNzX9uaeMUISyyhl6gbePw0y5zCOkPWdqR2xmrtvm5Vriq1pHEMcykxvwImccRCAz9D3FIqM9SUG+90K8kfMPVDclQyu5ummUvpuiyfnFxKCNkI1hkKJ6pTXzPFMsBZxe31b0/Ui+yEX4sSxw0bGmbyWX3J0FajFPQiLKqkzg++uC4Sw5MgGCVIzjTLkQA4JqldM3HcWyZGgHbCYPQvMkubv+2LK4reljvn/qZ7I6x41TFJ8NlKuC7jxQRucgZRRZmcp4r0uJ/9sFYyd9dBGvTKPUQfZn0SP0zUhaZlGlPFOsCjEwWFVXgPs0jJSLXHJ7Cxm7el3SnwayMr2md5IIKVjclAxNz2JdyppRyzikVc40iOtM3/RUq4Kx7ckKgw6ifL7AQqrLPFxlzP0kYqthoqwLpm6mqKUNeZkxzwKKSfJEjCZu5GFieVvGfKTM+6LKmQdHVsWb7SKjb/vrHAZPXmcMjcD/h07aOfUTVS1xUK0qxkFALd25pVoXjNGkIImI0ov5w3Itee2yljVURG8zeZVFo408xlAeN3t8FEaJ3mL1bvmLlr/8eiP9MxyXEormIEbCh7cjfvbsnndi3PtpQ5omvP34hk0M++cDfho5bk+MjcDt23PP0A4cNyembpLfCYHN/ZYk1bz+tMVmhrdPYhJ+fDsxDBOn3VkspSKsfRomOf/kBLCuFW+fdhibsH2Un/unPVM/ct6e6Jqe5tDQnAT4fd6cGbqJ4+uBMIuhtUkQM3KTsLnfQQgcXk8M4yjm0e1Af+pp92JkfNwccZNj+3QAAttPO3Qi0HCbJOyfD8xzNPIdZpp9Q9cMdE3PcdswT05g+QE2jztMotncbzHW8Ha/QQOntxNumml2Dd2xpz21nI7RGDqaUR9ejyilef1BTJC3Pwnwfvu4ExPitxNDP3Hen2kbseU6HRqmfmL/sse7md3DHmUUr582mDQRM3blObwcxEh9e6ZvRrpDR3cQcP1pe8KNnt3LgRAC2/staWZ5+7QjTRO2j3uCF0OCsZ84H5poeDBw3EkM7V/2uNmzezqgNGLonhm2j3uMhv3zHjfOnHcNQzfRHTqaQ8fQjtEofuL4dkIpw/Zhj80Stp+2JJll97wnuCBm5P3MadPQNwND09FG+Pn+5cg8OvbPB4xRbD9tsalh89MWjeLwfGDsBppdw9AMdIeW4RLDbyeGfmT/LGD37cOOJDW8/bQhSTX7x70YEryecMNMs2sZohF6s2+Z+onj64kQTRO01mw+bcgyy+aTGA/sn49M48R519CferpDR9vI+c+bM9PoOL6eCajrHHq735Gkmt3DjuAC540YSZ83DV3T0jVxDvWTGJrPnv3zDrTi7cetmIH/+IYyhv3TkXmcZQ73E+2+jX04cNwcmfqZ3fMe573EbCIG5kli2D5sUAQOr2Lkfto10Qy9ozu2TN3EeXvCjY7t0x40vH7akFgr5uSJYvd0ZJ49p63M/+bQ0J1HumbgvJN+PbwdCIQIyxcDbZPIGqIIcQwlhsd2ojuJmffYjZy2EkNiuKDY3O/FSPzHDSZRbKJZ+nFzZBhGzvu4hjQ9p0MjhupP0dD8aYexhk2cB9v7LUqJGfrYyvzv25Hu0F7N0I9vYuSwezkSvMyhxIrxQZoZdk8HPJ7jWyNG7q+HX3TN/7WO9M9wKAWL2xpQ6ESRGI1JpBg6iYzNEIQT6oNsfTgfIgHFXZ+yTJoIeNprtDdxi0rMqMX4VjwMA4p8kYMPFBd/0CLFBQGZm+hLqJRGJ+K1mSSy3SY+hCmgxetx9uRVcd3W1REi74KJjNxAYsSvNETfR++5+pXmdcbsPFmZ4hFSkkki81cjvoJGtolMZMymuUUFffVpzetMCD02kZKZOfZFKvkeY8TzUwXIipQQIFtkOBfEMspHb8UgrE+TxLyR4k+8RjU6sm7zMoWgxAItlguE4AXcjkLpgLm0OchWoYm2WjZPABM9LwPZ4uJbmRK0wiQGbWSLWxtFkhtJRSnJBYsVXoa/jp2nqPJr/xujhJuLjANw9X1VqJgTR/wp50ARrz0rMuEBW0NixcZOTern9gt1nTA7TGoJiE9qcIFqLZ6XSZ6ilYoMWoPNEvoO2TpLJP9mbIIPnqIuIEBe5/ggb5hKIb6mRhNUgneOJBV/XRPzWcor2b4DilUuY7gQv1abWclhGoVKTBTgEf1ODR4Zz9mJT2rw4rHqgidbZOACiTViwEAAI/GIUtc5FDwkmbDDsyqP4yBes3mRozSYVEe+MgSlZRyM6AOMNeACaR7jP3qN5nUmMHor7fepvDWlaUKLvs4hNCRpKuevU2l/meJmmRdOCYsWrcBInXGSyFs4imgAHn1zPVEhHsgqsa5L0kRKl5zHxNgJSuatsQk6pj2CF99W7z3FsmCenbxth5hvjVaQ2kR/W000mDDS7jwjeIlDP4lP7yU1hZJ1ULxWZQ276Bac95FqJuVqECiWhfRVlcX5pzA2EW6xmUkyK/lopbFpIiV1ZTz/Mo+5bH4WU/wCx69vpH+mQ2kBZmttZNATjVIhTpwEtDhbKJQYT89BSCBcwEeeJMLmjdXXBU0rhVfCJVfIQha8MGh9hCK42aMSEQ1pawQyHyetUeI1GqLYScXFPkQgvQ8hQiEkP4iWG6EyOua9DCr6dWokhxVUBGGHgM3SnwU2SmESwdMl1sj5giKJQGmTaDxgUrl2EdRITk+FcL1x6SQKCIg3kfhgIEB6gVoncVG0uSy+Jrpm2MyilMYY8yfXJIuiifk3ncgDTZILqDtJLcxiRKwUJGn8Ti0MYoWIQrgIZby4V3gni793Tto0R9FPkBuHjK1GGTG8NlpJWY0VlxwTRVk6Qs9VdM9J0uRnQZm5PEjIn5PozalCIOhwRU3qOKby3SEK4AAtAiVjFGnsmzRNCM5JrXKE14cgJCvU5WEpREEb188TxF9UKUCLiubisyr50RDNwuMNjMjT13ITT3OLD3JjDs5fBS1JauM4yLiYJC6+iYljp1FG4tekcjO4QOtN9Oo1SWz3xQFG/3zzNEpfofcqxoOPbRHxURQCRecZrX+eLzJm8UGKC7wfkkxuNDY1Ig6yAtc36c+AfKK40BhF0PGaYyxJLjcBH83DQ2xDNCawxpDEB0i5NPnOJI0GCIkIBC9wCJun8cYjJgxJNIoIOt7E4nrikYeNcDUG4DqGJhFRnYxTiAB6IAgOVKk4hwLo5GIIYOTarUG5QJKlYu6QiBgQFdcOrUlsFDLFGEnyJIIeIi41fneaWRnDi2gptkHpKJS6GD2EgNGXP/+Smt1fb6R/tuO0OUUAwQzOi3jDwzz6SFe5lHAEmkNDkhqaQ49JDN1ZzJWHXj4z9VLGMY4/Y+fcJKSisRtQWtMcG0yScN43JHnCcB6kxKGVouixE3TWOIw/U2dmwdf15w6daJp9i80s7bknidhBgti7+dkxdiPBB6ZO6lqDDwyxlKbZicfjeXdGW8PQ9lKmMchnxl4oT303xHOLa4XSiv48oA00x5YkkVpRlVkRXMQccnBCbQkhMI2CBiP4K87wfGhIrJHriGbXRmvGZsT5wDjMQkca5ljOIWU5AejOHVrBeXvGpgnN/oyyCcO5l1KKQUhMYy/oMkGTuWs5kjaK5thJ/28bkkzMyU3ELQbv5VwhMPWzINdmEfAoFeibOIaHFpMaumMrVmTdgEIxdtOVLEVQ9N0UXTqC8Emtpm17EqVoDi02FSi/SWJZUgjS1wHmXkowxn6UEobg6ZoerQ3NoYnnH0hTOT8uMLQDPkj7fZDyEBdt2OYIy2iPMt7N/oy1hv4Sf4N8Zh6EJjUNkVo1OSkL08T2y7Unqea8O5FYwT6KNZsjzF7a4qTNPhpPC6xE07c9WkF76EisoT12KCMlFd6LAYD38vtoQQReiGFDP2G04rxvMYmibTtMAkPbSynZpVwjkrWmYRTKmJeSLa1FSKWNjuIjOb9wi8XQeuol7qZ+EiehYcZHgpGUg0Fz7NAm4bw9Y1JLd+pIos3ePDumSAVy4/wzXSriCrumJzGK9tiQppZm16BSy9SPMe6mK2kpxHIiUa9L2ZEyWs5nZR2Q/u9R8fzeB8Ze+uFSpuO8jH9QwsfWRnPeN9h4fpPJGF5iJ8yOuXcRkenEpi3EOaQUzb4hSQztsRXWboRiDN1wjbXgxQw+hABOSshQiqEbUVpzPkj/R7HxL3b8eiP9MxwqvunlVYHNLPXtAm0MNx/WhBC4+bjCjYHbz29g9qzeLeX31hVpacnrjKIuyIuU+rbGZgmLmwqlFMu7BW5y3P3mFj87bj6u0QnU6xpbGKp1SZan5FVGVeekhWVxU5FYw+JuAUpx+8WNfPbzG1QILN8vSRJDfVORFfLZsspIc0u1qkgzy+KuRhvN+v2CEALvv7zFzZ71uyU6gcW7JWmRUi0LijIjK3OKOifLLYu7iiQ1rN+v0QbuvrwlzJ67z28ITtqfpJbFTU1epBTLnCxPKIqUclWSZinL9zVaK9Yf1vj4WT8Hbj6TPl3eLUlzS7ksKMqcrMrIlwVpaalXJSbRrG4XoALrz1a40XH7+S3ee24/rknShMVNjc0s5aIkzURElS8KktSwfLfA2ITVXU3wgbvPbwWQ/fka7wPLuwU2TahWJUWVys9liS0ti3cLTGpZ3S1Awc3nN0zOc/vlHc4FVu+XaK0pVwVZYSmWBVmdkRYpxbokyxKW75eYLGH1folSgZsvbnDzJOcPgfW7FTZLqZYlaZlSLHLSIpe4ullI+24XKBQ3H5YEj8SjC9x+XKMSQ7WsSPOEalWQlRk2j+cvLMvbGpNo1u9XgOLuizv85Ln97IYQYP1hSZJLDNssoVzkFIsSW8i4Jqm0AQLrDyvmyXH72Zp5mrn5fI2x0sdpJuOVlTl5nVMsC9I8YfF+gU4Myw8rAO5+c0uYPHef3+LnwPJ2QZJbymVJWmWUi4KiLsmu1xTbYAzrDyvCLNfuZsfdxzXaahY3NWmeUtYlWVlQVAXVssQWEhvGatbvl6A0t1+s5bOf3+Jnz/L9Amtl/uV1TrHIKaqCLJdYsLll9WGF1pr1hzUBmf/zOLP6uCZJNYubirRIqJYFZZlRLAqKRU5WpjH+DMvbWsbusxvc6KUtXuLfxDlkYwzleUpeZlRLaf/q/QKl5LPBw/rjimmaufm4RGnF4m5BklqqdUFR5WRVTl5mJKlhcVuTZIbFjawh648r5mGWPgye28/WGJuwuK3JSkt5U1FUKVlsh80tq48rdKLjNTvuPl8zjTPrj0uC0izvJE6rVUGap9L+ZS7r0E2FsYbV+yUeuP38hmmeufviBucc6w8rlFbUMV7X71f8kgUpv95I/wyH94Hf/CtfiKtIbsV2q0hpmyEqZ0fSqAZ0HmyRct4JGeX4dqZaXVSllv7UkeaWsRP7rb4TtFl/HmXrQ8HQTJTLXIg865rTrqFYluKaUKZ054GsyOij/VZ37gW5NczXXExzEEuk4+splmg0UlLR9IJUa0byIqNrR/I6l+9OE4IKDK3YWgkJqRZZ/SKnPbSCFDyN2Dylb3vyMqc9imJ2GEbJFWeJ0GRWIslfrGvafUtaZdIPuRCVbKSypHUqT+DWCLEoKiKPb0cWNxWnXSPKyUNHlqf051Ha0vVkRS7WbotcsHFIvrE7SUnAcXuWsoqozO1PPbZMo0LUMnSCWOxOPWlqcbO8XeRVxvnQsLitOW3OlIuCbi/K6OHUk+WWrh3Iy4z+3FNUVqy1lI5Ag0GufdNQryqabUNW5TL+pZS2pImhbwfKRUF/HrBZJizc0UtpyP5Mfbfg8HqiXJR0x0ZipulEFd3+HA95lUYQiGx5T01PfVNw2rVUNzWnzYm8KuhO0cKrEZVp147kCxkXW6bydj5JaYzEsJR3FYucdt+Q52m04bIMp07s0JohKlgvYHclSuRFwXkbz789i4VWjP/+1JPlCV3TkdeinE7rXN4snSg2pTRK+q5clrRnUZX23UAW56GQfTqyqGAXf1voz6IyP23jPNycyMpcXEXylO7Uk+WiWE4LS3fuRQU8ye5AmlnO+zbO4aOM4UGIQN1Zxn84dYJrbAfyMo2weAtBMbZSwtXsW+pYXlPUhcyVIqU9xHnQSJu6c48tLcMgAJQ0t0IEinOojir8S+zYIpUxLGL/VxIHSWYJwQv1q8ppdg31SsrLyjjP8yoX27VCrjmvpE1FLaUzBskV94eWal1xeDtSLwqO2zZWFAzY3EalcCrz77KG5FbqWaeZclHQHBoWtxXnbZxDu1au+Rzj79xd55DE9IjGYIxhOEvFwnnfcdqef9E1/9cb6Z/hUBp++t09RsuWn5tmumagP7YMw0R76MA5TtszxopqMCszXj9tyMuUw9sRo2WLxXtPexoYh4lpGOlPPW52NIcWheLwciSvUraPB8pFweZxS5pbTm8nUIHzQc7fNB1D0zNPjnbfMU+O0+4k53/ck1eZqOhKy/HtiDEJ7bEB72lPPfMw03c9wyl+x6ElqMDp7UxaWvYve8pFweuDqOnOuzM6MTSHjnme6ZqOoRmYxpnu2OFmR7tvSaxm/7QnL1Ne7zfY3LJ/PpBY2eIiQHPu8dPMOIwM5w4/e7pTR1Bw2jTkVc7mpy3pouDtYUuaGQ5vR4jbdS7M9E3H1I3M00x3bPHTTLsXnunh+UCSJmw+bcirlMPLHpsknHcNEOiOA1M/MvY93aljHh3NqcUHz2lzIivste/eHkTNeXg+oIzitG+Znac790zdwDRMtKeeaZppjw06UeyeDmSlZfO4Iy0s25c9SZrQ7BtQivOhxU2OYRjpjqJEbQ8tIQROb0eMNeyeD9gyY/PTG2lpY2pBbL/mScZw7Gdp/1nGsNmdQcPh5YCtMraPB9LMsrnfYFJLs28IBJpdyzQ5hnZkOHXMw0R77AiT47w5Yaxh+yDX/vZpS1pYDpszJon9PzqaY880OMZ+pjn1zLOnOTRoJedPs4S3+w15lbF93GILMXbXAYnhcZbzNyPTOMv555nzpiHJpP1paaOa1XB6O2GUoj10BOfpTyNjPzPNMv/cKOMQAhzfDhRVyvZhR1ZY+a7Cct4dURqaQ4dznr4dGFuZf92px8+OZtuirWb3dKBc5Lx82mCzhOPrCa01za4hzI7m0DEOsyh6Dy3jFOewguPrAVtK+7MiEzWv1RzfjvIdl/NHFfQ8yflVUHSHBqUV++c9WZ2xuX8jzS37F+E9N9sTIXjao4z/OAy0x5ZpmOiOHQrEPzZP2DzJOrR52JAWCaftGZ0omcPxnFMXz3/sYgy1MYZ32CLl9cc38iJj+3LA2oRm1+JnJ+fvJvpmoD/3zONMd+oJBE6bA8Zq3n7aYvNM1NRFwnF7QsWUk3Oe7tQztgNTP9EeG/m7Q4sygePrkay2vD2IEvyif/iljl9Vu3+G40p/0ck1QW6MEeVpFGZoI8SWizhBqYv4Rzw1lVGRbKOk1hMVVbNRsIIk/0Ok/0C09oruLMELm1UroQ4lxjBqES2REBWgCm1F4AIhCgoiKShR160RreRf5qIaNpekv9BFFOrqQgE/i4ciOkYEBspE5bBcj4kiHG0TcWyJVBitFbObRZB1ERdEqNJVsBNJQUkUwZioYFTBR5FMIsQYzfV7lTYimDJRhBUFPZdrNeYCb4gYPquFXGS0iGNUgknkO0TgEFXX3st3KyV9G4RU5IOM4RU4ozVKm+u4G5NcBTQheBnDy1DOniRR1zqqn0UWIrKSz0o8eMBaG0kz6hpHLorHCAFtIARJN8gYXMQaERrhfexjj46KYlFah6uY5hKbV8UvAaxGaYVNLRdLQKVAG4NzDpUkIkQyGuMCTgkSUV/FclxFYdqIsMQLKigq2x1c+l8rEbqpyKtRkWYVRNjjvdB1NKKGnt0McX6EIHZtotY2sR+0gEpSLXZeSmhKQtURtXvwYExsg5JrVEYL5YsoBruIomK+VSHx56J4S4RWOoqfuArnEiNjcxEaaS3tD0quxaSJjF0U/Aj16me1doRZXZX7LrqtKNljid8pc1zEPQ5HVKsbiX9MpIjFa8RJTXUIotL20XaPIFSsi0jpIu66rEcX5T46zm+lIIJALmIirWa8DlF0CcpEsVZqZFcuEeW4LJAKEwH3F+qainQrncTqAa1JjIr9b3HOSR9GcRj+l+UM/Xoj/TMd7768var5TGJ+loprLW4MLkSAwcT6/ZKpm1nc1PjZUa0q/CSSbpuY681IaRMl4opyVTCPjtXHBWM3Ut/VzINj9X6Bn0WGH3wgTRM5LwpbyOJdlOJMUa0L5n5m/WHF0I8s72rmcaRclwQfyKtCFL1ASGSiZlVGCIpyWYBXLG5Lxm5i9XHF2E3xOxxlXRIC1xxLCJBYUcFmUZVYrkrmbuL2sxVDO7F8VzEPjuW7BeM4k+ZW5PapxRlB2KVVhiIIEGGU83VNz+qzJWM7sH63lML5ZRHPn8ZSlajKBCmvcYFyWTJ1E+sPa4Z+pL6rmEfP8m7JFB0+UGIo7RGUYJpJ+UZWCqiiXlcM/cDyw5KpnVjdVQJHWFQEJypiG1WxIZfFIi9zCIF6VeLHmdXHJUPbs4hjuHi/kPKDKkMnmjRP4mKqScsUNNcSqcVKit/XHxbS/+8WzKOjWhVSylRmmCQB5bAugIcsFxBIsZQi+9VdzdDLZ/3gqG5rwixlGCCqSZ2oqOBMUUqcfYILFCsBOKzeLxh7ib8xFt8HJ2VAiTWEy8MXWmIzKCmzGB2ruyVDM7C4q3HDzPJuQZg9xaJEKSVlWIk8RNhcxiSPZU7lqmA8j6w/LBnbmcX7hUAA1hVhFtCETZP48OBjiU6GD4FyWeAnz837BWM7sXy/YO5nlne1lEEtcrSS9l/UsRcle17nAFR1wdBOcv5+ZvVuGSlNFc6J842KN1KFKJaLWNZRLIqY360Z25Hl+5p5mFneVuLwUksZWlpIqYxSYG0i+os6A4jQAznvFIEG8zyzvKvwTuYrRtTExksMZaXQrIpCXGEW6wVD07P8IH23+rhg6h3lskIrTVZmJFbU8TazoIK0IUip1NROrOK1r94tGPuJ+l2N956szkCBzQ04SWNkRQrOR1CHEwhE17P6IBCO5W2Fmz3lQqhEWZFG5bzHzvLAWdY5k/Ms1jVjO3P7xZr+3LN+v8RNjqRKf82R/kM/tNE0p45ikYrYZr3AJAnL2xq8iGv8PFPdLQhKaq5MmpDXOUlmScuUrLYkqYgnEptQLgt0gPqmxjvP8m6Bd556XWOMpl5UpEVKmqdkhSXLU7IyJS1EPGNTEZMALN8tcJMIVHzwVOsKm9ooCsjICxELJdaQ1bnYGS1yTJJQryuc86zer5inifX7NUorqjrHZgl5mZNVqQgeFjlJnlDUOSaKmQBW7xb4KLJxzougyVqyUgQ21lqKSoRSZV2gjaJalmitWb6rmZ0IZebJs7hboo2mKEWgkFUZeZmSZgl5JTfxalmiU8PyZkEIcn7nHeuPa1yQCW2t9I/N5TryKiMrrNCfEk1VFygN1U0FAd795pZ5FsGM1oY6imKyMictUrLSklUZaWZlfLOEYlEAcPPZmnkO1Dc18+yo1yK2ystczp9npFlGmqbkpSwixSL2w7okuMDNhxVzP7H6IOiyYikiH3sd/4xskWFSQ7WoSKymWhUEDeuPS9w0s363Ypoc1bslidEUixKTGooixRYJtkjJq5QkTyhricN6XRG8Z/1hjZsmlndLQggsbhekaYJJDVmWkmaWrEyxNqFaVJjEUCxzUFCtStw8y/h7R3VTilBlXWNz6bO0sBiryUqLzROqZYkxCcu7BQq4+bjGzzPr92sC6ioKyjJLXqbkVU5WSyzlVU5iLflC6kLrGxHsrD6scXNgcbNAG0VR5SSx/22WkBUpxlqSNKGoC2xqJYacZ3m7YJ5mVh9XKALVqorxn5EWOXkhsWhtQl4XpEVKua4IBKq7muCIoquJ5YdFFMrUpHlGVmZkpcRQWmVorSmWBcYaFrci9lu9WzLPjsW7FcEFVncLEmupFhVpbkmsJcvlASCvCnRiZHyNolyWzM5z+/maeXKsPyzRSXIVBaWJrEFpZkjyBG009arGpoZyVRJCoL5b4ibP8maBRx4+k8TIHMwzUiv9lySGvMwxJqFcy/yv7yq886zfr/Cz5yaK7aq1CPayOA/SwpJVKcYaijqTPlqJYG95uwAXqNYVLtoNmjSRsY6iw190zf9Fz/b/L0cItIeW07bhtOvYPu3om463+y3zNPP6wwalNU/fPJGYhIevnwF4/PYZ5xybTxuGRigt+9cD/aln/7xnHCdef3plnmeevn1FJYqHPzyitOHTHx9xk+P5+1eGYWb7tKdvOk67hv3Lgf48sHveMw4zr9+/obTi/usnUmv59LsHAorHPz7i3czrj2+RyHK6koIOT3uGfmL7ICSlx2+eMdbw0+8fMFbz01cPBODpu2fGYWb/uKc9dJy2DYfXI0PTs33aMY+Ol+/f0Aoe/vhIkiV8+v0jQcHzt6+4yfF2v2Fsew6vZ46bM915YPe8Y+wm3n7YEpzj4ZtnTGq4/8MntFbcf/VAmD2P37wwjRO7xz3dqeMY+3A8D2yetsyTk/4n8PDHR1Jrefj6CXTg/o+PBO95/f6VoRs4vp05Hxq6c8f25cDQTWwfdnjnuf/qiTS10v5E8dMfHvFOzu+nme3DjqEZOB9ads97umPP7mXPPE48f/uMVoGn755J0oT7r+4xBp6+fSbMjpcfnpkmIVKd90KX2T7t6duB7SehMD1++4zSioc/PJEkhvuvHgB4+vaFaZjY3G/pTyPnXcv2ZUt3HNk9H5iHiZcf3kBpHr55Is00D189gFI8fPVA8IGn794Yu4nD84H20NPuWw6vR7qmZ/OwZZpmXr57xZiEp2+eSNOUT7+/x3vP83dvzPPE5mFH3wnh5vAisbB/OjCPE5tPWwLw+M0TKtE8fPWE1opPf3jAe8/TDy8M/czx9UR76DnvO3Yve7qmY/NpwzzMPH37jNGGh6+fsDbh/qtHgofH716ZR8/bDxuh9OwaTpszzbHl8HJgHmc5v/c8fPuISeS82iQ8fv1M8PD0/SvTOLOLc6g5dhxej7Snjrf7DdM48/LjKxrDw9ePJDbh/g8PEODxm2fc7Hj9SebwYXvitDnR7Dr2LweJvx83OD/z+M0z2mru//CINpqffv8J52Zevn9h7Ed2jweGY0977Dg8H+mOPZvHjXzH929oNE9fP2Ezw0+/k/F/+PoBN8oaMvUjp01Ds2/pzz37P4lhnOf+6ydsmvDp9w/oxPD4x0fwgacfXpnHmd3TgeE80Bw7di+7GMM7pnHm9cdXtFY8fvOCMZqffveAUvD03Qs+ON7udwxdz3FzmUM9u6c9cz+x+bSH+FltNZ++epJx+P0ngvc8ffeMmxy7py3deaA5dBw2J4Z2ZPO0ZRonXn58QynF83cvZFnCw1dPqDiH3Tixfzr8+kb6D/1QWsnTf3QuuDgz+AgKmMdJXBuc5G4ujguStwGTJNH9QQLBeX91asBLXsk7H90UguSNojuJNpIfMNGF41JI72Z3hTzMF1eXWWrx0AqN5PqCA5UY2YoMQBArJhXzstMU82nOi9WDDygMSmnCFH8v5kvQlzZenEuk5s3HnIsKoPwlDxKvSV3aF/OzOjpXaBNdPH4GRmgi+CHmz0LMI8tOuPR5iEgj571AL4KP+RSBQoTLtSBbh95LHif4IMX4SuGmgFFSwH/JBQbnoxmO9G+s2MdYxexDpGqIdZhJDB7J1SmlYu0fuDmgfAAfCC5eu1LoJIkuJ9JH3nkBUWgBNEjuU/pLqjkv7h/qOu465uAuubKAj2CGCOxQF/CLACYUSB8rodcQc3LX39PyHz5IobxzTs7vfLwGIrFGxtzE3w/RCcU5H5moMp5GKfACSSDmnJWRXLsxkhQXR5lAcB6lRN3rY/G/i3EdXHRDuuoGYu4xNWIB56X2NgYCKJgnmTvM0T0kSH4dra9gimue1oOPtYogziZJIn0YVHS3iWNPzPX6OA89QhMC4Vlf53CQfvJz7JyYxzdJQrSDQiEglYuLDSrgg+gQjI4WdCo6SrlL3wfQkopBy9pwmQTe+WvO1DtxJ/Lzz24uKsaxADD09TuCkjERTzxxfjLG4EaxU7s6/1zHX8t6oRU+CExf3HWk3tTF9eTSJ3iZQwF1hddoI1AHpWM+OOZqfYTnG2Ou9aMhANGNSoWYt0Vd7dZ+qePXHOmf4XCzINO01jHPorGZEZ9Da8jrAmWgXJX4yVMtK4G+39TRwSDDB3H0SGwixfnDRF6ljF1KYjXlokApRb2umIaJ5e2CaRhZ3i2Yh+mKaMvKTDBtVkdakSGPbgmyTQOLm5JpiLnSpmdxU+Gisz1GcipudNgsbjVa2S4OStrgxonV3ZJxnFi/XzEMA/W6khxdnV8xbW52sv2ZZ2hjouE2lKuCafCSq+tGqlWJd7LlrbSmqAXdl6YWmyWgDHkpfZRXgrOrrv1QiwvGTY1zgSK2X2VCAJKt1xGtZKvLe8QoYJhZvVsxdgLfD7Mg+5TWFEuBmyeZxabiVpOVOUoFMRcYZ1bvV0z9RL1eMI2TbIF7MZJWBnJrCZF8dNmuKxcF3sv21OwcixuB7dcrMXMvliVKa/Iqv5KmklS2K22WoYyirAt8/OzYS/vFQL3CBU9Z52ijSY0g7NLckhYpxhiKKhfYelXINuXtgqGfWNwtrwbOIUh5llZgM8s4zJgkISslR1YuCtzsJO4u+fZ2ZHEr9c5ZlQvqMRHP0izP6DMBUORlSnCeshbj8eWtnHd5t2YaR8mRBplDCiEgjf2Itpa8sAQdcX4BAfUPs+S3x4miLiQPWpeyRZzkjN2IzWzMuQnWUaGolyXTPLOKsbO4rZlHAdVrLblMoSgZ5mmWLcRSYqNclsyzzOFhmKNGQHLnfvLkixJtTDRFiCVs2YBJDGXc6s7KjGmaKJdiVLF6txTdw7oiBMlzJ4lBp3JztLlsV2sjW77ee6qltP/m/ZKhG1i+W+Hi/NNGk5cZ0zhjc4PNU0kXxRx0uSyZJyd9N0ws360Y+0Fy+M5RLsqrWHKehbSVV7nE37JgngLVqmQeHcv3S8ZukNTT6MgXGcpomeuT4DinbrrGH1pR1oKErG8q5nFicSdrWbWq8F5iSBlDliYEJyLDvMgwWsd1ILBY15JvvltG0MkvS2T49Y30z3AYo2T7BEV/6q4lD/Mk8vexGwghcN4LSea0PZGlCdunLVmVSumAVrSNlK70Tc/YDwytlMGM00x77kHBaX/CFgJ+z4qU7cMWmye02zM+eIZzxzSMjO3INEz0zcjYifVYc2hJMs3h9Uiax/KDOmf/LEDq86HBzY6hGRl7+dzYT0zjSHdu0crQ7IVgsn3ek+aWt4c30jzl+HZEKWL7Z/rzID+bkaEbmKaZ5tiCEeB8midsHqUMZv96xKRGZO+zpz11DMPI0I5M/Sznv9KAziSp4fB6wJYpm8c9Nk85vh7RRtGfO+ZxZmxH5nGiawaGfsDNsxBUEsNpe8ZmaSw/SNk+7zG5EIbc7OjOA/M4MfdTtK0bGboeRSQqZQm75z1JkbJ72pLlluPbCa1VlPp7hnZiHmeGYbqSobpTh7aG0+aEtQnbpz1pYdm9HKS2dt/gvZPSmeHnNkzdICbILtAcW3SipYSlSKSEJpcSpiRRdKeeOVKppmmmawfGYWSaJtpTR2ISzvszNrXsnndkmWX3uCPNpPwohMDY9kzdyNAMuHFm7KX9gSA0JmukZKhM2TxsyKqU/fMebTTdqWEaJ7qmZxpHhl7KV5x3tOcepRWn/Tm2X0poNg9b0jwVULv3dAcpORq6ETfNjO3A0I34ydMdW4xNOLweyXLp/zRPOL4dhJZ0apmmib7tZdzagXmamEcZV1SQOWRj+UeRXkvIzrszDk937pimWcq3+pm+GSLtR0qYksxw3BzJs4TN4xZbSPtNKrQo76TUYxwGGcNhlvKTcy8UpL3E0OHlhC1zdo87sjIV8Hrgev6+GXFDPH8/4EZHe2xRieK4kT58e9iSFhm7JylDaw4t3nm6dmCaZ8ZuYhpkDeqbFkIkCmWG3fOevLBs79/I8ozj5kSSGLqzlDz17cg8THH8B8ZhpjtJ/J12Ykm4ediSVZkYYmTmWsI3nAfGcWbsxriGTPRNj0JiOEkN+5cjNpcyJJtZjq9HANpTh3NSfjWPM0MncTTOE+25QyeK477BpGLEcUEe/pJ+pL/eSP8Mx2W70eZWkvzLHJPo6xPgIqoC1+8WCKQ5R1t5arWpFcFJJVQaeRrVlMsCRUz2z4HlnSjbFre1KPCWGYkVkYAtUpIiiizShGIpQpVyWaK0YvmuFoHITSk+iKsSlCav5Un9InQwmaWs5dqrdYVWQdSgHurbinmeqW8rQFPUGWmWktdCc7GXN59UnryNiW3QsLirwUsblA9U6xIVEGFLFKnkZYbNE/I6w6YpZRWFKmu51tX7Cu89i7sFwYuAxSaWvEqxmRWhTJlh0oRyVaKNIq8LUcuuK6ERvVvIm+BtidKiBEysvG2kiSWxCWllSaymWMj565sSlJK3ltmxeLeAcDm/olxW8uaaJ7KjkMobtTGGfFGgQ6C8/fktygdHdVsRFFTLAmuT2P8ilEpzG/s/juGqIBBY3FY4F6jXJXhFsSpF0BNpVmmZYvMMbeWJX5kYf0B9c+m7mmmeZAwVIg5LE4pFRpZnJFFwo42hXFcYqykWBQpFtarBQ3Ur31nd1BhtKOoSYw1pmcU2JNKvJu6iaEV1UxJmx+KuYp6dqLVDoFyIsK2oM1E7FxcBlgjW0IpiWaG0pl7X+OCpbytRui9LTCpv7/LWmZEWGTYV4YlNRDBklKJY5HjvWNyKsrW+rVFas1hXEi+VCMZsJAMlSTx/oqlWFSaROexn5K1xFgV6MIa8ykgzI4K13JJkCfmijGKvEm00i5sS72T83RTnUFDUNwXWahGp5SlpkZHXOTaKnRKjZZfEKOr4traIpKPFrQjqisUlbkRoeBFAmcSIcE9DscgISlPfSh+KgE7SUSaRt02bJ9cxSFIjb+Ua8roERPRGCNQ3FUr569iWS5lDxWUdSBOySkRvRZ3hUZSrHIKnuq1wk499GaiWJYlVFIuMNEuu45/mEkPGaIqVrGHVuiI4mcNi+CHA+3JRRHFm+cuu+b8ae/+Lx/8cxt4//O4TJtH8H/93/xfGYbo6HkzdhM1Txn4UyDyeoZGyk83Tnvdf3LJ/OVAsSmbnCE5cPIL3OB9ItGacZFvEey9bhXnKaXvm9vM126c9Nx/XnHcnTCJlFxcHCAhMg8OmmnGYI+Te0XeyHbh/PnD3mzt2zwJWmOcZHFLu4oXpqYySLc5UciTee3lz3TW8+80Nm4cdNx/XHLcnkrgN66ZLPR3M/YyxAkbXRuEjN7Vel3L+L27ZvRyobiqmbiIER1Zkko+N2MV5mLGZFe5mzKO0h46bz5bsX07cfLbiuDldH2L85LBROj+PTq59dmgE8j1NM2VdcHw9cfvlDYfXY/RNFEZuVmTXHJnWYrCd5rJNphQoFWiOA7efLdk9HVh/WHLaNlKmAvg5fkdwzIOT/OIcfzphFZdVxuntxM0XN+yf9yzuFsJbViL99zGnqrRiGubruBLh/t25Z/1hyfZhz90XN+xfT6RlikFqYtMik/YPM0lqmWdHYhXz5PFOtg4Pr8fY/zsWt0v6cwdKkxVWcmlIbek0TPIdk8MoCJGzu3pXc3g5cPu5xHBW55IjdjKGBM/Yz6RZIltvWgs/2M2kWcp5e+b2ixt2j3vWH1e0hxaVSLnRPEWAOcIqvtQNGq2uoIT1+xXbpx23n99weD1RLKQ8xs+eLE8JXvjKysA8+2tNsptmbG45bRpuP1uxfTlw89ma805gHVlqcdFgAcScO8ktfnZoI/WrfTuwuluwfdzx7jd37J6P4qPrnDjDFDaykcFYxdBN5EUqvOyoZzjtG24/rti9HFh/XNFs5Q0rsZIPTNNEOLvDfM3hS821Yx4mFjc1u5cjd5/dsHvZU9/Wwvf1s6whIUhdppEctrYGN814Lw495/2Z289u2D0fuPm44rg7YVOLjqYM4uIi3G8da5wVoncY+4lyWUoMfX4jc3hdMUdyWZpb6ftYC+3GmSQ1zJNk17VWNMeem48Ldk9Hbj5bc3w7kVWp5NiDJ81SITCNM0kidbvaGPzsrn7B+5cjd1/e4OeZrCz4d//X/1iQhr/AveDXN9I/w6GN5sff3Yvyc3PitGs471p2myNjP7B52jF7z9N3rySZ4affPZJXOT/87p40T3n6/hkN7J4O9OeO4+bM6e1Ic2rZP+2vylqlFQ/fPJIWlp9+e09eptz/4YHEGLafNgx9z+7lQHtoOO8b9m8H+nZg87THR3Vmmlk+/eGBrEz54e9/Is0sT9+9oJx4DPZNz+FNlIf9aWD3tMdNjpdPb+hE8/jNE2lh+f7vfyLNLT/9/j56HG6ij+eB9ii+kofNSdp/v8E7z/P3r+hE8+mrB7Iq48ff/0SWWx6/fkKhrkrV4/bMaXOiO3Vsn/eMw8TLj68EAk/fvpIUop5NS8uPv7vH2ISXH96YOzl/d+w47xqOG/HFfLvf4Qk8f/+G1lG9WqV8+v0DNrM8fPNEcJ7t40V5eOK0PdMce/Yv4hn5+ukN7wOP375iM8MPv73HFimf/vCASQ3P37/i58Dh5UhzkPE/bU4M3cjbw45x8jx++yKK2z8+kRQJP/32gbRIefjj09XjcehGdm8Hmn1Ld+o5vB2YJic+tLP0YZJZiZ0y5cffPZBYw+tPb8zecXg70h47jtuztL/r2T5scA6JIaP49NUDtrD88LtPpHnG/R8f0VqxedgyNAO7lz3tseO0bdm/HBj7kbf7DU6J0txmhk+/jzH0+59IipTXH18JQXxku2PD/u3EeSfq2c39Fu9mnn94xWjNw9dPpFUmY1ik/PTVA8oo3j5tGVpRLzf7lubQsd8cmfqJ108b5iBjmOYJP/3+nqxI+fH3n8iKhMdvn8F59s97+qbntD1Hv9+R/dMegOcfX1Fa8/D1s8TOVzKHPv3u/up5Owwj++c950PLeX/muD8z9QNvnzY453j+Qcb/0x8eySqZQzY3PH33jAqB3fOeoRlFvbo90R17jq/irfny0xuBwOO3T+Rlwk9fPZDnoqLXiebtxzfGceL4eqQ9tKLi35yYxom3hy2zd7z8IL6kP331IPPw9z+RlymPXz/hg2f7dKBvBg5xHeqbkc3jnnmcefnxjaA8T9+9kMa+SwvLp68eMUkifTzN7J/3dKee067hGD1bNw87AvD83RtJmvD07TN5Jd+Rl6ko0ANsH7f0jXjSHrdn2lPL9uXANDre7t9QKJ6+fSUvRL2fVRmffnePzRKZ4yFc5/Bxd+b0dmLoBrYPW7x3PP/wgrEJ9398JC0SfvztPcaIacMv+Yr46430z3DoqLA00WpI7KhCBP0ocbSPCk6FEp9ELcrFqH+MxKIARuyOhOQR7Y+UeEFeaDgBEftF7BE+qu2MEesyjxBAtBJlnA7hZ/XnJSEfk/P+onhNEOVmVCMqrbm4KBGVhxcCk0SREq9TLUXf8ramrqpZ71200JK3U1G7+osYMv6d4iL4DVreWrTWcHkj5ULukT5VRqOTCwxFgAHaKFQQ5alOIsnpoowmoIKKzhXuSh7yniulRkeKjDHRL1NFwpO+0GXClR50oS6Z2GcXAtRlbLUITeM4h+uYaa1iG9SfEH6S6FMq3qkXQhVEXe2FGBMu4wEoUTsq5HzmEmcKeWNQP/vAKqVjHOrr26CcRyLgSnBCVKghnvMypkortBVlsCi4gUgTkniUGFVB1LMSxNJnP9OhLpZ80o6LxddVERtEAXqJHXkLJ+a7iOQuCFpIN3h5w3ReRUV0VKV6rkQp2bUgKrOjkpyAn7yopREFqdiwKUIQqzHlf46FGJ6i8I4ksYstmvR9VFNrc1W6XuajaKp9HK8LFepnNfkljRf4Wf2rjIoqck2iLxwlsWEMkfCjIrVLx/XBx3hRKFHlK+K1xT4NP8fhRYejtVCQwMcGyjh7/HXKiB+ujtfnZZ5r8C5IJUBUDrv5EguRdqYigU0JB1fFHRWjL2tOkPmuRP18iUNZ6xSEn68hwq6uFoQm2r3J+Ml8IyC0JA0YrjH1Sx2/qnb/DIebHF/+o8/4v/2f/3vyOkehMZkVQHyWkC8kj1AtS6bRs363ojsP3H15y9AM3Hy2ZppmqrXknfI6Z2wnTMw9SoF4RsBTr0Xheff5mu7ccfNxxdgMLN4tropYpTRJavGzeP6lpaiBy6iGXb0Xssndl+8Ymp6bjyvmwVGvBT6QV0IRSgqL7QxJllDWGURQwtRN3H62pjv21zYsbiUPW8ecRloUtKET1W4s1K5WNWEWuMPQDLz78pa+GVh9WDP3jnpVQRB6jpvErNx2FmMFtqCCqCanYeL245ru1HP72U0EwNd/oprUFJkFL6rVospJreTOgof1uyVjM3D75S3tuWP92ZpxmCT/g+Qf3egk59SlpLnkrrWGal0xTOLCM8Qx7M+DFMxPkn82iRS2B9+R5Qk2s5KzqjJRq94t6JuB289v6E7Sh9MwU69rFGJWHJxskdnMkqZWVMNaUa8K5lGK2rtzz7sv7+ibntX7JfMwx/y4oagMg4LsAjtIE6pFAQTW75cM7cDN5zf0Tc+739wxRhW5c1LsrgOYLGHKkivswmgj/T9OrN4v6ZuBu9/cMDQSh9MkdBwhIeWMapDcXZaSFglFmRG0ZnVXM3UTd1/c0J97bj7eMHQjy5saLvlYxBfWjZ4st1fqVrkocePM+v3ieu3dqWf1fs00Oqr1AoWmqHKmYRJYRp5K3nVRQBDXlaEduf1szdAO3H1+w9DL+Acv8ae1JrUpPsaQzVOM0lQrIXmt3q3omp73X97RnXvuPr9hnuYrMKWoCsZhFNBBZ0lzG8lRMd/ee24+SvtvP79h6i90JDG61lqRpDkuIgGzXJS8eS0xdPNeyGJ3v7ljOPfcfFwzjZ76ZoFWKpLAZnEE6mfSPM4hpahuauZ+5vYzoQO9+0K+Y3FbM02iCNYRtoBvSXOBntjMUq1K8LB+t6Brfo7/9YeVqNdvSlCQLwvcKNvoaSZxXNQZxhgW65opzqH+1HP35c11HfDOUa1rEmuwmbluM2dlhrEJ9arEXfQO3cTtZ7e4wf2CMiM5fn0j/TMcsi2xwSP5KzfPzP3MPM642dF3A8F52nOPTUXxllVW4PF1zuH1KJ6SpwbnHH0z4NyMm8VT00WAuEF8+LIiZfd6pFgU7F4O4iKxO2O0pm8GvHNM3YSfHW70jIP4Cw7dQJIlnHYteV1weN5T1Dn71wNp9MUMwTO0PfMkuRA/B+bJ07c9KoiXZlZmHDYnykXO5mFLHp1AlFJ05w7vQlQrTgzdfK1B7M8t2gocO68LUQ0ucvZvokBujg1Ka/puEOVtN+JdwMc+AX91stm9HSgWBfvnPcWioNmLmrQ7X4Dj4uk4T/JPIIiHZGpojmfyKmf/fKBcyXfYKqU5yPmHpsc7xzCID+c0OoZ+RKPpzp2odDdHsmXB5n5Hucg57S6Kx158MJuRaXKMw8w0TjjnaNsRYw2nYyPGA0/76/mzMqM9NOjE0LejqKeH6dqGsZ/QSkdXHMNh83MfiovJWRw3miGOoahl+35iHMQTtW8HEmM4H1qyStTa5aJg93SgKHNRRFvD1I8475hHxzx75mli6Ecg0LfibHI+NJRVzu75QLGq2L8eyXNL33QAAuwfZQ5M08w0OIZ+ItGKJjodyfiXHF72FFXOed+gjGJo+6uXp3Muqp9H8F4cXSpLc+woFwXbhx3VsuC4O5FmCf1ZPEWHTto/9tPVT3bohp8pZPUlhguOLyeKWs5vEsPYDrhpFrX14ER9P4x4PM2xQVuJoarO2T7tKBYyh9NMjB8CSAxP4gPqvcyhqRvRWlSpaZFy2B4pl4XkmMuMZteQJDKHgw8M7YifZRxEeR4Ym+GaY03LjP3TnnKZs389khWW9tAQvI9GBXLdLnqbjt2EUpruIC4xh82RvM7ZPe3IFgXnXUOayTapn0UtPU2inh6jn2vfDCSZ4XySGNp82lIuc47bM2mR0B47tNIM3XD1VA6x/WMv9fR905MVlv3bgTL2YVnnHDdHTCKOPz54pmGOOVHHNE242YtnbaI4H1vSynJ8O0RNirqyv3+J49c30j/DEeJNqqjEQiuvMqZpvta2LW8WzE7qJv0siDytFfkiI7GGvCgo6pz2mJGXmUAS4r5qtZCn0puPK3nivamYXaBelCSJoShztEGe/MuUtJU30HkYKeqCEHFeUvu3lLqtG3nzyy/qukpwe3mekVU5fkI4tTpEpalnebvCz/LG6WZHtSyuHqzaCp/Tlpb0LP6qUzeKatTAYrmIdWuCSFvd1FKvVhcYrSmrHJPKU6vNEtJB3uKcD+RVipsdq7sF8+xZvVuIenhZYhIiDk1HXKIljarRoR9JEh1r7gqmUfikbnTU6wXBOfIyjTV3ovLMovo2HSwmCpaqhXCIl7eL+CayZJ6ljk4htbc6MYLoK1PS1JLmKYMaKdMCdLh6Sq5uF4zDxGIpKuJyKQzcrExJEkVaROVsJgpMNzvqZUnwnlXkkS7uKtzkqNcl2khNotRoRvWuFeRacGLWrjQs17JbsLyT8y9va4LzFJXUJudVhjKGNBP18NTPJFmCd456WeCDYnWzEMXlOp5/KcrjvMhIlLyBGZtgU7l27x1VFP3UyxLvPIvb+DZ7uxD287IkMTqqXCNuLrOMcQdiHmfKWuN8YHVTM8dxcIO7xna9FIV2WWVkRUaWSfy7GdIyReFZrKTGeHkjmL/lnbCNyzoHDVklSuW8zDG5FSVrnTP3s/B5A9y8Xwnm7sMKnKNe1QSNYCmtIctzjLXYVNTrbvKYSsvbcZ1f55+LXGLnpSZZKR1rf5WonvMUmwq20k2TVASowPJmSXCiGp+dp16JiraopUa7qHN0YgSNWJc4F64g/KLOYv9XuGmS3aN5pl6UsbpA1MN5lWHThDS1FGXO2I/yvUZqb12sPR6HuIb4QLnM0SZiQdMUm6WyDgwJJk8IXpGXOc7JjtfUj9Q3FdMws1hXoi6vi8i1jpjTs6BPx34gL3OC9tRLUZ4v75a40bO4kbr1rMwwaUq5tL/omv/rG+mf4Zgnx2d/9SGWBQi/tVgUsp1TpBSxzKJaV8zTzPu/uKU59nz215+JAvU3K1HCrcQYvFzlZFnckkwtWSnbu8qI0fDcjXzxt+857xs++5sPDO3I8r2weItVSZonFEspS7Bp/J4sucLb735zS3fu+eIffUZ7aLn98oZxnISBqjXlUhbloixIkoSsEPNfpQKrz9bMw8zHv3xHe+r58h99ZGwGYcAGqG9r0kzaLyxducFam1CvBMq9/uKGoRn47K8/0J077n5zd4UrGCvbt0ncTizqXEoL6gJjFMubirGf+OyvP9Dsez7/2/d0p471x6XcNNfldSs4zaSsKF/kmMgv9i7w7ssb+nbiN//oc7pjx4e/esfYixGAigX5aSZS/CRNhAG8KtGJlEzM08THf/mO/jzw8W/e0517br4Qjml9G/u/ktKmopDrt6mlWudopfjwl3cMzchnf/0Z/bnn4199vELktdKxLMWS5VKWkBYZWZ1LKdWNgAA+/ssfaA6d9GFsv5sc1W1Jag31jZQj5KUYRSf2wiMVo+2xHfn8X/mM7tzx8a/eM3aSHgg+kFbyUJDXl+tIBTSSJSzuloyDxHB7aPjyX/2c87GV888T9W0hD3h1iU2FOyvlPekVKrK4XdCdRz7/6w+0p5YPf3lH1/RiOK005bqMpVBi8pxVMv6J1pRrAXK8/5fe0R4HPv71B7qTbNOPw0i1rqT0ZpVjrSErCtJSGMLlSh7+xDRi4uNffaA/dnz86/f0bc/yXRXLhUrS1JIvs8hEFpa0tYkAKSbH3V/c0hw6fvOPPqc99bz7y1vmcWZxW2MTMTpP05SskBtjmqfktYA57j5fM7Yjn/3VB5pjx/u/fC9whc+W1xKTJLVkdU6WW2yekdVSWlSvKtzseP8vvaNvBz77m4+0x467L2RbdPl+AVpK7NIsllblch15laNjKU/fj3z86/c0+47P/uYD3bln+X5JQFHf1SSZJa9lHcrzjHJZSjwvcwiK9YcV/bnny3/1C9pjw7svb5j6icVtJSU3y+LKjra5Jc+FPZykCYs7eaD58JfvaA4dn//tZ/T9wN2XN7hhFnPzTCAwsobm5HVGlssYogK3n93QNyNf/qPPGFrZhfglj19vpH+GI80t533D2M+cN0eaQ0t7aDhuj0z9zNv9Bm0Cz98/i9Lwt/fkecpPv/2EzS0v37ziPeyfDzSnltPmzHnf0LeiwnWj5/V+gzaJKF7LlG//Hz+RlimffvdAkia83m9w08xpc6Tdt6L6O5xws+Pt0xshBJ5/eBWl7e/usXnKd3/3I1mR8vjNE94H3h5FtXnanyLztmf3useNnqcfXlGJ4eErUVp+/9tPJJkR1Vye8vbTBj859q8HTrszzb7h8LZnbEfeHrb4EHj8/oUsT/n0h09kZcr3v/2JtMx4/OYJrWD7fKBvRlHt7hr6pmf7tGcehcerEs39N8/kUa1rC8sPf3+PTa1srbvA4e1Esz/T7FoO2yNzP/N2v4UQePr+BZsl/Pi7e9Ii4bu//xGbivJWAZunPX07ctycOO8aulPP/u2IG2aevn9BG83DN8+kecoPv32Q9v/9J7I04eXHN9zs2T8LL/e8F9Vs1/a8PmwJwfP8/Rs2T/n+d/ekRcYPf/8Jm4qKWieat5829N3A4fXEeXumO7fsX0/M08jLj29oK7zSYpHy/d/9SJZZfvytqDZff9rgXGD/dOR86jjtW/abE33bs3nc4Z3j+fsXbGr56Svpu+//+x+wuSigkyxh97Rn6AbOmzPnbUN36Dlsj0zDyOZ+i1aiOM2qlO9/e09WZXz/3/9AmqeiWg7itdqce877huP2zND27J73OOd5+uGNJLXcf3VPXuZ8//c/YXPLp98/kljL6/2WcZg4vJ0471q6qNqdu5m3T2+g4Pm7Z2xu+PG3n8gqy/d//yNpbnn85hmUkhg6dZw2P8fQ7mmHGx1PP7xiEs2nPz5gU1HcJoXlx79/wGjN66ctcz9zeDlw3je0h47j9sjYjbx+2uIDPH4fFa+//YTNEr79ux9J04SHPz4CsHs+0J46Trszp53Mof3miHeelx836FTmsM1E+Z7VKfd/eMQYzcuPG+ZxZv+ypz2cOe/OHLdn4dXeb/ABHr57JstTfvz9PTa3orwvEh6+fYEgyv+hHTm9nTltRbW7ez1E5f2GoDSP38h3fP/bT6RVyvd/J3H4+lM8//Oe9tDQnjr22xPjMPL2aUMIyBpiE+7/8EReZvz423vSzHL/1RNKw/Z5z3COc+jQ0Lcjh80B54ULrpQo/20mitustDKHMsvL92/MIVx5vedDy3F3Zmx73h53TLPj6bsXkjThpz88kJUZP/zdTyRW0537X3TN//VG+mc4JK8m1BRPVCaKUE0UdsHjHJFtSZR+iiKXIEpEpYVpSZBavYCwX6PW8k8Ue6KaDSGQGPE/xAeMiopBH30WueBZI4sywlFDVMZpa6JiVF2Vt0lU2BIuLFZRVBKVgMQ6wqBEDWsSKwpLJ/xcH227VFQyaqNJElF1Bi+8U+/EQ1HUjJGrGaJqlYu6l6gkjeq8yPFVEYHqvNRrai1k0xCVvW6OooPLNSojSuELXzQqekMIovjzoIwocq/qan/pJ4/SPyucr36xF1VpiH6VSlSjF6Uh8fxGR7WuNsKZjZ/18xzbJNd1URJffGQJFx/N+GcZCJSB4OOfXYjXpNFKM88uqr+jz2sI0VsyXFWo4h8psam8FsVviOreyLAVaae6CjcuQkjhqHp8PL+6qIr1RSV8URD/iZ/kRf16EQa7C+/Xi+eoEfWsMaKUDSp6YTofx+OiTAelfJwH8QuDqEqVMT9fq1b42aFUwEeWL1xSJKKQ1friuauk/5VCY0QRG6/DXzjWERSsABNV1xdFtnMSI9bKduJlDimtrjXUQYv/btCxzZdwD5Efa6Mfb9DXeDLxM5d5eWEG69jnIfj4Ow6Cj2p5BUS1erxedWElKwjKX9XCOjGi4tXgvYvrg4oq4cu0iwr9iwL/ouoPojRWSuZWQNTUzs3iX3tRz8cRUZE9HeZZ1NGxKkGmt7qq5lWcw87JvA/eIQpfCVptopduUGgubHEZX/EU9ly8d3+F1v8DP/qm54u//Ux4sZH0kVc5aZ5KDqKuIuNScgPr90uGpo9bjCOr9zeM3UixLGVrLxJistzGHKihrEWtWK8W9OeJuy/vaA4tN5/d0jYD9c2SEJAtuEQoIVmeYjJNWmQYfeH0Cid2bAbefXFHd+q4eb9i6keKVUlAXckkSaZJL5zcsiBMYic1thPrL27oTg3v/uIdQzcIcSiEaP8ldlgmEZutvCowRmhJbhZP0aEd+fAXd3TngZsvZFusWl8Unz9TdtJrHjOLnFphvN58fsNw7riLisPVuxVKQbEoMEboLjZLsFYUrzZJKBYlY+/itlTHu9+8oz2KalS8HWuh6Sx+tvZKCysUqrIABdWyZhom1h9u6E8dt1+8o206lu+WhJg7NtpEX84EYzVpnqIjBWgevTBum4nbL25pjx3rj7f055F6vRCeaCXqxjSqTU0ieXQffIRHONbvpQ13v7ljaEduPqzxk6dYCae0jLQcmwr1x1rJY7pIh+nOPe++uKU/9dx8ccPQTtQ3C/BQLOOWdik5L5PI+CsFZV0xdhPrjyv6ZuDdb+5ojx2Ld0vc4CiXQhMSay9JLdhCrLGqleS1ljc/x3B76qN6d6S+WeAVpDFXl5Wi+E2sJa+EMFWtKuZx5ubDmv7Y8e7LO7pjx/Iu5vDX9c+emqnkfW0hfVJUQglb3NRMneP2sxvac8O7L97RNwOLuyX4INvI0d4wSVPJH5c5WklOfJ5mbj4s6c4d7798F9XzN4z9RLGUvGdRZtFi7MKajrlAB4t1TX8eWX+2pj1LG/p2oLoRu7G8yjHWkFUpSZqgU8n7msiwnUcvnq7nIba/Zf1xzTTOQlxS4oEquVvJ2Wojdne4QHWzYB4Dt5+vZQy/vKM/d6zer/Czo1gIVSivxKLPWKF2aS2estM4X1Xb77+8oz+N3Hy8ZeyE1wySd7fWSL60TDE2oagKyY3fVAztxM3HG7qTxPB47ll9WBEckpe1QosyJpFt7sIKLay+eKrWdOee2y/fR5Tkr1u7/+CPNLd8+uMjCjhvzsLaPbd0Tc/QT8KfdI7T25E0s7x92pBXBY9fP1Esct4+vWKt8ELnaaY9dozdQNcMtKeOaZw5bY8EFdg+C9v16btn8kXOy/cvFEXK4WWHAtpDy9wJ17VreobzSHtqmaaZw+uBNJXCa1skPHzzSLHIef20EX7q5kiYHc2xY+pnumMXua8T5/0Zr0Jk+6a8fv9CsSx4/PqZtEjZPe5QSjieUzfR7Tv6dqBvBprI8D28HjDG8va4Iy0t9398pFzmvPwgoIbjazz/vmXsJrpTz3AamPpRyDNas3/ekVUZLz+8ki8ynr5/Iq9yNo+y9Xbet8zjSHfq6dqevh2EHTrPnDcn0kzz+mlDXqc8fPtIURc8//BCWiQcng4EF2h2LeMwMZwHYdf2I+f9meADx7c9aZHx+uMrxaLg8Zsnqrpg+7hFJ6KmdbOjPworeWiHyF2eOG9OKKOE8VoKCKNalTx//4zNLfuXPbOT9g+DnLs/9oztwPnQQIDj5kxWSgwVSzl/Xhe8ftoIx3Zzwo0z7b5jaEf6bqBv+hhXZ3Si2D3vsEXK43cvFIucp++fyaqM/csOQuC8bRm6gfbQC/e5m2iPDW6eOe9OpEXC5qcNWZHx8PUjRZ3z9mmDMorT24mxn2iOLWM70rUT/bFnHhzH7QkUotatZEs/rwoevr2c/0BAcd41DF1Pf5bxG/qR7iBz6Ph2JLGa15/eyJcFD988kS1yNp9e0UZdrcuaY8fUCnO3Pwl/+bQ7goL98460srz88Eq1rHj69ok0T9k97cHL1uLUSQwNnXB2u0OLc0F4tNbw8uOGrMyuc+jlh1eSRLN/PeC9o4mpme7UMzTCOz7vz3gCu6cdaZHw8t0L5aLg6YcX8ipn+7SX/t83zL2waYfIue1OLW6cOW1PJDZh87AjqywPXz9Srkpef3gjSTSHzRE/OU67Vsb/PNIfW8ZhpDmcCSj2T8L2ff7hlbxKefxGADGb+w1BKc67Tsbw0NK3E0M30Jxa5slx3pxJEsPmcUdRZTx8+0KxyHj58RVbWA5vR/zsaLat8LpbWUemXtYBrQLH1wNZnfLywytFnfHwx0eyWs6vtOK0a5jHme7QCe+7HWiPPeM0c9qcUIlm+7yniPM/KyxunK81u7/E8euN9M9xxO0QE93sVdx+sFbssZLU4LwnyVIC4magCPK0qwPGGlQixfPGGtm2TSyEIPWgzpMWKUqJsg2tSDMrBeRWY6wVfFzc3rG5RSuDTRP5rlRADRd0XlpYVJDr01psvLRRmHh+rZBrUpo0TcAHssyigxI3lhBIEkGYmdRgotuHMrLlZzOLSrTApAPYPI3XkRCU1MUpZbBper1OYxMBKhjZHEr+pO8I4gTivcNmljDPEWGmMcaIU4YWWINScp6L/RwhyGcC2Nzig1yfn+U7lZHr1NrEcZA2mMTgHGR5QgCy3BKCIsksKKRflMJmBoyKwIifYQTOzSSZuO6kmYyDLSzaGMHfaY3N5LvTTPi+SaIxVvrXphYQBxqQ8VZBLN3c7EmsxgcwiUEbMDoCK7SRPoPoACTx5YPCGLHrMxH/ZqzAFxKt4/askVSAin2jlKDqkJpOgkLbBB+35rQGay06ka3dxCZgjNTNKh1Vox5bWCCQpgkqjmUIxPgDm5q4VQzGaHmjzVIZ/0S2O6UNAWPj9eQ2xkUq28OJkVhMpP0qgMkMfvYSqwTSzIJSJGmC9yr2U0DHftdGoVODNjIPFIrEJPEzYmVoM4tSEpdKq4jVi+OQaIyWzyutSawFNDZPZL5lFkWcn3H8iVuUJtHRtUn6IkktwUv78GAzsRyzqQUla0gI8c9oTKLRJkEhrjXaaGxhI7IvlfmfpTIemZV4jGUjSWpl/icyl5SScVUXez4fSLMk9reMpU3Fvi1JjIBUItDEGIVJE5RRJGkqWNEswfuAtYY5rmnMHmsTAjo6XglQRRlJi1ibSArAapxzpIW0LYsozjSz8p1JQiDaCf6CS/6vrN3/wfE/B2v3x9/fk6SGf/6//7/St8OVNTk7JwucRiyNUst5d+L281vePm1595tb9i/HGBxBtjeXFdM4XZNL3v1MNhnOA/myEMblb27ZPexYfljS7TuUgSzPxPbJyg1kniQfYqxh6ieyMuX0emL9+Zrtw57bL9fsXw6US7HGcqMnX2T4SbxJldH4yV9zP13TUS1Lds8H3n15w/Zxz+rDkvbQyg0iTXDTRFpkQkKZ3DXXN/czWZVy2pxZfVywu99LG54P0Zptxk2eciXWUp5IIQo/5w/HdiQrU45vJ9795pa3+x3rzyKn1GqSNGEaZimdmJ2QcJTklP0ozOBm37F4V8U2CGu4vqmYu4nZe4o6YxouHpVBCC5GbjRj9yfn/4s73j5tuf1ixemtxaRyQ56GiaIqmCapgTOJ3ESDD5hU0+07lh+WvH3a8O437zi8HChWBXM34rwU47thQqcWnMPF8ddGMbRDrJ098O43t2wehTV7fDmSFBajNdM4CVBjnvGTMGPFEzSQZJr20Avr+WHLh798z/Zxx+r9ivbYXS285sFJDh3PPEtu0SRSG5gVGcfNkdsvbtncb7n74pbj24m8yggg/V9LDLkgvq6A5O80dOeB+qZi+7Tnw7/0ns39htX7pdQwo8hKgTDoLAEvZCFjxN91HmbSIuW8kRje3O+5+2LNaXsmKzOCD6LcXcj26yWnF1PtJNbQHTvKdcXucce739zGGF7QHgaUlgemaZxJc4ExBBfzm5H7nOZSh73+uGL7sOPdF2t2r0fKRYl3M9Poog2gE/KSBjdJ/jdJE/qmlzF8usS/zKFm12GMwhYpbphI8lQIQqO73mDmfiYtLc22ZflxyfZ+y91f3HF4OQpreJxxzlPVBUP0QEaBn8XTV6eG4SzleYfXE7df3rJ73LH6sKLZniWdkyZM/URe5/jZ4yYfqU5iF5kVCYe3hpvPVmwetrz/izt2j3uBmPTz1cpvGuQNMWgIzqGVQVvDEOvQ969HPv7lHa8/bbn5fMV5c0Zbg7WWeZrJypR5nGX+R69cNwk7uzu0VDclu5cj739zh3eONE/5J/+r/wWru//v1vD/T+8Fv76R/hmONLfcf/XI0A0cXqNq89Bw3pwZ2oHN/S6ybl+Ek/mHe7LcRMWbKD5Rmv3LkfYkjNrT9kx3Gji8HpjGiecf39CJ4fnbF5Is4ce//4TNU56+eUYlis3DTrZv3060x57zXnizYz+y+bQF4OHrZ2whfNwkNcJ6TS3P376igmyL9eee06ah3Xf0x47D25FpmHj+/gVjDA9fP2OyhB8jJ/Xh62e0MWzvd8yj4/Bypjv1nHcNp92JsZvYPuzxwfP4zQtplnD/+yd0KurhNLM8f/uCQrF/3dO3PcfNmf7Y0Xcjh6e98GojJ/bxm2dMZvgxcmofv3okSQ3bhx1udpw2Z7pjT3NoOLyd6NuB7acdzotqVKWGx69fsDaql1PL49fPOEVUrU5X1XRzbDm8HembgZfvX1ABHr95vvZ/kgkvN7Gat08b5tlxeD0J63fbcNo2dOcuqlZdZC0nUTVt+fSHe0xuefn+FeK25NiOHN8aztuG5tixfxXV6MsPbyijefjjIzYV1Wiay88kS3j9cYP3Xs5/6mi2jWwRd5Oc3888f/cmqtU/PEbFp3z2/g+PKBXYPe0Z+4nj5kh3bOP5D4zdwNtPG1CKx2+fSWzK/e8fyYpMvis1PH//hneeQ4yh876h+RPV7DjNvPy4RSea+z8+kWaiuM1Ky8PXT2DE1mueAofNif7Q0R07Dm8nuqZne7/Fe8/j10+iPP7dPWlm+Ol3DxijefruhRDg8HKiO/ecYv/355Hd8wE3TDx88wJGc//VAyaVGM6qlMevn1EmsHnYMQ4yhs2+5bw7y5xoB3YPO0LkVRubcP+HB7LC8tMfnrBZyvN3LwQ0h5ejnH9z5rQ90Z97Di8H5nHm+fsX0IqHrx/jPIys568ia/lhx9zPbJ+PtIeOZn/mvD9HXrKwbp++fUEbRD2fJ3z6+3tsZnj5/hUVz9+2Pc32THNo6E4dx+2JoZ94+e4FpTWP371iM8v97x+wufS/SRM29zucC8KZ3nec9zKH+25g+3zAB8/D16J8//S7exIbY8haXr59JSjYPu7omp7j9kRzbOmOoqAeupHXH1/RJvK684Tv/+6TjP9XTyRJIkzm4Ng/H+iOPedjS7trGM4D28ctITjhklvD47cvZHnCj7/7BAr6dvyVtfv/E4dCWJI+XFV44movDiJGR1WpDvg5EOKTuo9KOzc72Zrw8gTtZidvRKNHaRPfDAPzNP/8lO1cVLcBQeEnYWBe5HZuntFGM00zyoiq0Uc1nkoig9Y54XU6hw8BourXRd7pPM0YI0+DoJjHGa0CuKh+RRSiznsIoq50kzA5nRO+rRvlO+ZxZg7CCU2MqF19VPO6WdR38+Tx3l/dcGbnSRLFNPrYJn9lnRIZozhR/fnZ471cT/CirtVay1N1Ij8TJb+rEtka5aLinC/dFuQ7ZmGDXp6CfYCQRPGtke1GfBD2aASHhlncPXxU3l6UvfMkxsNhFqVq8ERHC4V3Ln4W/Aw4f22b0kreSDQ4J9zTefKg47U5B0FHp5FwdRcJQVSVzslbuYyZGK1rIwpKrQzBhz9h/GqCV/IW5AMujq/EnWGa3J/0pbiwXNS5l/Xr0u844bEGJ2TgKeavLv3gZ39VtbtZrkGHqDh3MnfkOnxU4iqmyZHYBDd7mSIBWc2iOjggimgfr1u+Q37OowOTEGZHolVUnOt4frlmYQaLuviiUCWqzbXWDNGFxU0zxkgbgkL6fpZ5GOLPC33Yi/CXOfa7vyiSXVQGX8YqdocPouqV/yf+mm4Wx6Opn1FarlecXLzsGCkVYz0w+xk3OdzsZfy89I0bpjj/RBE7D5Nce3zjJ8j1KqOimveihhV1vELexiWt4AiKn7dztaSz/IVvLMsAwYN38iY5jS7uFjmJEye7PMRxBvB4iPNN2NgBZlnv0Iqpd7LOOalEcD6gtYnXKq4+vyQm8Fey0Z/hGPuJz//6I8H/3ykW4lBvEwkKmwqnFaXEamny1DclQzey/rikb3opUB5H8ioHoyiqXDiduaXPErSCrExxLlAuC6ZuYP1xxdCPLN8t6LuRciUUpWIhXpRpqpknR5KYmG8SNaKPNmbDeeDmsxVDN1HelHFbuSQoyamIHZtYsymthXjkhKgzdo7lXU3fDCxvF8K6va2ZZ9lWvUD83ehIEo2N+cXLFnJ9U9G1wpod2p7Fu5pxnISOohV53Bq7nF+bhLySXFG1Kpi6ieXdgqGbWL5f0Xe9sIadj0XviqxIcbMXKEXMCedVyjB5qlUhStePS7puYPlhST/IlltwkJUWhSbJE8YuQSshJ+HEQ3VoRxZ3C6Zx4vaj8HLrSC8S0osmNWJHZhJFmiUYo8iqnHGcqVYlXdNx81GYx8v3iysQY45AhEt+MMkStE1Ic0vwjnIpDNn6phTl4+fC3F29XwpruM5QgM0TgvOiGi4kjyiEHU+5Lhm7kfVHYc3WNxVjN8Ridy+qSa0wVjP1k9BuipTgJf7GaMUnSteK7tRTrQvc6MiXmbCWy5S5n0T9m9sIaciu0IyxG1h/WDK0E6sPS7p2pFrnzE5swLQ1WGOZBie+u1mKD15iaJQYGpqR1fua9twLv3eeqdYFoIQMNcpWrGgEiHHlyaqUvhlZ3S0Y2onlhyVDM1AsC9EQVKnkOBOZQybR5EWKiqr0qZuo72rhZH++Flu1OIbFIsdf5uvkpO8y0RBkpcRkvsik/98tGJqB1ccl/XlgsSpx80xWpCijsVYzTzPWJqRVKm2ocqbeUd2UkXG7pDtJ/M/9TH1To1CyvT6L7WKSibVjXucEoFrX+HFmcbdg7EaW72rB9lU5fnKk5SWXn0iOOUuwmUGFqBoeHGmZMvUji9uS9tyxvK2Zu5FiXUHcosdDEtuulBCkvHMUi4KxHVnc1gzdJICIZqSO9K5imZMkClNn0CBgjTIR39siZfZC3OrbnpvPlkzDfC3z+qWOX99I/wyHzSz3f3zCGMPQDpGNOjMNI36ehbWLoj12GGPEP7HK2DzsyOuS/dMem2XCCQ2Orh1wk2MaZ6Z+ZJpmhmZAGUVz6MjKnO3DjnIprNFykdMeJMfSNz1ucvTtJJzTcb6ydvtzh04SDm8nikXB5kEYl4fXI1km/NQQxG9xmmbmcWKKvOCh7VFG0xxaiioVxm+ds3naUdYlp+35mgNyzjF2o/BKp1k4rSHQnTrS1HJ4OVAtCt7u36iWpfByi5T21AlusZE+nIeZcZiYp5mhG0ApmmNLUWfCmK0z3u7fyKqc45twOvtTj3OBsZtw04wbHGMv7NL+3JOkmuPmSF6l0v5KWKN5kdGdOkA4rfM0M/dybudmoadoGcOssOye9mRVxtvDlmJRcNyc0EZycPPorrxWNwpv182BvuvJ0oTj9khR5XL+VcX2cU+WW5p9g0kU/bnHz+LF6KY5cocHlDa0p560SNm/HqlWOW+ftpTLgsPLAZNZ4QR7YR0753FzHAsnHGijNaftibSywkmuZSzTIqXZN2glvNp5ckzDdGUVD10PBNpTh80tu9cDeZ2zfdxR1AXHzZkkk/4PITC2E27yzOPIOETW8KlDaWFN5+uS7YMoL3dPB/Iq47RrSUwinNphlrKGeWYaB4ZuILgYQ5nh8HokX+Zs7ndUi5LDy5E0tTSHVjwzuwnngnBahwnvhBdNomgODXkprOOiztk+bEmrlPO+Ba0lhueZqZec5xx5s94HumOLzSyH1yNFnbO537JYFOyeD2RpSnNs0YEr63ce4ne4mb4dMVb8dNMiY/t8oFqUMofrguPuTGJlDglrWOJnnoR76x305y76qZ7IyozN/YZykXN43pMVKedjc2Viz5PDjRPTMDENs7QfaPZnkswK4/lP4r/ZNmgjeUxhE4+yhvTTtQ+7c0eSac67Bltadk87ijJj/3zAFsKrDsHTNQPz7HD9xDRKHI3tIH7Cp5a0TNk/Cy97+7gjr9OoyDb0pwHvPGNcS6fYBucDfdNjjOa4OV37P4uiql/rSP8Hx/fff8+//+//+/zVX/0VRVHwN3/zN/wn/8l/wjiO/8Lv/fjjj/zb//a/TVVVvHv3jv/oP/qP/l9+55c4dHSKD0GS+sboqATUBK2jqlRuuARPsciZo8Gyn6T2ax7naBz8swLwoqy0UYmID6SluMoUqwI3OPJamKQXZVxibVRQSnL/okDUWtR0eBFDzJPUi3nnoimxqCq1FhVdYqIK0RhRUlqDJmDzlNl5ymWJi9xgNzt564wKSa11tAkTJV9ipejdJBrvZoq1cDuzUsRRWVUwjvLmAwpjRX1pkst/66sFXFqkwjFeSE1kUZeE2JfOuavy11yUtIlCG1GHmjQRxm4lbyZFnV+Nrv2FTaqUqCcTFdW4Cq3Mz32YW3yAYlWAgzKKMrJC3pgu6uPr1leiMVpiQRvD5BxZlTPPXtowSTw4F0hS2R8TBXSEJWiBJ2ibyJtmluDnQFHlzL2MnTBHU7ybUVr6OrH2auVloqrZpAbnxXg7OGEt++tPeRO5qLxNhHToqM69qDKTVN50izqPJtaZfGeZiaglMVFFeYEU6GtM2NyCFz6qH50I25wnX+QEF8hyiw8ee1EwJxc1qiidL383jTN5mUvdbOTYZmUW3Zaimt1cgBKi4taJvhb2J3kmNde1xExe5tHUPRU1fbxenaioSI7jn8g4eCcM3nn2V2FbXqU470lTSyBIDCYyFjpRGG2uW7a2zGTclzlTrNuco+G4nzxJmmC0imrkCEtJojraRkFfmUPwlIsC7z1pJWuKTROCUjLnYhpH2zgnrKiFk9Qyexd3YOT8wQfyOhNVtzUCFDEaZWUb3FgryuJUXJXyKiN4ecsPiutckt0PTZqK4xFGVNJJkqCTqHTPU9wswjo/TCLUmoLEhZMta5S6Xoe03URFsKinsypnmpyI82La4Zc8/kFs7f7+97/He89//p//5/zt3/4tf/d3f8d/8B/8BzRNwz/9p/8UkPzPP/kn/4T379/z3/w3/w2bzYZ/79/79wgh8M/+2T/7Ra9X4M4FQcn2nbEyYX2WRUiABEi5LGRrd13StyPLDwuG80heZ+BlW9bEBTMEjUkSsioFDflCArdeiY1YWedMY4QbNCNFFbc0M4EgECD1Qm8p6xznoawznIPlXUV3HqhWJfMgRdTBB7JSCrFtFstHtCGtUlDEm24QAHw3Uq5yxl64mPM4C0RbKdLSXktWhL4kxeGA3HwnT7UuGM4jq3fS/sVtyTw6sipDJxpLgkJHGLyUXRR1Dh7yMmXuZxa3ldiX3dYM3Xi1iCrrQhZxY0idRSkBLAgsIiPMivqmZOxlK3VqpQ+nwVHWKcoosipFIQ8yAoUP8fyeRdzaXKxLxnaSbcp+EosulLBFrZSkCHlIkS9TQvBUywzvFYu7iqEZqG4K5namWhX42VNGC7qsykTtqoOA17WiWhZxWyyO+/sF/amXh7B+plyWEKBc5LGEwYNKsZE7TAhUi5yAolxmjMPI6p1sz67eC2Qjz1N0LK0yaYJWiqyUXGi1KglBtq7naWZ5W9M1PbcfV/SngcWtQMXzWgrxlUrRRtTPWZ0SkG1xHxTVKhfw+W3N2A1Ui1zSArVYxdkskxIKBd65CPMomV2gXEsMrT4uaHdd3J4dKNfS/qxMJR0BzN5LaqO0BOepViXOeZY35XVLszsPLD/Grd06h2gBZ6wR1XAGqBg7PlCtC1nAFzlTN1Pf1kydMH6D8zJ21pDFvKds6cpn6xuByVd1xjyN1OtCQBgxhharUsAJRSr9HzzWe1CaYiVzt1hmzM7L1nor/T40A/VtRZi8gFCMhjQ+UCQad10HUvzkWNxVTL2kGIZulHWpn8nLFKVlC1rHB4fgxSc4r6WErVrkuClIeqidWL9f0h5ka9/PnixLYmmXlG0Zq0gLKYMpFxl+jumJfpR5cBqkTyNrHBRFLXNo1pJr1RqxkfRebroelreyhtbrCu+gWKa/6Jr/D+KN9N/6t/4t/sv/8r/k3/w3/03++q//mn/n3/l3+I//4/+Y//q//q+vv/PP//k/57e//S3/1X/1X/Gv/+v/Ov/Gv/Fv8J/9Z/8Z/8V/8V9wPB5/0eu1uRTIVzEHaFNZkGwmNI40y9HaiLNJlQoBKebpFrfijbh6X+O8TAQAnVrJtWWyqKd5RmI1IchCG1ygXJUMZ8mTTqPcEJ3zJPFpMEkM2igSm2CNEI7S0tI3o5Q5RJpQfxpY3YmrS17J06ktLMqoa+1dXuaYWDuX1ynz6CkWGVM/sbqt6ZqBYlkR5kCaS57M5lbeSNL0OrnS3OIHcd4Y+4nqrqI796zfLfGX8wdBGGotT69oqadTiRJvxEXGOMwUq0Im052A7Bd3Fd458Q5VhrTKpC4tkXq1LM8wqSYguR7Xz5TrnPbUsXpXM4/iFONnqQnWWpNlki+7EJ4Sa6TdgyNbWsZ+ZnmzYOolb+l9ICnT65u9STTWpBCkNjJNFGEOFHXB1M8Uq1zydHc18+ColiXKQ5LLU7zNUkBfa21taikXsvAVy5xpnKluK4Z2YPmuxrsgD3NJQppnoCHJUzBa8mWJwUS3jqGXRbw79yyin2pWpdfaVpQ8zCmlyfMcncjbZZanjMNEucolP3dX0p06lu9qeSuMNc82sz/XWgJFWZJYhVKGfCEuM/mioO9GcXW55OlDIM2lxjnLc8HbxRKgNLXki5yxk7EbBsmtTfGG5JyLD3+KLJVcX2rTWLdpr5Zb5SJjbCcWNwvGU8/6dsHQjSxWBcF5qXU2Wq7j8oaltZgZ5Fm8aaaMncTf0Iws3okzTlbJW5otUnSiYq1lHP/URLeUgrFzlMuScZhZ3kmeuLgp5AE0S+KakWISRWJtfMgRCL33nmqR03cT9e3i6gnsJgHWK61QcWckSS71omncWTGUtZUH4JuCeXQs3wuxq4rnzwpZh9JcHm4TK7tFSZZIbXVQVMuM7jRQ35WSL7+p5C29TqVOuJA34CwVslKai6dpkiQUS4n7ci3zYBGJafVtKWK8TPxfkzQR5Gacw2lusanGe0VVF4zDRLFMKaNL0y91/IO4kf6/Ow6HA7e3t9c//7f/7X/Lv/av/Wt88cUX17/7x//4HzMMA//df/ff/Y9+zzAMHI/Hf+Gf/6mHnz3rj2vGbkQnJqookXpML36OBGK+YSZNDf15oCwz2kNHuSxoTz2J0aLoi2CFEDxumgl48TZ1UtM19WJY3J9EINEeO/IqZ2hH2QL1Hu9FZRtCVNrF84/dSFnlDN1IUeW0x55yVXA+9Ng0wU2izpvGOSoeZ7SWt+55FpXu1MlW1nSeyKuc86ElL1KmfvhZHewCbhQPQ+9nNDDPM+MoMIWhHciLjPbYUdQFp31DYhPmyUndaFQw+mmOykYX6yEdYztTVjnjeSSvUrpDR1ZmdMcOtGIcLopnUSQTmbOSs/YYDUPTk9UZ3VlqM0+7BpMa+maKqlhPcE7GToGfZnwQNevYDuRFyniaqRY57bklLzO6Q4fWGj9ertWLEtZLPe00iKdiYsRzsigzurP4ap52LTZLGNpRZqkPOD/j4/nnGEsE6E8dNk8YThJD3amjKFPO+w6lYR5mvHOi/PaBMDs0MPWS51Ja0Tcy/l0zkpc57a4hK1Lpf6OjSthd6yiHfriqacdhJi8z+pNY5TWHnrwuaffdVaBDiOpjFPMgdmDjMOCngI410UUtN7NqWXE+NCRpInNIq6j6lDwxRMVrUFF/MIp/bjOQ5hntsSevUs6HTlTq7UwIXlTo/MyDnadZVKhKfH3LOqc9nsmqnPOxJStSum5Eaa7sZzc6AqIaJkg9+DQ70lwEQ9WioDv05LVcR5pa5mFG6sInfFzctRbVuov82KmfrraLWZHRHVvKOqM/9qIXvqiPZ48PXNX6bna4aSYxCe25F/vFQ0tR5TTHFpsmTP0sC5PSUYkfUEpU/AHh2Y6dp1zmdIdBvGB3LVmZM5zHKzdbqYuqOaq3FbjJMU4eY5TMnTqnPXaUi4r21EV1rkfHGPbOM02TKI6jwtk7H8c/j/M/pTm05GVKf57i+V1URQubV8YtXPOtiVF0jdis9c3I2I0/w6F/geMf5I30m2++4Z/9s3/Gf/gf/ofXv3t6euLjx4//wu/d3NyQpilPT0//o9/1n/6n/ymr1er6z1/8xV/8T76+C6B7nmb85KIhtWMYR0LwDN1EQIrRtQ40px6jFad9h9YqIuScmB+3oxh5N70k19sRMcMdAEV36gWjdWhQUfwiQhoRaLhoJu2dj4ufmPGioGsGTDQ2TmzCad+iFAzNgJ894zDRNyIScdMcfVZHEco0I1pBc+rRiaY5dGDi+QOM48TUi7ii70ZmN0u+OgS644AH2pOcvz0PYAzNuUMrEde4Wcyr52FimqIZuveysAHdaZCf5wFtNfvNGWXkz94HEUTMnnlwTMMYBU9ict6dBgLQt9O1v5UxNIdoQtyMUmrTzyKqmBxjO+IDDONECFKnprT0vzaG5tSjEs1h24BXsc1iRjx2A9MwiuDIO7pmxIfA0M4orTmfOhKjOe8btDJxDL0I1MaZeZjomgE3BYZ+AgJdM8pnDy3aas576f/zsQMP4yBlD1PvmHoxBB/aHucRs/lrLGkRvSWa9tDGPu0JRDP02AdjK+M+DBOEwNBOqFivpxPFad+ilea0b0Appm6MN1nHHG/YQzvivWfoJ4J3dMc+xr+YUzeHLorQWgiBsZ8Z+5l5msUg3XnGYbia3XuF9EOMw0Qb+nMHStG3IwTPNIg4xU1ehH9upm9kDIc29uW5R2vD6dCitaE7dVKu1k24cZabdSfG8OM4EpzMS///ZO9PQm7b9uxObMxq1bv4qlPc8r0ISRkW2A0JLORWhMFCBrthY2GsRA05pY7A7lgYBIkQJGk3FB33jA2OMJjsmUSQBltpomEbjI0aFgglpBPp3fveLc5X7WLVs3RjzL3Pk5wWmcq4V47Q3XA47333fHvvtdZca875/4/xG4iYB4ZTDEcKc4bTxPExMMh7XS2FTp5jMvl09TguwwoJifG0QAiBaVghlMR8nhFiFsjFhGgZQh68xzIviMFjGVYkRMyDRRISw3mCMjrDUORVoGZXBzvzPrLzAqSIebKEVcwOKSZ+rhQ4vUyAJFaTiwuK67zj8bos8otZbAUhMA0LpOSzRGiZBWoS8zAh+EhxVRZILtOCkEPmU0qYTjM9nyOPezxOEFJhyOdjmSyFRS4g2ICQrz+FYnz+LYOFFBLDaYZQAlM/IUVg7imG+7Fe/0on0r/zd/4OUWD/gj//4B/8g3/md7799lv8xb/4F/GX/tJfwl/7a3/tn/lv/2lsxWvKx/+P19/6W38Lp9Pp+ueXv/zlf+HjklLi9HSm32xYmWq/eris1rTTkgeyhdYa/csAZRSGI2keVGtKrOOcHzzcOUUX4NeQFW9cKU6nCUVlMB5GFKXB+aWHKU1WRF4mRU5K14T51fEmm7hjPL8OUFpieD2jrAx3Y6WialikPKHxgRZsyApCBwFQ+WpkVukaDIcBulSY8jG41QGJRJSwRj5QnANCRLD0sw2HAWWh0L/0MKXG+XVAWRdYxoVEptXxHNqA6AKiZ3B6SsA8zDCFwngYoAoef5HVgkIK2OUysfKB4C0n1ug83GQhConxdURRKRJxSsVzWBkqAiXg1pBX/gFudvA2ZDB25EPYkGlrCoXpOEAaifF1gFTcuV/8nsHzYeCsvR6DKiWm44SiNlQ+Fgr9Ra3ZzxAA7OKRshfzch3svFI9PS7QhUJ/HPgerz10rfP1kHDzyh2MDRxDgQ8lpMhVuySPuawLnF8HmIK/awrNMSQEJ5QQ4C2V18FH2IUTJVWTGsPrAF0pDIcBxiicX84QSmIdFi4aVntV/PrFI8QEt3pASszHEaY0OD/z+vcvA7QxmIYJUpNgFUPktbMkNLk8odtpgTH6SuI5PZ2hC43hwHtpnVaqdi1V69F9VO3aeYUUkmO1kOifPx6/1gpjPwIQnDRDRFg9Fdcuwi0WiIBbLLTRGF5HUo5eB5S1xniaUBQ8fqQEt1hOLCHwf+eddEwJS08S1unxBFOSdmYqjf40QEkBuzikkODWwJ1pAILLP5sWlIXEdBpRGHUdh/1hhCmpuBaCCyu/cmFyoYbN4wqAFQ1lBMYj77vhMEArPo+EBOzIxYO3AcnTT24XjgU/O8jLPVxq9McRRW3Qv47Ql2cIIuzEZ0+0fI4Fx0pGignzMKNsNM4vA4qKY0mV+TlomKTl8uQdbIALPJYUeV5lITEcJ5QVlb6kUbn/ws/x/zyvf6WIwOfnZzw/P/8L/83PfvYzVFUFgJPo7/zO7+DP/bk/h9///d//Z5RZf/tv/238vb/39/AP/+E/vP7scDjg9vYWf/AHf4Df+Z3f+c/0nf4wEIFf/Ue/glQC/8H/8j/EOq9kbApgnRY0uxbD64jupkX/yocfYkII9Hi5xbKHoVj6KxsKQ6IPMBUl+bu7DqfnAe22yrsK4sasdRnpZhEj+1rOexTGAFJgHma0+w7DYUS3bzAe+ACjETvC1AXs4mCMZtSbj6hb9k5jpEJ2OE7Y329wfh7Q7CqM5yX7KjVsLjG7hbslU2qssyeXFiyBttsaw3FGd9vi/DKgqg1CjNnPV8HOKzm6KVJB2hQ0jgtyfYfDiM1ti/51QrstMZ5XKAModUGJGeLIQC6ntyw7ppSwThbNpkR/mLG564iya0o+lJFQ1AZucdBliRgcYqCYyVlPBm3BXdPmpsP5dUC7/1i+FEoiBXrsCBz46Dssa6pP3UwxVn8Ysbnt0B8G1E2BdSX9oajZYzNlwYdOTCyZryErpml32tx26F/4+eOZFpGPx1phnRcqkzUfwlVbApG743pTY3gdsbnje5RdwdKfoDrVWoeq5jlJCSzvWsIHpBQMfL7j9W9vG0yHidzXJKhWrQusiyM/GNwRttua1gfHfnV/GLG763B8GdBsyuuOxGgN5wKKwiB4nxXUBdY1wGRe7HSe0O0b9IcZ3U2D4TBldjFLtkVVwi4WKvcDiSgs8kIkwNQFpsOUr//AcuZoISWgSwM7WyqPc+XBVAY+AwSUBOZxQbNvMbyM/PxXThzRx6xpuNxD5Fh7R8xkCCGzeTXG44zt5R7e1Zj7+aqm9y5ce84CArrS8NajLAwiuPjqdi3OLyO2d7yHyrpE8CErrQuO4ULnNlKkots6snkrjfEwYXff4fg8YLNvMBwnqKxmD4HX8FIa1SVLw2VjEFOCnzyaXY3z64jNXYvz84CyLRBWLs5Mvp9MwbbM9R72/qr6ns4ztncb9K98hgyvtDARkhJgamoN2E9XsItHldXgbnFouhrDaeI5fOlRNwXsGjI3vESdffp/6X/y38bu/l8DROD9/T1+67d+61/45zKJfvPNN/jt3/5t/Jk/82fwe7/3e/9f8uY//+f/PP7RP/pH+O67764/+/t//++jLEv82T/7Z3/U46raEk9fP0MqlidSYG/P+wgREtzKsuQyLSgKjf44oN5W6F/OaLYNhtOIqjaw48rV5GJZ3sgewhgTrLVQRmM4Dii6AueXHs2mwvHDCWVXYzovZOrO/Pfe+rwrYYkTAMZh5i7mOKLa1DhnP+n5tc99mgWAgMsPleDyajJGzDMn0HlcULUGx6cTqq5E/3xCvakwHEbehKvFharE/pCAtZy41nmBbgoMryM/9+mcJ5oBRV1iPE1IYD/OZ/+r9wFIgg9LYzBPM8q6Qv/ao+oqnJ4GVF2F82sPUyp6JiNX/96yJ+ksy8TLtEAXmn3JbY3z84iyq9C/nlE0FcaePkJ7/b2QiU4RbllhFHnDZVtiOAyo2hLnlx7ttsF4oo9yHmfufpYA7z28pw9QSoGlX6BLg/E4oW5LHB/pRexfe5RtgeE0QoBM2+A81sVn4hN3c8rQR1o2BuenE+quop9226A/9ChKzV0XkHeDHs46rAtL3NMwQxuTz3eB03OPpqtxfDqj2dQYzxOUlrCL5UTkAqKLubS5QiBh7GcUZYHxxEnx9HRGuymvvsZlWllWnW32AOZdZQLstEAbjfm8oKpLnF971G2B8+sZZVdh6hdA52vo+R4x5DG0rBAQmPsJuuQ9VHUVzk9ndLsG43lG3XJSFfjYj760OpAS1sVClwrjaUTZFjg/ndFsa/QvPaoNe4xaS6wzWzLOs1wufMqVBmCZFy5wzxOaTcUFxrbG+eWMoi2wDDMXkQtL4/TScpFkV4IRxn5B0RgMryOqrqIneFNjOI2QWmAZVoSUfcT2spvjfTUPC3fxhwFV19CTvqnpDa5Lljol4Jy7UpdCnuDc4iCUwDKtqNoaw2Gkj/TxhHpbYzzNMKW+VlWCi3CBY9hZVgSWiZ8/nEdUmwrHR3qAT5m3PA0TlJKwi0MMpIw5GxAjqylSKqzLiqKtuLDe1h+P4YWVsqWfuRBdOf5dYJXO+4C5X1gJO45o8vXXORTiR2yR/tGwv3z77bf47d/+bXzxxRf43d/9XTw9PV3/27t37wAAf+Ev/AX86T/9p/FX/spfwd/9u38Xr6+v+Jt/82/ir//1v/4vvbP8l31d0h7IiE4MsBUkroccXptUDlwWF5xZZqSBOzEKA/h+lMfwH8qcqIKMvmMaQ+6rZ8yguCDNUsbVCb735XeFkoAUkEIggniyiwhCZMybzIBrgPg5ICEiMVs4ZnB+TlMRkrYOBhDzTYQgTg0x/dp34R9+n/z2pNAj5xGTSJLh8tfvoiSETJBCXt83Jr6vwEcQvRSAkBSFXNB3Icbr9xc5EeeSaCLBpA0AOWiY2EEhBJTMx5ORjULw/RMoMEK+vkryHF6CkwGi1pA+BpMnKcBIdkELRSL8XCAHbAMMI88+z5gSvaJSXL+PzKB0CO6s+He6fichJYOvJWF2Mj9FKNK6oNcY5C0Vk0FUho/TG0sVLJfWifi1y0tc/ghAcHxKLSHB68FiHxGPBMNnZGKiZ1bkNJgUeb6vocsZZ4c8bhIS8jDnvZEfhvISdC8EbCL+UFy+q8x/53+fZMq7s4jg/fV/x/gxyFtqQVwfLiEQAjEge5N5rcSv7TEE8jjOCL0Ajv98gZEEKzox8v1j4j0lYm4t4XKcESkxlB0ZW4jwEckIkRiGzdsKAkxgEnmMijw2gBzGnQQEKISTggIi0kJ5jQipl/xZomc1+sv75fsyMKQ9XR4fKYfBXwYPOOZCjDns/fLfeN1kvmAqn1sGufO+lPkZE/L9EIMHoCFVhv+rHNiOSBQiwGcG/wf9ypIkL6IuAUgJKShQEyLfv3n8hIRr4hSfWz9esfWPRPrL7//+7+Ov/tW/+p/6337963/99df4G3/jb+AP/uAPUNc1/vJf/sv43d/9XZRl+Z/5s/6wSrvaKPwH/+v/M+y0oigNeyNZ3bjO/Nm6UL1rGo35uKDbt5hHkmq885TUNwVZpIIPo2WyKJoSbl6hCs2+2+JQbhssw4x212IZJkAplKWGXT3K0iBE9leL2vBnVYFlWjlpaPYh2n2bV7gsRUZLg7dzlskVgjvBqiV1yZRknfps25j7JePu+L6m1HAry83Be/g1ErO38GfzMNPoXbCX0+5aLOOMsqbP1vuQS9WOcVmChB4qkleY0mDNu6WqK/n5W1pghCAWz7tAnFwM8DayVLTSIzcNKycEIa5y/blfrui24ANLu85DK4UkqK4smhLruKKoDYVjIaLqKszDhHZLPyuRdgLWBcIZco+pKA3W1aKsSizzQihFAqX+Nw3mnspLn8ktZVvCLZalQpHgZn53u1qYwmCZVqQIFI3BfKZ/cB4mKK2hteSx1hVipMpba02EZFdiGhYoYyCyAK7bNxj7iX7CYUHMPkxvPUxJ76tfPExVcBdRFtytRvpb5/N8tc+Yigi7daanNnqPGDnBs3xcYJkttFGIIWFdVmz2HcbznK8hqyFFXcDl8xUTe/NFVWCdLcq6wDpROFdUBvNpQXfbYuonmLKkUtenbM+iclopkce/wZLbKDEmuMmi2tRYpwX1tsY6LvSBVyWCczAFS5tuJbJvnVcUVZHL0oQMLOcFm4ctxgMrOjFyQqubEnZlz04ZjXVa+BxYHYpCY1ksogtodw0V913JHqBgfJhzjmMoay3YgrEoKu74tQKkNpj7Gd1th/k8EQzhIrxnOd8vdBAkAHam3c3O7O96T+JRvW1yGk7D/rxiELtbec+H3F83hcaSWwbzyMqUlFQ+dzct5jMVv8FTodtsiRFkEZEug7ItsS4WpjQUFFr6hpd+RrNrs1pbQin2d+uuQggULxZlgXV1KKsC00DFegJghxXNroUpNbTR+O/8j/6b2D/s/qWe4f9554I/EhPpj/n6w5hIP3z1hK/+8S/xf/v3/x/ZxsGMPjtbTqreQylaSyhqmLG73+L1+wPe/vwBH/7pC+4/v8Xh+wP2D1uKfbK5eZ4titx/UIW6RnkNhxEPn97g8ZdHvP3ZHT784gkPn9+ifx1RVMVVBVfWGs4GKKPhV5cfrDN2txu8fH/C2y/v8eGrJ7z98g2ev32hwX12SJGEFbvkY3ABUitOrDX7Xnef7PH8zQFvv7zH49cvuPt0j+FlRFGXSII9yqpmz0kZRX6v0Zj6Ce1+g9MjP//7r5/x9vM7vHzzit2bHRWCAIxmGchUJZz10EbBziujpE4Lbh62eP7mgHc/y5//2S3654GknBRhRwddawTroQt1/R52tKj3NY7fn/HuZ/f48NUzHr64x/OvXrB/u8U6WShJotKy8OHHa8iJytQa03HBzdstnr894u0X93j8+hkPn9/j9HTMpvGUbUoadvHQhYT3kaXD0aLe1Tg/MQ7u8atXvP3ZPZ5++YzbT/ZYek4WWmssy4qyYt9WaYXgAjFzZ37+yzdHvP35G3z46hEPn93h8HhCt22JuHOBiyvLieFy/Ou0otpUOD32ePPlHR5/8YJ3P7/H41fPuHl/g7mfScZSEtO4oKq4MFBa5/KkwXyesH3o8PrtGe9+8wGPv3jG/ae3eP1wxO62hbMUvJV1Abd6LrKcQ7dvgQg0uwanF8ZgPX39gocv8jj84h7HxxOJWbk0XdYVlok2jWmYadc4jdg/bDj+vrjDd794xie/8RYfvub3mM5U1V5sR2VVYp1WFG2B6TSj3dU4vQy4f7fH0zeveP/zN/j2nzzi/Zf3ePn+xGg9y76tLjXszBjCeVxQVAXmfoYQwONXr3j/m/f48NUL3nxxh9fvjtje0RMZEiehdV65MMmwdpfj2M6vI+4+2+P1mxMePrvB49evuPviDsPzmYCXxIVkUefrb9g6MVWeRHcdjh+OePcbD/jwi2fcf36H129fsX/Ys5wfI7ThQlYXBikECEVBoCkVptOK23c7PH97wJsv7/H01TPuPr9F/0z8XkwRdnIocw9dlZr85CxqanYtTo9n3sNfPeH+81scvzti92aPZViuvGa7OJiygLcOxkjYNUCVEnNPKMvrd0e8/eIBH756wsNnNzg9D+j2Dbz3WCeb+/Z8/l3sWHb2qLc1jh/O+PK/9B7rEvBX/53//o82kf6RtL/8//srxoj9mx0HW053uKQt6FJjnflAnccFSRG7F/LuaxnogaNIibmh7E94SM3Gv6kISjdG0dcWgaIwWCeHquFNzYcNpeHc0QLBe2itSS2pKIoQCpCQ8DbygTCuqLsa03mCUgrOByjFQG6lNdzCMG1+vubnJ4YkM3uTnN+qoojlUkbSKoc6VwbWclU/D1z1CyERXd4lXB+Q7B9eRArBB0BL2IXg/XVc2QO2ASkIlv1WevHGfkFZF7BT9iB6IsN85I7QLh5lRRITw62B5CiKGIcFVVtjHviADC5CSgXvmVzjFpt32h66oDhJRAGjFcU8dYllmLnjmKhojT7mcG+SfdzCycCOFlIxSSY64tzsRErVPMwoq5LCKSkhQDxhyNfJLw5lZWAXB5kBDRQWFViOI6qqxDKsUFJe0zWC5wLKLZ4748lef5480YjruGYBDneVfqFFCAnc0Thew3V2UFlgBiQoLTOissDcs+e5TCu0VvCB5VSAOzK7uiucRGvFe2IkWWs+LehuGkz9TJFKTnm51BNlrowoJXMZmf2/qq2yEKzFNKzY3nV5ktP0ygqZK++5BC8Sy+CRwfLLZNHtGkw5cGE8z2i2DBXQBbGY8tdKrCyDsgQdPMEV3nrULe+hqq2yvYegeanoBdfG8F4reQ5NwfORIrNPwxpRVBrLsHLRcblGNjADNTB9yC4WJld3eEji+gyZhgVlV2Ed6QV3zrO8HCgo85aVlnlaOZZnB5EkTKGwLvQTr8OMouZzRsqcLiNkHsPsmxvDBYVUFJsFF/I9vKDZ1FhH6jiYw8vrJTV/xxTM6pWFwTJbIEqonPFa1fkZ1hRYZgdtKNoTuZ6rS5M3BSXG8wJTmKunuWx4T7DU/q+J/eWP7Svj8KSSSJJln5R4g6zjyhLaecbuYYtlmNHsKqwLd5YpsSQqBVdvTDsRKLKku9mWWMeF4cPDQqxaFgv4EFHUBjIrRpUktaSomF5SVoYEmn2NsV+wuWHKQrtvsCxc6YmUckK9zBQemRWrfCDTNE960jTM6O42nMA2JYLnQ4lsYDb9lNKZtxo5AY+WQpZ+wfZhizWHg1vnUXYlQqSyUStJgotiUkRRMD2i7kosk8UuI/G29x3swpJOcKQoaXnhmpLPKQ3zzjiJOnTbGvPIhJa5n9He1FgWrvQFmBSiMtP28gA1hUL05H/O44oml+E39yTgVBsm1BQ16U1UjSoIJSCNRIKAMVRg1psKcz9jc8dr2O2IaKs3LUIIMBWjqKQWUEJdw9hjTFdbULtnysYlOaduSoSVgcbQErpUUAVVktpwEilKDWs9J+qRyuVlYLC3XSyqxiCEjHVLAtqQx3shOCVPbKOdWMJbTxO2tx3WiZOgcwFVzTaKMrx+SpOkI0AVt19JK1JGoWwqmKrMPV/i33jz4Npzv8ArmJxDMIQyBISoQsP7BCUv6DoAvwYvuYgMLtCJEPOCxrK64i05wt5xofsxuJv99RhT7h1ykgKQPz8nKRU6B62zt+dcRJE5zbrQmUWrsqobTE9xnmlOMylm40AV9jKtqLqKaMy6zAQwVkGUVMR8ZiX+sqxotjXWfP8vA5F83loUOWXFmIzVVAraZApUxVZQ3RZYhhXbuw3mc74PZ8JcQoicmEAmtlLyWroWQqDM91C7J05wc99hPtMFsK4WRVuQRFQQTaj0pdcPGK0RXWBraLbobjom1txvYBdLRGlWHguVn4OSzxFpiBlVShEnuK8xDxN2bzYYjtM1waluL9xyJlz9WK+fJtIf4KULJqrEmOlBEz2P03m+pntsb7d4/uYVu/tNTn0pcHjq6ec8jNmobLFaUmlY0jDoXwY02xpPv3rF9rbF87cvaPc1Do9HmNrg9DxAaolpnCEkPZvLuAAiXpNCXr8/otvVeP72Fdv7Dk+/ekV7U6M/DFBaoT/27CVltaR3HvPIflJ/ZKn0+ZsXbO86vH7zgnZT4/X7E0ypcXrtIRQwDjRV29XSLxcjxn5B1VY4PB6xvWnw8qtXbG63PIZthdNzj8LQiwfJvqX3Hj7DFJQB+sOAbl/j+ZtXbN9s8Pz1C7qbFocPR5RdgdPhDEiB4TxBSgm7Orjcx1uGfPxPJ7TbGs+/fMbuYYPnb45otw3Orz2KSuL8eobUEvOw5t62Y99VC4ynCd22xuuvXrG9aZn2cdsx/aUpcHoZoI3ENMwkr8wW3jmkFDBNM3RpcHrqsblt8PTNC/Z3Wzx/84zupsbh8RWmVDgfRlpN+hkx99bX2UIqgeFE4tDrd6/Y3nREUd5WeP7+gLKjF1Qbg/FMs7tfHdaV/cl1WlFWBoenHvWOn7+97/D0ywO6fYPXxzOKyuD4Qg8sP5/Xn0kphEZUXY3X747Y3G3w9M0Ldvcdnr95RZVTgJQQGI5T9hs6zPN6TXspKoPD05G72xCgC4F1cSiqEvNpgiqpRJaZ9qQ1++wpxpyrGa79axFjrtQozAN75uNpgi4NpjPPtbeeoiIX6YFMJPnEGEk4AmDnBcpIzDnJZsweTDtyR+9zJmYCd58IzDpFYuZrUZVYe4u60fQx1gWGYw8hBdZ5zTaQiHla6Fc99Ki3Nc//dQy1eP3uAF1pnF56SEPYATLFyC4OAhFjP6Oq66s6+/mbV+zutnj51SuaXYPjcw+j+RlCU1XvcmrTPFmoQuL8OqDelHj5Fa//8zcv2Nzye1RNiePxDGUIVwFY+rWW99A4rijbCq+PJz5DvnnF9n6H529esdm1OD2dcxrLGVLx+Cn8ipjGBVBM+6nbCs+/ekF32+DpGz5/nr5hYs3x5QxlFMbTlEvPNlfmgHlib/r1qUe7a/DyqwP2uRy9vW1wfDrDGI0pP3N/rNdPPdJ/7vWHJTYqKoPf+7f/PQAMPb4YnetNnXsU+or5KwwfFqYy7BuWGt5GSJkAJVEYg2mY0XT0bdabEn529C4CuU/C3lPdUsykdU6dkMR70eYyod1UmGeKN+g3jTDGsPeZhTVEA3IFLrWE0Yb+uU2F4Tih3pCLy/SWCyLO0G/WXkQMLAfLvNIvKto8ml2NZaDYyjk+jJRWWFf2Wl32wi4zMWJaKEgj+N51yZ7YpiKQwiggRDjrWIZcPX1880UcEq8lOG00pvOM9qbBdKZlxGf/pJQqWwAqOMuSkV0dQfF5V+zye4/HibuBmTSeFAHnLMqS57+oC1jrriIWmcuAumAsWrOtsUwrypqgbqp1BdbJ0Y8YIsosSNJKA4phAXaluGPMq+8ll+W8DfA+oCgoQClbfg+tmWwDKfKO2mA4T2g3DaZhQt3WsHP+fMFS3VVYVPFaqkIBAJSQ12zZ4TixbDet9DiugbvowsBlIZpdHYoy+0+FwO7Nlg/E2V29srs3WzJ7mwLBOqyLw+37PZ5/+YqHL+7w/A3j4JCIhysqip3sTIb0+WXA5q6lRUIxY7U/jHjzxT2+/ycfcP/ZLc6vI5SS2WfJ8qYsCAnodi3OhzOaTQM7Mdpt97DF4fsj3v7sDR6/fmZ4QKBSVxXMf338+hnttqUoaFtjOhP8oZXG4fsDy665dB1svoeMhDFsW7D1wqzPi981xQSfs4q9tai6GstIa1ASPP8RCabQ1/G3jCz92pWCRSFB3nRb5l40RYUyq94vwrS6YT+53hAML41E8jF70IssBGQPWlea7y1YYTOFxnia0Wwb2t4qXmM6AhTWle9BLYDJrRN6rLUUWFefx/CIZtdiGRfC6DMoRBtW3S7HoI26CtSSSIRVHCmGWwZiQO3srveQmx3KrkRVG0BK/A//nf8Bbt/d/ChzwU870h/g1W5rfPOffE8RxrDQszgzjy/FyCxNSSpOWRqcDz3qXYXTy5k+qpceZWOIrEs0gQefyS7rimA95omK0/61R1WXOD31aPc1Xr8/oN42OL+eYQpNtFoinehK1lksECOmYYYqDY4vJ5SbEocPJ7TbBn0GFXBXIzCPC+IFWedczrRkliDzSEscH3s0NxWOH85o9w3JKlWBeaBnc534ez77GBN4XLIgyajdcJVd72u8fncid/c4A4oYOu+YRepWh2gD8YZSYDiOKOuSHtQdfZTtrs7HrzCfcx7naq9ZnG6l0ncaZqiCHrx2V+P4eES9qbKfs8RwHqGVxDoRz2YXB5+Pf50viL4BVcU80HpT4vB4pBfz+QxTmnzukHflKRON6MGbh4W7/NcR3Z7ev3rL1T55vwOkIEgjpQtX1BE9lzFr43lCWRY4vZzQbCscPpyYZflyhm4KTP2CCGLYYq4u2MVfd0hGSwzHAXVX4/iB73F+OqPeVqQUFcwDjYkK3Gse7fxxDBVlQe/xrsHhuxPafYvTSw/TsA++u99ASYnupkVZG1SNQbdtobXA/Sc38D7ik998i+k849N/4z2Gw4jP/tQnsLPDmy/vkGLC9mEDqTS6mw5lU6KsC2xvNhAQePvzB6yTxSd/4i2G1wGf/RvvMRwnvP+Nt/Au4O7TGwgpsL3foCwN6k2NZtdASYX9wx4hRHzyJ97BTis+/ZPvcX7p8dmffId1snjzxQO8D7h7v4dSKpOlXMYYBkzHCXVV5IpIhZfvTsyDfT5z4dXPREnmXGC3+oxIzJg7ITGcxlxNOqPa13j+7sD78NBnMR5xf0T25TzS5YJInLMXdkK7ZQ5qt6+Zz9pVmXAmMA0TUX+rpafUB0zjTMznmVzbwweKml6/P6Db8TlgCoNlYPapnR2iT4ie2EgI4iRlWeD8MqDpChy+P6He1Tg90tc+nEZiIMcFiPQQ2+xlXRcLKOIETVXg9HpGu6uvPtbj85nH1hO7aBdHP75zWBdWWS4+1vE0otlXzHKuTO6p/nhG0p8m0h/gFUNODck+zxAitCK1RBnJFZspaOvIuaEQzCiEj/w7JJa/IvtMKUT2c3xE1dVZOk7putQKUhDorLRCdCThXFbhKWSxjeNK2c4OJhOALlQYKZgPGrwHhETwkTuuDMaPPkKVCt4y5WKZLIpM8VGa/swU2VMMmQQUnKd3LiZSfjyl685y5+pmj6rSiCFkEpBGcuxBIUb2rbJQB2D2prMOps32j7yrVTqbymLKwiB/FdEIyRW/EgrB0350kd+7xVNI4eM1J1NEkXtZoFDHZ79jXpG73Ae1s71SZ5TRCCkhJkBJzV1+wTxWGiRTVmk7yCKrNGuKrkzuW0FISMHdgVYKKauiAUBIngelFD+/yoKNTH3SFa9hEoBUzBhV5uO1S4H9+ugDBWyrZ/Vh9SjqkmIULSANhUEii1uklPBr7l+6AKUEFc8lRS6mqeDWAF0ZJJ8gY4I0GsE6epQ9wf5IpEIF73PYu4UuSfIRkhaXBKDpagQbrlF8VVMCEdCV+ZiFqtk31IbkJl1RLNZsmEPJaLSEbnfJpS0AMENUF4q7I61gCg1TFVCau9ngEvvsPlzj1RjFl1DVBaRgnxBCZNEL8z2V4TUqKgORqCyPPkEKlcc97T1KM1tWVxyzps7WsFrzHEqJJBJEAJ8VPkBJqrIh2PNVRiIlZq7afO/6Nfd7HXvEWufxrFitkVIhIefCxnglDhX5/jcNd7UqJ/MwHYnPGakVgqPYMSU+l7x30EXB6kJJzYXRAiFyDCslkTx9tN5xRxqDgNYaIefTButR1gwkKEsDuwbofH5SQhY3eYocIzOdL9FvMSVWf6y90tS0oQIfoDYiRgZk/IvQsH/Yr59Ku//c6w+jtPvNf/IdxtOEf/9/8X/AMrIElwB4y0GpNb2M9Pld5OyBIqGSSCxTK9jB5ZBjTkZJCCCby3VlsM5LLssS6ycyhEBpCTdbmLaAX/jgBSSctYQIaA2/WqiCPNkie+WUUpClRlg8TEn1HUOe84QgBVLudxSVIdWlpKevKEwWXQCykLCjRdlVtAnk/MHgmNwhFdMziBCkR9J7DyUYNectb+x1XOiBszGbzYmhSyFlReGSLTkuByjTMK4LirrKLOoom4JcTs+emM6Trc7lrqI0nOSUhjQCcQ0wjcE8WNQdS8YX5awPgWKOkjs1UxawMxM7Qoj5wa/h80RnJ4eyNTn1wmfhjchiFUU/YlFgtY4CK6MZ6lwaZmJuK5ZZlYJAgvNM8WEyzJo9fRaFoXJRpARdG9jJUhg1LMyO9ZFpQfnh4gOtGPNsURmN1QYYTVFH9AGqMFiHGfWmgbOOocxZoRoTxV/LvFwFXLqgV1nmyYLX3WCdLf7kn/kNVi6aCsu8oGwLGMNos/2bLU5PZxR1Aa011nVB07Ww04J1sdg+bHH+cMbt+z3G8wxlKHyaTjN2bzZ4+uVHi1ZM9Gwu05pzTEltuvtkj/6FJXE7u5yFWeP4eMLN+z1evzugqkuIPHFoY0igWumtPT8PuPv0Bv3riH/6j78mou44YXe/ufYq18mSYpQ4eTrLcPt5WHLuLwkXAuIKyDCFwbLwHl5nC5NjCZHyoma29FvOFmXFMey9Z7lefrTNLMN69Z7LjPXz2WK0TI6ZsavnQgtMzgmB6u91WYlGXCwKrZCkBEJ2F4zu2qoxtbliFpPkPeQsPb3LtFJIFwKU4BhifKTGPKxoNiW8DRmswsVYTAmmMFjXFdrwHipKgyQkUsah2mlFka9nsykRQoJ3DlIqiIQcEamwjOybOuehpMDmdgOkhH/rf/5v/mR/+aP8qpoSx6czhJawjh5QYsK4EzgfRjS7Gv15xuZhh+Njj+6mw3gcUbaM/yoqA2sdpARiJJLrImIpNyX61x7drsP5+YzuhmXhelNgOI4oWsY/FVUJHzxCIOHIrpYRUa8D6l2D/rXH9n6D/uWE7maD/jCibmhyLhoFb4kQC4F4NGOYjFFtKpxfB/7Oc4/9fUtu7abC+TigairM4wpdcgUb0gVr51iyzqb7PjOHT89nbLYsBxdNieE0Z2ZpgBAJ3rOkJZTAOq2o9xVOrz262w59Zn6eXig+GA4jytpgnlaoSrEUmRWYbqGP9XwcUW2JQtzddzi/8Pz3Lz3KukB/HGEKQ5RiQu7hRMgMrqg2JfrjQObuc4/uboPjU49u1/D8NwWGYYauuINOARl6TiDCcJpQdTXOTwO6HY9/d9OhP4yo2gLTcUJVEVggBHfWzgfyl2eLqiESsr1pcHoZsb8hc7TZV+hPM6raYOoXLpg87VGEzjvoSrPP3lXoX0bsbjucXntsbllKrruSgqLGYF0dlL7EjV3OP+PG+kOP7oas1+amxfnljO2e8XdVbTD3E3c9Ob3Gu4D+OECXBq/fna59S1PRg7jZNTg+HrHdd3j+1RO6uw2mIzF/Lsd9BeevPUvvAoH6q0fRlOhfB2xuGrx8f0C9a3F67lFvSqyTRVGW1wizFCkQosqW1YxloAr79Ei85fHDCd1NR+zctuHnR8A5j8IwMNoUhBtIJVE2XPzUWzJoi67EeB6vFRsoAe/91fu7DNMVRbm53eD8OmD7lp/X7pvcrjCYxgW61CQ0xYiYUYNFyZSXdlfj+NRjc9fwObDfoD/O17bMZbcJcBEZXIAuJeaROoPzyxmbG3o/uy37zlVboD9M1z6pMRLOk10tpMC6cNE8nSb2mZ97dPsW58OAzZ5juOkqjMcJptZEOUpxDR0QknFrVVOiP45odxw73e0Gp5cBzYY877I1BIYU3J16FxG9p/2tUNSMbCv0ryO2txQ5bXYt2csVfd4/5uunHek/9/rDJBv97/7d/z1ils1ro8n/zKsz5KR7Z2mo9ouDNgXRbz5CFYo7k4pWDAoISkzZXxUclYcqqxp1Sb8Wkshl3ABdSaTARrw2GvO0fDTEG3XNdyyqgp4uLQEQKcbdH8s3F5hE1dK3VbclH2rIpJqFYp/gHYOfIbj7MjKj1+izZF5iyR13wVJ3jDGXcliOJCpQQWS2aVUa5j+uNMBPZ74HJwjuUp21MKZASjSYA7kUXUiWuY2G1orexLbCOhNq4H3IHjeVIQkEk8dExGEMtDggI95MpdAfJ7QdA9szQI1VhYqgcyE18W2RpbjgIlShr5mjzbbG3NPfyEQYB5XFXqYoAFBZKjVzTHWpIQQn86IuMJ0nNG1Ff2nGBtrFZ8qUp13GiGt5LTjujKQSOcC9wrpkelVOI1FSwVmbrx0yVi6yVWAUiFsDTKkw9yvKhh5hmT+HAjmGBiitr2Q5CE5aX/zpz/J4ZWnPzivu3t8BIqHZVFhnj+g9mm2D8+uA/f0Wpxf2mMsMO+juOqzDCqEUdKkwHyc0Nw3OTz2KtmAe53kmlOK7Iza3DKZ2q8fursNwZi/fO6bg1JsKp5ce3a7FmGPrbt7u8fRLgjRevnlF2ZXQRmEdVmzuNhhPE775f3+Hos7HarLYK5foD98fIaUiIhIiU5QciqaAhOAuvS0yvSqD5iMxhd7xPkwxAJKtGu/i1XYmlcqhDQOaTS6pG4WQEnefhb5m+yIRnilFgrMBZVNcs1PL2lwnshC5QLwco67NtaQKgCVpI9g+MPrKpa47Zh3rQiEEsGVQKPrjC40kIgQ0hKJq3JQaQih458j/PU0kFTkyly/3cFFycaVySyNlEVUMkaEGmS3dbFhZMLm1cgFN8DtptLsa3kf8tf/ZX8bNm/2/3ESAn3ak/8pf7a7B0y9foCVpQtHnLNCcwBF9RARLvVIJrGOW7p8pOqBylmZ/JGCdLHzI0WFI8IvPLE3ALuvVKqELw1JhzZ1QUbAPm4TIK/JIA3fC1dYicx6p1FQzFpXCNDAQeBlXQIkrtHpdHASycCeHStvVQimB6UxI/XSaMyw+03NWD6MknAv87o4h24TwX37moAzDzXWpMR0H9nIniyRTXtXSSgRF2DgfQvEKbFhnC1ko7uZLjWlaoDXpPQKXsjo/Syua5IPnA49pFYpxVqXGMnI3ScsLVZgheKyzy+V4dw2FXpec6dkT8D2NE8oM29CKJCiRADczvGDul1xh8Ln/JeEWGtfn88Qe8uJy2XUhPWly18iuFBlJFmNCSCmLnpg/ayp+7iUCTRvCP8QliitGWGuvCyhrLUQEnOUiap1WmIqZnsTfzdBGcleV8XgpJPgM8kieVpIkcP3cuZ9QNtx1E4fIYOZL7J63ngb+HIVV1AXGw0A83bAQqNDTWzmdJlRdRXqSUnnMZe6twBUC0m5q7uZuGu5M71qMxxH1poJbqe72NgBSfmThCpGtK7xnNncdXr59vSp392+3GI9T1iO4zG4mizmGfC4S4JYVVWNgp5Xw+sOAolKYx4k+V5vP/8r8VmYS87q5XCZPMUAZgXmcoSqDZZyzyMteSURC4ipws/n+d94jrI7Xf155H54I8V/GBSrj/S7nXQhOpjFGeMtoxMuYFDJHMpZFDiJguVnpghjW63OA7wEBogW9h5AUs3GzMNF+dRqv310qhXWmlcfl82CtR0gJCXwOURA1Q5caQ47VG/uZlaGF199bfpZdLELOtw2B32UZGNKx9DMAkcPgf/KR/pF+pZjQ7hu4QMEMAFRNhbB6NFumSrT79rpDiFlYVNQFouPqiiszDcQEXRggBlQdV2JdfthUmwp24opPZSB7UZITW5Qmk2zUlSjkrUezrWkh2TWYhvUa02aMzJ+bUBTsEZUVOb9aa8REoziZrB39bC17gBRtaCCydxecz+Zv7sqcJ2TBZ5HP1C9odjR0100Fv/J7KkORU9kU7KEWmjSWgrunoi3hBovt3SazeRssw0oIgIiQQrLH6hOqirtmoSg+UBmJV3U1hn5BuyeTtd7W8IuHLhVMRWxbWRaIHijKAggUaKTISLV5IHlnGUgAsotH1VKMAiFRlixnVlWJGD2MYUydrshbbva0/7RbWhzqjj1QXWjoijFWFE9EWpR8hMppFmVTws3E6o09VZp2sqiaGkJEiCR53ddMP0rxKmYyBXtc9abCOjlsdg3RhFv2wIrCUNSWgLJixaMouYMjcD6xcmEd6l2D8bSg2ZWYeou6qyHJm6cgywZWLfI4BICyKSEksLlp4FaL9rZFs20glcLt+z2QEu7e7+FdwO37PVJM2L/dQUguTIumQNWWKNoCZVOg7iqYyqC77ZAScP/JDaIPePPlPVJIuHm3h4RAs21RVQbNpkJdF6jbClVTouoqdPsW2ijs7jaIPuLdz97Au4A3X9zB24Dbd3tILbG5aVE0JapNhXe/8RYPn98gCcFjkyT6F02ZgRUFvIvZ/uNoYXF59xgi6mx76vYtlvOCuiuwjMRuSiGBcLn/Isqaf+sMbS+yPa69aTGPM9r9BvNoUXcN71NjGEEYIopCEx6hDUJMJAzFyDG0ODRb8nSbbQ2XucWmUEhS0NbiQq5auauQz5QGbg2ouhLTecJmv+H911SsgJWSWoUc/xds4L0bSENLkWN4nRy6XY35NKPZ1WyXNBVPZSJ0JLhAOlrmXIfAqkewgQCZccbmtsVytigbgixUqaEK3itSyp98pP8qX38Ypd3L63/1P/3fwnsm3BcNPVBFVQAyInrkAGCWG+1KSLMpWeY1tcGad3OqyL3JtuIqUTLqxDv6BW3eUQnJFAStuSPVWuckEqoKh9PEkk5W4pnKMJg7T7IyKxp9XqnbXAKWUmBdPFSpYQeiC4XKKlxzEd2YHNqQsnhhhSno/WNZVGM8MCbK2QCliZ27+Bbt6iCkQmGoWCxKKnOVJuPVzhZlRyKLEIq73oWCmmXg7iuLn1GYAtbTy5kSkDLx6fw6oOlKOEtkYlkZTP2KsjY58xPX4zeFyTxTSWFH9uaN/YyyolDGZ7HFNM4oCsPPT8jBABTgeBsgpUBRMsu06gjrlkJ/VHBnUY66nP8QrjuCsjKMsPMRRc3+ZllqBDCSq6wNln5BUZdc2QN5wrvwbLkjN6XBdJ6y927NqlfudquOpCVVaILFMw4wXCZRAaIBG8ZVFXUJgFYeUxnYkTjH6LnrM4a/KzV5wr/1X/0TSDmvM/qAdtdCGo12W6PqKvaAZ4vN7QanpxN2D1sMx5H9x5q+6Kopsy+Sk/U0LGi6GvPALE9dkjd9+26Hw4cTNjcto/NcZOZnRj7GQM9i1VbZE0tSVvARm9sOp8cT9m/36F/O0KWB0QrL4tBuKlZkBLBMK/6j//t/jO62w3icUFQUer1+d8wTmoT3AcZo+oGN4bkeFwrBRlZgpFLMCy4UlpHIPWRRnSo03GyhS5Nxd0BZaeoHarYlBAR525OFKbPCV0kUmsKfC2KU1zWzvmveQxQgiqxCZ/WpKC84RUHBlXNQ2uSkIQoMh8OIsisQXU6bkRLLnL2fo4UqNJQWWams6KkuFJTI7amuwHgYUTYlkgDCShX4khm6wTMF5pKDasqLIlmgLDWGMzUA65KFe0qyZJ5xmcJIFFrBBY9/82/993D/ye2PMhf8tCP9AV/es4SyWAKj15kCnPHI0snhA0ky59ceZR6kUiv69nyEXyyc84g+5XBpYDxRuTgPfI9pmPi7xwnKGPQvIwBg7hf6Nj2zOCMS7Mwy7JAz/I5PZxQVjexlVaB/GSE1ew3BR9hphVsdfAhYpgVKCszTcvV2FaXB0M8oqjL7RksM/QQJ0DcaWUJ0K7NIV8vBz4cfxQS6LijQKAvMZ5ZW52Gm522mfzTFgDUHTY9n9hf7lwFlRVGXKQy9cFWB8TQBMmE+Twg+5T6ZQwgJIcP652FGWZqr148+PonhdYLQDK9GPl/BBQQfsCwWCcAyW8jsPS2qgp7fkp9blvweIqfJpBDhrEVwDjEKrMsKSJlL+QrDoUdR8vobo/P1l7x2geU/uzD/cZ5WhBAxnWdIrTGfV5SlwfHxTA9e9h73hwlCAFM/wfuIdVxZhg6BJUrBBCGtFfoXZqYeHo+8locRujDoTyQrLdN6nXis84SmLx5G09tYlhrDa8/feR1gKoP+yDE8nmdmaK4O67RiXR09lUri23/yCCkF7LQiWofhdUBKCefnMyCA0/MZMUYMxwneOoynGW7xWMYFy7iS+JUhCv1hhLcew2GAkgKHD0dIKXB8OiP4hOk8wa4Oy7jCLQ52trCLo8p2XGAXT4JPijg/nZEgcHo8IQHoXwc4x/++zg5zv8DO7Lu6leKhdVzhfcTwOkIVEsfnM4TKx59bKX6l/3JdqIyfxgW6UBiOvO7nF5KUhhP9lP3rCAGWS4MPV8FWSLgyuOfzBF3k819yglXGYHgZSOA6TlSq5/svBN5DKgcPqEJh6ieUtcH5uef98DKgqDmGpOJ9EHOWr7MsJ9uVPdThOEEajveyyte/1ji/9lBaYTiNHC+zQ8ifvywWKRIcIbXKofB8dpWVwfl5QFGQTqWkxDLObClYh+A8QgTstAJSMQ/YUHRV1SaLuwym4whZSCz9erXN/RivnybSH/KVd1wyidyTjLlP4K+DXCpFuLtUfNj7AOfYOwnZduKdR3Dc2XkXgJzkQoyepZpzcdfSSLYuIqWLQpGCBOeofvQLJ2W3UkrvF/Z7QmSuol9dzt2MSFHAr7ScJET6C4Vk6LgSWEf2V/zikYJHWANi7iOJyJ0UUryC0X1MuecTsYwrpCCoWgh+H+8YXHxZBQsp4WwgNzXweIQArMtqxNUDimKhJIDgyGpNEUAKcItjXywvKpAYhUZ8G3u+68g+UnC0tnjrr1J/ISi2EDHx/K8RIlEtekHgQQnYmb2aX79OF5B2CglutfQXpgQ7ckJbZwcowE4esqBADMhjBkBWc2VxWgLy+RQpwY5MhHGZbOMW9lFTzLmcgX+iZxZksAHRBSRE2MkC+forLeEW7mSc9XnM8HqFPNa8jTkMmmMDAljHFUlKJuMoCbd4IAokFxFjyFYgkRcikZaHNf/vrAL2uUd86dW7XBXxLhDmn7m30QckkU2GYHbuhX17aYu4xQFZXJUu10zymgrwXoqRY5rZrCn7jMnRlUrBZbj85ftcrD4XwSDS5Z5IeXxdXGEpW49YZYmRi68U49X24nJvOqbE7ybY65SSvUepRdZE8Pgu3xWJgdopXc4bxWgu787t7ClGnC4K/5SzR9O1kiFlPoee7xkcI+WWySJlsSAkd4eI4prfGhwzSN3qgZiyroDedGd9nuxYNVpHe/Ufx4SrZS4FfpZdA0SiatqtnuPfOkjDoAahJPzqAcHjpV2LaMdg+fwJluHgKpPAkqI2ggtXB6lpK0uRHnYhf7zp7Y9EsPcf1ZcuNIzVgGJIdbejpHz/sMV4HnH3/gbzMGNz01BJWhsoJVAYDWMUtFLEdAVBlZsP2N60mM4T7t7fYDxNuH27xzoQGh4jwfBaKyitYCpDgHQGFrQbYuFu3u4wnibcf8r32N62cC6iaUr67yoDXRbQxsJUik5/UFxyEYPcfXKL/mXAzds91gzNjgmo2xJKaQLPSwUd+F0EBOqO/Zmbhx2mE99jOI7Y3nXMau0qHn9tYKoCZl5htIL3AmVdIIWEzY7JIHdvbzCeZ9y922EdFnTbBj6rEoWk2d+UH/t0Qgo0Hctzu/st+uOE+0/uMJxH7O63WGdCIoRgOVGXmsBvTeC7apkvub0hLPv23R7jab5ew+6muSIKhWZ5TRcaetEZZC9Qb2qs1lHI0g94+OwO/euAmzdbzGf6PQGBsiogc0ndFFTSEtiej39acfNuh+Ew4v79HcZxwvamI/C8MhmWzp6rseybQUjmQtqA/cMW02nB7ftbDIcRN2+2sLNFt60hANR1AVOYrNRUuYdOJWW3I6z/9t0ew6HH3ftbjAPDA7ynQlUpiaJQ7PEtLiuVZyayTCuenccv/p//MUxjYJoKy2lE1VRws0NV5vzRXYXhMGH3do/hicSdZWQZlw9dZvDOT2c091vYnthHZwnZWJYFzaZF/3JG+24He2RGpnMOyQG60ZgPE7r7DtPrgPqmhZ8sZMkeb1kqTEeC/cfjhO6G6t66puf26emI41cf8Ft3G2xynzZegOuSvWpVFtDKsscdgaqtEF3IubcT7j+5xXAccPvuBmtPRXeMId/DGrow0JVC9Pk6QKDZVPke3qM/Trj79AbDacTunvdQ3bDsrkuOv0u7IOa+ZXIBm32LuZ9x98kNxsOAu/c3WPqVUXGREAulmMpjcrnVlAZC8Tm0zhb7+w3644iHT+8wHEfs32yxjBb1poIAPaK6UNR+VAxDULJkaT+Ph9s3ewwvPW7e77CeqT0IjphBVWgUWsM0BQrPVhME2ONfHXYPG4yHkefwzAi9JWcVC7BHzWXOj/Ss/9E+6V/Dl3OWyro5ot02GI4z3n5+j++/esT9F3d4+voVD5/f4fGrJ7z58gGn5wEbF7EsFpXzsCsDqnVJTNfu7Rav3x7x8MUdPnz1jLefP+D7rx9x9+kdXr95RZsnZL86uHmFayjTdy6h6RqMxxlvv7jHh1894f6zOzx+9YI3n9/i8ZfPuP/8Hqcn5jKus0W9spyyzgJS0Tqyq4iCe5PzRt98cY/v/+kj3nx2j6dfvfAGGVdUO5aT/Orhrc+JJ0x8uf/0Dk9f83i//yePePjyDk9fPeP+szv6SbP4oNn4TB7iSncl1LQCAAEAAElEQVSZLKqHEv23PR6+uMfTL/n5H37xhDef3+PxVy94uyGDttu3cIu7wrqZmlJeFwCPXz3h3W+8xYd/8oiHLx/w4RcfcP/FAz1xtx3WxcK7AOccrNNIgYrJ7R09p2++fMCHfAxPv3jB/Re3ePrqBfdf3F2Vp+vqUK6WPtKUsnVlwf1nN/j+F49497MHfvef3ePDP3nC/ed3BNBvW55/G+Cch50sPcCLx+a2wXAa8ebLe3z4xTPefHHJnb3D069e8Obze6bauA52tqjzuY/5wTKfZ9x8coPHXzzla/iMu8/u8PT1M/Mnv35Bt68xTxbVhjhIuzgEx918u635+b+WFfr9Vy94+OwGT3k8LOMJ8bbDurjrNRhOIxCB8zjgf/N/+n9hgkQyGjACMAZwDkgRYvloKUo1/Zr4j78HnIdYA5CzJyl+iYBSEM4jVgbI1QaG9gESCVFICB+AzGSGUvy9BEBJ/o5WgA9IpWEZQynASGANUNYhKMX30HyPJEiaQqCv9/GbF/zlL+4ZZaYk1nEG8n1Y25pe1ZlxecuwYHu/4T30xT3P+xcP+P4Xj3j49BbP3x7Q7WuGpQcCIfzi4LyFd0DV1hhPEx4+f8CHXzzizZcPePya9zLf6x7H5zPamxZ2svCd4+evrMAs/YLiYYv+uwPeXMbfl/d4/EW+ht+84qGtMQ8r2l24lqWdJ0+5rEvM/YK7T28/jqGvnvHwOZ9HD1/e4eXljG7fws4r7Eqery04zSyTxeaWftm3X97j+1884c3nD3j8Zf78X77i7Zf3mIcT38N6lpWdR0wcw8t5wc2nN/jwiye8/dk9Hr96wcOXd/jwT5/w8OU9/fU3vId/TLXRTxPpD/iSYHyUUAmQFNzYkP1i2RcYQ0DVVdeQX1kwo1HmnFKZsxiFljlc2yBGqoBj9Gg2NVW5GTUoBGO7VI49ElKw5IRELNnl80NA1Rb0J1ZlxolpqOy5lIrCJXq66EMVEjAFlbxUdhJCzVU06U2QOTMSfF4JxbzRBCqYg/fXVI6y4XsVdcm803y8UtHsDkVRFUS6xmDpgoSXsi4RokDZVQhZ0ZhEhMwRZlIpSEX1HlFhkVFkWUHoLOEY3luUdYXkA5SUYOAZAAnGUEmFGInHSykxkNlTURsv19BTFY2MhJM5ek1KCan5R4gEKXNaSEEWaNnWcAuFL8TJ6Wv0mFDgsRQSwgtoHbOX0yD6hKqtqLBuKsTI7wUw71NIYuyS4HFQ0Z0gNKOoyrbK2Y287ld1dqHpYVT5O0PkvNYEFdOVFhRDQtFW8P6iJI0wdYGIBJEkY9+0YiVGCRhjkELEaj2m2SFlkHhdZZJPVMycDSyx0maCK00rlhJqoxFBIYqAQEgJjEkVUFIgeA+pDGJi6yGleEU7KikRAtsnl9aHvOS0SpKGZIYGKCkZt9YyyJp8xJT/PUvBUggMswfWFeIYEPJ9F0OClBpCSkihoBTvhSvqUSkkwQCB6CPKtr5miCaIqzocmdGVwOPjGOZ5lVrDe6rfWW0pshCI/18rVjIIq9fX8c/nAn3apiwQPcddCAllrRFANCFy0IVSxCoy1ID5r1JLKE0VeFEXiAm87lmNGz3zRoUEhFTQWhNfqmRW0gLIE2LwiccfGegRIoVrMSXeM5cIN15wKMXKFnKkXtXwPYrsi6+bEilH7cmcXSvET6XdPxYvpSWkFihNdc0SjM4zy3Fy2NwwRaHuyDutG05wRcWHoi40tGbCi8l2lnpbwk4r2hvuHKuuhF8c6k2dLRrlVTGnlETUMgdz077gV08T/ORQb2vYmSUVZz2qNls1SoMYRS7vkXd5wRjW2/JjHuFkWSaa1nxjJ9RdBYkEUxdMb8iGbySBqinhrUe3bWBni/amgZ1XdDdchV9KX2VTQikGDZcVv5OoeQM1OybPbO47zP2Ebt9i7Rd+vmWwbwwJpuKELDVDrAVwVTtubjvYeUW7r2Fnj3bHJI5mV9P+0ZSQQqCodS5LJwhBHmy9KbFYh92bLaZ+vlph2i2TQoraUCVdF5BK5dIaF0N1V1G+f8Nz12xKhqFv+fn1tuakVBUQCRnGwIVYURfXa7guRBfaecX2tsE8WtoYLMPRAR6DkgLakCsrhURVGyZkNEyK4fizzCWdLjYGLjAgBEylAZmu2bQxROgM72i7CnZesbvvMJ2Zsess7T2X8SouubCCfb+yNNxNArjdlvhv/PZ/GUblsGiVsY1Kw8eABAGRIqwLKJSEjQlSXCZFlpqFSIgQ/Jlj4LuP7D/G3NMrCoVlDSiNZO8u86/5YM8qcReuWadaKbhAGpQUib9b0rqShCBiL0b8h//Xf4xT9lsCQNmWGF4ICYgpoexK+AioQmVLVsgLx4Amn7t2W2GdVlYwloUK5pRQb2pad9oKplDXhKiUgCZnlrLEuzIXuJ/R3TbwzqPsKo6TproydouS91CRx3/ZMuVlc0M18/Z+g+m8oL3t4F2kKjfyHmKmKFXytEBpBOvR7RvYYcXutsM8rtjcchdcdRWQgKotABFhCpU5zwyOBwTKpsA6r+h2Na1ANw2WgTnF3uYJ3pEhrbTKJW6DlCKqDa029aaCyyHs67DwWbY4lG0NpIR6W1370z/G6yex0Q/4Etkb6iMngBAjNrcbLPOK7raBXR3aTQtErgqL2gCCvU2lVe73qez1pG3ALQGb+w0H7YYP3qqrIQQgFUhRkQpFW0AoeiOREpotV7+7+w2W2aHZNwjWo97mG7ApaOvIEHFlAFMz4Luo6TXd37W5xNhhWSw2Nx1W69BsamgjoY3IvRSFuikAKdnbSInB3yHk32VPLbqIZtvAOwLCtVGQWrIvnD2xfKBzpdrdtLCrx+5hg3lYWMJaHKptBS0IMDd1kVfdBlJqlFUJkXsrwUds7zpMfQ5EXwNh5zGi7mpOOJo3OgAUFaHlRcVJtN3UcDbg5s0W42lGt2vhfUC9rfg9C42yrQgLqDkJsj+aSLIJCd3D5hqM7h0rCjHkyVtLKEOIutQ8d0IykBkRvP4+YHfXws4ezb6BXT3abcXdYmHo11QCplKQQqFoOKGVLSfi7n4Dt6zobjYMV942eRFXwRTsLdfXgHMuKHSlESPQZBD89p79qPamwbI4NDvucKuGJCIE7i60EDA1FzGmMrmkmvvtoGgqZWpSTJFwgvz/U4wIibtPjwStBGFgQiIklnhjyj+DQBKCv4e8A0OEkAouRAI4+Gbc8UBeBXkxf4eYhTAxEmeZUoQPieKjLPpJMe9YkWUDKUFUBaSSuHmzhS4U6q6Ckor6CCMZjZhjDNOvjeHNw5Yl/G0DawPqrmGQtpYwVQGpBIPZhaQFKgYyc73H5m6DJU/Adrbods01ELzMeoCy0Xwe1AZJIi/EgO62hV89dvdbzINDd9vyOXTTQIiIstIo6wIQtFEppVE0jGRsthVSBDb3G8zjgu1DC2sdul1eRG1qFIUGtOB9iPy3FCi7AikJsqNdwO7NDvM4o9oyELzeVQCIXjSVufaZpVQoSw0RwYXIdfw5dPcd7Ew/eYpcqCujILLO4lrZ+BFeP02kP+BLCv7RUl0h1etk0e0pTNnddXB5J+JWKiSlYNoBi5FgqU9dfF1MHlmHBZu7Dn712O5brAt3hEjIJR2wqCyZYEIQdsr8WIvNnjvCzU0LP3m025ZpCVpBRE7IEgpaErenFFNF1sXTwzVZ7G47LNOC7Z79iLLhjlRK5m8CyOXpXGbNpSu3eApWBotm32AdHdpdTcxhRR+d1iyLCUHAPXJpKTqPqqGBfbNr4aYVu3v2Q4u2uCakCM3SlhAJUgsmYYA7fDux13jZCSxL3s2tVGymlHjOpaQpVEpAMeUjZsDB0q/Y3NRwq8VmxzzLi1leSPbpAFYjRE4tSQB0oeBmfp4d2cv1q88rc5eTePjwvmAaVRY8ScPyeJmJS91tc32IrhcPXu7biUtZS7MuJi/qRSkRnEe9abBMCxdCK8eByzm4COwrqRyoI6XkxKAlEBOKDMvf3LVYJ4tt7od1+wZu8UiCpTmtJSAllFB5glA5vSRbEgKzWi/0GX5r5BJvJNw9l5NTArS8lPkEQkjX/66EQLzGhoDXAAkusDDKrE7Bsr/gblYogRiQJ2dO3CLxfaSSJB9JxZZKtlAQViEQkOAdCVMQ7MVeAr5DiLxOMUAbCQEJJSVMFs4oJZnd2/76c4ALkXWyKCrNFk/OEJVKIcmM+CwLMN1EZwFXi3WxaG9qLLNFu62p9jYfH+lK0AOtBEu6Wstr5WkZZlaCct9yneizDdckJgWlgCRzWVcQcKALjZAXoMtg0eZs2m7XMF/VKCByYpE50UVKldscIifylFiHBTcPO8TVYn+7hc9gk0u5naXlPAhzawu5bWPHNecaL+hu2tzTL645sCkmSIhr9ePHeP00kf6AL+c8lskheo91cvCLp690tAiO3rMkEsbjBCmZSB8BDOcJwXsswwK/Bkz9zBzD2VG8EwKm04wUE86vA5PrDxMSgOE4IUZgHlYEmzD1M/2H4wJvPaz1mIYFKSb0hwlBJIynETElTMcJCQnTaUEIHuN5gVsdxoG/6xYLu1ICPx5HhAAMpwkiAcNhgsiIspQSlmFB9AHzsCBYj2lc4BYPby0zSkOgf1AkTKcZEJLHkOiBi4F5rc4GrOOKYAO9g4uFdw5TPyFBYHidkGLEdJzpMz1OQCQyLDieO7/wM/3KHMWpXxBDxHgcgARMxwkRAeN5ASAwHGaEGDCfZyQfeR0Wi6Vf+B7WYR5WxBjQHyZA8Lgh+PkRCXZY4a3HnH9n6Rd6DxeHZVqv19AHz++M/N0hMZ0mxJByDmTAlL/7fJ6v4q25X5BCJCc2AeNppH/0xPda8+cv/QqXjz+6SDTd7BBc5BgKCcPLiJR9mzEljOcZPiTMPc/DksfOPNBXvM6W+MjEsQshcH4ZAJEwHmekiDzu6P30PmLuZ9qeQratiBzZpRRLwJe+HoAiw0UKI1liV+xcK83HlVEq99S5WNRC5AlDorj0AbWCFIKQgwQUmjsjbXKcWQaCSJE/VwJasS+sFVnDRivIlKCV4q7acHFZ6CL33QX8zEn1/DIAMaF/6hEB9IcRMRK/563D2E/MI50t1om5mstgkWLEfJqRkNC/jkgA7618zqKjTczNFnM/IdgAuzrYaUXwEeORXsupp293yuN/Huhvnc4TvPeYR+YYu9FSCOY8M1JjRP88ACFhOI7XeyiEhPG0IHmP8TTTSz0ucDZf/+zxHvsZMQHDsUdI/O4pMms3BI9l4DiY+wVh9Xns8LkyHGeEkK7najzNSPleColZt8F7zIOFXyzWgWPIrR5utoiBzyoBniskgfk4QgiB8Tz95CP94/KKjkCCeV45UU2EKZyeeuhS4vDUoygMTi9nCK0Y9Js9n9HTT+idRbBMf1ESJMsUBoenM7TRNFFXZFtK0JMWM4TBOypvbfYYLplo0z/10IXC+YXBzcenHqog1D6lhHVZ6Wl1HtEFTmLzcg3yNkWB0/OIolY4Pp5gaqbOiASsi+O/XyyCdbAX/2okEUZpmrdVYfj5GSqgC4ll5AS3TIQIeOfhV8tFxMoklPE4QxuD8+sIYxQOT2cUTYnzYYDMPNAYIuxFMbwGTv45SFlqhf4wQpcFzi8jikLh8NxDZ1pOjPm7u0uQus8PLw8hJKYTge+nxzOU0jg+nWhIzxPKmtnKy7wiBH9dvMSQsE4rlJE45eM+ZCDG8emMojEY+xwCP9kcAk14gFscFdxSYjzN0IXG8bmHKQscH88oG4PT65B9vbz+60qAA1XbTE1ZM4/1/NrDVJqfWxocn5l6M/VLDkiwSD7w+BdC2W32j07jiqIucXo8QRmN03OPoixxfhmgMswjZpYsz58j5znQR5y365CCwifWPLJWN0P4swkaIpdgIQVSFjJJkhhZcYCAAHeQl1fCRWCW8rtSCMTfv2xwBD5+ZMo79ixjkkCW5iIBiELm7VUWMOHy2fyV5FlJWmcLoSXpRylltetlDHMMLfMKpSXmnmHop+czVHm5lrz+UjBhxUdOmMGH6xii95NM4+PzGcYonJ57mMrg+JTfY+CkbOcVIftZvaXyelkspJKYz4xOPD8PqCqDw/MZRVsR9qIl1sWSy726HGQeyPeN5H0rIzG89DA134NjaUBRaUzjCoGEZeZ9EHykenv1WGZCTebLGHo65+9+YurSYSA5arZAIMyBHnoq2C+AFWnysyvfO7o0OD72KBuNcVyQwIAA/Hjz6E9iox/yJSRLhNIwP6+uK6yzw/aeDfqbN1uW6XYtwrqirFmevZQnlVYQmmVRZSRioJhnnlbs77dY5hXb2+7qn7pkDErJ31WFhA46l6cSyqrAOjLJgnaODctyO5Ypy5opEcaYq0pPGgmkrDR0tPEs08IMyIGezDUnMoTw0W+mlKbyLgcxI4t47Gqx2XdYs592GQkMt7NDURfZg8berDKK7xFFhjpECjWmFbv7LS1BdxvYaUWzYXnclETqaUXlsrIhe0HZN/GWpcx1WMnszYIpNztUdQEBIu6UvqgUWVJMoPm/2bKUtbvfwi4Ou/sd1pVio2CJ9hOJGDul8x/F0lZVM0x8e9NRqHHXsTx122I+r6izV7UoqHZURl9V0yLzTusNM153uRy3f9jwHG5buBzTxx0XE2eU0lRPSvZr/erQ7hrYfP6nacE2l2kZWRaoABYiCz2o5BRSAhGo6oKthdtN9kSzX93tm4xs/HgN6SPk3zFEmIbJQAmASARFRMFJMGW19LXUKlhV57NQXPtdVLH+2kSGXN4Vib8jWLaV2QjDjWOCgsjVX3XF8KUUryAUlVXqCYn/Pcn8+RFKmivYgP3Zy7cF1KbG9rbDcBjJaa4MgCzUy0pTkcd/UWoEG+mrvfQ4R4vt7QZuXtG0FfzlHsavKWWNhsq7q7JlNNz2boN5stg/bNmu2POaVnWJFBOMKdgSkLwPok/k/Wahzjou2N1vMJ8X3L3ZYRl5DzvrM/cX+RoaaEsxlgB1C3Z22Nxu+R65589+Le+hFAFTmKyczwHuin3nFBKarsQyLvSe9gt2b7ZkB28bRBeuAi5tFLTRUIbpM1JKCiatY1umn7G766g5uG2xjI4+2kgltPyptPvH55UEE0+SJOrKlJmNWhGAXpSaEV6GCk5x6fMIeaWnxEwoEYrEnKoyZHPm5Ioy5x4qTTqIyJDxmCk3MT+EnPPQNRNJGAhOzFZwAcXl85XM5JcL6YhijBATpBFMlakN1mXNWZIzVM0gZ6UZlSSzSlgEfv+U2Jdy1kMVOseOFcQcVianjtCScvn8lIkuCAIREcEnwDA1QpfMQyzrIveWCLkvjIJbLLSmQCSGxGMAuaDRM3bOLpbffVqYUJPZxj7TUIKLEDmk3IdwJekIzZ0WObgORZnDxU2Ro+RyUEDBYGMRSbzhtoupNcYohjhXBuviUDQle6z1JSmDdBbaLRJiDEgpMPlEiMwmLrDmc7iMK4zJbN2KiUFSyysBK4rE3ilSVqeazFctMY8Lw7dzJJZb8jW0pBXFELgjuNCAJBM/dKWv52HsZ9q6FkbZ+exZ9DYgBnKOY6D3cp3W633hY8zK2kywCemqsuTfAjYfgwuZeJNjx6xjxqz1pEdd4sB8iFhtQEwJi2Wv1FqOA+s8AiKsZ6i0C+H6GSlmu0lIiCH3YEXCah13N47+Vu9JtfI+5hhEgXLXoLtpKUQqOOFCyWuyUcy0sMv5J8HIUq+wepjawE5EdrrVQmt9PYchkk4VfMyCJ1arVCGpvs7XUBWK71WYnJAiCZ7IX9M7Jr6EkADFFCdT0VdcdhWG84Sq4v2vDaPJICU9yL9GhErgjlCVCuu00ps8LBlm76GuCmgmtQBcfKaQE3sAjm9L+wwxpwWW84qiKmEXy/NgmQbjfaZk+YjgMm3Nky++DCvv/9XD1LwPVEE6VAIwDwt+PBfpTxPpD/pi1iBVgIgZOaeIc7uA2CEF7Mq4sMtDhwPWIsaQyyMeKYAPldkBUsLOCxTywBG8WS5KQm8vDz+i8S7B1sTrkfUqtSAAPmO2IPkwuwQnB+uJpIu8kZPnA8rNDoiMflMgKk+BSK4YM9LLeSBF2BAZKJ3/jiFACjJchSSPV4oL3o5A8xgy5i4EqixjQHSRi4GMCJRGXSf9dV7zMTv4lAO8Q4Sk/hMInIRjxi+S8WoJ4p8swfHWQySREYERMUW4Ne+UEr97uj7UAqA01mlBkoCdeQx+ddfJgLFjfCCnlFge93kc5EgzoYjXk0KwbCwVogtA5CraWT44+D68Jkj8HCmAdeTYYUnx1/FyzBgVgqi76AgqIBoux1CNK1JiPJ+QF0SlvGLtUgS890iRpdOUbSNEBHpoJeEmm9F8RMU5GyF0RtBlPFz0ASHl6+pD9nBmMZNSYLc0/yx7HWNMxAbm9/E+QETaVRISH1iJE7oUAuHXFptApnilBJ39oULi6gdl2ZfZsiojB6WkcjcEYggve03nIwOpfX7zlLKaN338zrhCv4g0jD5zjSPCBct4WdB63tu830OOT1yAmBg1pwQRoiJfZ0ssX4wxj0lO9jH7vS9lejc7KAHYmWOJWEOKtYLPhIq8o08hQgKINgAi5Wi9lDGaGQWYuKDwKxcaIVyUzFxYXoQ8diGadJ2I6LPzCqkEYl54ISZ4G69nKl7QhCHlKDVO6FILxiQKZHgIgCseMfF+yIpujmEucp3lc3AZFggQu6g1gxNIkqSv98d6/ZT+8s+9/jDTX37v3/73mDuZg2+nfvm11A2L7rbF6cMZm7sO03mGztL1FBldZq1FURQQKodnF8z5FNmSMJ8XNPsaw8uIZtsgeCaoXHY1RaE5mCTLJNNpRlHRML4uDvWmRP88YHu/wXgaCRsQgBICStLXx7BthkcXpcI8rQAk2m2J/nVEd9Pi/Dyg3tQ52FnBaMX0lZwhKYWELjXGwwRTGwDsIdWbGv3LgO3dhuD8xmTtJoUlPP4SUgLrypBx3riECkzHCe1NjcOHAZvbmhOCkowhyyWiS16p1JIrYK0RYoR3Ad2e331736F/GVB1NUJwkMpAScDmTFfkm1yXGnZasyWowHiYsLnvcPhwRruv4WYHqdXVP6sMV+YsE+e817LIQQQB3U2D8/OA7rZD/zwQERcClb55V2EMg71DBLSRmM7skZlCYTwv2L3Z4OXbA7b3HZbzAlkYTiKRpTzn+PnKGKx5B25nhih0Nx3OT2ds3+xw/P6EelsjZcuHlIK+Ts3rFXLY/Dos0GWRg8JXbO86HD+csL3bYDxPMGUBASCkyBQS5/Fbf+5Pkd0bE/7d3/sDpLstbroCf/G//l9hUkpeYKVAgMdl8pECWJ1HWSg4R+sJd3mJrQMJWlkUF3BGK7iLRSUEOBtRaAkfI7S+LGy4K+L7S4bPR068PkYopfOiL0HIxBgzxUQiJTlxS5Hwf/y//GOcP/T4+bbEv/WX/mv47p9+wOu3x6z8ZjXH5AqNyeHw3vOenKcVEBJlbTCdF2zvW7x+d8LmtoNfLHRRADmUu6g0ecmS98TSLzBlTm5ZLcPQnwe0+xrTeUHVlpzss+LauwBTKkghuZssqNi9lPrn84LtXYfX789Ugi8MNJBawa2MQ/TZQkRy08pUJYCe9G2N80u+h14HPsPyokhrBedcbi2wmqVKA3c5/qZglNpNg9Njj+6mxppjIYXkovB67rMffp4WlKaAjz6DQQpMryPam5bpUm2NlHjv/Xf/x/8tPHx296PMBT/tSH/A1zyusIvNOzBi7sqmwHCYUNUFXr87oWoLnF96Jjr0MwDAzQ7eczfqVwYir9MKpRWm84yqLTEeRjSbmiXOxuTf5cpQJHFFjMUYYEcKddYpN/lfRtRNgeFlQN3WOL8O0DlYm2ITJr5Y67FOK0UGE3ev80Aj+eG7E+pdi+EwoWgYYaS0vCbH+MXB552UndfrqrWqCkyHGVVbYziMzAc9M4WCEG2uroPnTtTOOcR3sJCSqRNlU+L44YiyLXB+GVA3xO/pHEuW8s7JzhZ+cdyBIz+E6pIAgV2L03OPalvh9HKGqQ3GfoJSGnZcEAOyUILKynVeoXPqRVFT5FN3JY4fTigbTqrKsOSVYsQ6UWnprSfQO+JaBptPE+quxuHDGVVX4vh4Ypn0PCEhYumpdHYLVcYxAdN5ggAwjQuKpsDxuUfVFXj6+gV1U+H83PP8DzMrF4uFc1moMq1ADJj7BVopzP2KZtPg9bsj6q7C4ZsDyrrAeJwYEp2TZoj4y8KTXJaehhVFVeRrV+Hw/ZFir+c+L9YmQKR8/QOsdVSfhojxPOHS9Qwx0TsaSdvDRTSUPaQJCSGxlIogri0CxNzbFAkAqwcyiQuAiBu67AMVEojIn5FLi5c9Z8yTTSKlITOTkCPLIpL4NW/pxbeKRHBD3pVe2UO54qSUwHha+G8t7TDBX0IaBOZ+AaTA1C+o2xL9y4C6K3H47oSqLtG/DgAEhiMTnKKnWMtZh3VYISEoVKqK/Ls1jo8nVG2J6bygrDTGfkYSCeuw5qAMj3V0VAEPK3SuhNRdjf51RL2pcXg8o+w0E6SkvCqyYwhwa0C0AXbk57OlUubrz/SluqtweqZwza8+V3uYHBQsxyDDzDmpjscZdVfg+OGIesNjqeoCw2GG0vk8RRBz6LPYcbQ8/tMMZSTG44KiMpheRz4PTxN0WWDqJ8QUMfXLj+l++Wki/UFfKWEeV3gXsEwrloFRTpR3M+IpQqI/zBBCYjhMSIkPnOApGbfWYTxNOb7JYZkW2DVgODBi6vw8IAmB/jBCSIHhMCKEQAl7pKXDWY95nLEujJOa+xneRdpfUszWBYX+dUAMEeeXEcEHyvIjKFdfyF1dx5WRUsOKsFqcn3tIIXB6OgECGA7ZBtEvSC5gOk1wq6f9YfVYF4txmBFDQP86Aini/HhGSgn9cw8lJPrjiBBijhOLmHuqeN26wq4WfvWYzoyJ619GJCScn3pASh6LFBhPE2IIlPh7j2mc4ayHXVZM/Qy7Op5vFzC8zkAChpcBMUb0h4H2n+ME7wPGM2O81nnldbCB9p7Ac4iYMJ5oQxgOIxAFr23M1gVL+4FbA+yyXlXJtBUkTMcZkIlRXJJxWjElLOMM5wLGw4hoPX9vdnCLzb8bMQ0rYvQYjwuQFxoxJr6H97Qh+Ii553mzq8Oc7SxTv8CHhOHMh+94GgEhOA58xNRz7DLGjLYht1is80qbj/UYDrTb9IeR9p/TBJFoPwjZpmNXh/61h50WwLF3JoXgbjJGqExHiPnnISXSiTKhy0Xm4sZInyfLjSn30C5/KFyKkR5T71ku9iFSLJa9qDEylShGynZjnkRTDLlsG6+7YfZKRaYcSYSU/44RKdLXKLL6dzhOEFJgPA0AIvrjgBBoofIuYjotWUXOSdEujveo89n+RiuR0ALTaUT0EcNxhM/2l5DtKuvqsU4LLXE5Yi6liPPrQBvKC9XzQ7aszPnv6TzRDjWvvCaLzZ/j0R9HIEmO3fwsSZHfJwWPqZ9grcc8zPx7XDD3tKZNZ35+/8pn2vnpzLjH8wwfAobTBO/47/zisIwz1sXCzbRTecfvnpAwZAtXfxgBJEznbKEbZ3hPC513Ec7xeIIPOL/wXjk99UgA+tcRWudIQvUTIvCPxUtXBbR1Vy9bt2+wzg4377aYTjPuPyPk/ObNBuvi0O1raMm0hLIumFzflIghounYK9vedFjGCXef3TLB4dMbrKNFu2dJo2xKmJJqO6af4Bq63WxqOOdw+26LZVz4u5PFzcMWbnFodjWUVKgbg7IqsVYrypxS325rpJSwuW3hJovbT3aEsH96Q1D7bUdua1tAFxpFYWDqgqWlrMYl+MDi9s0O83nBQz6G3dsd/BrQ7hpACtRNibIqsRgmegQbr+kn3a7FMlk8fH6LZVxx+8key0QlNMvFJbQiFahsP36+FEDTNXBrwP7NBsuw4Pb9Hku/4PbdDnZhqVVphbotUVQFytLQpO48iiKTae5arNOKm/c3GE8zj2GYsblrmbDRMTnGVAXKuiRWsS2RQkK7qeBtpOJ4XHD/yQ2mfsbNux0RhfsaEcSr6dLAFAZVXcIqBykKSCmzatji/tM9ltHi/v0+p3G0REhuKijNtJwih2GXdYkYE9ptwwShrBp/+PwW02nC3fs93BLQ7lsqc5sSpilgBoWqKbEIio8EJNp9C786Jgf1M+4/v8U8rNi/2cLZyPQPRRxjUZcoVod22zD7clPj6kkQuMI7Qo6Lk+kjhEIKQBiN6ANKY+AjsYBGCfioIYWAMAoS9JpGEEKSFEEcZaHJqTdUGwslMguZkBCVrTQqe1JZj6YYTSf2uItCsqStaI/hGWC5UchISlOhs5WHvcR6U2eiVoGqMliNRN2UhP7rBjGmjNNbcffZDeZ+xd2nN1cFPu+hEjqjBaumQApkOQuknHIUsH+7wzLk3z0vuH2zhVs9ml0NqRSqhmNnHRdSfhyBMACwuaVK++7TO0z9iofPbrEMhGwgRmI+leQYrEoULsDUJQQS2q5GcJH3UL/g4fNbjMcJt+94Dzf7BikJVLVBWRqUNe/DixhJCHH9/IfP7jgOP70lqvC2RQrEcOrCwFQaRVVcxzBSQrMhPpD38Ir7z24wn5nGFBaL7ibfQ035o8ao/bQj/QFfLgtQ1ixucatDWReYhxVVx5Ju3TIU2lQa62iRJOBdRHTML2XepMBqLXTO3azqMqfMVzg/Dygrg3W0UJJ9jUtJ5yJ0ctnjZleLqiwwnRaWZ15HVHWBOQcN25klKGsDPZAuYl0tUoiY5lwWGi10pTGeZtSbCufXAVVb5bKVYjnZRXjPMOmYEvximT84Uuk39QvKpsDpeUDdVTmsWtFnlqiw9J59KrswINzOVBTa1bGk+zyirAsMx5m0n9FSkTu5LGzw8JbKSTdbpERRV1EaLINlj/U0o9xW2c/KsjUSdzrBUbTjczbsOjHBw02OQeqvA8vCz2dUXYW5XyElRVAhZ6r6QKHPOlukHJQtjfwYhpzLY+N5hqkMS/BIcItHDP7qpU15DIlcdtMFy2NFozEeJ1SdwXCaIQSuJTVnA/zCXuy6WO6WxglCy3z8BU6PPUvsxxFFSSUoQLEasljNLg4pe/qE4vvrUuP8OqLu2CcvK4PhNJKcs/rr70VPkdV4ptG/fx4yyIBlUtKnKBBSEFDZxykz1ktlklESgJIMYLA+QoHABaQLtUlkuwgB9qTwJBptEnJ+aEJMyP8+QcmrlZR2MUEYvYLMJC1xtSFKkMAkIBCTyKB7/rIoaPd6/xvvUHfskwtBD2bI+aNLbk9M4wIpKe4rasMWT0cPblmVFM4o9tUvrGBveQ3dVdRjYUqqVMu2wniYUG0q9McpaygsAMHr7/31XgggJEGAXuMij7+yK3B66q/ELuaT2ixOzB7kmDN8ATjroUuFqV+vpd1qU7HlUmsK+UTOFs6lXTsxzWadLJSUWAeq1vvXAWWlcX7pUTYl5ix+9Ivnd87HgJRgV3pg18VCGoVldCi7ivdQW2E8TlC1xjzRg+py5ePHev00kf6AL6WyAVFSQBNjRMJFeUYFScxqTAFaZVICRKRAiMkYoIgoAUC6JlAwjDh75fQFAXfxzsmsgMQVZZYuSkogJ2NkabqgGlUpQfZpyg65/B5KSWLKElf9FwFA/DVzfaDUlg87iNyoYkkshkRLS0o5lYTngSWzQAZqiPSsUrDJHUT2FxKVd+GhRiTPhJfEehutBZK9LSH5GVLKj/7DkKCN+Yjuk5fQ4cRyXsjfSxCDBoEcGp0+ntJI61FEuIZNI1GsclGB8r0JEeDF4nWl/5DxXUpK6OsTXNDMnyTSryPxslBDyFw6RLYPXaAEALShIEYmWoWi51Ndm+w5VswwlYrnQCp+hgIh+uwLAhefZUwMg46RQieOU5ZDpVTXkicuvcesAhVSImUxGxInH0SWVCUEBci5TBs8rR8s4AIqK4xjpH0Fl+t7UQgj0a6RPr4HS7uKKtt4+T4AwHizeC3ZXsLts2r62s8EEAMVrYHjlX3a7GcVYF//8rOYfalIxGZm6lz06epRFIZe20//1HuUOQkJV8kcINKFyES/a8r3nRSKSub8bEi4RMTl65342YI3AKQWVy4wBBAd7T3B5zMaIxGfImX1PgiRyP5Zkbg7V1pcx1MMIQ9VAvyRMmIT/DyRBC6PMJF7xCnlxJxMqBLIC5UUOTrzYuUyji+IwQSiS3lliZGMIUJqdV2wIAFC5Rs1n1/2s4k6vfTQJYDgfY7Eu6T8UHgmAEiTa/k/oo72p4n0B3wVdYG6LVA3JZSR17LMw2c3mPoV7/7EWyz9jPsv7uCdQ3ezgRIC1a6BMRplbVBtShR1iXpTQ0iJzX2HdXZ4//M3mPoJ7372gKWnuTllJabUDAA2BZV5zaaGKQ26XYMYAm7e7rGMKz79k28xnRfcfnaDdfZobzdQiuU7YySqpiCIvS5QbysoKQhPWCwevrjF3C9488U97Bhw836PGBOafUvw+aaCKfMx5HJzu2uQfGRJeXF4/xtvMY8zHr68Jzj7toOSAu2+gS4MqrZE2dQoqgLtpoKSEt09+cRvvrjD3M94/xtv4CaH2/d7xMDyeRIC1aaGLjXKpkTRGBSlRrOtkQJyKXfFw5f3WMYFb7+8Iz/2voOQCu2ugSk16q6EqQyKpkC9aaClYmnbejx8eY/xNOHNl28wDwtuP92zfLsnfLzeEIJfbwqUjYEpDeptlc//DnbxePubbzEPE979/AHr4rB/s4VQCs2ugdIS7aaCqUtUXYlmU/Pa3Lbwq8X9p7eYxgVvfnaPdeT1cDagve0glECza6BLg7IpeP5rw9JxiNg9bLCuDm9//pDP4VvY1WH/dgchgM3NBkoJNJsSplIoKh6/UgrdTYfoIx6+uMN8nvH+Nx9o6v9sD+8SNncdj3vboCgMyq5Cs6tRNRU2t5vrA9LnRRRh9QneB6SQbRJ5QUEbD7BmOpa1DiEGWOfZB3WBWZkxIfl49ZOGkOBcRAToBY0pk4ESVpf9mCFcRUgx2ypCSAgpZQsarh5a7zIZzHqEkOCj57QsPi4+U2QvdnO7YQl+10Iag6orUFQGRV2i2TaQQmB312K1Fm++vMfSz3j383uso8fNu21uAXVQRqLq6lyiL1B1vA82e3pWbz+53MNvMPcT3v7mW4IR7naQSGj3Lco8hi/Xv940gBDY3LE8/+aLe4zjjLc/f8AyrLh9f4OYItqbFkJI1Nsassjl2a6EKQq2B1zE3Sc3sLPF25+9wTQsePvFA+xssX3YIIEBC8Yo1E2Join5HOgqKCV5D60OD1/cY+pnjv+JrRaEiO6Gz5AmPwer2qBs+QxptjViSti93WKdHN7+/A2m84y3X9xhnRZs73ZAkuSH+/CjPet/mkh/wJezHiqTdqq2hA8Jm/sNxn7G7q7FcBrR3nYInj4+U9PQXTZMlC+bMvddGLOmK4NlduhuGwz9iM1NR1N9wwQKkQSzBgOzJYUEisrAx4iyNrCrRbtrMc8rtnctTi89+5KReaZVa66S9xASdKlI2ikNEBLqlvSg9rbNRCISkuqOSS8p0mgdAj8vBGaNutXDlBrWOZS7GtOJdp3hPGO7bxl3ZTTqTcUYp9ogeZJwUvTQhjaepqsYIbZtMPYzqU4DVczI/ZCiMYiRcH9ExpoFHyGNYcrGpsRwIfOMC2PYZgIailKxH9oU2T5TMFC4Yvxd3dVYHaH7/UuP7X2HaZhyhBp3eaYiRaaoGDKgjcnJKOyXVl3N8O19i/HEa2hXi6Iw0IVBsB6mNdyVa4ngHHNcg0fdVXCLRXWhK911WMYF1baiWhLi+rmmUoyTK3k96raCs/kYZotu32I6T+j2DeZ+QlGSopRCQtkaRJfyd08oGyaH1JsS6+LQ7GtM/YTdwwbDcUCzrXCJWVCl+jiGPWPMnHUoGwO/WgZkx5AtLAI6c3bJ3GUVpsi5qUYpOB+zfYQ90hgSCsPsXaN1/n2Zqwri2ne9VFgKzUxNrRlHprWCDXlMRQ+Vmb9aK2jJ0rDRMu/8ZY5d07A+XMH5RmqWjTPIgVmhBKiUjYFbPMpKIYV4rR4UhYLzTEpaLelW0zCj3beYxgVlWyBGADGhylmjZc1WRlHSxlSUvIerlgH2mzuGhHe7FuuwkASmJZJPV21BURv4wB5/WB3Kin3z5qZhX/KGdLO6K3BBeJU5qaeoeJy6ZJ5sVRdw3qPZNZhG2mbG00QymPckWRU5r7Qh6MVUiulSVYHoIqqmxroyyWY8DdjcNOhPE6qWvXWGe2gkH1DU+pof7F0gcMIHNF3N0I+HDv1hQHfbYnUORcXJ1q2Ovxt/2pH+sXgR/DxSKXqaYecFdnaE03uqNKNPOD2eobWm4k0B/XMPbz36wwhnI4bDhLAGcmMnC78GDC8jkIDz0wAAOD2dIbXC+fmUVbsz3BqpUJ0tFZeZPzudZsQAqvRSwvH7M4QSOHx/gtQC5/z5c79mhdyMZbGYJ4tlnOFXT2VnjDg9niEAHD+cII3C6fFEq8Nhgnce83nK8PoVfraws8vydqpjkYDTB3JiX785QAiJ08sZwQeMhxluIbx+WSzB9yOtMcNhRIzA4bEHABw/0MP3+uEMABgPE5zlv/OrhZ1W+MXBzQ52mBHWiNMTf/f0eIZWCq/fn6CUxPm5R/IBw3FCWD2G04x1ofLWDivcajEO5CKfnwbgolZUvB4hBUzHESmxL+XWgDGrJt3qqcL0HsMLAwdevz8hiYTj4xEQQP/UwweP5Uzr0Txw3IxZAR1dRH+cEELA6bkHEnB8PEMWCqenMwQShld+3nQe4K3H+TCQe7s6zNOK6Dz6lwExJpxz7/L1+yOkljg99QgxYjgPcM5hOo2w04rxNCNaB2epEg4u4PwyIiVJD6VWOD6ekWJAfxgZzHCeOF6PE+ziAR+AmIOyI+H1CRnxl8veVx+9YAoNgIxiyKk8uZfKIiFLxUKk3FYAIORH5J9gef8CfGDVMKeymIIl9CSulUCCH3KpPglcCBCXMnECAJWtOIk7YZGJUwIJx8ceQlH56rMi1ztaT6hUnbEMWTV7YNDB+fEMKTl2pBY4fH9ECLw/oo8YTjP86q5qc7tajKcJwUX0L7TKnJ57KK3QP58BCZweT7DOoX8Z4W3E2M9U/C4ZGm9DDryIOF7uocdTVuD3iMFjOE5wi8N4HDn++hluZnjFnJ8ntOwknD6coZRE/3iGlALH70/5+PM4OQ6wK5Xn67gg2ITxvFBh/jJCQODwzRHKSBxfBvgQMTwPVKafFwTrProHVofxzECP8UCV8ukDXQOvH45QWuL42P+oqt2fJtIf8FUYBioXpUFMEWVdYhlm7O42GE4zbt7ssAwL6g3VrEorCMk0DFMaJl/oS6CugVvp4RzPVLoOp5HZfDOxfSGwb2qKAlIDpqDOsCgLxMjPH88ztncdhuOIm7c7TMNK9ursGIEkRFbsEQRQFAYJAmVlGOi8azCdZuwedhhfCXOYpxVlVSI4GqF1wSDrwmj2WUtmkhZNBZt3suNpxt3bHcbzgnZfwS0OulRZbCKhsrHfVBSWV3UOJd/VmI4Tbt7tMJwm7N9sMY8rjeg58FnlPovOzF5dcFdY1iYzTjsMpwG37/bojyM2tx13TTW/p1QKqiwACShDdm5ZG3JKuwrzsOL2YYvzccT+zRbTtDLIOJGJrJXOSSNUKZpKIeZg93Vk5Nh4mHD7fo/xPGJ7u0Fy3Ple0ki0Zo6pyjsqRlwxt3UcZuzuNxgPM27e7TGPC5odQ5G1UdzdicRQZXnh5QpUdYl5XtFuG4znBTdv9xhzNuslFJyB15LnTkgqzqVAkXclRV1h6mfs3mwxnKiWXOcFzZZADlNonjPBDFIJiWZbQUqBbt9eEUQx5N6pyySkjMJLKeWeMeACw7R9iJCC5Vp57WNe6DfsqfItYu73Jnj/kVCkjYKzjMnzMcFICesCvA/w+TNjCleUpg/0sHoXr3aXQjNGT6REdGGSgI/AsCAl+mwhmC5z6REWJfmwxigkJCrxbUC7JTxh/2aH4XVkRvBor7tSZSRMmc9/kdNsCuYKl1UJOzls7zaYTiNu3+8xneZrJJsyl0B7haIwhIeUBlIKlBXxf+2mxpKfP+NhxPaezO+qKdlr1AJC8f43GbBg8j1Mv/eC3e0G43nGzdsdhsOEdsdoSFMp6g2Mzrmqmd0tVVbAB7QbjqH9my3Gw4j9uy3miZUV5wmyMFnEZQrG2ZW1wSUcfh3J1uUzbI/pPGNzs0FwAWWR770iPwd+pNdPE+kP+LrET439DESgPw7QWuP1w4lm+l++oNrW3NVphfE0ILjsV1yZGjH0jBSbMizg9Nyjagu8fPOKuq3x/O0BRW1wfuYOcRnWa1QbEzhy5FikT8sUGsdHggCev3lF3RZ4fTzBaI25p29rGhj9ZGeLaZgRrcd4mrhbexlQNgVevzug2fLz667EcOwhJOPLvOWua5kt7EIfWswxTbpQOHw4oWwLPH79gqor8fL9EUorzGeuXpdphZ0ZtTQN9IsN5wkQEuenAaY2eP7lK+oNz2GZgQCQhB7YlZ6zdaLvk8cf0Z+pjj48nlBvKjz98gX1psbL90cYQxVjCAnruMIuC31vM+EEw3Gg1/U4wlSax91WeP7VK5q2xPGZO5GL124aVtjJws6WUWcxYjrPUKXG6alHvanw+PUrP/87rsQvn7Euln7Did7h6FhZUEKhP1Dh+fLtAVVb4vHrZ9RdgfNTD63A2C7nMefrv870GkYfmbojBfrnHk1b4vFXL2i7Cq/fHaCNwnjKu6d+gfcB6+xgZ4ewBKaKCMnPLwq8fvuKqqt5DdsCp6cTpJD0C1rPczivcKvPsVwBh8cTRA6rJa4vQSlml0rN8uolLACCwQMyZ2Mao2E049W0puWF/11wsZCFXFKqj5m+QqIqKLwi3Ydl2wSqfrWhQEoqEDCvJKleQkBLBV2IaxSbkDmIQctMm+K+NWXLzkVkM/aM/loniyXDFOZhQXT0hUopqXRuSzz96hXNrsLztweYiir+FLL3fA28fqtDtBHLMPMeOo3ctX04od7mMbyt8frhxGSXfkbMkWfWWbjFYhlyHOKJ0WL9YULZVXj99oBqW+Plm1eUdckdqsjxfTZgmS2TiGzA1E8IPmE4T1Ba4+X7A8qm4DFsarx8OEIqhfE4I0Z6Xd3K+29ZFvqRs3r7/DqgaAxevnlFtal5D9cVzk89lJSYx4v3nRUsvzqcjxOSjxiHGapUeP3+iKor+bstnyGkfeUIwn79Fz2a/9BfP/lIf8AXcX+Z7wmwvKTwUaUZIuDJcaXilVzTFKheDADKX1NRUh3LMlWK6YoTVCJzRC8WvbwiTjGj0KS86haF4OfKbDTPNTIqXwNX4EIAMbDkJsRFLcjPT3mXEHxOn0+ZChP53imkj7YESQqNErlfkRJ5nVkVm+EyEJEluBjiP+P9SsiBwjnImcpGPnypRPzoSSQLlN9DZguEyDJLeTHi8yCyClXSDiHAXleKuS950RAKIOXjz0phgGb+i71C5dDpBLAemXm8QvAaXNWEgirRiASRIqKnyjQlXgeqUrPKOSUEFzP3VWQ6DlXRIYarQjiFdE3kQGIvG0pe+0IylzgBBqWnlHLQMhWXWeyKBGRFNdW8zEBPGcoOnid4KCGvZVSqwD+qIikSosKXWiKOX57/lMcc7ShR8XjZ15SQ2QaDRNU6hIQUvD+E4BfUeaJSimNM5+xSkfBx1yEEpPiYTepFoopa8hgkcnkXbKfLrGTldxCXt2DaSooQQsIIIIh0Vc+z0CGgc8g18nvmK5K9qPnf5/ePiRafmM9nSvEaCsE0FPA8qo9jJ13YtonvF+JlrHHyviiYU07KSSlw/GVed8hWHeT7WyjJErTk7h4ZpB9TgsTHhc0lkJtjOl3PVQJVsykzi8WvHXqMVP6LQPdACDx3KaueeZ6yUh+Xmz2rsH3K1iJAyqzATimfn4vKn4HqWmYQxuUejgAkq3VC8GdC8bmo9Mdx92O9fppIf8BXUVG0ooyCkgLdroVfA3ZvtliGBW++fMB4GnH7yQ28DdjcdlRr7jsUlUJZGxRZcKQ0y4Tb+y3cZPHw+R2G04y3X9xj6hfs77dISaDdtVBSoOwqmEoBoqAtQkls9x28d7j9hOXA+89uMZ9n3H26h1sdNjcdIASaTYui1KiaEmXDWCaZfXu7Nzv4rJqdThPefH7HMtXbHWJIWTUsqbIrCqQ2whgFqRS6bYsYIvZv97CLw8NntxhPE24/u4VfHTb3Wwgh0Gyy4rQ2KNsKwXmoQkEkge39Buti+bvnBW8+v8N4nrB/tyM/dt9ACIILisIg1iyZAgLNvkVMwO37G6zTirdf3GE4Tnj4/J4CoJsOIlHxagqqdcu6hNeOJWYp0d21sKujarZf8eaLWwxHllhDDNjcbaGUQtNVVPxaj6opASHQ7dki3L/bwS0O95/eYRpn3H92i2WY0d1sIKXA5qaDMQWqpkBVlwhGMyJTCezuN7CW527qeQ2H04zb9zcIq0d3UU1vW6qm2wJVVSDEhHpTAwBu3u2wzAQyzKcZbz+/xzTM2N5vAUi0N20GU1QwFXdfUnNhsrndwHuP2/d72NkSzHAiVCIECrGk0qi3NZSmarrZNVjHFe22BQwXGM579P0M55naYx1tKUoJuGxNuQDTCy0RwMkvigQfIkpjYJ1HUxawIdASkVc1SpJrmyCgMpSeEwHLwlpLeB9RFgreRxSFgXUBUiRIscCFCK1IRwoxwBjyZo3igjSElCvUDAa4vILz6G5bCAg0e46hsuEYjoEl5iSA7d2GYJL3N1jGFQ+f32HuV9y83SEhYbPfQBtJ5XdTkltcFpAS6PYtvHO4e3+DdXJ488UdxsOI+y9uYReHTVbe15sGpiDQoKgNk48KMm+7+w3c6nH/yQ3mYcb9pzeYcpxZiB+V52VbwZQliiwAklIxLjCmDBFxdCCcFtx/fot1cYRKJIFu3+XjJ9wkhhyPlgQ2d1vY1eHusxtMw4KHL+4xnmbcvtvz+HctlJZXt0FRUwAoINDtCK+/ebvFOiy4/5zq/Ycv7zAPbBshJtS51fBjvX4q7f6Ar5Qi6q5E9AHVtkZwAc2uRfAR2/st1smi2bZUK+Y+QPABVVci2ID/D3t/Fnpr2+d1Yp9ruMc1/6e9n/F9663S1koRFEuMsTsnMQrpNDEJmNDQKCEGD0RCFIkHAZNWPFECGgiNEJLWAzVIThRJhfYkEk2wKZt0W1Xv9Ex77/+45nXP93VdOfhda+2n1LY7sd6nqOrnhs2e/mvd0zX+vlM5zQRbneTy91lO2/RMVxOaSnJEu24kLRJMluBDIJ8Wwg4tJRcwO7NopxnjMDJdTGmrjulqytD1FLMC58AkJurgxJ3GjY5imuJHYcB675gscvpGzPabY8dkWTL0jqzMYvpFIJ9nMfMwE6ZfmeE9ZLMc5z2TRcEweqZXcv58XojjTGrJcnGyKWY5Pt6D6wcx7naeYpHT1T2TeUlTd0xXOX03kBd5XH0Gsmke8dCIC0cGbj7L8IMw/tpTx/SqpKs7cVvqB6w14oTUj5fPFJMMNw7k0ZmmmGay4FlNqU8t06ucsZOf0zE3NMsThmEkn+T4UdiJ4zAKa7UfmU5z2ranXEzou55yFrHNNCGfpLjRk0/kM8VUdIlZIe425SSnawfB2GrBWsfBUU6yKHKEtBDmdV6muM7JROwCZZTeFItcMnBX0g6yuWRQJqk4KflRntmZeeudI5tI2ymKlL6V7NeuG5ksp3L+RYFOLChFVmY4N8Z8WkdWpjGnNKPrekiSKD+Buuk4nlrqduB0bBiGkcNBrO/2x5qu6zlWLVXTczw2HJuOuu5o6oGq7qjrnlPbczw0tP3A8dgyDCP7U0PXj5zid+8PLXXTczg1tN1A3cbPtz2nqqNpO47HmraXzw6DY3ds6Pqeuump6o6m6amanrruOFZN1IsGCScJYl2olJFc4NEJHjjGPjz6+Awd5aRgHESmNg4jk5W4bWVFgs0S6SvTnGGQ9u9HcUsKBNJJIWELiwlN3TK9EvZuuZhIoo0xZGUa+5C8d+nDgazICN5Rzgv6VjDGpu4pF/L+80mGScTlKZ8Kw3syz/HDSJ4nBBfIJ9KnJvPzOCRuYvk8wzuwVsXNw0ge+2E5yyPzNpV2scjpu57pvKCvB6arkqHpKctM9LEesmkmz6TMhGkc7ykvJIRiMi/pOhmHXD+QR7Z/mlnSzDKOnnxSfMva/VcdXdfxO37H70ApxT/9p//0V/3fl19+yb/z7/w7TCYTbm5u+JN/8k/S9/2vz4Ui7h6HlyNdPVBtK8Et6o7jtqJvew6bI34cWL/dooxmc79Ha83mYccwBPYvJ8FJtye6phfcrRLc6biucKOwNRWwvd9hrWb9bg149i9HwRbWJ8Hptg1t1dKdOupdw9CN7J9PeBeE8aoUL+82hODYPmwjI1QYn6dtRV+JR2t7bOmqntNeGMXbxwOewOZhh7WGzdstIXh2TwfcOHLYVnR1R7Wtha3YDFSbE33ds3s+gfNsHncEAut3W5SB7eNePG93VcRWGsFaTh1d1TEMI6e1/N/u6UggsIuM2827LYHA/vnA2DuOLyf6duC0qcQnuO8v33dYn2TQfD5gEiNYoTXsHvcE7zhsKvmO7YmhGWgOLc2hkfvZVIytYxOvdX2/xRjN+n6HVrB72TEOjsPTUZiP+5q+6YU1uRMW4uH5RBg9++c9Skfmq1asH7Z4L4zccRB2ZVt11KeWvmrFp3Ur17a93xNCYHu/QxvN7vkgz+PpwOgc+42wJU+bmrbqaY8tzaFlaDqOmwo/jOwexR91/XYNGrYPB5wXD+ZxcBzXR4Yzaznivse1sIB3jwe8C2zi/b+826CAzf0OPwQOL0d51i9HmkNzgSaMFklKWaYYpZjOclwIrK6meGC1KAkoppMcE0kneQyaTlNDnspn89QwmcpCarUQC77rxZQQFMulWBKWRUaSGtmhpwZrNFluyRJLOUkxRjOdiYRntZwCcHs1I6CYlJkETBtFllpMYinyNGK90RDkXOLEsX67AaXYvwhrdbc+RpZzRd/0NHVLc6oZ6p7Dy4mxdeyeDtKG3mywiWb7bgPBR/b8wHF9oj211LuKrmqlP++EPX9Yn/Cjk74DrO+3KC0MbD86eYf9wGl3oqsG6n1Dd+xom+7ShvbPwt7e3O9QCtbvtkBg+3hgGEQ90DcDp11Nc2jpmp5mJ/7L+5cT+MD6YYs2ht3zHpMoNvdbuf/nA0M3cNoe6auBeifjR9f2HCOjefd8xAfP9uGAieMfKrB/3jM6z3F9om97TrtaPtt1NLuWoRnZPgnDfvewE9buw15Yw097KbF/Q8dvuIn0z/yZP8OHH374L/y7c45/+9/+t6mqin/4D/8hf/Nv/k3+zt/5O/ypP/Wnfh2uUg6bCTkhLdK4Ws8ZxoHZsmDsB+arKWPvyGe54JOJ4BnGKLIiEQZuEtm7xXlVmMuK8nrK0HXMVqVYD5aR8ZcarJESjsks2irxqSSIpjPqwIauZ7oq6fueyayQiKcsEZxLix5VGyXMS62xRYIbAvksY+gHZouScRiZrUpc78gmqdxzai5p9jY1aK2kLKMgm2T0vegQx25ktpqIpm2aE3wQP9Gg0UZYd0opYQAj1+HjznpoRyarCUPrmV9PGEdHPk0FH0mNkFEiW1VZMaXQWpOWKUM9MIsr2cligh+FRSlRd1YSPhId3ZAkikzF84cQyCZy//ObKUPvmC5FoF5OMpzzJJnEqGkln1FW4qJU3K2ddyFdPTC7nkgU1qzAj16Y0pHte37+aSqMyyRPCSGQFxljNzC/ntC3PdOrMupDc0YncXnWnt97gjWaJDORRSp6vHKeM3SjxHYNnmKe43rZNSmjxKs3TWI7MBhrhLUblDDMe8f8aoIbBmbXU8auZzLL5f5z+Zw2mjS3GGPIJxnaCHv37DAUvIR7D6NkY3a95M9WVYcOYlMZvKftelwQhyjvEXzZeQbn6fqBYfC0MYu1anpQULc9qEDTDqgQLiHXODFbEMMGh3OBthMLvL4f8Xi6TmwSj1UHQdENEgR+zsP0zoshPkCicdpwtiKUNmfF8lBrsiLFaHkOlz48StWob3vxZ3ajtCEH2SwV7DvRGGtRVti7KrK2UZCWmewWFxIbOL8Sg5TJosCFqB+PBK40T9BWWOtaadE4e08xlx3f7EpMCyZLKYNmE/GktonBJnH8icz3JE8ufXhoBzl/3BUOvRM9eC/6XIK04SzPMEZUAyaxpIW04ayUIPrZqmRo5B7GwZFPE84RaGf2eZJLW5Z+IGOp+EKXjKM8uyFGIo5DbH9G8HLRH38zx2+oifTv//2/zy/8wi/wl/7SX/oX/u8XfuEX+Gf/7J/xN/7G3+B3/s7fye///b+fv/yX/zJ/7a/9NQ6Hw6/D1RLDjAU7AbGes9ow9g5lNH0M9MUHgni1oSKQ7scB72Ecxf92HJxwGaI129j1GBP1a0bj+kHIPBGo9y5IvJSXn9FaiADGRLs2ZcR0wRhG5zBGi+1X9AQ7BwEP3QhK4/oRo2VAU1qCl43SjL1DayTE+EyUQQgDQuAR71iFZHoarfGjv9jGWSspHypE6z4tpIuz3ZuP2NnYizFBcEJO8aOct28ltknOq/CDWIZ5PwrBI14TCrlWI1FrShu8dxitxVuWSOZQ4PsYpeUiEUepGIrOxRpv6EYJhY72huf3E8b30gw/SKLIEL+/78Qv1/WSrzh0IxgxGZCMTHH3ccMoIe9j9AxVEpyuUTh89PR1F5s1oxXDMKAjkUmpOPGMXnyXe3Hi8c5hrGS1Giuervps62eQeySSh/DyHmI49BgtKft2gPj9KPGT1udweOQ7ImUFF40XRBqCfPZMUIrcnD56ufbDiA6BtheP1rYbhNTmw5nDwxjj1cY4IY6jOAq5aLU5jGPEQeV5d53Dq4CL/cZHjDQQLqHhbpS/9zHcvW56Rh/o+gFPoB+9tE0fXY8IODde2orKhMCF4qJb9LwP8w5eHJICMPQxjLwbYx92kfzlMUbheiEVSoJNuLQfCel2aKUlqF1HspdRDJ0YIYydu3gChyDnHkd/8atVRuOGEWsNYy8kN3kf8s6MNeIRjTzsECQC7vyy3DCilY5txuAGj1ZyXqNlLAtK4aJ14Dg4vI9RctFzehxGtInWgDqOHVZySrXRYncYFGEUItU5F5Yg7Q8t44A2Uu3T8b0Ybei6QfrjMIJw8y6krm/i+A0zkT4+PvLH/tgf46//9b9OWZb/wv//o3/0j/i5n/u5X7Vb/YN/8A/SdR3/8X/8H//nfm/XdRwOh1/169fq8IGLeXvw0YDeSN6eSYyYSCsxSzeJNNLxbFkWlDBiLx3eoTT0pw5jNPWpR8VsSWMNQ+9QWjrfGBl97hwvdV5Jd4OEelctJjM0+wZtFe2pg9iwlQvSoXqH88LkHQfJ+AwourrHpgn1vkFZRXNqMallaAe0FqNt74NMCF3U6XkxQB8HhzJKzLkTRX0Qk+721KITOb93YpoevAj3ZQKQScUHyUU1RmQWOgZNK62i4b5MFn70EIRZ7AYv5umDixOJGL9ro6n3LdoaCRNONEMzohCW9Nm6zjsht4jG8Hz/hvYoRvv1sUVpMabHKAlyd3L/4+jxQxxUnTCelRJZlDJK3p2WwHGtlAysSiYvHxmZ3rloXC+s367uwQSaYxMlQ40YnbeyOBv7GFbgidctbMzgRRepFKIZttL+rNHUxxajLePghC0+iumD+M2KAX5w0o6GdpDP7GusTWhP8izH3mGMMJxDkEWEH9zl3Y39wDjKMyQEtAWFfi870Up2T0b0jgFFlgqfNktlh5/HQGubGYyGxGiMNWiNENq0JksNISiSJDpdpZYQIEskjDrLDRpIrY07Hzm3NYY0ag+L1F6kM1pBklj5bCLnT1Nz5q4SFJwONc9fvkS5UA9OxSBzWYyGUYLkgxNabN+I8X99bNGplgg+pRjaAbQs2lxkuLv42XGQ7xvHEWMtzalFayOSNSWBCMpKaESIwfXnBXwYPUN8/s67y/vvTj1JYuUdIjnIChgGWZAoH+LYI+1XMpJlAddWLSrR0neNojl14t7UjpEB7i/t0LsgbWqUxe3QSdh5e2qwVsc2pOjqFmNlwiVOqH6UyoEsCl1cdBj6ukMlimrXyKYkBo4PnfQD/w3aA8JvkIk0hMAf/aN/lD/+x/84P//zP/8v/ZmHhwdevXr1q/5ttVqRpikPDw//ud/9F//iX2SxWFx+ffLJJ79m162NppyVJFlKVmYUswyTWGbXM5SH+fUUFQKLuyVj55jfzFFa2KVGKSaLEpukkT0pvq/FvECpwOxqigKWd3PcODK/muHHwPxqikZFb15FPs1I8pR8mpFGK8Fp/Oz8doZzsLxb4HrH7GaGIwjzzSiKSY7NEvHtzcUztJwXqMg8VEqxfDVnHISJO/aOxc0MjWJ69d5z12aRAZsnaGMis1gzv5lBCCxu5oydY3YtrOHZ1QzQFNMCnWjKufjlJlkizFMN85sZCljczgkOFnczKRdHjG2ymopf57IgyRPyeUFapBhrmS4nKBOYXU8IQc479J7F7UKe5c0MrTTTRYlNNJN5fmE/5vNcrvFmjlZavEUD3Hx8jR989JOF2WqKsYpinkWv2oI0z9CJlfdrDKsP5H0vXy0ZxpH5aoL3ntnVBEKgmOfoxFJMc5IskWiuaY7WhunVFGMMy1dzAoH5zQzvPPPbOSHAdDVBa810WWASKa+mRYJJpQ0Bl+e9uJuLB/DdAj8KezwoYZ5qoykXBTY34rk8y9CpZXYzQ2nFdCWxWfObKcPomF/PCCGIX6sW5mlaJMyuZqS5lYpHlKFYA5NC2JizqRBGblZTum7g7mpG3zkW0xIfFJM8lck0taSJIbGWLBMIYzbN8T5wtZjQdo7XtzO63nG9muCcZzHJhcmdp1LqTixZarFGUxZSdp9Nc7p+5OZqSt0OvLqe0XZ9PH9gWuZYoygyS2rtZeQ02jC0g2h/h4HF9RyP+MVqpcnnOTZPmcT2l2QJ+byU/nc9RSvF6oM53nsWr+aEQZi3CvG11kZRzPMYrZiQFRnaKPl+A7PrGVrB8naBGxyzmzkSdzjFWkMxL7BZQjHN4vnFN1sbmF5PUEazuJ3hQ2B5J8z7M3t4sirlHc5zbHz3SSYl1slqgtbCovdBmOBD55hfT8U3fDmR9rEU3+islOeQ5mks9Svmt3NUHI/c6Ln64Eoi2q6nBCWxiyoxlNMCmycUE1ERaGspVxO0tsxvZSxbfbhkGByL2xljL56/Umn6Zo5f14n0z/25P/c+7eI/59c/+Sf/hL/6V/8qh8OBP/tn/+y/8vv+ZbqhEP7VeqI/+2f/LPv9/vLrq6+++te+r/NxNmsvFjk60rl9LwP1ODhuP7pm6EeuP1oQnJc8zCh/sKngLflUcjGny1I6yM0U5wI3H60YhpGbj5a4IXD14UL8UFcTdKKZrkqyIhMZyzRHac38akoInvn1lL4dWL1a4Lqe249XBO9ip5SJI8sTinlGPstJ0oTpaoIy6oKrrD5YMHRitO6Gkfl1CYh0J8QJPC0y8jwRE/jUygANcfJ1XH2wYOxHrj+5lqzVmymEwPS6xGaGfJqS5znaJhRT6bjTqwlu8ELV7510oG7k+oMVRFN9axRZmZCmljROvsbIxOi9Z3E3Y+gdVx8sGbuR20+uBfe8naKUIp/l2FQYkGmZo62wMUEmee8kU3QYR65fLxh7YfYGH5jfzjBak88z0lyewRkrmywKFIHFrfjrzleCby3v5DuXH6ziOSbY1FJMcslGLVLKVYkyKsoLEPlJ3bO4nTN2g+RBjpIpahIjzz9PMNZeDPSniwkEz+JGBrurswzpoythg65KQkBCC1JDMUnJipQkMUzmpchfllP84JjfzBjanlffuWHoepavFmI4fnU2PC9J8oximsV8S8PqbgHnnRzQ9SP7Y0PvRg6HDhQ8b49obXjeHEHB9iDB0IdKLO6qtqc69VSdMG6H3rE7NDjv2O7Eru7+6YgisDmIBefu2NCPI8eqoWlHmrajasW443BoGQbHdl/jgefNCWMMz+sDBMVuLxaXx1NN3Y9UtbB3Q/Qx9Iin9urVQrJe72YiYVtNsZkln2QkhWCExbxEaVjcznCjk/CEbmB5G9vy7ZwQNJNlAUpMJNJCFmLlvJTgiWUJPgg3oPdcf7RkbEeuPlrh3cj8ZioLreuptKEiJZ/kpHnGdDGRfnA1ZRw9V68XkmX7Wibh+e2U4IO8L60pZrn0ozylnMg7vCxgo4Rm+Vr68NWrBc57Vh+sRCaznAgumovhfF5mUZqlmS6nDN0o4Ql1x6tPr3CDY3E9FVbw9QxjDdPriRhxFGK+rxMj9+88y9sZYz9w/eGSoetZxMl4cTdHaUM+zeFfMe7/Wh+/rhPpn/gTf4Jf+qVf+lf++rmf+zn+wT/4B/zjf/yPybIMay0/8zM/A8DP//zP80f+yB8B4PXr1//CznO73TIMw7+wU/36kWUZ8/n8V/36tTqGVhi6x01FX7cc1ke0NTx89oy2mq++/5ZskvHlf/aGrEx5+OIZVODpi2fGyLhrDi3H3Ynj5oAfPet34iX55vvvSBLDF7/8jmyS8NUvvyPJEp6+eEErYc0JW66m2p1oTi27pz2gePpyTZoZ3v3gnrTM+PF/+oa0yHn48SPaGp6+WuNGz+H5SHNsqfc1hxdhbm7udxijeffDR5I04c0P7knzhDc/fCDJUx6/eMZqzfp+K6zCXcNpV1EdG/brIxB4/PwFmyje/OCBNE/58p99RTHNuP/RE2mW8vLlGpxn93ygbVrq/YlqKyzc7YOwUx9+9IRJDW+//46stHzxy2/J8pT7z57R2rB5u2PoR067hnpf0xxb9psTPnievlhjE8vbHzyQZhlf/NJbimnGux88kOYJL1+twXu2zzu6quO0PVEdKlw/snvYoZTi4bMntFbyHtKEh8+fyMqU+x8/oq1m83ZL3w8cXw40h4bm1EaGpeflyw02Mbz78QNpmvDm+w/kZcrbH9yTTuQZhhDYPu9pq57j9sRpc6JvBmE0anj3oyeS3PD2Bw9kk5Svvn9POSt4/OIJrRTbdxuGfuC0PdEcKk77msPmSPDw8naLSRLe/vCBJE/44pe+Ii9T3vzogXyS8PTlC3jYPezpGnEmOm6Eab592aOt5uGzZ2xm+eKXpA2/i+/y8fNnjFW8vFnjBmGt719O7J/3PH+1idFXRM6RurgCBeXFYCOaAvhw9uN1F1kEWvBcE40cjI0Rf+fYQKJBQwjYKPg3xuCc4MtEiz+CwiiDQ7BppcSVyESeglhPiIOS84INOy/B4ec4PM5eINEU4vGLZ7Ii4/7HT6A1z1++MI4j++cD3aGl2lUcNwfGzrF+u8VYK8/fWnnvheXN9+9Ji4SnL9dordk9Hhgi4/y0raiPHdvnPSh4+vIFbeHNr9yT5Alf/fJb8iLn/oePGKt5+vyZcRzZvhxoDjWn3ZHD+kjX9mwftmijpb/llrfff0dSJNz/8JG0SHj48hmjNS/vzmNIxWknHsH7F2HpP3+5JkkN737wQJanfPX9dxRlypvvv8NYzfNXL6jg2T3vaeue0+4k6oO6F4crq3n4wbn9vSGbptIPJhkPnz2itbShYXCc1ifqvTDmDy8HvAo8fbHGpJa3338kzTPe/OiRPN6DTQzPX62jNeY3c/y6GjLc3Nxwc3PzX/hzf+Wv/BX+/J//85e/v3v3jj/4B/8gf+tv/S1+z+/5PQD83t/7e/kLf+EvcH9/zwcffAAIASnLMn7X7/pdP5kb+C843BgzE53DuyS6kXiizxGgLs4mZ0DeOwDBFoJz4iajDd710SjbXwYhd3YLCeI34p18txsE43Kjiz6i0UkJONuNhBAdTcKZTOEu3yE/JtgikbxwdlXyMTIqeH/JXpSrURBiRqKTz7n4ee8cWiWR/CP3F2V4uOAuxAICDKMEQzsvxCnvxHHIBSFAEMSYQB5WwEVCkPxZiFbDIIHeIGxu7QImsQTnxEEoCIaslcIrh4p4slIRn41erYJvCsnDje593mUI0fklTgQxB1bce8B1Y3RSikSlELNDo5erDz6mhqiYHRlwXtxfxroneBUzQ2MuJYK3ipmOkLHkfiM5ahQM2kVyio8OMNHPRxycLkSUs7PT+bMuOlxJhujQufh+v5b1GSAgPye/xDEoIGVa786YbnTbiRwP8a8NwPs2dSbmxCYcXW7Epers9oQy8uy+1rZDEOcu572YxhPzdp1YCGnOp4nXpEARCEra9fk5eKVAC/5rlL7g8NFWR56PshDEfQoQxyyk7YvNw3t9og+S/xki9ht89Aw+32sIeO1RTvqWjy5a7twWEbeiEF2AxtiGx4v7V4h9DcnPjaYTgUhO5HyNHs/ZMUmcic78AgiooPFhxKqYLxsdgeT9KGE0B2lTiuhzHJ26nPNo4wjYS8rROcdV+sqIOl97OLstyXcFH/AuBoxHxzYB4uN54/n9INi6izi9j45vSoWYgzxiSKXNe+T9xF8u5t45H0ll4/k5/VdkR/pf9vj000/5uZ/7ucuv3/pbfysAP/3TP83HH38MwB/4A3+An/3Zn+Xf+/f+PX7xF3+R/+g/+o/403/6T/PH/tgf+zXdZf7/cuRTwecmC8lynF9JOeT6oxVtHR1N6pabT24ITlxLkszGHMKErMzJJgXGSrk3+MDidk7X9Lz69Jqx89x8dE1bdSxezVEKillJOskp5jn5JCXJDdO5OCbNllPcGLj+8EpyOL97R18N3Hyywo9BSstWk01ysjwlm+ZS5kkt86XgFoubGX3ruPvONUM7cvvxFV3dsrydEzxS0ssSuYdpSpIZcbvRmtlqiutHVq/l/l9994a+6rn5+IqxE2xQZBIFWZmRT3KKSYFJLdOFlB3n11IOuvn4irbuuPvOtZSpXy+AwGRekhVSzk2KlKxImMwmaCNlWTc4rj9c0tYdN5/e0FYDN58Kvjm/mmGSM65tKWc5eZljcyvGGSGwuJmKK9HHq3gd13RVx+r1Cu895XxCmmfkE3FFsvH9a2uYX89x3rN8taCrO24/uaGve24/vWZse5Y3c0ySSJZrfP/pJMGkltlyggowu5Ky+O0nV7RNx90nN/St3JP3nuliKq5E0xxbnEvbosWcrqY458Xo/9Tx6js39LG03dQt85s52mrB5nOBBLIii2XhKcZo5lcT+mbg+sMV3UneQ1+L05PzQbA7aylifmaaJ0yWE9I8iaVdmYQUYjuXWNk1JJnFOc90VjCMjuk0px8GyjIjeE+Ri81kkSfooMmMxRowVmO1ZvSeohC3o8kkZRgck2nBOATyPBWzkhgKkFiL0hqjjRjKB0WSGMYxMJnm8fwZXTsyLTOcd+SZxBKWWYo+L6CQRZ3rHd/5bR/hR8/8akKaWopZSZYnJFlGWRboVN4/Gla3gufffCxuRDcfX9F3I8u7uWDjs5K8yMgmBWmZkhQJs+UUm1jmqxmud1y/XtLUPa++e0Nbt9x8dBWlJGLwUkwnpElCXuZkkxyTGGbLKaN3zK9mtO3A9UdXdMeW209uaJue1esF6nz+PKWY5qSTPHIjSqzVzFYTxsFx/cGSru24+84NQzdw9eEK1wlHwujYh/KMrMwppiVJnjCdl+jIr+i7nptPrmUc/PSGtu5ZvV4SfIh5wBn5tCTNBKKYLKbYxDBdzXB+ZPFqEfv/LV09cPPhinEYWd5IabeclWI9+Q0dvyEm0v8yhzGGv/f3/h55nvP7ft/v4w//4T/MH/pDf+hfKpX5po6u6bBJQt/2mFRLwkGZcdo3TOclp11NOcmFNauklNU1HUma0NU9yuj4HZa27kgyS3MUN57d84FyltMcG3EvGoTKn6SW5lijjZHPpAntqSVJDV3VkhQJ1aFiMi84rk/k05y26i8+mkMr2ZFd3WGzhKZqSax8V5ol1MeWfJZx2jWSxHJoSbM0UtWF1l5XLWlu6Y49SWbp6jay8nqSMqU+NkwXJYf1iWKe01ZddHdSjG2PVtAeW2yWxOdh6JtB7v/UUExyTvuaybKk3jWirRy90OtVZNYmWu7BWrqmu7B1kyLluJUMxeP6QLkoxCggLo77ZsRYOZ+2lq7u0dbQtx1JTI/JpyXVvqVYFFT7hqLMcP2IHx3GKrquJ5/kNFWLNsJKTBIjzzKXZ1jOyot5+WlXY1J9offb1NIcWoxVNFUnLMmmJytTSVqZ5hy3FZN5yXFzIi8ThnaQ7EwNbd1jEkt77NCJvDuTJXR1S1ak1IeGclZweDlRzAvaqieJUpqhFxea5ihs6KZqQSvaSpimzakjn2ZUu5pyXlDva/JpStd2UhEJ0LfCbO6qAZMaulNHmqfUp0Z27yFc9nTW6PelWq2iQ4/G+XAxqTdWhqkkptjYVIlcLPrYmmhur3X04VWaxMp3WCPe0amNSUiRzWv12WNWYa1YE1oj3sWJMRACaZLgEYlYABJj8SFcjO9RCuVFd/n2R/fSgAK0TeyrVSvPoelJU2F4J4mlPnbk05zD84limlMfWrLMxuQauZ+2akhSQ3sUZnlbd8IWbzqSSSopTssJ+5cj5aykrYU97X2IbVhd3kNbC6O1rVrSPKGte4pZzmF9oryKbajIImvex2usJDWnPvdhUQe0dU9aJpz2LZPZhOOmIp9mNFUveaKjp+97jBV1QJon9HUnY0g7yFhWtZTTkuPuxGRRUm0riiJl6EbcKHKutupIMkNXNfI86habWrqqxaYpzaljOp9w2laU84y27uPEGaL0a4yys2/m+A05kX73u98lhMDv+B2/41f9+6effsrf/bt/l7quWa/X/NW/+lfJsuzX5yIBfJDsSScNzA0iYejrTsTmVU8AGayQhh889P0Q9YtRttANFyP7cRgIPjB0I8FDXXUED03VgY5/R11Kdn0r33WWlqgQaKqe4CVlxRFoTk2kjsvPdlXPOAah8hMYxqgHGzwhSii6SvI4m6oHrenqAXTUGwZFV3eioYyC93O5RsXvd97T1z3ei3REG03XDiJ8D1Iy69uO4F2UlIjZ9jBI+aptBjjfdwi0p1Y0oVEXKGXlKLR3ATeGS6l9aHv86Ok6Rxg9TdVilKZvRbM7jKPoEwcR57soaXFRV+v9SF+1cv+nlqDkOpQRGY53jqbuUETpTpQtBC9l5LEbUCi6diCEIPePyIJkMpUBwDsvHt/je/r/0DsG5+ibXnSYjehM26aPCxHRuw7RWMCP7lL2daOUnMduRClFWw/gPadDg9JW9J54mlMt7Td4dJCAbCmZj9FAP9A1HeDpapFMtKcerZToXgkMUYbhhqirHUfR88KFBOKcGDF4L+9CaU3ddGgdqOsOow3NuQ0OImsaetE3OucYvdxb143oaMSgteYYJRlt06GUkjbgRdYxDqKvHKJMZ4zPpInPpKo7lIJT1aNNoOscKMXYSznWjSF+NpKNvJSA26pHWU3bS7scWjGBcIO0pb4/QyOesR+irnnA+0B96qIcqollflnUjr1DBXCDyFmGdsT3UvLsu0H6UDvgxiDnN+/DJNy5z44OvGd04wUuGftB5C7dQHBcTCjaWq6jrWUMcaNIdobYTt0gi0WlZaxyzjE0w/s+rBT9cD6vPKMutoOuGy6w0dlso6t7nA8yCVrF0PfoRIvcKjj6dohyrLMMa8AHh9aKvu5lDD11eCf9z2hNU8vPZLPiWx3pb5ojnPVTTiYy70WrpWNjQTSKIWJn9anBpIZmX2MS0UoqxIDbOZnYvAtxwNcMo4QJB+/fi/6bTnR+p5agwmVAHXvH6NxlwB16T9BBXNQDjN7RnNoYp9aQZrKSDl7JRB7kHOeYJWU0fe9QSjCJoR9QPlDvG3Qquz+0TBL+3PGdk522jpgIPg70grc0p5YkTTjtK9lJVgMozdiJFrfrxtgBOzRns4jA6CMuqhR1XMHWh4agFEPbSWeMg0BbtTIwDqMMbBHPClrR1qIJbQ4tSZbS1vHa6x4/jAxNTwhRb2fUxYxiHD1uGFFKduPGGtpDS1CKLi50xt7hhuico2TnqVQEdiJO1tU9hEB1kLi7tpJ31XdiZNC1vUzKzQAgE7KRRYMfRexfVQ02MbLLN6JZPU9s3stuEY3k35og+uPgCd7Jzt1YmqrHJLKDCkrMClwU93vnRXwfFH0XJ81xjIYBoie0RvSNOjF0TUdQssMAznApgOh+I958xm1F/ypzbTeIkccQzR9659AG+ku7FxjMx691EavVShZ/Smn6cRTjiNFdsD9ZcLmIqUUs8WvXMXqP1kp0r9FIAC2fRcPoZLFyNpfQSlPOckKQtpJklvrUYhNFU0ubGeNEMrajVD7qnqCJBhqxfw4ySVa7WnTOpwavAkPXXVKIzlpqWSSPsZISuRQuUB1lJ1vtG9LUxOeu6ZuBMDpZvAFd3YkudRgxyHMY+4HgAm0dd86HeP5WFu9jL1Wv7iRtyo8yhgUXF51K09U9aSpVL5MY+rpHFgWxD7cdEC6LVt+PMiEPnq6RxUxdNZh4fqVFX4oX8wlpf300AxklrenM1/CBvukwRmw+k+xbZ6PfFIfNEhJrKaZpDNZNQQWKaYZzjum8IIxO0kG8yGU0SujySiyyTBSjJ6mJtX+xEywmUs4tJjkBRVFGG8AsQUV7viwV3aS1Es6cFanoVGc5zjnKaSnpF3kCTqy7ghKje21F7J6c7f6shHWLVR4XI/ViUhC8IstSfICssBd7rjSeP8nEKi7NU9GlTXMxcF+K9jWfFvH+UwKQ5ynKit2gTg3Kymc1mqKM9zsVW7/pvAQXKIoE5QOptVKei3pDYywmlbDlbJJKMsssZ+wFQ3Ojo5xPCKMY3Wsllm7KqIvNm+jwCpTVFEVGUFBMCjGBnxQQTfIJUJQpShvSzJLlKUlqRf5iTAxHhixLoyl9wTh6ijIXi8YiETu0PEMpsEZhEotRCp0YtJL7RyFm986T5dEUPU8lNKBIpAwZ5VNJJtdgrRG7t/A+JFzeXZD2EAJ5IbKLPE8xWnBDY83F3k4rLVIqr5gtSrwTg30c5JMMHyT4OUSrOm0kBqucZNgsYTIvLmzXELiEmCutL65A1mqsIWaQGolbQ3xtjTL4EMQC0xq0URgtvr1axTKxEfJXYizWRjwUxDkKIuM2hkcn5/xSJTFxQcrL1pr4/DXagDYxXDteo5FImfc769FRTEWbm2TSP9LMoq0lsRab2WgVmIBS5DFQYTIpJQyhzAlBkWbRSjK30R402uxpi00MKCW2f1oxmecEB+W0wDlPmkrfzcsUT+xLSvpwmp8t+jLpB5kQHxdXM/zgyCZi0ZkXmZw/i8HsaSL2ftZcrAfTMrkkNI29ZzIrCE64Cd6NpHlC8IEsT2OGq8LmFhulMEqZOFZ4iqng4YvrGX4YxWZzDKSpaIazPMWmidgupiaOJSnKB4pJDGEoM1zsQy7E8U9JO/yvjPzlN/sxtAN9DPYdBtnxGaPZvxyxacL2cYfJDMdNhUnF4cc52bUOfY8bR/pWylFd0xGCBEzrzLJ72mMzK2G4VkKhlVLxO5yIxLuesR/pu4FxGMVRSCkOLweSLGH/tMemNp5f3IoCnrbpZRU6jHRdT9/Jd+CDhFOnlsPLAZtY9k97jFVUB9lFt6dOVq3tEK99lFLuMMZdquK4PpKUKZv7DTYzHJ7lXtpjG0veHWM3MnYDQzUwdCNt3eG943SosNawfzpg84Ttwx6baKpdDVYwPRc8fTvSd4KTjO1I3480R8GiDy9H0jJhG+9/97iX0tqhIQRoq46hGxiGkb7uYsB4Q3D+cv7t0x5jE3ZPB5LExl2EuDV5Lzv0rpaA9i5+RxerAcftUQLWH3YkWcrh+YBNZRcXnKKvO/rB0feOoesZ+pE+YpD1ocZYze5pT5om7J+P2NRIaPT5/E7KZkPr4nmHy/mDgtOmIrX2/f0/y/XUx4oQZEcyjlKOHAd5hs2pY3ROdglWxc8msR1qji8nweVPLR4pX4+97JRPRzFa329Ol75hlLgOzWYFiTIs52I8f3s9xbvA7WoKPjCd5thEM59lWAPzSU6RWfI0YVrkJNYwmxVobVitJjgPr6+XjM6zmotZxGJWYrVhMStIE0WRp5RFQp5YJmWKUZrVQrTWN1dTvPO8iprO5bSU+LIyRykxkMhjHJkQhBXaKF7erjFGxzbkJVyhl2Dvrunpe6mGeBdD2hPL9nlHkiWxLynqQ43W4nTmnfShrm7pe3FMGkcJblBKc3g5kmSxHSQJp63oX5tjC0GqO+M4xr4jwd5t/fXzGzb3O2yWsHvcY63itK1QWoLF5fwSMN/3I109MPbDpYR8WB+xmWX7uMekVoIfrKE51qClD7nBMQyOvu7p2kEqPM5RHSuMNeyf9qRZyubtliRLOW5PcRctY1jfSjD50I3y536gjdDVYX2Q8z8dsIlh/3JER7e4gKarOsn6/YaObyfSn+ARQETQNjIxM4tNxeEnTUWsrbRmspTV3OxqhvdeBPo+UC6nGK0kHzCVbEmbpeRRZG2NEcN7YHEzJzjH4nYu4uqbGQQlriCJZjIvJEEjCrzPRg3aqmj24MXhZPDMrme4Uc6vNEwWRXQnyciyJLqsSM5pPs0Jygsjd/TM7+Z4L0474IWxnGjyMou7tIS0EJemvMxFeL2cEpwXVxznWdzMIEC5mmISEaiLOUUhAu08IZukJImV+1diIhDGwNXdkjBGY4Czw45RFLNcnIkmJUmRXtyetIkib4SR7L2YLQQv7jAoRTkvsIkhLTPSLJHvKVMx25jL+aeriTir3Eyjw8yM4IPko2pFMcuwqRg7pGVGUmTk0yy6L5WEUdyQvIvOQl7ccVDy/G1k89o0IckjI/hstqE0k6XE861iLuzsdkbwXlyJrLgTmcSSF7k4PBWJRGcZfTHNn69mhBHmV/LZ6VIclqZLeYflNCdJDEWZS1ZuKq5LShkxyhhHZtczwhDdsUJgspxgjQj480nKOX1e7DMdh0ONJ7A/SLnwcXME4GVXMThPXbe03UDTDgyjp+l6Ts1wiVobR8/hILFmu32FUoHH9Q5CYH9q8G7k1HR0w0jddlTtSNePHKpOotbqDh8Cu4Ng3i+7CgI8r48456janqF3VG3H0Hu6YeDUCLaHUrEoL8fZFciPTvJ5Ry/GBDo+/9TKOBAjA/Miw1pNPivwAWbLUljVtwvcGB2ulLwfnVjKaUGS24vLl80Ssmke3b9KvHPMr6a4Tn4PXomLmY4uXamlmGfYzAgrv0zl32YFQWkWt3O8g8W1GEYs7sQlaTIvMKmhnBck1pDm4nCU5FYYwVYzXU0JHubXc7wLzG/nOOeZzAsxUlmUMv5MMtJM3I2yMiXJrUQpxqxV6UMzGUtu5+LiFpng5bwgzSIjvJDdajnNxahhUUi/X0o7TPPkW7LRb5Yjn8okV0yzWEIrGGJiRlN1rF4tGWK+6DgG0iKR8F9iGRb/PgtyWuA6KQfXx47V6wVd07F8PY9M2wy0wSTiJAJSKiaWCp0PlHNJDJnfzGIY95y+7qXRD460lJQObRRZKWkTeSxZTWYTfJASTlt3LG7n1HUXA6W9pL94j01jGfacWOI95bQgKKHVD93IZJnTHmpWHyxojy3TK0mSSYoEZTQ6ickZBikRBXFbcYNYAEr6zYymasQlqZVElYDIEWxmSVJxhcF78pk4CuVlRle3zFYT6n3N8m5OX7fMb8XmMClSYQ9rYhlKSSIKyGDjHZPFhK7q5R3WEobcdx3lQmzfTCqlvOCRUPQQpIQaoJjmDF3LNDKFbz66ojnWzOPAlZVSRkvyJAY5KymdKvl9jDmTfSXvvTk1XH2woOs6KZsGKWEmmcEYJaU8ZUjLnBBiOXgcmS4lk/Usw1ncxfc/TdFWSnHn82eTnBC8lNJ8oJyXNMeWxe2c9tRw9eGStmqZrkoxQsislOM1pFkKQTJih95JsPfXCCA+YpE+hPfZkQGskUCFNDGMXnxyhxFsoi+5l6OTsHvvfNTAakYXRC8bRBYzDB6bCAEtTTRuhDyzjC4IMziIlliIxPLnM2t2dIHEWtp+IE0l1D7JRCKTWiOsYfWeJfrhz7zGjSM6Mdgo6ckKST1KC+kHk6lMlNPVhK7uRcLR9OJ01I3k81LY+1ZLOTOxkhxkFMVE8jqLacHQDMxvZ3SnltXdnPbUsrib4ZyTPpRIWkuWJ9LuJynOO8qJ2DBOphOaRt57WzWsXs0Z++GCKdrcYjOBKpLsPRwTfKBclZJcdT2lPbWsXsv5Z0vpw5K0BMYa8iKV8aDMCATyssB5x2RW0pxalncL6mMrDk9NL4vhACYulkHOH4K/lMOLWU7fduKK1PQsX8n55zczgStmGVpprj++/pZs9Jvl6E4tdXSV6ZqO41byJ7fPR6xVvLxbkySW56+kLPT85Ro/SrajGx2nXUVzaGmrjuPmJKHFL0c08PRmgzaKp89fSFLL85uN2KLdb/CjZ/98pG9bmkNNfWzo6pbDyxHvveSepkYcfqzl8fNntDW8fPmCIrB/lCzLw/Yk+ZXHhsP2SN/27NZHVPBsH/Zoo3j8/AmdWsnSNIbNmy1+lJzQcRhpTi2nQ01bdexf5Ht3j0eU0jx/tSHJE57i/a/fbFEaNo8H+mFk/3KibXrqQ8txfaJre/YvR/BBSkra8PJGHE6evtyglWJ9v8O5wObxwOgG6qNkKLYnyd90Tq5NacXm7RaTJjx+8YxONOu3WwiK7eMeNzj26yNd3VEf24sry359hBDYPR4wxvD4+TOJtTy/WaONlhxOJ1mSQ99z2tc0dUdX95y2FeMAh42UYd/+6AmTWZ6+WmMzw/p+RwCe32wIIYgTTdVSHWqafY3rHcdNTVDw8maD0vH8ScLzO3HLkSzXwPbhiOtHjntxtWpPLafNkWFwHNYVxsDzVxustTx/8YJNDC9vNngfeHmzkff0fKCvO6qDuFt1dcd+fSIQWN/vUdby8NmLOGp9uUFrxfbdFoDt4xHnRqptRbVvaI4N63ebS98ICDnIRdG/52zSHxh8NL734IJH4k7ExGP0YmTgfYw1i4YFTlwK4qQsphESPCCmBxJ6EI0NIrHpTDQbz2YEwcdrEqMTHw1AXFDCRI2JImfDAaIRg7aalzcbgWvi/Z9zWk+7iq7p6aqWw/pA33Rsnw/4EHh+s8EYxfqtQBzrdxuUgu39+RkeGIeB5hjbwLHlsDkRQmDzboeyhucvX7CJ5fGLNSaxrN/uMLEfjGPMsq272P5PDO3AcVehQNp/Ynl+u8ZYy/pe+vTm7RalYP98FHes/YlqW1GfWslQHSVDVWvpwyYxPL9ZY1LDy1u59vX9BudCbEO93MO+om9GDpsjOsDz2y1Wa3E6y2QcsFbL+Oc8+8cDfS+5pW3V01c9hxfJQV6/26FA7v/ch6zh5e0OlShxXouT8TdxfDuR/gSPABf3FYUW+7NE4/tR6OV9jLwaHCZRKA3ELEdJcIn2ZVEArrUWtw+r8Z1DaSOxZlaLZkTp91FfCsCcDVsiYQOUtbjoRBJGf4nPMnEVffFK8VF6oaKTSogOJOf0hb7HaKHba6NwbgQt53dR76IU788freCSc4xSjHMLMYLNGCMsXhdQnrM9CyE42Wkq0Ru6waGMkbKNRmKcrMYPI8GEaDIkVnB+DOCjNVzcQFhtIsNVmNNeB/zgSYy5SBq01sSckmhbJy4pxhjC6FAxckoi8ABtcP0o54DoaAMEIcr4rznSaKPizypJg9Hyd7QhxAgqo1V0aZJDBXV5jiDaSD/6S6ycUhKjp+K7wokjTFDxWapwcZwxStJFAiJHQgsrXFlNiDF7Z+KP6PLk3DG/GgjoxEhcleJyzX5w4h51/pn4ClEqapTj96loyBDbVPDhklY0DtG9yb/PDMWL29UYdcrOievPeJ5so9GNdyIvGUOMwIttyMXUlcF7nBc27xDj03yQidw5kYr56Pzko0POMMb4uUHO7waRkIxRxgSarvf0MfVF6fcOSsRrEseiuBiIGtfgwCaWMEpE4dg7zlGFypj4WR/7Mu9drqJFotZiXaiQ6DGMtH+t4oIjiCNWcOJopkI0kVIynvi4mx/diIqMcmOVPEP9nkClwtk8Qxq2UfJdWsf2r2O8WyK/26i/BWEyeydRi2enLXFikgoEifQliQIUFrQfx/NjQsW+oYKWPhjcpf0bq2KcothAqiDtT1kt7k8XJvw3d/y6WgT+Zj+kW0W9mXPSSQfJs1RKE+M6McbgexmslZGPaIgr77gC9j7a2MWBSSvpWLERaSvRQd6HOKGpGGMkA4uPFnwu5pu+d5jRMd9Tvvts2+bPdmvev2+SXizvxF7vvY9lcAFjrFj6+YDWJuabhsuEeC6zjOMZWwqooFA+yMLBuYuo/ow5aaXwThETTnFeDB9AOpE6421xYMAj34sI98+TQHAeb7TIYOIiQ0VjAO3i5Da698/be3S8aRckK9Y7z+jkGblRpEbi2xrQWgZGP/qYJQno8+AueroAnHNKzwQVreT+ldYE52ShFM7mbrJwcS5eM/pivTgM7vIMA4HgnQxu5xH8zIw9/92BV/Lch7ijU18bZ7SWhZgI+n20dZT2ODq5fmM1XrZ8hEEWAupry3AbFxcEkXSc24tM7O8XYueL0xqKPCFJNUZZsszQdyOLWclmf+LuZsp6VzNJhIWsdUqRpaCRRQ8QfEKaGrLEMI6Oq0XGoeq5uil5fjlwvZpRNS1JkpHFSLQsTxgGg1bSZvNM/HjzLKHtR5aLkt2+4WY5Y7s9MSmlTD81GWWWoXQf2bwaRlmQdG0vMYjDGBetKtr/xQWkP9sjvp8gnZN3eG7r4dy2z5Z50TPw3IfC+67EMMqkGZQsHsLoL2YMWpvYh+NiWskCQSrgIS7qpW0oNBi5hnHwl6zgS5tQcLYwvOz2Q5AxRMUJ1gfC4CWrNEqMzosHFasM8hXnVi3PITgXJ8o4PvqANkZkcR6UNr+qDclnz33CxwXa19u7glEmarFcDJdJ/Zs4VAjf4Nl+AxyHw4HFYsF+v//Xthb8D/+3f1smsWEkKTOqbS1ShNRy3J64/fSG+x8+8uFP3/HVDx54/ekNh/WR+fWU064hK1NcP5JGbC8pMtE0upHZ9ZyXNy+8/t5r3v7KPR/+9C0PX75w8+EVh03FdCGONWlucaMjyVPag+hUlZY8ydtPb3j3w0c+/JlXvP3BA3efXLN7Pgj+uavJJpJknxUZfdOTFqmIxglMrqasv1zzwW95zVe//JYPf+Y1j58/c/3BiuOuZrYsqY9tPL/IQ5pjK+cH6kPH7adXcv7f8pq337/n7tMbtg87VndzToeGokzp+pGsSBmagbRMaI+dWNEtS7YPG15/7xVvfuWeD773isfPX7j6cMlpVzNbFrSnHpvJDjwvc6pDQ5JafBBW681HV7z70SMf/PQr3v7gnrtPrtk/HVjezTntaoppRtcOpHmGHwbSPKXaS/5nPk3ZPR549b0b3vzyPR/+zCseP3vm+sMVp13NZFFGZyk5f1bmNPF5jIMYKqw+WPH4+ROvv3fHux888Oo7t2wfdyxv5+KcNE3FUarM8f1AWqScduJalU9Sdk8nXv/UNW++/8CHP/2K+x8/cvPR1fvnf2pJ85ShG8gnGe2pI82siOMHx/L1gofPnvnwt7zmzS+94/VP37J+u2V1t6A+tOSTjK7t5R6GkXyaU22rKINIOa5PvPr0hjc/eODDn3nF/Y+fuP34iv3LkfnVjPokjj3f/a9/hzRNCCHwZ/6D/ztYTZZa/s3/xm/FOUeWJvTOIwUZhQtRxzl4RudI04S265mUOU3MQ5VVk8ichuF9QHwgYK1UG9Cy8237kWmZ03QDWWrpBjHESKzGjZ40twyxKqJjlcVYxRDPnyWWpu2ZTnOaRrJr/5//5Ie0vec61fyPfvsnvP6pO776lXuKMmH7fGR5M+N0aMiLhL4bycv3fUj04YHJ9ZTNmzWvf/o1b37pLR/8ltc8ffHC6vWKalcxWRSS81mk+GEkKzPJ4U1EjtMcW24/ueb+R4+8/t4r3v3wnrtPbtg/H1jE82dlytiP0g7aITpbtaACk2XJ5p30oa9+5Z4PvnfH0xcv3Hx0zWF7ZLosaY4dWW5xgycpU9qTOCyFqPu+/eSadz965KPf+pqv/tk7Xv/ULdvHPcvbGaddQz6R9pcUGWM7kBbJxTUrn+bsH3e8+qk73n7/ng9+5jUPP37i5qMrDtsTs0VJU4ku148j6bkPZZZxjH3owxWPP37ig595xdtfecer796xedwxmRX8d/9n/x1efef2G5kLvp1I/7nj13Ii/T/8qf8Th/VRtFyFyE0Wtwt2T3uWr5bsng6sXs3YPRyY3c3Z3u949Z04mH0w5/B8EJKNF3edclGyfdizerVk/7xncTNn97xncTtj+3Tg5vUVL2/X3Hxyw/Zxx+xqIuHNiRAXTtsT85spu6cjVx8s2NwfWNzNpeNdz9g+7Hj1nRue3q65+mDF4eVAOZ3gRnFgKacFm4cty1cL9i9H+ezTnsX1nO2TXNfmYcvtJ1dsHvYsrqYymCeJyHzWJ+a3M3aPe1avF2wfjixfzdg/x+u633H76Q0vbzdcfbDksD5QTMsYOB0oJxnbxx2LuwXbxz2rV3N2z0eWt3N2T0dWrxds3my4/e4Nm3db5tczTvta4sQSQ7WvWdzM5Bm+XrB/OjC/mbF7PjK/nrB/PnD3yQ3PbzZcfbhk9yAWguMgO9C8TDk87+X8z0dWt3MZNO7k99XrBZu3O+6+c836fsvydsFpW5FGElV7aJndztje71jezdk/H1ndybObXc/YPR64/uiKzbs11x9fs3s6MFkUDG0PSpMXqbSd1yv2T3tWr2ZsHo8sb2fsnw4s7mas3+344HuveHmzYXE747g9kRWZCNurltn1lO3DnsXtkt3LnqubOZs48G4f91x9tGT7bsftx9dsH/bMliVt2wOiFd0/n9vwgavXCzaPB1Y3M7YvBxa3Mzb3ez747i1Pb9as7uYctyd+++/+rfS9uOP873/hP4FJTppZ/s3f+2/QtQNlmdLWA0kqtn4KqQxooxmGkTRJ6LqBaZmKA5EWg/1uGJiUGV03kGUJXT9ijb7sVFyEEIZ+ZFJmNK2YBbhYIk4zS98NTMqUqulJrZXdv1aX3Uw3jBRZQtvKz7XRgen//Ys/om0dc+35I//N306zr9Cp5bNf/Dy24S1XHy44PB8pp4W4MA2OYl6yfdxx9WrB9uko7eBpx+xqxv75wOqDFeu3m9iG9iyvp5yOEqJuU0O9r1lcT9k87Fl9sGT7eGB1N2PzKAtA6UPXPH+14fqjFfuXg2g+xxE/BspZxu5pz/xuyf5xz/L1gt3jnuXNnN2LtIPN/Y5X373l5d2O5fWE066ORDhLfaiZn8//Wvrf4lr60CL27duPr3l+s+b6w6VYGM5Lxk7CIPJJJp99tYj3K+1t8WrB7nHH8m7B5n7LXezDy9sF1a4iyRO00TTHcxveMb9dcHo5sLxbsnncMY/9YPVqyfHlwP/8L/0Rbj++/kbmgm9Lu9/AcU63sDbBGHMpp2rzvrxrtfwbIVwwLVT8mRDwRsTVZz9JFQXkaBGgBx9AB3SiUUZFMbS5lOBM/LwxVrAcJ+W6c81IW6REEmOpTCy96gS81xDjrLTRYM4lK8FlQyyx2kSLuF1rNAptpMSqbBTUGxvPr8FpTBKR21huPZdvFLIzwYvPqpSoieVsMVfQ8TvPpW5/jpMx6oLJ6kRHYwn5OZsYEdfriDnG61ZKynsXPAp5X1rLMxPMRcVyspw/EjbR1kiZNJbolYl4tjKxhCwMRvlZjTE6VqLUxSRARRMACGiDnENJed9ag9Pm0hZMakkSI6XjwOX7QvCX6/VOymfKSIlfW8HnlREDgss9a4VTgmWfDb6tlvYTAWJxjlFEOEKhjSzKlNI4L6xYKbNKIoyQdIKU6a1AGCpRqFELY1efkVbB3NJo+tFbJ163WkqOwcuu0ykVS7ejMIrH8zuQ0mliNeNoSKxhHL146Koz1i/4uXMBq8VcIrGxLIy7sEu1UVhjSBIFo7ThoALBKWw0b+it8AiMcyQRmsF1ENObzpN7QCByHUumSgEWVK9QJrYhwCN4vria6ViqBK0F0FRojFbxHWpsEj2JtUYZMVgJTmLgzp7D6nxCLe9cx9qusJ01QYvbk9JypTq6AqlzDJ2T3bw2536s0FbML0x0vdBWo7RBoWLKj4xZ5z4bYiKR0kp+LvYjrRXBS5s3xshYYTWMAsucS7w2NWgjuKjSZ+xAXTgc2sp7vDwfLXCE0mCVcEhMKm3TJN8cBehbstFP8NAy1ksnURC0YEVJZvHOY410KZsazkjkOaJJx8Z6zloMXrwudWw42hopYxlLcIEksRHQlwZ97qzEQT2oMzYpgzNKJimlPDaxEp+k1QWT0IlFktakh2qtQMvPhDGIS49CzhuJL6OPnSgO4ErLAC3SBhlovR+i5MHJtcOlVHSZoBAZi0I6ZvgajiJkJoe1cr9JYkXikdoLtmgSeXaK86Rq3uPJzglJx3tsIguNJBE3FpMYSflSCpudFyE6bk7CRWoxOh+NzGXgCSqQpImQPCBO1CJjQGn5TiMDafBBJmcvz13F9+Gdx1oTPXwUOr6jEAd1rZHxFs/QDVgtE782Wtx+koTzoKbPE6iWZ6C1ukzwPrjYdvyFvJYkNl6XltcfiRwqvnv5DnkGKAmyTlITSSyCWaeJITjiYI9MwiFO8hEjlcSUSHpDXIzO0XcCjAl2G/CghCWbGM3gPFliRaKUGJnATWxDVtyOZPI5kwtkN2q0RBkmVjN6R2oM/TCSpgrvFWnE9bWS56GULGDObYDgsIlhHDypNWLonyT0oyMgJCudJATvpPwf29YFg4xaKqP0hTAXcNEZKRKOQsDm0TUstXH9HLkSxAWhEtLN+bo8jiSRydTG9plac36EkZzDZUEkZvgi70FHHDUojI5m/ImJbdjiYszd1xeZZ4z2wncIXrJgg3zmPJZ459FWQusUspiITUhGtUg80FbeT2Klv8mCC6wVGEpDnFzjIvD8+YiLCjlK2q5NZWOQWCtyprhoVWjOCT3fxPFtafefO34tS7t//d//29THVlZ2iSSKGKXQueG4rrj7qVve/eCRD753y+PnzyLeJ67otWXoetJUVoTDMJKmliG69cyupry83fD6u7e8+9EjNx8JNnm2g5PB3DP2Ltq1iSm9Qia36tBy++kVD5898fp7gu8trqeM/Yi20sF9tExTJu5gjRi7D8PI/HrG+mHL3Sc33P/4kbtPb9g/HijmecwrDII3OYc2RnR9zYhOEbP5Y8vNx9c8fv7EzSfXPH+1ZnW3oKsHGVBiNqhN5VrwYFITje5F6L592HL36S33P3rk9js37B6PlDPR0AaFGMR7YRlrqxkb2dWAhAlcf3zN44+fuP30hsfPn1i9WtB342Unj/KEEEldTtiqYiwPxSRn/3Tg5tMb7n/0yKvvSCm0XJRCzjHCgnXBX6oQ4zgKKcmNdHXP1Qcr7j974tV3b3j8/JnVq0UscVqZW4KHuDvFy4DTNVJmLWYZu8cTr757Lfj2d2/YvN0yu5rgBo9OZLB2IWAVkek8XCbPvh1Y3s15/HLNB9+7490PH7j9eEV1bC87Th8JIbJ7FMZ5V41RI2w5rE/cfLTi4bNnXn3nhud3G+arScxlld3UOIz8Gz//05GZbvlf/x//AUwLMgO//7/1X6PuOooip2t7lDZYrRi9w2gtXrJJ3LUYAI3S0A8Sq9a1A0WR0bai9XSRGGeNFvJMoiUAwsdkF60uCT3jECiLjKptKfOUphtI4g7a+0CiNU0/oK0mjAGlhehiE03XOf7xL/6Q9thzV6b8oZ/9mE9/28f86D/5HDTCxo9VD4V/v7MKkhTTteI4NltNWD/suPvklvvPHrn7aMV+XVMu8ovpu1YxZlyJXWRf9ZhE3kl9aLj79Eb68HfvuP/siatXc/pWFgDex+oWACqSxkz0/XVMllPW7za8+s4N9z964va7N+zu90wWpeyU4851HGRMsImhb2MfCoKRXr1a8vzVmtvv3vL448eoKx6+tguNJEarYJQ+PDQ9PnjKecnmfs+rn7rh3Q8euPv0hs39jumqvDDaQYw7rBF98tAOl0m7a3quPlzx8OMnPvzeK97+6IHbj6+ojy1DN/Lv/q/+B9x89M2Udr+dSP+549dyIv0P/sx/KMkuHopJxn59YHm7ZPO4Zbaa0hxr0lIigNLEMjhPOcnp6pa0SKMsQso6bdUzW01Z32+EDLNtKGdZjGoSMkBepHRtTzZJaU89aZ7I4OKDnP/pEPG9A8urKcddRT4t6KqGJE8ZB0c5y6gOLcUklTiyTAbVvhuYLUs2j3uuXi3ZPe4plgXdsSErMrpupChS6lPL9GpCW/VxxyE0/bxIOOwrlrcLNu+2LCKhSiK4Bpmke8d0UVCfOopJztj3F3Zu3w5Mryas3+24frVgvz4yWRbU+4YkTeh7IWP0VcdkWdJWLUmWMA4uiuIzTrsTV3cLnt5sWN7OOe4qJrOCJsa+Da2jmOY0VUdeZjRVQ5KKqN77kcliwvbdjtUHCzZPB+ZXJc2+xaSJGEokCX3XMV9OOB5bsiJj7CTeKSsyDtsTi+sp6/sdV3cLDttKDBYaGbDl+ZdUh4rpvKSpJd4MpfDjSLmcsHm3ZfV6JRj49Yx6X5MWNq7SLUM7CEml6snKhL4ZsNGzuT7WLG7mggG/WnDa1+SlmPMnqWXoRzl/1TKd5RJDFwdkP3omq4LN/Z6ruwWbpz3zq6kEDeQJQzdeFjqTeUlXd2RFSt/1/NTPfVei6dqe/93/7RchTcgyy3/73/pZKU/HcmzXD0wnGftDw83VlOeXE1kmC6lhdMwmGaemlwzTuFhLYjWDIDv7qmm5Ws1Ybyom05S6aqWsm4hkK0tT+kHYrmlqGUdPkmiCV/TjwHyaszs0LOclu31FmglZzgUo84S6lQn3//H/+r6YCSSW/8nv/h7j4PCD5/ntmslcSEJ57ENCsFMM3SAEn4c9V68WHNY15SyTiLBYms5KISPNr6fShxJLPwwYpcknGYf1keXrOS9vtqxu55z2lRDJavnZoRuZzguqqhOyXt2TxHJp2w7MVxNe3m5YvVpyWB+ZrsTgJclShq4nL1KaU890VQrRKU8YxxGDIi1SDpsji9s563s5/3HfUpQJXTtgbezD84Km7snLjLZqsKl4954XD89vNqxerwSTvSqpdg1pkcZKh0QnTpcTmqOMS+ddapJnVPuTnP/dluXNgtOhophkNHVHmlr6dqSYZQTgD/8v//vfGNno29LuT/IIsvPx3tF1vaR0DKPEAcUUDe+8RIClhmp3wiaG6tBIgsuxQUFMIXEMg3jmutHRNS1ucLSNUNFP+0o8MDeSHNJUkmPYVx2BIBFtiIOM68T7dhwceElkMVpT7U5oY2kODdZY+rpHocTn10n6y9iLf/AwDBCjyHyAel+jrLrswJuD+Hl2dY9S0PUjrnfioTsIeWnoBrxD8lITS3Oo0FbTHGqMlRU3vE9FGbtRnt8wSjxc5+na8eKTm1hDdWyi52mLNpLBqoKSVfDo5fy9PMOxkVST9tShifdvNc2xJsksQzNgTYwkczC0XqLEBrkP10tMlNLicZtklurYgVKSI6ljrFrg/T0MkqIyjOJj6520EXn+NcZAc+xQWtOdzjmuXUz/GSVpppM4NYlVkx1qfZDFgKTPiOerVoa+7vBIdBxBNKQuRl313UgIkgijtRavV6No9ychdpxauY4Yidc1Y/RP9ZfKSBft8qp9E71eG7RV8netaSrxGz68HKgODcRJTGn47PMHHp42fPHFPW8fNjx89cIXXz3zeL/hBz+6Z/2846u3L7w873n7Zs1Xb9a8+eKJ5+cDX37xxNPzli8/e+Dt45avvnzky7cvPLzb8IMfveP5ccNnP37g8WHP51898/y05+3bLY8vO776/IHN5sjnnz/wtN7x5RePPL5sePfVC1++WfP0uOOzLx54etzyxZfPPD7t+eqLJx4etnL+l2N8nmIGIfhokD58qFFWSEFam+j5qi/RiK73uF6eXd+Jf3bXDPKZ6KNcn7qLb68yMLYDgRAzX0fGxsU0I8/QxkSWusNoRX2o0NbQHGrJ/mwkorGtu5gVK7Fx3nuJpuvj+YnJTdpSHevYDxvJNa16XAgSe+YkbcgNEmc3dr2071OLVvG+jabeS55pVw1oBX3TxfQXSYHxbmRsB8beCxENRX1oSDJJHVJGx/xWExObNEPX45wk1gydpMb0zXBJaFJKUx9rrLVs7vck+TdHAfqWbPSTPPR7UbvgJArngxgLxJInKsRVv0ejo56RiI0J/qatlTJbXL0HF8R+Tau4YxGSiRsdykh+n+AaUc8X3uuyQhADhzEKmz2C5bkIsAjOEzWKEZOw1jIOIwohCuAE30NBEtNBkjwRPZuG4BXn6GYdv0MTsY4QUMbgYumNSPhwIaCMBneGlYWoFIK/kKNUEPOHMHpMItiYMUqIXKloCTWiGw1n4b+SezRKDBdG9/55m0ykODYx0VYuiW43kQSiFOJxIzo870cpkY9O8FR3xpvEkm4cR3TwkXwVTRE460rVRdZmE9lFnUvI2ghGZROxxtMqlpPj+VXE2AhCUPERu1MejLZCzLCSBap8iGVB+SUYOTil8V6i1JLM4s5YcSQpBQLG2osO2UcdXoilyTMHTllFQN5/UMQw7CCkIy8GAIFYRlVCXFvfbwijLAQjWEi7a/il7RvoRsgTaAdILQyCj2IMjB6stLcLc+eiHVTy75mR70gT6AaI/YHRQZnJdySKi8PG6OTffIDUQO+gSOWzWfKeEOUD9KNch4+5bufzn2vdznNKbTRJsfh+iIYL/lISFz8PMSYY/EiI/U3FHbSPvytAJ4ZxcHLK2IcE6+M9XwKNj89/dFKm1kpLGLkSbN17fzFsP2PYSp/NO0LUjUuup/NICk4k47kgxgoqGkCcJ10dv1shWlQT+5BNDBotZhzqrDeWG/c+xqwFLiQnrSVNxztph2eehY4Yad+7yPGQxZbwA6KOicj9cOF9G07NhQ8g/A/hn2gt5/ymjm9Lu//c8WuKkf5v/jbbl330iQyMo0cjrLqu6lncTtg8HljcTKi2LTrRpEVCV0l5rD415IXosJQ1aAXjILmFk2VB9VIxu5myfT4ymefi+tKNTK9K6n1DMcmpq4a8zCXzM5oyKKPo6oHpasJxfWS6mnI6SCJIkie0dc90UXLa1xTTgr5tMUki49Agq8lsmnPa1Cxvpuyeo0xj8LjBMV1NqPeVlAn3tUh4LrmrQkJq6575qmT7cmRxNeW4qcmmKUYLllvOSo77I8V0wtB2mMSAF9w0KJGinLa1SH8e98xWpay2EU/jtmopJjlV1IMOwzlDUib2vhtYXMm1z66nHNYnsjzBpIax8+SzjOZYU0wK+qaPWC0M/QAo2X0eGhY3QvmfXk1iyLHEQ7V1Szkr5PyTgtGNIpJHdJKud0yXU3brA7PlhNPmRDaVmKu+G5kuJpx2J4pZQXtqJS5KSRaqRqFTRXNqmV/P2T5Jiaw99aAV+UQ0u9PFhMPmRDkvcTFTUyGuNePomM7l/0W+cKCYZqAUQz9K2zk1TGbFRQ/rfZA2hMAN9bFhfjVl93JiflVSH1q01RSTnLbuKMqc6iCa2q4d0Br+r//0S2oFVB0qMeLuk1hUO4DRBKNQgyMUKTSdTJDBCztWgQqBoEEpS+h7yFNU1xNSC300AchTmZhnuUyM1vA+vNSh6l7m8zQhdINM5MJsej9BKw1dL5NrL1mbEOT850k10fzsd+74t777io9/9kM++/98QX1osJmU1CezguP2RLGYMDQdNpbppRLhyac5x3XF8nbG9vHA7Kqk7yS3eDIvqPY15aykOdZk0evYj5LReu7D8+sJ64cDy7sZ1b4hsRaTaLpmYLooOWxPl1J7kicQAkM3EvDkk0IkadczDusj5bJgbMeL2Xx96iinOfVBxgHnRoI/k/8kJ3e2EtnY7HrKcStQgTGSVVvO5fvFn7q7WPaN4wgOktJS71rm11N2L/tfJZPJJjl93VLMCup9TVZmYmZCIMRJeuxHpqsZ++c986sZxyg1s6ml3jX80X//f8zV69X/3+P3txjpv8bxa6oj/dP/Z/zg6Pue2WrG9n7L6nXUPF1PqQ8tWZHQ9w6cMHGF2KjBOTCKMASyqRgBLG7mvLxdc/V6wX5dUUxy+qYXGct5FR2ZfF5xoeW73jNdlqzvRZ+5ud8xv5GOlxUZwzCgzmxf+17agVaMg5ipNwcxhn55+8Lybslhc2S2nNKcGmwiWKzysqs02oAJl13n0I3MV1PW99uoX90zv55RHWrySSohv0pHCYnGh+j+dGYIl1YmjasZL189c/XhFfvnI/PVhCqWf5yLzTiATbU4JgYhCLnBMZkX7J72LF6J1nT1asFxezZdkBK2ijszrfSFYEXwEvFW9yyuZzy/eWH1aiX4UjSdSCIhKkTms7ZKLP8GJ5aQg6eY5+xfjqxeLXn+6oWrVysOuxPlREwflD57ssDZ6lGwUY/NLUPdMb0WcsjqbsHu6RjDB2qSLMHFgHaliLsDdXFL8qMnm+YcN6K5e3mz5upuzmFbU8wL+lpw3HDeCai4mldCFjGJEESmNzNe3q5Z3S05PB2Z3UypD42I/Yce5RUYsMa+t6nTYtWYT3KqfcXq9YLnL9asPlhKelE8fzFNOG5qVq8WPL/d8MFPvWL3uJN0ExTNqWH5esnDZ0+8+vSWpzfPLK/n1CcZbKu9mFBsHna8+u4dz282XH+woDo0aK3Jy5T98/FiIHD9YdRYzku6uqeYitnF6m7O01cbPvzeazaPG8q5pIl07cDV7ULO/90bHr98YfV6GRdqOfVJIgAP61O0QtRopD+60YkRwrFhebfg6csXVncLjpuKyaqUkmZqL+5aSgvTXicKN3iUBdc5JssJu8cdq9dL1u92YnqwrwUL7dxloXZmukqbll1llluqQytt+O2LvMPticlCQgikKqPwboxkM3VRC2h7nhhLDusDq7sF67dbFnczql1DOc1oY0SfUZGzG2TXilKEwZFOUup9I2PIuw3L2wWHlxPTlfAZTCILphArB9ZKFcY7Ob/vPeWiZP9yYPVa+tDqbsFp11BME7oYcq7iuZPU8j/8X/z3+OCnXn0jc8G3GOlP8giBw+aIGxyn3YmuHWiqjnpfX8yjx8FzeNpjc8v6zRqbWrb3YiZ9XFcEAsd1JXmCp4au6ehbR7NvxNh+XxOUGN3bzLB5t0Vby/ZhT/Ce40ZMpk/bk+RKVh3NsaWvB077mnF07J+PqFTzcr+9GE8ba9g/H9Ag39EPNFVDW0lGYHvsGPuB07YmeM/uYUdaJGzut+hUs73fY4zmtDkRxsBpV4uJfT3QHGrJ+NzXjL1n/1JhjWJ7vyXJLNv73SVzNHjPcX3C957mWNO1krVaHxq6duS4lWe0e9qTZobt0w6TSNbnOXt17AeO6xNDN0qQwKmjqweqQ30xcbeJZX2/Jc0sm3cbjNZiUO/huKkY+zG+t5GhG2gOLW7w1IeG4AObhx02le9IsoTt/RZlNYf1kXEcOaxPDE1Pc2xoTh1dK+1gHByHlyNGqZgPKee3ieXwvAcdOK1PuNFR7Wq6aqCrR9pjy9AOVLsGQmD3dIjn32ESzfZ+i7WGw/oQ3/+RcXDShqpeYsUODX4YOWwly3b7sMVmlpe3W5LEsn/eEzwcXo6Mg6fa1Qz1wNiO1MeGvu6pDg3eOfaPJ0xu2N7vsalh+7BDWcVxLSbr1U7aUL2vaU8tXd0LizRKwlBSKlRGZDdnW0UQUhE6esYGIFrdiZzJR8wtQPQIJi4IIPpUS1cUq0kluxktJ46WkwBnRyPLZUUTS7nBy/eAbGqJ7kfnsmcIYosoz26DSSyb+w3K6kvIwmFzZOxG6l1FW0tWaXNs4jusCf7r73CLzS2b+x1Kw2ld4VzgtKlivmhPc6zp42f7wcdMU836Ibahr/VhRs8h9uHTsaare8ZhpN43+MFT72sIsH3cUZQ563fSDtb3W5RS7F+kHzb7mjHmijZVy9COVAc5/35zIjFyzVkhGafn8wcU++cjznmaSsaevpP7H3vHcVuD92zudySpYXu/I0klgEFbzeH5hPOO41ZM95uTjEN931MdKkYn95dozeZhR1qkvLzdkBXpNzXSfzuR/kQPFT0rz1pGRJdlo+ZLI5tPFb1O0eq9FhHB+gjqIpAGLkYI2ogUQKm4g+Ks1wRlhHaPEqH2mcruo7+mmBKIoNlqGXQMol0LsaoVlBCT/EX/R7wW0QKq8w5GR+G2VtFPOETau4CdZwp+iEkaGsGCAkS9o4x/PmJnZ7/YgIo4pZz/fO1Kif+oieJ9fdbNES6+sPKciF6e7zVlAm8pMb0maiVFgii4ijrjmIEgolfBcONgK7il6CKVAR8RVCIW+N6snAueGaL21eqoJUQwsRCiPtBwwXeUApyP2Jq/+B1rrS/s1rM2V95VDAaIEOJ54glOSDAhyjMFJ40Y2VnOM8ruWSkdUTRZzfsxXHBlH00WBEONsIQS3FrHKogSnQ7oED1Wo59wbC/BI2YQUSyvMGLQEQ1HAtGYIuouz2b2XJ5d9KONGuWz3lprMQLRWkePZi4RbSrimCpyEgjn75EdF0pdvG4heiHH6s04vjdHdxFHFCzRXfxvQ1AXLaiK5RvB8b1g9jp+NbFPwEWziZKKzcUQ5NxO4w6QSGtQZyITcH6R0vekL5qoI9exGHXhYlyCFOQ2vA94de7DCoOOY5I8969zGbQK0diEy3UQZUegLv1QXKeU9GcjrcdEvfNZPoSCgODFaOGFhJgwoDTooKP5SLjonHWMtgucgwTOmK60YxMFqcGLcYkfpYIlO1Hxk9aXawwX+cw3cXxb2v3njl9bHen/hfXbDcUslwiovkdFY3DXj0xWE06bimImOjqCopgXVJtK7P9eDkyXhUgYrEUZ6GvBwZIsoT3WlMsJ1UYkEMpomqpndTdn/3JkdjWj3gk93jmPG0ZMZhh7x9iJnKHanCgXE9q6k7zBiM0sbmbs10emC8kwNVbMsMd2ACXknvrYMVuVHLcVWZkQPHTNwPJmzn59ZH415bg9US4KXO+i6YFm6AbGITBdlZzWFeUip60GApJ7WR9rVtHCrpiX9HVPmgmZYagHyRxNLG09MFnkHDYVeZmgEJ3l/HbGaX1isiw57ap4/mhGrxVDTAQp5gWnbUW5kHzEc/5mva9Y3i7ZvxwuWFFepkCga4ThaoymbXqmy5LjpiKfZoI9diOzmymndc3saspxe6SYlYz9KDScRLS4eLHcO+1rkescxH80K6XEePV6yeHlSDEvaU8NaS4GGEMbda5aGJjlIuewPlFMJa/Uj47ZlWBei+sZh+2JcpYxdgIyKqsYWvGaTaPU4ozHJXmCtQn1qblYuE2WJXXEuS8MX2NQSrSo0+WEw/pEOc8YOmFUnjG3xc2cw8uByaIUnD860fR1B0bz2373z/D4+ROf/vaPefuDB+bXU3wItKfuYi+YTwv8KEzjYlZwWB9J406j2p344Kdf89WvvOPD771ifS+7sHJRUG1r5jdzmkONMkYYzYeGyaLktD3hg4SNP33+xCc/+zFf/co9y9sZzgW6k+S9VpuKbJrjB2HG5tOc4+ZINskIzlPtaz746Vd89ctv+ehnPuDLX37D7uVIuSiotzXzW7n/cl4Kzp6IvrutOvErziztsaWM/UCyZ4XhPb+ectxWzFYTTtuaYp4JU3ZwYpDfjzgXmCyKiy90U/doJMRerPxmHF6OlEvBSNM0QWktKoFEYazwIcpZxnFbUUwznIOh7VncziN+OhGZ1rTADePFuGTsBpyT8eK0rSjnBc2xRVvJzj3tKlZ3YiV69gzOYhvuahkHk9RIH57Kz6eTFDy0Tc/ydsZxXTG7mkSZmmTaEkmJfYRjsjKjOgoO3xxiHy4zTtsT/9O/8O9+YxjptzvSn+BRH1rBF08tSW5o6p5imtOdOorZhGrXkBQJfRcxUiU08rRILvhhc+pJ8oSmEr1efSbRHBryaUFzFBNpF2SQzfKE5tiQRoNrkaB0ZJNUtFaZDJ7FLKXa1WJEXXcQvU27qiVJRYKT5intscFmlubUkGaW+tiQT/NIREqpj+91rK538WfEm7M9NWRlRle10tEjntpWHdOlGKBnZUJbD4DHGk3XiKatigSD8yTSVKLLbOpOOuqhoZhmEaNLcF4IRDZ66so1t3HBIcbXTdWRlCndqSOb5oIRTzK6uovxa8j9J5ZqX5HmCW3VyjVWjXxX1VHMMqpjQzkrBN/Khe07Dg6bRPlQLs/KZvLZ/KzpyxK6Y0sxLagODUWZycCqZXfTNwN5kVHtKkxmaU8NNjO0Tbz/Sszk62NLPs2oDg1ZLv6xfvQXGUtaJFFOYGMbSmnrNuoEW/JZbEOTVAZgI3hs37RkqaXeVSTRYDwrMmlTMbQgLxPqQ0sxk0Euy6UNe+cuzz/N5RkmRSLvPUsuusS2kX7w9of3pEXCF//sDcYoHr94xo2ezeOWtu44bCtOmxPVvmb3sqepOtb3W9w48vjFEzqRz2Z5wpc/eIdS8PxmTV/3bJ/31IeK4+7EaSvfsX3e07c9z+8ky/fND+5JipTP/9M3JKnh8YtngpPzdzE/t9rVVIeaw/ZA18j5/Tjy+MUzSWr54j/7iqxMefODd5eg8O4oxJpqV5EWGX3dSV+qO5Iioa1bionotbNpTnPsRC/pHEM3oI2iPrXY1AiBKBcjEOnDrQRAVJ0seg+N6Ceb8VJ+7uoOmyYio8vTaPQuGu8kt/Idk5zqGMeYSsacYRRZTZJZ2mNNUibUR+lffd1FzbG8w/rYUM5yTvtKNOdtj+gSlPSZzFLva2xu6aqOrEgkxKCQPpVPMtGRlwnVScbB4KHvBtJUxpAk9qEkS2iiLr6pW+FVVKJTrY9CyGyO7QXb72LQQ1f339hY/+1E+hM8vHfsniVMudpWjF1Pc+xoTi19P3DaVeAC+6c9JktZvxWM8OXdFptoCc9VcNrVgpHtG/qmp61b6kNN348cNieU1ezudyR58j5g+H6HNkHCpEcvOFvvaOuevu5xg6M6NLjRc3g5oVPN5t1WcM6HfcQo9wStOL6cGAdHta9pq4G2bmn24h5yeDmhgN3DnjRPLvewe9gTIkbpxsD+JWJ0jYRMt9XIcVczDKIx1AZe3sj5128FZ9087NDacFgfBY/cVvRtR9f01Puavhs4bioJsr7fkWYJ63cbwTkf9milOG5P+IivjP1Ie+qoT/Icj9uKMYalq4hRJpll/U52NtunPWgt+NLgOe1rwYergeYofz5tK/zo2Jzv/36DzRK2D3uMURzPGNlaQpLbU0dTdXRNx2lXM4zn83PBxl7ebTCpZf8o4cn1tmEcgpy/6Wmqhmpf0zc91bbCBQk6T1LL+mFLmls2b3dgFIcXCSI/rgWrr46CkfZ1J22ydxzXJ7Q2gi9lCS/vNigjODdacdgcGUYf70HaUHNo6Fu5h3GUoHeTJqzfbsjyhPW7neBbL0cCcFifYtB7Ixhp08cSdFS0GH2JvtLRR1pHsoz4RotSz1gt0hsXhMHpg1QhnZQZL5+5+NLFEmaQhUrAS3kRgUgEFpCfCzG0W8fIPRVL6WfQNDixxtNaR4mVVP+9E7ghTS2bhx1Jfu7Dlu3jDh+5EkPnqDYVQzPS9wPVXrgCh/UJQhCMvkjYPu5jyMURYxXHdeRSvEgfrquWrmrp24HTpmL0gX3sQ9t7Of/mfotNDfvnPUorDpsTfvTUu5qhGWirjmrXMHR97EOwu9+TlTIOmTRh83YLAfZPe9zo2L0cBec+Cc7fxvY3DCO7pwPKKl7ebUiLeP+pZf90xAP7lyPeeapdI+5oTS9jWDdy2tT4iJGmpfAskjRl+7BHa8XhZU/wTrganROeQSU482lX4ZznuKlABdb3G5JCeAbZJPvGxvpvJ9Kf5KEiBopop875vlL0j2QJIpblvp77KR+W0GMpZ/hztmPEelRQMfCb6H8ZiKCaaLcihV8q9xF/jRKUEH9edKmStHEO/nY+XDw7fXiPLwl2qtAmGspHbAeiLWf82TPA65wTL+Gz/jCeXwYuA+octi0euUqLlyghDnYRCwnBvb8Wo1Eh4jUXbRloFcN9Iy1fsLkYmh1JKfqCESOEljOOFYhs58srk8ccMa/ggliE+uhVGmIw8dlonIhx+7NnrMLEQfeMLfs4KL/PKpWHFCG6yJA2EQs8E21iyDQxoDveh9x3ZHaeJ4g4KZytFINXF4vGcMG0xNdWhahLDXGyiRi6Ml/LxgTxaY3foQAV9c9E4g/67GasUImOP+OkbcVMTRW45Joa9d7kXBuNPrfpMxb6tYcf4gTo4z15f85x5ZILG1DxncVMy4gVB4gM6ngv8XrUGQgWw1rB1M74/fn/Iy7uo/9viESjc1B4iOf3IQj+FxmilxCESE7yPr503t+PVu8xxfP7PGeWXvoNgvsRAOdj7qa+YMby9SFihV8LTL/cyxnD9xe3p+DDZYESLv1TXTgERLa8jV7K52ceuyImtXINICHdgYhJmwuz/BKEEMMh/CjaURe8hMfHRcyFw4GS9hdfuXAM4gv0MdM3ENutgRD7jj6PZ/prFoxn/kZAm7O1ZuxD53fwDRzfGjL8BI+sSLFpQj7JBf+b5RA886V4WS5uZ7jBsXo9x7vA7HoGWjNdliSJpZgUFGVG3w6kucKmmtliggfmtxNG51i9WjB0PavXC4JSlLMcbRXloiRNRBeaTwpC8JTzAqUVs5sZIcD8diqByK8XuGFkdj3FaMNkkWMzSzHJRTQN5EbSGvJJjh89i5spwSHnH3oWrxb4AJP5BKMN5bzApJZ0kpKWGSGIP66ymumqgADLuzludCxu5oydZ349RaGYzickaUIxzbFZGj1/xZy6mMu9zK5KwhhYvZb7X7xaELxnejVFJ4rJsiTJEopJJrmuPjCZF6CVeIkGxfxmBt6zfLXAjY757RyUYrKckCQJxbwgL1N88CSpxVhNMS9QITC7nhKcY3Ezw40j87sZ4+gppznKaKarCTZLyCcZeZnjBsETtVVMFhOC98xvZnjnuHq1wI2e2c2cEAKTRUmaJhSzUsrW/UhapCitycosXvuUcfCsPlgwdiOL2ynOeWZXU5SF6aIkSROyMqOYShRcbjTaKPEyDZ757TS2vwVDP7K4W+AVTJYTbGIp5kVMnDGkeYZWUEwLgvPMVhPc6Fjezhj7keWrOaOH2c1M2t8sI80zillBViQMWmFSi9JQzCUa8PaTa6pdxd13biRa74MVKJguS2xmyCYZ+TRnHEZJbsksk8UEAyzvFrjBcfvJNfunPTcfXtGcauY3U7S1lPOcrMzE4CAx2MQymRfY1LK4mTF6z/WHK5roV7t7lhgyaR8TkjylnJcU04y+09jUkmQJ5WKC0pqrD6TN3H3nlv3znpuPr1h/9cJ0OcHENmYyQzHJJAM2eNLCYhLLZFHikPvEexZ3M+lTtwvOOaHKyjiQZoZ0klJMcoIXXD8oKFcTgvMsX80Z+pHrD5a4MTC7mqKNpZyX2NSSl/IcIESrQEM+yfAeZquSMDoWdzOGwTG/meNjH1JWMZkVGK3JypS8THHOU+ocpWC6KiHA4lY+u3olfXh2PRecel6SpvIMkyzBe0eaZWijKJcFIYTLOLS8mzH2A4u7OX5Ezp9oJrMCm0j2bj7Jcc5RqFye0aKQPnQ7k3b4StrD7GaOUjBZTOKC6Js5vt2R/gSP4Igm5p7JrJRGPM2FoJtYksxgEkuaiWHDZF4wNAOTeUHfDZSLjLEXgb9SAuI770mzBK01aW5Fq4UizSTAd3Y9Y2wck0Uhxg2LEu8c+SRHXwbiQJanMjkYQ1qkhADlLKfvOqarGd2pZ7IoJMNwWuA9lLMSbRRJmaKNDGxJbkEZimnO0A9MlgV92zNdTRg6R17KAFBOClSQxYXSmjRPxRVFKzECQCaQoR+YrCZ0jZhSBOeYTOW8k3mBD3L/1lqSNJG4KG0pJzLg5pOMsXVM5iV9P1JMMrwLlFMRtKd5CkrJABXN/NMiJXjIy5ShHSlnBUPXM11OGPqBcpqLX/FUyCB5kUnMVJLI/Sgj1zp65nczuranmOX03SDvbBSijBscaZ6ilRB90kxi5dIsheCF7DEMTJYT8cydF1E/KINWOcvRBvI8Jt/kBqOFgV0sSrzzFIuSoZH3Pra95Kn2A8VEBsViVuK9J81TKZNmIuBXgWj+MTJZlPTtEJ+/l4k/BMpFgdKBvMhQSpEVKSY1GGNkgeUc+bQQv9fljL4VfaaPpBStYDIpUUoL7nqoOYfMawX1rgKCWMJ5cP3A2I/4wTO0/cVi0gNd3aKUotpXoKE5NYQgRB4/ilh/7B1DP4i13DDSdwNu9NTHBnwQazwjGlWFkKdC8Axdj+9H2qpl6F0k540xgckRvMielFLU+wqlFG3V4IHZ1ZS+j++wGZks5dnNVjNACGYhQFYk5GWKzRKKMicAk2nO2A2Uy1L4DpOcrnXkcUFQzgsh2ExytFakRSJZx4n0Qx9GJotz/xOS3mwlRLdyWjD2nrRM0VYmR5sYTJpcxpPpUn72PA6V84Ihntd7mCxKlFJxvBB3ISm7a9I0jZ7eEiA+W03ou4HpspA+PCtFT1tK0lI+zTFGkSQWay3ayMLdeTlf3/RMrycMw0g5FxP/cprLMyxzglIkRUqSGKyxpIW9jGFDM1wIbt/U8e1E+hM8hq5j+7ilrVp2z0dO+4r60HBaH2EMPH+1JQTPw2dPJNZw/6NHbKJ5/PIFjGL9dodzTogWx4bTvuK0E03p5n6PGxxPX6wxRvP4xTM2T3j87AmbWp6/XOO9Z/e0p697jusT1aGmO3VU6xNDP/D05ZoQ4OnzZ0xiuf/smSRJefzsEZMoXt7scKNj+7ynq1tO25Pgte3I9mHPOIw8fv6MMZp3P3okzeT8JrU8ffECePYvO/pmYL8+UO0rmmMjusR+4PnNBgU8fvaMTS0PP3rEpoaHzx6xVvP8dot3gd3LgfrQcNyeLtjo9kGubf1mg9aKdz9+JC0Snr54RieGpy9fIAS2T3u6bmD/fKA5NnRVx2l9pG8dL283eO95/PyZJDU8fSHX8fTlMygVn2Fg/3ygrRoOG7n/ru3YPe1x3vPw+QvGau5/9EiWpbz74RMmsTx/8YJSsH3c0vcDx/WRtuqojy3HzYmhG3j+akMIgfsvnyAx8izThKfPn9HW8PJ2g3MDm4cdddWwXx857Ru6bmT/JJjn0xs5z8MPn0jzhKcfyzN8/PIFrwQ7Hs5et7uKaifEm7Ef2bzbgws8f7VBJZqHL55IMsvTZ09Ya3h5s5b297inb3oO6xPNqaPvBtHH9iMvbzYEHbj/0SNJmvDyxRNJann64gmlYHO/o+t6tk976mPD6VBFPeDIaS+T0Wl3QqeGtuoIHobohzx0I36QSXHoxXGnbTqUElcnYzSn6O162onXdN+K85Mww8+TqXgkD624Ao2tkNJOmyPKGI6bIyYx1LsaEMLX6M6T8YAbR/pOElu6uoUAbd2hreK0q0XruatJ8lTaYZpKnzKK9ZsN4zCyfdzRHKUNV7uavpb2jw/cf/6MtYZ3nz1hs5THHz9jEsPL2xeUEo300AzsHg9U+1q+Z33E9Y7nrzbSDj97IbUJ9z9+Is0Snj57Jkksz++EHLV73tPVHfW2jlh/x+ZhL+3/yw3aaN798JEsszx+JuPB85drILC939I30ubrfUNTtZw2R4Y4DqjgefjyGZu8/+zj588Yq+X6Rs/mScaQ46bitK/p6obd45HROZ7fvKCUitduZQzLLI+fveADrN9u6bue3ctROAanNnJORl7ebvFIP7SJ5vGzJ5I85emL528x0t8sh2g1xWPSngN6rY160ZhLGDEjpaIHZ4x70irm+WliJqn80lE4piI+JuSHS/qm4FfhrP+L+IGOetJIxDjjr9oa0Zxq0MHHj0Z9n4pEC33GNAS6MUbjo/uNdxIRFiLeCUTSyFkipy85ipfnEWU03r/Xp4qXbNQJemJ0lGCfZxxEKdBKdj/yXYKDKBWdkL6OQV20pGd/UvkObSTEWZ5BFLSd8VZ/xgxV1OxGh58zkhMzHm2UcGgt4ldjY6g60bf4HOxto35YG8zX5Gz6nNfpBTfXWrAnifB8f94L/mXsJSjdKI2J+J5kPcb2FDHV8/OXN03EsVSUq8QQ8IvncrhkxWqt0ecg5agzDVGcqvX5eX0N5wrv25aOGuhzKL1A5e6iuRWdp7wHok5X/vz+M+81pqLBlHv7GobLWcv6XrcIgv+ZqNPWWqE8glGqczBnxPX1OdeXGLUWIt1AMFGlzQU/dJELoJS+9M/zszy3YRW1mkHAb4IY6qJ8xPbPnIT453DOB9Xy/CXbl/j8PUarqNOVpmaiXtTos8tR7PNKdn9nL2YfiFmekhcbVPTHPd9LiN8Zg8i1MShjou+3jDPKiybbX3ySidm1oFQQfac6h32LfMdE31xP1FhrdQll15EUIuOD8DMkzPt873L9/szdCIgJxrndx+cf/BkXFn9vbaTtX/BU3nNPlNISSH/GTEN4z3/4ho5vMdKf8GFTKwOEgcTKhJFmCVpp0olEdOXTnGFwTBeC+0lJcSQpUvCKJDOMnUgLjJVBN8tTrLFkRcroHNOriZRyZwXD6CjmpZSBixSlwWaGxMognuQWrQ1ZnkIIZBP5TLkoCIhXrR+c6OU82NwSxkCaWIw1aGNJSynrJUWCCjBZTRl7RznJAE8xKaSEWGZoxITAJNLpkzRBG7FtCyjSSYbrR6arKQQpS7rRRX9REf9rFQdEK9miSZagDKS5YKjlosT1cv/4cClpp7l4f6I1ehjFYD9N0NaQlSmoIF68TnS9rh9iKUvKTz540iIRo+zEoBPxPE7yBG0UNgZ6F3PRypbTHDdIedg7L+UvJI/WRomTSRLR0WUSbJ5PMtzgKFclfhQrNDd6skkmE11qMUrCxk1m0UbFNgQ2swSlmczLS4SWd8j5R3mHKDBpggti8p9mCdoYbCr3kJeZYGMLwT0Fj5NSd/DSho1RF5xQG/k3ySVNCUG9v4d5QXAwWZaxlJ6hUCS5TEQ2MySpAS2EtNGJLjJ4j0ltDPqORLCvEWPOg7NS4iKUJDJ06RgwbdME592F1Pd+EhbSSYimCVqBjgEPNpXAgbNBSpIllwWlUsjkpc/jsY+LOYV3IYbRQ5LJvdgsZegFBx/HkXImWtM8liPT3Io8yorBuwry7JTSJNGLu5yVuG644NDFpGDsRynHajCJtH1tNDZNBd7JEkKAYlYwDv6CDRazguDEszbEoIJx9GgTF99Kia7UKtI8iaX7EjfIecP5egaHyVNQMm70vYbY7o0RiCIAeSk612IhUEY+L/DOUSwKiarLEoITk3ubWKxJSIsUrYOcHzn/OITLODiZS1nYxD5kMoPuR7TRZFkCRsrb+EA2yXDu/8ven8XctmX5XeBvzrn6tbuvOd290d0IZ7nKpBCulIWQEbZUEsaFKJAQ9WApVaAUEsYUPMADCEuZopTKB4NUT7wgFQ9UlVBZyRN+SQlLJbCQStjZ4IzMaG7Evfd0X7u71TdzznoYc+8TmUDaEBk3MpNvhI5OnHPPt9dec8251ppj/MfvL/cObz2Li5J5nL+0+/wTkOH3xR8mkOH/9cu/SlM1GGOCH6PUZIwx1LuaZ1+95t2nt3zlWy9494M7Ll6u6JvhbIRt7Rx2tPLGbCLN0M04O7PYiDfni29c8+77N7z8xjMe3x8oN1lQB2uUE+WfPPykiVuFm0N77Ln++JJ3P7jj1SfPuP3BPZcfb2irniQJrFZ3uqmFXZbRYltkhfu5fb/n5Tef8fa7N7z85nMe3zyyul6JEXDAFU2TxUSGKDB3CTuZoe65fHXBzQ/v+PhnXvH2+zdcf7ShPfZEaYTcOcMbvtLIBizADLywW3e3B1588oz337vhxTef8fhmR3lZCmNWmTOFxUSyE57G+Ww2PjYjF6823H5+z6tvvuDd9++4+nhNexAfSRfcXwQqI8xaHZ1MieUhc3yopCH/d97x0c885+6LR1ZXC6bRnm+61snOw0RaPEMTzTxImvHi5Yqbzx/46JMXvPuB8F+bXUOcJ2G8ZYceNMJiixd645I85vhY8fIbz3jznXd8/Kc/4v2n92yeL5n6iTiNcI5g1K6JIiNzwYil1zxZLp6v5Pw/ecHb79/w/KuXHB4a8lUmTj6Rwjmws5OXCCPAC63EoLnZtjz/xjPefu89X/mZV7z59JbrVxdi5Wb0mXYlWQgdnIVkHczTxPXHV9x+fsef+2f+LN//jc948bVnVLsGpRWriwX1TmAl0zjjnSMNfYMm1sEqa8fXf/arfPrrn/Gtf/QbvP7uO5YXokUYWqn193Uray6OmfqRJE8YmoFxnLh8ecm7777jW//7b/Dpb3zOq0+ec9zWACwuytAzmzKNQuw68XKjWFSru7s9X/9HvsoPfuNzvvmPfo3v/P8+JQo2YPJw4IN6+7Sj1Jqhn6RuuMp5vNnz0bde8PnvvOMrP/OCu9ePLDYlznlMWCvzLGNojGEMfabOeYZ24NnHl7z79JZX33rB+x/ccflqTXuQPk3vvLxcaMkCKeQh2rcDAMUilzX0jWe8/e57Xn7zBfevH9m8WAkEJjX42YljVWgJwnl0rJhnx1QPbF5tuP3sno/+1Eveff+W51+75PjYkBRxUNBKpsE6mUMqmDIo70mKlMPdgeffuObtd97z6k+95OHNluVlwTQK41l5aS06EbbkxVox9dJzK+ziez7+1kvefP+WF1+7YP9Qk2YJ/6e/+s98aX6kTw/S3xd/mA/S/+Tf/c/Y3eyJU3EkqHaNuIU8HFhsStpDT7nOafYN5UUpk/qr19y9fuTF1695fLtjcbVg6qcgRpGJv75eUh0bioUAAfIASLh4tgrA7+fcvX7k6uUF1a4izRKUMaJqvFqxvd2xulzRVg3FohB3h3XB8f7I1VeueHj9yMuvX/Pwdsfy2VIeHtaTLzP2tweWz1bU20pcS44d5TKTc7ta8XizkwfzF49cfbShemhIyxilDG3dsb5ciFvL1ZK2binLnLpuKRYZx/uKq48veXi35eXXn/Pwdsvq2YKhmUBBXmYc7g8srlZUj0fKdUlXiwl5HUg225sdz7/+jPsvHnj+1SsO90eyZQYeunZkuSnY3e5ZXS2lqbzIaOqefCnUmquPrrl/c8erb7zg/s0j6+slbSX1sDRPOT4cWV+vqIIzy9AMZIuMdtdQbAr2dwdeffKC28/vef6VZzzeboPgTPwcV5elOH1sSrl2q4zm0FKuCo7bmsuPLrh//chH33zO3RcPrF+s6A49UaRJyozD/ZFNIBaV64K2kuvf7FsWlyX7mwPPvn7Nw+tHnn31iu37A8Va1KGyY1qwvdmxuloIVGIhVCM5/0aA6G8fefHJCx5eP3LxYkVT9URGlKv1XszZd7cHcfk5tizWBdWhZXFRsH9/4PnXn3Hz+R0vvv6c7bsdy02JdSLaWQRz+NVFSV3JeV9/fCmeseNEvsrZ3ex59clLtjc7yo1kJ8Z2ZPNszd3re66/csnD2z35KsWJt4MouyNDfWh5/pVr7l8/cP3VS6qHGh1HAq1/OPLs40ve//CWi5eX1NuaOI/ObTzTKK5D25s9z79xze79jtXViqkXNu3iYsn9m0eef+2K+7ePLDcLxn4SOzTE3/X177zl6uNLHt9sefH1ax7e7FhclcHVxFEuS3Z3O5ZXAnzPlwLkSIuEZtexfrHi4c0jr8L1v/7KFdX9kSQXZ6C27lheLtnf7YVcVjWUi4K66siWGfVDxcVHlzy+ueflN1/w8Pkjq+crhnZCaU9eZOJ4dL2ifhTqUXvsKRZC2VpdL9m+2/HyG9fcfvHI84+v2d3vyIoUpQx9N7C6KtndHMLxW4oio66FkHV8rLh8dXVeQw9vdqyfLeiaAW0gzTOODxWrqyXVtqLclHTHjmyd0WwbFpdLdu/3PP/GaQ1fs3s4kJcZeM/QTyxWObu7QzBt6MjLnObYslgVHLY1ly83PLy756/933+B64+uvpRnwVON9CcYHo3zUg9RpzYvJY4ukub3H4DbIHUXRah5qfNbZKgmnFNVhIZw+Sv5n7cOInXuSdOaUC9VUjdT4PWpd9FjotB35+WN81TTUKFX0IfUGCf7tw9sbyIjfpqnPlMXamM61As9oWbjT56KwgU1Rmok3guT1FuP89KrqYwJNR9ptj+fswu9oKGX0AavQefcmb154ugqHepm5sQE9udxc046/6RXTlCB5+P78OfZo7X0Yp6Yv1pLbU1rdU4tmkhjR4tBUpI4j3UerUKvMIBSOIKPYyj+nnioPqQzpT/Rf6jb2sD/DelIubKhlmU0brKhhqixs3BYnfWh71JABlLzPOVCfdgZf+ixtV769LQRV5pTzVOmo+yCTn3E8kvLvDjBDkKvpA87fcIx3Sw9qj7Up4ySVhttxA3ndH2sD6jGSP8IeF7OwZ0ckPhQK5Y+3w81cY+SuWKt1Ied9HU661CRkTUU6vy40LMa5ov0bXqck5qdJ4xD2DnZ2aEiGTdJAetzT+sJzqAj+Uw3+x+ZY148cs/zT/+eNSw9tKEm7a3oAIzGzpK5cdYHHYLMFxUmv7CB/fnfn4D56kd6X70NYxp8jJ31xJFksZSAomWeOPehRhzS1866090j7J6lV9qfzAMUoOXfGGPOLFsfWLZCwxKWbxgo4WBHOugaTv2qAbARemJ9KDFYKz7F7tT/7GXHLgzhk65DXKV0qJWLo1DY6QZnI48wudHgrEUbuW98EG785OPpQfoTDIVnfbXAGENxWZLmKcUyJS0z0jSVXssokj6yyXL1lUvsOHH5asPUz6yfrVAaVlclURJRrHLSIiFdJKSl9MSVFwVewfrFmrmbuf74kqGbuHh5IX1VlyXawHJTkiQR2SIjLTKiOKFY5mhjWF0tmPuJy1cXTMPA1Veu5PjPV3itWF0tMFFEuc5Jspg4i8iWOUmWUG5KAFbPVgzdyPVHG+Zh4uLFBd7Z0NfmWW5K4lgTFwlpnhKncnwTRywvF7hx5uLlBWM3cPXxJdMws3m2kn7HS+nrW1yUJHkivZFljo6Fq+qA9fMV8zhz/dVLxm7i4uWGebKsrxdoFItNSZxElKuCrMhJ84RyU2CSiMXVQlKdH13QNyPXX7nCzTOb5xtm61lclphIxj9OY5I8JSszosyQr3LAs36+ZLaTHD+M5TzPLK+X0ht5uSROI/JFRlokxGlCvsqIUkO5LqWf8+MLpm7k6uUl4zCxebHBWcfiokQbQ3lVkqRxuIYpURZTruX4q6sV8zhx9epCrv+rC8ZhZvVsidaKxeXp/HOyIiXJErJFJv2VFyUeWL/YMHYTVx/LOVy83OBmy+Z6gTaa8nJBksWki4y0TInjiGIprUvrZyumaeby1SXTMHH50YapleM7B8tNQRRHLFYFaZ6Q5DFpmZ7h68pwTh0SHvwuvEwA4WUtiIx+5MXThn/jADVbTkbqJ7GWDS86pweGiPbCC5STtKHk308vYpxBBafnsY5OL4Tq/FYb3oPlj04eRFM/c/XRJWM7cvnRBfMws3m5wnnprxUOcEmaJ9KbuciJYyMZCzzr52uGbuTqKzKGm48ucFbWkA/9pXGs5T6QJ6RpTLbMiSLD4moJs+Pio0v6buQ6XIeL52ucl/5SoyMWm1KufZmQlilRrClWBUrDxYsVYz9y9fEVQztw+eqKabTSG2w064sFUWrIF9JfnaTSa20iw+JigZ0tly8vGduBq1dXTOPE5uWK2TpWFwt0HLHYyBxKcunv1qkOfd3Smz0NcvxpkPugnaVXFKVYXpTEacRiWZIWKVmakC8zTGxYX8oavvzogqEdufrK9bkM8mXE04P0JxhKQ7WTmktzaLFWsHzzNDF0I1Mw0R2aEaVFhq/jmOrYkmSG+tiAV1RbsaKqDy0u2Fn52Qryr+5RLvTeaThuG5JU6mcmgfrY4j3UdYubfbBOm2nrjnmcJOVYD+goojo0RCaieqyI04h636KVOrcWtFWPc46h7aVXb5gY2wHnYWg7dGQ4PDboRLN/rDDG0B5bnPPU+xrnPUMzMFuxRJvGCTtZhmbAaUVbtZhIU22bABlvQRvqYws+fIZz9HXPNEmLRF91YvFUdxijOdxXmEQ+Q0eG47ZBGeHPehRt1eHxdM3INM64UOtRGppDQ5SKfVoURzTHBq3FxkopT1t1cvyqxc5S55z6CY/0L56s13QkaEJjDPW+BgXNtsHNLli3iZ3UPFrmSc5Ha2kDMbGh2tekWUp9bKTFY9fgvQ/WeWJ7ZWfL1E2M3QhK0TU9Skk7SJxFkraMhVmMVjS7Fk9AxM2Wvumx04ybLUPT4z30VSdYv11NkkQcHyu00WJV5z31rsLOjq7qcdbR99Ji4r1ibHsiY6h21XncdaKpd/W5TcU6T3voBAzfjnjnsNZSFNKnmy4y5klaU5RSIsoJytUoEtcYE0k2JMkinHUiLlPSA2udYPpsqMWelcrBGk3HEThRiVorfbvKQ1IkKAdxmuDsLL25cMYSOidpYx/qdNY60lL6Y7M8AQ9pngpOclcRhbWTpBHNTmq01WOF89L36pyVcZgnhmFmbAe8c/RNi4qUzL80pg7zsK1b6Vk9SntOc+ywztF1I/M04Kxn7AZQmnpfE0WG3f2BOI6o9jVGR3THFpSnObY468Q/1Uu6fRrkM5pK2NzVtsbEcv2jKKLZtzjvqfYN3knrj8yhQUD21jN1I0or2krm8HFbESUx1a4hNoq6Eru/5tjgwnp1VvjcYz+ENdRjjKHaHjFGU+3l+9T7DoB6J9+jPoTv0ck8dLOjqyR13FbC2W4OzRkm82XE04P0JxhpLlSTLE+JY0NWpJhIs7xcYGchG50UdihPnMbEicYoTZzFGG2I84Q0S0mLlCQJb/FGUyxz5tmyfrZi9gIJiIwhTqJzo3aW58RxRJqlRFqgCXFkWKxLFJ7FpZCVFhelUIPyBBMpafJOY4zRpLmAG07whKzIAMVilTNOM+vrFcpLk74xmiyPydKUJI5Ii1TUsWVGnCYCI9CKxUp20atLoZIsNqU0eqcxJhbIRBzHAUKRCjgijojjiLIUOMVqU2Kt5fLVBRpNXmYoLa44cZoQGU2xyKRhO42IkogkjVFAeroJrwrmIJxSypDmKVob4jgizlI0mmyZy9hniezAFjnKGNlFW8fqcol3pxu6IomEJhRFQrWJTBx2gDFZkRHHMYuVwCnWV0uc9ayuloAiy4T8EhkjCkWk+T4JhKYoCt/RGFYbATBsnq/BOopljoo1SRIRRzFRpEhzabSP84Q4i0hS2QGWSyELra6WWOtYX69AiXrSRIY0iQSYERnyZUqSRORFGihd8h3LZY6fxbAdvEBDkHkoLjIReZFhTESUR7IbD/OhKFNxLlkWzKOVna/zrDYlUaDhpFlCXqRkpYxdHnZv5arARJrV1QbnnFChJsdVcPlYXiwk27EqSHIh4px2gMUixySG1VWJRglRa7Zcf3zJNDkuX27QJgpUrIhskZAvMrIilXUQC1kpig3lSuq+Vx9d4qx8hlFKYB1RJO0aqSibizIlzoUOlMQyD0RQJZmozfUSlCHNM2ITkSaS9THGEGcJRhuSNCEycv2NMhRLIftsrjbM88RiXeIV5LkAF+I4IsqT8xo2UUSSyxzKygyFUMjm2QoswnvyMkNrWft5nhBHmnwhmYck3AfSIsFozXJV4vCswjoo1iUoTZqKSv60Zo3WxEVKHBkhvUWGcinErGXoTlhfr9GBvOYNxElMnKUYHe4JQR0cp9KlEMUReZEESESJnR3lRQlokjiWFqCQNv+y4ulB+hOMrurpu5Hq0NA3I82+wc6e/e2eKDPcfS7N/LvbA3jZtQ6d7FaHdmTsR/pjT98KHHwcJtnhei8GvpHh/vUjJtZUW9mttVUrb4zdRHvs6fuRpmoZ+5H60DDP0mAfxZH8bKR5fLfDO0ezbxjHmb7u6ZqeoR0CHH2irXqmcRazawJgO4u5/VzgAYf7AMVuerpuYKh7Mf3tJrpjx9DJ+c+hOVyO/0Ccxjy83aI88t+ncPy2p+8GMTBuRvq2Yxpn9tujAK5v9kRxzO1n96ACFNt7gS60A103CKC9n+iPPeMwipH67Dg+NsSpAA+SNObh7Q6Up943srttOrqmZRhGmm1D3/TUh5axHc/w7cf3YuT98OaRKBJDbe+9APGbUQzEjx1D19Mc5XsITGNkf1+hteL+zaM0kb9+xCt547ezo217xm5gnmaaXSNzaF8z9CP1ocY6x/Z2j0mk8V0ZMRiQHW/H0Pdn8+Wxn2h3DV09UB8apnGi2lbSrP/6ERPmkFKy850nASUM3SDH2/V0/STzrxNIv3eO7e0BHWtuP39AG8X2do91cg4yf3u6WgDl3b6n78L5jxOHhyMKMUNP85gvvv0abeD9Z3e4aWZ7s6Nve46PR+p9S3PsODxUdLUATuZp5vaLO0ys+ezbb9BG8/q771EK7t8+MvYjh7s9Xd1zfKxoDw3toWN3J2CJh7c7vPO8/f6NOLh8+w0mNbz99AZnLdvbPV3Tc7wTAEJ97Ki2DX3ds7/dMw0Td28eMEaHn435/Nuv8QraQyM7zXZgbEbGfqLay9ypdg3DIOMPcP92KxCR14+gfVjDlqZqGZqRqZ8Y655hmMRIfZiodzXzPAXj7Ii7Lx6IkpiHdzsUBKN1yRoNjRhL1IeaoR0lGzLMHPdy/Me3Ata/ey3X8PBQ4WYr67WXc6h3DV0ra+l0/e1s2d8dMFpz98UjJlY8vhO4Sn3oxMC76pn6gaGf6A5iJt4cGgFLPFQ453kIRhN3nwsAZX97xM9e7kPdwNAPYrDQz/TVIJD+fcM8TuweKqJI8/BuK2bo73aSAdw3skMe7RMi8E9KeHxgb2rKdWDPZqLgjaOIdCnYvmIlfVubqxVutlKzHCeWFwvQSG0uMmSLnCiOyEp5S44SQ74qwH3oI1s/W2NHy/JK+skW6wId+gxNJPWNOJN+QNkJa+kfDXUUNzk2z1bMk7BnjVKUqwxjNPkilxpdLhxVow3lZgFO6ojOWnnLHWbWL9fSz3VZSn1tlRNlMflCGKBRbEgXubyxbxY471hs5LzX1yvsZNk8W8u5reRNOS8z4kRQYkmWYGJNsS7QSlFsStzsWV8Lc3NzvWIepDdUaRV+JmJxIbXCKInIAvlksSlxs2OxKbGz1BvdJAxgEMyjiaQeGmfCAE5S2XWkoV90cbHAWzn+NM0srpfytn+9QmtNXiZyvZa5vFmHWrHSmuXFQljLFyV2ntlcr5h6K1xXJT2hURRRLIVfmhbxWQmerwtQimxZILXKBXYSju+pRh5FJnBbZacWRRFRHIUapdTItPeh7cJx8XzF2E+srtdBaZqFLIhwU5MiIc0SkiQR9iuaxabEe8fmahnmsDB4lxeSbSiXUtMvljlxlsg8TMVDFqVRGKllBvCId/4DyAM+QOeVCH+89R9MsANA4oPoLMAlAgzAI/VXMYEW0dLp709tKQqFn0OrSoBlqLCjUfgPja1GMjai+RP52klo472XWuEwyxqeLcurJUppylVGEmrUUSpZijRLQAV+s1MUqyLwizfSVx1q94tNLuO/EAb2iV+bpHIvUOrEj3Ys1jl2lGs3DaLSVlr41nEcCfs4ScnPu+ywhlHSRx160sd+ZvVM6qur6wVGSS0zSgxJGROlkWAOFxnGSJ3fOcfiomDqJ6mZj+JN61GCiDQRxToPay8jy6SfOV8VoPUZp3jx/IJ5mllerpimifJC5na+SEnShHyZk6QRURpLR0I4fzc71ldLpkHuIWP/hAj8kxFe7LOst7RVJ7vNfqJrB6bR0h47vPccHyqixIgFUZaInVccc3yoUN6HncxMV3XM0ywWRHWHmy3NvkYbsSuLM7EPirMoWJCJfZV3XiybRrH/GrqRaZil5qI81VbqCY+3e9Ii4f79ljRL2N/u8QrqY8c8znTHjmmaGfqRvumZZ0u9k3rG/m6PSWN2dzviPOLx7RYdG47h7bM5dEzdRFc1DN3APM60xwZnHfXuKHWduz1ZkbK93RFnCbvbPWjEKmye5S13mOnbgbbpsJMVKzoNx/sDUaLZvnsgKRKxYkojsXGzslObhll21oPUp9u6A+updhVRIpZXcWyCBVXC4/stOoJ6W2GnmbbpmYaJvhMLKTvNtIcWNBweDkSJ4fFGruHuvbQ9VQ9HMYE+9uEayi6x72e6ugXnqbZHotiwvT2QpnLctIg43B1QRgysp3EOGQvJVvTtwDRMtIcWo8NnGMPDux1JLnMoyhKO90es9bS7lnEY6KqeoZ8Yx5Gu7rGTpdpXeKXY3e3Fiu3dlrRI2N5sw/EbZj/THjvJkjQjfSfj2Rw6lILDw5E4MTzc7kiyRCzh0ojD/TH0LbfMwyQWgv3I0I90dcc8WU4ORQ4fDFhsEPEQHlL+TKsJonZRyv6olBM+/MegzAZ1VlH/KGnnrCS1Ikw6Oct4wkM5/Ly19vwQxgcR0+ywJ2Uw8tWU0bgAPRAbtVjWcBKzv9tLtuPQMk5T2BVOYRyFC1zva5RSHO4PRGnEw7tHmf83e0xqqB4bnLXUx5BhOMrudBwnmrrFWy+12Thie3sQVOP7LWmesr/fo5TUF8dxoqt+5Bq2gj2st5IhOd4dxILwTuzMHt89EiWG4/0R5+UeMg+Wvh5FH9HPdFXDbB3V7ni2jUuLlMf3W5IsZXezkzl06LDTFNbhxND0tG2Pm2VeK2B/v5f7YFhD+5sdUZpQ3R/xnrCGZNzGfmLoB/qmwztPtRfM48kK8PH99vyi/GXE04P0JxgmMmfcmAAVpA0ijmPwjigSJJsQbgSc4BD8nzKC3sIoaYkw4U0bxWyF7CK9c2IdFCUBcxasy3Rwa9FGgTm9zCtpRokjrJOGZ++kud5ZTxRFIknXQmJSgSaEVwEOf+q3EyqM8h4Tx1jniOII5Z0INXx4cz8jYpBuDCPHj2KDd0IYms/joQKE4qTKFHm7DjgyFdBjRkvLSRzH4CCKw3ePzRnDpgPBQNBiJmDVgo/kbNHhvKX/T+DbhD5E5wVdqLTn5GspKEU5rlLBlzIQdKJY8GZxHJ/bB+T6fTh/FcbOBLBGFAmazsQn2osQjozRzAHZJy0XYfwDrk4ZGTucJ44icJ4o0VjriZLofI2VdwE9CGgt805/aKEQ+zVPFHB7cRKD93IuYcd3hnAE2zaNkbYQI+0ZJpL5l2QRKoyDDy04ygeK0KkFC847RW9ld+dP1Cfl5Lt7T5qKQblcqzDnIo1XYT0ENB5e6GD+R+ZwHD7DJJHM1xNqM9IYHdpgItlVKqXFQCCNBPSQJTgrZggC8DBiSmCic2uSjoyMXWzC2jUCqkgjnLWkecw8yrxwJ/qkDvMx7GbVCWeoNHZyRIm0ycRxjFcQhTlttJYWDj7MJ0H0yT3FqwAnsAI5sMj3cZNDo7AI5vJEc1JhPpkTmEFrnAr3DBRRFgdBVbhPaY2BDyjM030g3JtOwBfnnQiyrNyH/Mn27Nx1Im00JzzjCU8ZhTGK43Dvig3eOZIkDgprUMqDVtKypuQ6KgRXeLJIxIGJ5brHiay/KI7QkSFO4y+1/eWPFZDhb/2tv8V/8B/8B/zWb/0WZVnyT/1T/xT/xX/xX5z/+xdffMFf+2t/jb/9t/82eZ7zV/7KX+E//A//Q5Ik+Yc+xh8mkOE/+7/9TcZBTLSzMqetWrI8Zugn3ORYPl9y/8UjH33ynHc/uOX6q5cc72vyVc7YjuLoYOVGMw9zcJVviOMYE2uaQ8f1Vy95+733vPzGc+6/eGT9fMHQTcRpzDxZ4iTCTZYoT+jrnqxIAxxc0pG7my3XX3vGzad3XH/1ksP9kcW6ZBgm4tgITzcWpFpWpFT7hjRNRMV76Lj6ygXvPr3l5def8fB6y+p6Sd8OZKXYv51MkpM8ZgyN523VobyivCh4fLfjxSfPefe9G55//Zrt3YHlpmTsR9IsZhrEQstZT1rE1LuWNBVecd8OXH58yc33b3n5yTNuPrvn8tWG5iCQgrEf5QbvPXESMXQTSZ6I24eH8qJk+27Hs69dcfPDO55/7ZrdzSE458zoyOBmTxQZZivn3x470lxu+EM9cPnxhvc/uBcIxWcPXLxc0x578pXAGqJExi7JE8Z2JC0TmmOHMYZ8kbK7PfLiG9e8/e57XnzyjMd3O1aXS4ZuJM1jxn6Wa2gtaZEFNWKCmyeGfubi1Ya7Hz7w4pvXvP/0jmcfX9AcpDl/6ifiJGKaZrI8pW9GkjwSepY2JEXM8e7I9deveP/9W15+8oL7t49srpf07UiaJWEcNHb2ZEVCe2iJixg7OuZxYvNize1nD7z65nPefXrL9ceXVNuKYl0wttMHNF4ivyeZqEB1JHZex4eaf+TP/294/+ktm+drxl6UyOsXa6qHStxMhhnvPXmZc9xWlKucrhmYh4lnX7vi7fdu+OibL3l4tyWOJWVf7RouXqxpDm1wKdEM3cBiXbJ/OBDH8dk8+9XPvODd92+4fLmhO4oW4PLVmv19xfJiwdCKqjkrM+p9Q75IGZqBaZi5+viCm8/uePnJC7749luSLKLa1uJg0s8kRcTUzbKGrCMrEupDRxxH6FjT7luef+2aN997z6tvveDuh/dsXq7o64FskTK0E1Ei8zDJE/qmI80T+m4EB8U6Z3ez48U3nvHue3dcf+WS/cOR5UUZQA8xtreYLMZOM1mRUu9E2e8VdPXA1Ucbbn94x4tPnnP72T2XL9e01SDAkXYgCt89zWKGdiApUvp6ABTFOhOAwzef8eZ7t7z8xjO273esLhf0TbgPDJYo0cyDI1+m1LuaJEvxePqqD3P4npfffB7W8Jr2vIZn6bmeHXEeM7QTaRHTHTtUKJltbw5hDd/y4mvPuH/9SLEu+D/+wv+Br/zMR/+L799/IoEMv/qrv8rP//zP86/8K/8Kv/mbv8nf+Tt/h7/yV/7K+b9ba/ln/9l/lqZp+G/+m/+G//w//8/51V/9Vf7tf/vf/ql956EZuPvikebQcrjfs7s90Bw77j57xHvHZ7/1hiSO+f6vf0acGH74G1+gteLtd9+jgNvPHuiOPY/vdhweKg73FY/vdgzDwNvv32Iixff+7g9JkoRPf+sLkjzm9e/eoJXm9ocP2GHm7osHqkPL4fbI4U4cUB7ebvEovvidN6AMP/yt18RZxOd//zVRbHj93fd457j94pG+7nl8v+N4X3G4P7J7f6BrR959/watFT/4jc9Jk4gf/v3XRInmze++RWt498M73Gx5fL+jPTTsb/fs7o40x5bHt3tma/n8228xkeH7f/eHcvz//g1xFPHmd9+B87z79I6+HXi82XPc1lRb+ZxhsLz/4R0Kzad/7zNMYvjBb3xOHMd8/vfforTn3ae3zKPl7osHmn3L7mbP9mZPc2h5fLPFWidCkdjwg998TZwk/OC3XhMlEe8+vcN5uHu9ZegGHt7vqLY1h4cjj++3tE3P+x/c47XiB7/5BUlm+PQ3v8Akhs+//QZl4PXvvBVnjdcPtIee7fsDu/sD9b5m+3bHPFle/+57osTw/b/3GUmWynVIYl7/7nvwnjffv2UcZh7f7jjuG/b3B7Y34qJx88UWlOKz3/yCKDV8+puvyfKYz377LeB5890b5snx/of39FXPw9sth+2R+thx//aReRx5890bTCzzLslTfvBbnxMnMV98+x0KePfDW4Zu5PHtjvrQyPW/PdBVPXdfPOCBT3/jC+I04nu//jlJbvjs77/GRJo333kPOG4+fzjPod3tnuqxZnd7wM4zb7/7HhNrXv/OO6IgnPLOB8eigerQ0FY9XdXR7Bv6uuNwf2QeZ3bvd+efzfKUt997j4kUjzc77Cwp/74RkV69k/9/fKgYuoH9jaSbbz+7J84MX3z7LXESc/PDexxenFKakXrf0B5aurqn3jcMTc/h/oCdRGwWZxGvv3tDnCS8/f4NUWr4/NtviZKIN9+/xTvP++/fMXYj+/sjx4eK42PD7v2WoR/FKSjSfO/v/ZA0zOEokzmMhjffucVOM/evH6n3DbtbuYdUu46Hzx9xduaL33mL0obv//oXxHnEF7/zlsgY3nxH7iE3P3yk60YeXj9QPdTs7yu2twf6fuTmh3doJXPYZDE//M0vSLKYz/7+W7RSvPnue+xouXvzSHto2N0e2N0dqfYtj28emaeZ17/7jiiN+PQ3XpPmMT/4rc+JoogvfucdKMXb798xtQOPb7ZUu0rW4fsDfTvw/tM7lNZ89t+/JsoMn/7GZ8RpzOfffovSijffvcFax/2bR5qqY3ezZ39/oN63PL4/4Jzl8999SxRpPv31z0kSOX6cJdx8eht8WL+c+GMBrZ/nmX/r3/q3+Bt/42/wC7/wC+e//9N/+k+f//+v/dqv8e1vf5vXr1/z0UfyFvIf/Uf/Ef/yv/wv88u//Ms/9u7yf0l4L07v3oc+cydUIrzHzh6UZ3Y21IQ082zRRmEnKySi2QaniQ9u72cKiPOMgz3TQ+w4A555lLf3eZqEgOTCwY3QX5yTvis721BrEhd7rYWFqzzYyYpD/WRFCOLAKyHjCDtTSDbzZOVENUz9hNaGabLgFXM34pUAxr0PRBJrcVaIKqfzOeVDlNKMo3Bc3WyFDDQL6QXnAYubHc5xJgI5ZwOpSTFNMyZSsoNSRrjCgUnq/Ikc48/sTmctnD/LgXbYUcQJ8zDhrMcGS64wUCKAsYAF7yxumiV95BV2toFnbPGOoBh08u8NqEl+1nsh2dhZqELzOEveXXvsOOMV2HmS9OfsAq3IoSdwgTXqvdCR5PqIg4ifLV4p+TxjhIKkPN66gCiQ8VROaDhzABGcIPF4F+aQvJR6J99HEegx1mGDK4dSQuWxsw0Qd4ebZ7wTzB5hDjnnsaMVTVCALZzTu06daUIg43VSWfoTX5VQJ3XCHHYnYANg5zCXnD/TeuR7yp+FCHSeXHKNZQoHGIPUTG2gKsncdGehkxCfAgTChTV8WkvI/DkRt5yT8YnSSDwwvWMeZD3a2eGVws4Bho8/MSfwdmaerJCHlMKOwtG11oKXMfaB/HQikuHFHcZ5j53k/BSIiw1K1qFCesTR2GkOtCz1gcJlnZyThWmaJO3qPNM44Z2MLR7cJGhOoQfJfcs5h3aEcZN16J2XNYvHDoFnPcsc8rPFEtaNdqGMHcZ0tthpBi/rRMbIy9hpYTPjPXZyMpfDeQoNy+JmH35Ojo2W4ystf/clZnb/eOxI/97f+3u8ffsWrTV/9s/+WV69esVf/st/md/+7d8+/5v/9r/9b/nZn/3Z80MU4C/9pb/EMAz83b/7d/8nP3sYBo7H4+/59YcVJ/NbL9MwuE+csGnBDklJfck5R1FmTIMjLRLs5IizRB5qoU5jYrES0kZcLARZppmdODbY2VMsg5H0QgydxfibUPcJlmxGSb9oqN9EqWGeZvlZJ03mzoqjgptnVPQj9Sk8GLFkMrHULsUxImO2jnwhji1ZmeEncU451d+UlpqX0gqTSN1PG/n/zjrSXBwc0iLBzV4cJazHxAanxEFFxuFUNw52Tk5SVpMV5xJrLfkiw042KENDnUlrvCYYB2iMEW5OlES4SXoh52kWxxQnzh3WSf1VsGYBE2cCOjAy4fiS9ppnS7ZI8c6RlSlulpSytx4dh/MO9dI4MZiAm5PU1em8HVmeyu+LHOumUO8z4v4TUHUKJXVqc3LUiUIJQcbwdA3FtNyHYwf3GqOIYo2KZPy0EcxfVopjSZKJ0Xu2zLFuJkoj6fONow+1Om3EiSd4xCVJHIydswD1T/E2OHvMghPU5oONnjKCPzRaMY1zUNx+QM3xI+IgF5CEp/viiVOkTiw9AiJQf7BYC0olQdKFB62Qk8KHnARKQdD0AWcZcJnOnlGVLrwQK6VwInMgPAo5iZdAWi6KZTDDLtMAbkix80wUS51SyvdS8zVazClUQArGmTjoZHmKnafwuwtOMx6TfLAQlDV9qoWekINSfrChJ9TNM2me4Ga5hj6sgyisQx0JP1kbg7WWJBMXoDRPsDhxX7KWKI1R+DOsX0XqR9aQDrV6g7OQBBPy024wyVOU90RpsPQ72b5FYsJgkkhwhkpMAcbJSp/zNAXwvjjHOEuo3Yead7BkFD2HADvm0REXKd7Kcc8v+l9C/LF4kP7gBz8A4Jd+6Zf463/9r/Nf/pf/JRcXF/yFv/AX2G63ANzc3PDixYvf83MXFxckScLNzc3/5Gf/yq/8Cuv1+vzrq1/96h/eFw83DK0NJhH3jBNhxXlPnAkgIMllsZnE4LFSdMef2wOS0IRvtEFFBueVNFtraUDGiZ2WdeLu4U7yfh9s3MLDU8cRKlJEsZBdolSEGSfhRBTH8kAL7ic6ErFMFOvzDV9HBu09cRbhHaSZuDxEaYSd5vDZ4b8jWpOTWEr+P8SJwU5im+WtJ81S3CQPwXlyYollrYyHlweZPHTFSspbOS87O+JgUxfnKXZ0QTgViDbIAwslwgZjFLExwgpWSoQpSpFkkdyowgtNnMSBGWrOogdjNCYx4cVEgBl4SBIRTMRpLC8OaSzM0FhuflF4gMpDRG58URLhZkuUCHRCbNogLTKpBWWJ3JxiDVbUoDrYb+mgVE0LsVhL81ADDg/MKHwPE6yxdCznmmQBzh5oP0IHSlAeqaPNIn46PYydtfLQDmKQkw+uibTYhmUJWEscLLCyMmUe5cZtZ/l7a+X7oHUQf8iaiKJwXVODc47j41FSpWmCDTurk9Dq7CdqTkIZJfShs8hMRFdxKi8Q0priz4Ip/SNimxPzV1xEfCAoicjOIzaB1rmz0485eZ8GgRZ44Tsjc8NaWaPCSxarnpO92o/OXaVEJGZisT3TkWgPoizGO8LLhicrE+bRkuRxuJZByBZqvEbrwLEVGz/rwj0izAc7Oalfz2IrJ0KmSNqIwr0oSiJUJNc/DjZycRKhvCYtE+bJygvcGPQV3pMkBlCYKBInJaNE7HgWmYmdodRgM3mByOPzi6z38iKPljksugU5b+UcSRZjHWE+OrSJ8FYRRaINMGENxXGEDsAYY+TlW17U5bOc83L8aSIN6+HLip/qg/SXfumXzurA/6lf/91/998FKTv8+//+v8+/+C/+i/zcz/0c/+l/+p+ilOJv/s2/ef68k1H0j4b3/n/070/x7/17/x6Hw+H86/Xr139o51cscpRXFMtAySkzlFcs1oX0KT6XfslikYk3ZOjztM6J64V1FBc5+LBb8J7FKgcnfaLTMLN8thAqTRKJ+hDpO7WzY329QHnpwzRKizdiECi4yQmfdppYXArLVxlIFwnTePLmtCwuFyilyRah53JdYq1jebFgGqfAwUT4qVmM845ik4vTxzrHo8hWGUprio3QR4p1gbPCZ53niSL02CoN+TKR87wsg+NGgVKaYpGjQ88rSmyu5mlm81xYpmkWBySYIl/IbqC8KIOvolCH8mWO91Bswvg/k/Mv14Xg52JNWmSBdiTkoHJTYowiXSSAolzk4GGxWWDnmdXzJdbKjSzOYpyHfCE7ysXlAg+U6wId+nCdl/G3s2N1uWDoR8pVGUzd5bsLKSYP51+itSYLb/jZKgcN+SpnGqXXzltFVibEwSOyCH6uy4sSPzvKdYaHcA09+aoMVCYZw3xVCk0qi8gWKXa2Zz/X8qKQ3ekixWhNGuZwucqk5/Z6KS8QRSK7X++lH3KyrK7keywuS/BQrgoUinwtVJ7V9RI3Se8lwNXHF5g4YvNiTV6krC4WFKuCfJmz2BTki4zVsyVJmnD5coP3no/+1CumyfHqm88w2nDxckOSpywvS4plRrkuKDcFxSpnebEgLRIuXm5Q3vP8k2fY2fHx/+4VdnZcf+Va2NfPVkJCuihYrOVny3VBvshZXq1IkpjLVxuwjuffuMZZy8c/8zIgDTX5Uh4mi02JnWbydQ5h/XvvKTc52gs7dh6FqY2Wl8O8THEeyvUCF8ZI+sQz0CrMZS33ECdkoXmaAg1KXsyKZZhDG1mrxVJ6eRdroU/liwzwlMG9ZnW9xClPkkqPsrX2vL5Wlwu8k3sKShyYCH2hbrasni2xdg49prKGs6W8EBebknkaKdeFzN0wh09oxmKdM4yyhnAQFzFRHOO1olhlzLNlcbUCH44fCFpeQXlZYp1jeblgmuR+ZYIyOw+93Uke/6Hdy/9B8VN9kP4b/8a/we/8zu/8gb9+9md/llevXgHwZ/7Mnzn/bJqmfPOb3+SLL74A4OXLl/+Dnedut2Oapv/BTvVHI01TVqvV7/n1hxV9PzLNlq4eGMeRtumY5pnj9ojSiu3bHTqKhBbkZvFJ7CfplWpFlTg0A134NU5z6D2F422FjhXb9wc0muYoxJG5FwbsPErP5DjOdHVH34+0x4Zpnml2LSjYvtuhjeF4V+G8ZWgnUU32M1MrHNzm0DC0k5BWBvmzVnC4P6CN5uHNDqU07aETj8Jhkh7TcaatRdkoCseR9tAyjxNVYNfu3u3Q2nB8rHFYuqCEnLqRsRnws6evR/q2pzk2DP1EsxNm7fGhwkSGx/d7tFHClHWesRsZx4mpF6LS2E9CG+rl+GP4DA/Sp6cj9vdHnBVusZtmbD8z9EP4jJ6hFbLK1I80dYe1M8eHI9potu/2aCNEl1OPr/R4Sq/t1AuVpm+lh3MOdBqtlRCmooj93UFYuseOYRAaztBN2FGYvEIp6uT7VB1YR70VDvD23RYTKepdyzzLGI7dyNSPtMeeeZrpjj1jN9JVoffzKOzc3a2cw+H+IPzTQ8cwTIzdwNjJ9W+PA1M/n/tP26OwmuttLXP43RYVi1J1npwcu5P+xKGdceNMtxdiV1t1TJMV3quHw+1BenDvKrSGmx/cMQ0TD28f6eqB7e2O9tBS7Wrqx5rqoWJ/e6CrOx7fbnHe8fp336AUvP3+DdM4ihivHdjfH4WEdH+k3rUcHysOjzXNoWP7bss0W25+cIvH8/q3X2Mixc1nt0z9wOP7HUM7crg/0hw7qm3NcddQ7Sr290fqquXx7SPOe95/eotSije/+w5rZ/paaD7TONPVPW4WlvU4CB1M6EQtzlmZQ1rx+FaEY81BCGBjK3N+HufzNemrjnEIdKJp4vhYo4Hdw0G4uPdHZjszNgP9qVe3HaRntP3QQz0Ocg3t7KgeKkxi2N3sZQ3vG/zkGNqBvhuYh5m+CfeQpmfoRtq6ZxzkHqI00q9uDLu7A86Kz/Dcj8y9zAM3e/p2ZOwmWRf9SFsJd7x6qDGRYftOel2brZDHhqZj6AfmSeb7FGhr4zDRn8bwUQhv+/uKOI7Z3ezBQ3s49clP5/r7lxE/VbHR9fU119fX/8B/93M/93Okacp3vvMd/sl/8p8EpEj+2Wef8fWvfx2Af+Kf+Cf45V/+Zd6/f39+8P7ar/0aaZrycz/3cz+5k/iDwrpzK0WxKpknqaH0VU+cxRSh2rO4WjC2A8trMWXePN8wdqPQaaxjfbWgqwbKZU5f9yRlStxPRFHMYq1ws2V5vWbsejYv1kz9yObFGjvOlGH3s1jlQh7ZLBjqkbTIzkKl4qJk6ibWz5dn546xH1k/W2GnieWVtAAs1jld0xNnKXE+ECURi41QmcqLkrEfuHghzjWbF2vcGHYlo6dYl1hbU2xyuroX+XtIsxXL/Ew0GvuRzasLxm5kcb3ATrO0IPQD5aaQ1pplxtCORLGhWElNtliXDP3A5uWKqZ+4+GiDnRzLS6EV5euU2jeUFwV925MVibiLaEW5ERrL8nrJ0E+sni+Zesv65VroPJclUz9SbkppC1nkDJ3Un4tlJm/Im5x5mFi/WDEOExevLhnH+QNhaFPSHDsWm0LGMI9J5wxj5PjzICSpaZCWkrEbWT9f4ayQbcZRatjjMJEuMuJ6IE5S1Fphnewgp35g/UyINhevLpgmIexMk2W5KWiOPeUqnP9SaurGCNnITbK7mPqJi5eXDP3I8loIT6vLQnwgNznjMJEtMrp6JM4SCiTrU16UzP3I8vmaaRhZPV8x9sOZzlNeyLwvlhndsSUrU6ZhIkokBT20I3PiaD9tUJHh3ffeYYGbH96ijBbCz1RQ7Rp0YjjsKmYPQ9djlMYpsTJDKd59/wbrHG+/f4OdZ9p9TZzG9O0IzlHt5Rj1riYvsyCQkrpltW9QWtTnTomy1wdx3RB8X01i2D/W2PDiprXGIWKnzcsVdpi4eL7BjpbycoGbLYt1wdAOFCtpKUkXmbSHJYZyI9difb2gq3vWL9ZM/cTqWghjJ3ekYlVwmKX9p6860VI46TUtLgvsMLF6tmYaxbR+7qWNyI6WxcWCoR0o1zl9O0prS/BSzZcZznvKywV92wf3qYnNyw3T6FhdFMyTUNKqfcNinZ/bcObZnbm58zSzfC6m4JtXG8ZhZHEtpKvl1YKhGyjXJX07kZUZfTsSxUJ9ciELNXYjlx9dMg2W9bONfOZGdt/lRUm7a+X4RzFdP4k2F5dCVNu8kHvXaQ19WfHHoka6Wq341/61f41f/MVf5Nd+7df4zne+w1/9q38VgH/pX/qXAPin/+l/mj/zZ/4MP//zP8+v//qv81/9V/8V/86/8+/wr/6r/+pPRbEL8pCodw3KI6zMfmJsR8ZxFCrRsRe25rYizmL2N3vyZcrD+x1ZmQrP0ijqfYt3Vkgkg+wMh2Zgmia6qgelONztycuMh3db0jJjd7MnyRPp2cPLjmmYGZqeoe2ZRnlDtlbYlnFieHy7JV/mPLx5JClj9vdHTBzR7OqwO+mx/cg8yRvmPFnaqsfjOdwfSLOU+7eP5IuMx3c7ojymepTdb71vsMPMcByEIzvPQnaxjvbYYqKI7fsd2SLh4e0D2TLlcHckSWJxu3Ge7tgzDzNTL3Qfa4NzDZp6V5HnKY9vd0LleSMMznpbo5SM/zzKMadhZhisOFB4T3voMZFmf3sgW8jYpXnM/mZHEpw8rBPXnXmYseMk3330dM2Acl7cVpKIx7c7ilXO49sH0iyheqxAIT87Wck09FNwfelwThjLSsP+RgyUH99tyZYp+9sdxiiqXSss5KZn6mXHMrQj8zjRHge891S7WohG77akecL2rXzW8bFCa3HSsNYy9HLtpk7IQuMcHIQixeHhQJInPL59JC0zDnfS4nHcNQC0Vc88TcGxQ+ZiW3c4b6m3NVEWs3u3Jc7lHJI85Xh/JIqk59lZKzuuITjndCN2muiaAQ8cH2riLGF/s0cnkfwemeCgJGQdO0/M3czQyPHHdhQ3o32DUlocS2LN/u5AFClxATJaHFPmmb4Thq0dQ6YksJ29chy3FWkac7g7EOeJZH2MDrsvRVfLLmlqR8aQMerbIWQTeqLIsH23Iy0zHt4+ki5iqscjJhIXHBvWy9jPzONI1w64ydNVA0pJ209e5jy+eyQtU3bvhfBVP9Z4r6gPDXacmLpZdpxhp2atlwyFMWENyfHjMudwdySOTeB8z7THPpz/yNiNsgNsR5T3HB+OZHnCw5utEMbe7kiSmGrboBR0xw47BjpXNzJO4hxkZ0d9bNBasbvZky0TOf9c6ETGiBuTs0Jzm8eJaZKxs4Nk7Lz1HLeVzL8w/7fvtyR5El5uODsXtfXIOExM48TY9XiraPadrOEfWUOSwv5y4o9F+wvA3/gbf4Moivj5n/95uq7jH//H/3H+9t/+21xcXABCsflbf+tv8a//6/86f/7P//nfA2T46YU6KwVPlBzvHNpLS4foRkTH55yYaXsH2gWdvhJJuHfgNeCskI+8C5p3ae8g1JNn+0Gy752HQFQ6fRz4s4ITwvcKqsizoCJ45IrO+GTafXKFBK/U2dCb8LEnMZNH2iFOmDatlbTXBMVlaGI5j4k7YdecSOlRHnU6lvogt3ce9OwhPikxkX/vQ/sCiKwfG8g6KpCClBiUh9YIUEJdCsQUHRSv3log/tBigBiNowjHl7d+rTVE0jYgSLnQOqOEWOO9vJ1rL+pCtHyP0znp0H/hINBZdDgPREEbhCzhK8vc0CpwZpW0rshVOF1+GedAAnLWyquxhhPSDq9Q4Xqc2hHkR4M9mdYMszu3EZ0UqMqfDMN1aD3x6HDNpT3Kn3UMRoma1M4u0Lfk81FhTiPj4zzh+D5cWwQLGMQ4AfwjgqREFMJRZIK5uqh8fWjjUJEKJuSeyESgdVC3a6I4DmpksVLT+kRoCqrcE63IfBA0mSgSA24fxlRrtPIidDGIgvdHpBY6DmI1H+bx6YJooTZJ25v6gDk8ibVOxu0+jLUKnqjIObrANDyNhcfjlQ+zRuNQWDuH28NprN1pCsqc9iB28tIuY63DWYhCGwzKY50c22iFnWeUToKYi7OC2iO7vZN364f5KMIhUTWHvZiT7y7kIRkoFRT6XnlZK17GS3b4gZIVCano1KJjXWibObdlIXMxtBmpMHdUUF1LR5L8vQ/3jWBT/iOEpZ98/LEiG30Z8YdJNvp//PX/N/MkvWJ5mVLvW4pFRlt3IgyJDX3TU2xKDu8PrF6sqB9ryosFYzcQZzHTMIqUe5zJy4zDw1EECdYzzy7QfhrWV0t2dwfWz9e0x45ylTM2AyaLmEdRxLaHlmyd0e1bdBwTx4a+7SlWBfu7I5vnK6rHmtX1gubYnakkSWKYxol8kVFta7Iyx84z8+zJyphm37C6XLG/3bN6tqE+1JJqbEeiLMaG795UrXzGriXLYrzRTN1IscnZ3xy5eLFif1+xvl7SVnL8qZ+FijI5ijLlsK0plpJixEOcRbSHjtWzJbubAxfPV9S7lmJTMNQyhvM0kRYpfdOTlznVribNM5TyjMNEXqZU25rVsxX7+yObqxXNsRU6TSf+mNM8U5Q5h8eKxUrSY0op0jKh3rcsLkt2t3sursP4XxT09SDqzdmT5DF93VOsC6ptRXI6fjeRLVPqx4b1syW7uyPr6xV93ZEthE4UpYaxt5SrnGpbkS9y+nbAGLGI6w4txaZkf39g83xNvW1YXZW0dS9tMbMlzYVGU2xyjveVtOl4zzTMFOuCw+2RzfMl21u5Ds1ezn/qJnQiLU7FIqPetWTLlL7uMZEhSiLaY8fysmT7/sDVxxuqx1rGvxmJ85i5n4jzhLEbKZYyh9I8xXnpGSzWOceHivXVkv39kdX1ijaM/9BOJJlhGkVN3OxbinVOc2hJ4hiTGNqqo1wV7O+PXLzcUD1UrMIcitNIcHxpxDxMZMuceldLm9Dsgko6ptl3bJ4tebzdsb5e0x5aSfk3AyY1zJMjD8fP1zntoSWKI6I0kuv6I2vo+FizuCjpGykhTKOoeedhJi2FDpWG9iQ7i0q+eqzl+t8eWF2v6aqWxUVJd+yIUxEApXlKV8m8qPetiIuMZu4kVXy4r7l4teJwJ2u4PXZkZcI4zCRpxDhKa8lxW1OUGUMnfaJpmVI/1qyuFuxuj2xerqh3jaSjmwkdywtBnEUMjaSnDw8yhmjP1M9ki4zqoWb9fMnhvIZ7oUC1E3Eq558vM6pdLdSiYcY5yPI4lD1K9ncyh5u9jP/QDMRpxDzNMoeagXwl1zDJZQ7bYSZd5VR3Mod3DxWryyV/6f/yF/na//YrX8qz4I9FavePa8RpTL1tMEoHQ2kYx0nSKb2kJ+zkxPw4i9nfHlhclGzfbSmWGYf7A0ma0h063Gjp6h48TJNjmizzJMa8YoHVkq9ytu/3LDaFwMuLhONDjVE6CDw8fSPpnHkUQcQptZNkMYf7imKTc//6keVmweGuEnPiqkN5Td9KAV9SKhN2mpm6GawYWSfLjIe3D6wuF5LiWeUiLDKGumrxFsG9Wc8wjmdT4KEeSdKI3d2RcpNz9/qB5cWC/e2RJIsFjO4VQy9N7tMwY0cr8AkrLTrVtibNEu5fbyk3Bdt3O/JlLgbnUUx3lBTQ1E9S7+rH8/hNo8PEEYd7qT/dv31geblgd3OU1NqhRXkxz9ZKMU3SvG/nMP54eUnJErY3O/J1xv3rLcUqp9k1qEifRWJ93WOdF2HSODPPVlJrRlM91pQbwSYWq4LdraRa622L1mJa7B3BkNwyDRPzOIfr2hOnIrpYXJQ8vNlSrgqZf7FgCZVSYsTuZAzHIErrqg5tNMeHmnKdcff5o9xUbw6CdNy3aAVtM2CdY+wn7OwZ+5mxlyb+LiDt7t9sKdYF23d7qandi9F1e+jAK4ZWfnYaJb06T2FeKzEQz5aCnFs9W7G7PZItEqptg9FK/h0wdTPOunD+FmflfJIAei8uSm6/uKcI5x9nEV3V41Fn0dzYjthxFlHKMEtq9b6iWORs325ZXS3YvtsRFxn1tsVoWcMA0xAM4ceZcZjF7LzpSTIRri02Odv3O5YXJfv7miiJBGmnYO4t02iZJsvUT0yTjKFSksLPlzn7mx3LywUPr7dkC3nwoYM5vUXOe7ZyL5lmxskx9jNRHrG/PVJsMu5fP7BYF+zuKkFLVgMaRdeMuMkxjhPOO+ZJxGVo6OqebJHy+EZQnw/v92TrnGbfo2It5QwHQ6g9ToOgTu3smHrRDBwfKhbrgvvXjyzW8oKcLxLaY4/SWsweLEyDZR5EjDYHkEZXy4N/e7NleVWye7+jWBccH2uiKKKv5DPGbpTyQjfK+rWWuRvRseGwrSlXhdwHL8ov7V7/9CD9CcbYBZeNVuoIXd3hQ03MRIbDgzgmNLuGKJK/t9YGpZpl7GaGVpwy+k7qCPW+ATzVY4WJFfvbvUzgfS2fvW+Yxzn4WTrsZOn7QZxSDg0a8ezTJuJwfyCO5QGGloehc15UxsMkD/t+xPaWrulxs9Q48OJmYWLN/v5AnEVUjzUGgqOFC36qE2M/iIpzsDSVeAU2xxqtI6oHUR7v7w6oKBI1ofWM7cg0irvDOIgCtG06xmGm3ktNttrVmNhw//aBODJU2xZt5GYr4pUBO8uNcmiDWrGSWmtTdURGcbg/EqeG3e0eo4PyVyuGZsLPjqHvw81+ZmilnlsfGrx1VLuaKNbsbvZEcSQqyiiiqwdwMLUn5arU08Zhpq3E5aLeNuA8x/uKKJJxiGIttUgPXS31zL4ZpKY+zPTtKLWoQ4ubLcdtjY4025sdJjYcHiui2NAeOrx1dHXPPFr6bmRs5TzausVZcWJRSgm3OTVU9zVRYqj2Dc4hquvpVM8UFXffBrebqgXguDuijOK4rYlSw/ZuD0qd58dJbTmGmqydRD3urKc5tqGeWRMlOrgfSX1TAW3dMgd3nDk87PtmwI4yh51z1PsOnUTs7g7EacTubi/86X0rtdh2wE1WfDUbcSvpjh12munrDrTmEJTfu/sDyhiafY0CcVka5+BSNIkSvZX1dFLHH3YNoOS7xxHVfSUvQ7saa0WBPQ9SS556mf9tI6rlrpKH6nFbYWLN4f5IlEZSiwRR5o4zXdufX7imTq5/UzdY6+irjsjIgytORPkttfAG76CvB2ZrZf2dFOi11DjrY4vycHyo0FoevnEcsb07iJ7hKFqAsR2x/cw4jEytvIB0dYuznmpfo7Xm8HBER4bdzYEo0tT7FocXLcLkaJvu7FTUNT1ucud1UO0bdCSOMSYxVNv63AFgB3FnGruJoRtk/EdLfRDf4ya8/FW7WhybbvZEsRG/XO9o9vW5bfLLiKcH6U8w7Dyz2EiP3Mk3MMljIiOUmiRLQCtRgfYzm+sFXdVx/fElXdWxul5Kn+OqQGlFWsSYSJNkCTo2xMaQFNm5V3LsBi5erOnqnotna/pmoNgU596+s9N9FBHHShr/Vei7HMRDcKgHLl9d0B471s+WjN1IvsrweNIiwcQRaZ4SRYYoMkL/sY7iomToJjbPVzSHlovnK4amZ3G1CH2J4luY5OJBGKcRJpZm6myZMfcji82CsRnYvBBo9fpaFMDFKviWLsSDNI5jcXkwmqKU3sx8ldE3PRcvVlT7ls2LDe2xZXm1wFrPYp0L0SeLMEaILnEac+o7nWbH4rKkO/Rsnq2oDi3rZxv6rqdc5jikV9REEXEeByKNIc4FPFCscsZ2YBNSautXkuJdXi2lH3WVY+KIJPjIxqHvVRtFtsiYR+kdbquOi3D+Fy83DP1EucnwXuhR4uMqfcdRrMmKDALJZupG1tcLmmPD5csLOf/rJfMklCatNUl+mkMxkdFoE5EuhKiz2BSM7cj1RxfUu5bN8zVDM577cbMiw0TiqRtHMUmWiIOK95SrQtTiz9dUu4arjy5oDi2LqyXTMJOVGfpH5nCUiJ+q0eJNaUfL8mJB1wysn0t54OL5hr4dKNYFHumlNJF4uWqtiMJ54CFbiJJ783xFf+y4enlJc+xYXi2Yhpl8kaMjTb7I0JEmzRJMEgXIfQbOBkXpwMWrDU3VcfF8w9CNFBclznuyRYqOjPQMx4Y0j4VcBaRLUeFePFvTVR2XH13QVi2r6yVjP5KtpP8yL6VfPEkSTBITaU2aC1GqWGcM7cD6+Zpm33D1ckNfj8Gv1snxjSHLE4wRyEuUClQkW2ZBJb+kr3quPr6gO/ZswjmUoQ81X4inb5wlAimJ1XkNl5uSqRu5fBHO/+Warm5ZXpWyhlfpefzjOAq+wjFGa4pVxjSKOrk7dmIAUHVcvrqQ8sFS5qn8bEyUC5ghTjVJnqCAtBSjic3zNU3dcfXqkr7pWF6vsE6A9yaKSMsEExniJCaKDCp4utpJ5lBfD1x/fEV36L+0e/3Tg/QnGDqk67zztMcOO1v6ZpQ3vEHUijb48UVJzPb2SL4suH8nqt3j3ZEo1jSHNuzk5I12aHqmTnaNfTOggONjRZqlbG/2FMtM3tQzI6pVr6gP0mcoXn4D4yAKUuvEZ1Qn8laZLlIe3j5QrDJ27w8kaUK1rSF4itpplp1KPwR/SXGBaB6rsx9jvkh5eBv8QO+OKCV+iNY6Oefwlj+0kuZsDx0mMaL8LVO273fky6AaTaR+dRpDN1vmWTxR7Si7be9FtZjkGQ/vdpRlxvbdI1GaSq+eUhwea5yDrpGd1ckT01on5x8pdrcHilL8ULMyYX+3lx3jXnaQ3bFjnsWdZBhm7CB9g95LpiDJYx5vJR0q6tk49Aoa2UkF1aodJlEedyNT6Pc1iaZ6kNrV9t2efHVSXovjDR7ZDU1OVLvdwNjN9I0oj6uTavbuSLbIeXgnfozH+yNxooNqU9Ko0zCHc5DUYFf3srt8qMmKiPt3W0mx3uyIUkP1UIlq8tDgZtnlTdPM1A2yywjK7ygRpXOxznl4tyMrEg73x7BT7HCz7FTtNDMOg+z4ZhlDExkOj0fSXNSqeZmxu9sTJTHHbQVe0ucuzOF5GIOvZlC+75uzl2++kvNPi0R6dVMT1tAps+Jlp9jJWuzqXnZzu4r0pBot5PckjakfaxSK9tBjJ3fuBx4HSS96K4ruOI5kDq0KdncH0jLjeFeJ8nzXgPU0lWR2w3cgVQAANRJJREFUxmFk6gfmWXaqHqi3rSivb/aUoUyTFBHVtkIpRXvscbOTHd4omYqhkTRvH9bw4e5AthT1fFKKL26SiI4CJ/eQebQM/cwwSK9y30jJqH6siPOY3e2BcpHz+FZUw8f7KnQgtOEeNgRP1SGk+UXJq2PZoeeLgsf3O7IyY3+7l51zyKSJen5kaKawW58Y2wEflO1J8CHOFxkP7x7FLWd7RCsd7j+WrpGM1dTLPdDOlu7Yooxmf3ckK2QOZav8y7vXf2lH+l9hiLJT1Gsu+OwJaUmj4wiNqOZE2+nOgHp1VsxxVsCBqPT0SY0oZoei5A0eik6LKtQHmLc6qSUR3qhWcizBpwWBp9dnGLtWok7UwWtQePGibsXo4I15OimFQ8HswncNHFoU/uQnefYRDWpkQJTA6uxZqbw6KzhV+GxFUAYTVItBh2d/BFitEc9QP7ngdSjsVRXYo4KzC8fVov4U4LXjLGIO4mdnPRrhhno8Z6Za4KvqwCT2CHPVuaDSPF+7DwJBdVIGKwU6KE61aCixYiZwGn9BpwnqTDlR51oXxjOoR0/qW1FoalErenfGDnoUWhnBOQZZqdYnpF3gwwYPUAKQ3RPMD0If70khqbTCucCCFXFnUJaCViaojD1uskGtHFSjWhS+cvnUB36tkvOW8TjNZ4Ji9cP4eivXRSlR1oJgNZWS89UoMKeRFqU5RrB/ZzK5QlTjJ99MEA/WoPgNl1OUpkHFLL6zH8YkTDhZn9p88FIlqFm9F3/Nk1fwSQWvCAhFgkLc4qYPrF+nglJenbTrgSuMEoB9GAelkH/rw1QNfGDvRdnurIDvXVDky8cJtvAE1Fdag1VoZM5qpbCnjoDzeYN3s5hoKB/WyMnzVZ+Vtdqo83J33gcFuj+nTFXwBj2fjxPVsrNTWMdhXmiFOY21J8x/h3Ief5qTszvPd7mconx3KPlcBSddrJut4FK1EQME7/FOob0KPb3+NMp/8A36DzGeVLu/L/4wVbv/yb/7/wyiCku6EB/A5UXB/r5msSmYhun8cBr7iThJmMeRNM+Y5pEkTUW1m8YhxVewv92zvlpy3LbkSwEzOyuc3L7pyMpM/CeLVFSzqcCc82VKs+9YXOYiqlkXQeQgIPu+H8iKjLGT48/TSJwmTONEkiUM/cBiVXC4r1lcllS7hmKRYGfPbC1RFDE0vXA6p5koiZjG+QzkT7KYvh4oN6IuXGwK+kYasr2HaRyJ84ypG0jShHmeSdJEmvbTiHmcKVeF+KVeLKj2DfkiC44VjiRN6JqerMyYh4kkl7EzsTnzY9tjz+KyZB8EOX07icm2grEbifOUqRtkDMN5z8OESSLGXhrD9/cVq6uCw0NDsciY7SwPE6MFFpFnzON8Pn6cxuHPCUMj57+/q+T49UCSRiI+GgSS0TcjWRGLSjFLmIaZODFM40y+FMXv8lJELItVLm4jymNMxDDI8cduJC5S3CRM2nkUH9C+GUXEcXNgdVFSB2X2PM3iu5pEjG0vmMRZjj/3EyY12NEFxXXN6rJkd19ThuNrBcoYpm4Upfk4k2bCj9ZphO0nkkK8JBcXBbv3MoerQ3sG9VsrjOOu7igWOdM0EacJ8yjA92lyFAvxGV1dluzuxDd3GqZgvm0Y+kHWTD+QFmm4huE6ZLGkqS9LjrcHFpclzb4jXSTYyeOtxcQRYzeQZCmzlfk3D3M4f0u+EOX98rJg9/7I8krmkInlxj/24XjdQFpmTKOs4XkSX9yxF0DK7u7A8nJJc2gpFinTNEsbTxLTVx3ZIv8w/8ZJGNDWkRUx9V6gHrKGM8bRCjvaezleljF2PWmZM/UCzZjHERNH2NGKavuuZnFVcnyoBcYwO+Eyay2wiOC3G2cJ8zBikhODWURDi4uc/W1FeVkwNuKXaq07z/OxHURxPsg5iPJe1mGxymQNXS44bI+Uy5xxFJeXKIroO/HBncYplDwmdCTjL8r3gcVFcRZm9rV47J4EbHGWyDVMYv75/+tf5mt/+uMv5VnwtCP9CUa+ELm6TKaJOI4F9Bzk9FEkjiEoSFJ5EC4vSo6P0gJR72qyZc7Qj5jEMI8TUSw/E6cm3GQjtCYwU3Oqbc3FizXHYO7bHnviPBICS6xD/5YYhetIFoCONFme0TU9i4uSw8OB1bMV9bERE+W6Oxszo5AbU2IY+lncRBzCFF1k5589bmtWl1LzS4qIsR/RGuwkx5uG6fyA0JGRm0jdUW5Kjo8V62dr6oOQiKZObgRz+LfOC5x87CaSNEZ5cRBJy5RqW7F+seb4cGB5uaA99qRFIm0sicHNjiiWczFaMQXLqCiLGbuB8rLk8CDHr7Y1xTqnqweSLGYYJqJEY50nyQTSL44ZsqPPi5Rm37B8vpRxuF6KmfsiZe7HM9BcK7F7i2LNGGynTBxLTXtdcHisWD1fcXioWV0IESdOYuZRdrPzYIliHW4yOuw4ZQ5V25rViyWHe3lYtMdWSFDdSBxHTIOM3Rzg+HM/kWYp2ig5/3XBcdewfrbm+FixuCgY6l5ejIYJY+SGGMUaN87nmy4ekkLUwatncpNcXS9odjX5KmMMBtXSiiI/k6QJdhDTb60VQ9tTrnMOj8cw/pWc/+nmGkzep9FKW8tsz8bp3jvSNKE9NKyuQwvGsxXVtiIrpX4aJxF2nM6kJBNaUqJE45WoUNNFRnWQ9pHjQ8XyesFQdSR5xHSyCDu300hbiZt9cHqSOby8WnB8OLB+vqI5NuSLQkhcibgsnUD3SSovHXESo1FMw0S+Kqh2dag11yyvlvR1R5zF9N1EHEn/pjYaN3lMpMO8ECB9V3csLuX40sZSs9gsmMcZk8ZMg0VpxTxOxKm87JpI463Fupl0mVEfO5bXC2kjulzSVR1xWEMm0thwXDdZTKSZgllFlMjL9Opa2pjWzzfUe1nDYzegY7lnCPDfyovSCWzvEOepMqE5NqxeSDvd8mJBd+xIyoSpG8+mGFESMc8C/h97aVGLUyN0rU1J2whF68uKpwfpTzDGTtoT+laIPF0rrNm+6sA7Do8HjDJU2wavREI/TY6hC/WzXuoIQyDRCCe1FQXsXloC9ncHANp9Dc6JSrIVld44Cv1j7kWm39cdfTfQHhuc86KaVaJedc7SHtpze8vUCflk7KRNZqxFOTf0okqtDy1RpDneH/EaIdd48Z8c+lMNQ1oUxmZiCsrTeZB6hvNCMtGR4vhwBCU1SDsHzm04dl8PdI18l6Ef6esOO4ryz0RBeRhrukMLzjHUPUPTn8d+DqrRsZvoAoO0CeffHBsiraj3tZCD9i12kPrd1EsdWz5HrsPcjXRVj+0nUd5q2N3sAMVxV4lHbDsyN2H8AzO4r3v6Tr770A50XRjDXYMxUO9rUF7INfPEEK6fmya6bmQInzX1E2MzCBf32OORcTfGsL8/hNaEQZSu/RxaXCbGwD4exxE3SbvLbC3NY4XSOnBKvSg9gaHtmHppD5F6+Mzcf6hrT5OjO7RYHPu7IxhFta2k9tcLm/f0y45CThIFsjCQ613N2E9U2wo07G8Da7gZ8M7L3O9E9d13wpseuj7U04J6eN8CnuqhQaGptjXWWYZukPUySB15HoLqNCjf50HqxH72tIdGyFEPotZtj6LqnrsRO8yiHA/s3CEwjMegZO6qDq8Ux1P9btfinKNve6awBoZ2/PBzY+BYDxPdsWXqB6qtMIYPdweclzqzc3Ng3fbMQYsw9kLzsv1MF1TcXd1hvRC1ZPxrvBf60DSEcWvHQF/qRZvRDcy9jIufHc2xxRg43B9Bi+IZLzXTsZM5P44zUydzaDwxwMf5zE2udkIOO9wdwPsP59uOTK2ozodmYOhn8fmdhN87jTP1VhTGh/sj2ijqbYWzlrEdsK3c74Yw5lM3MU2OsRuYuknGyjqqe+EV7+8PQZEuivP+2Emp4EuKpwfpTzCstSw2Jc6JqtMoQ1akKC1vT0meQCQ7mXlwbK5F6XrxckN37MWdZBhZBNZkvsgwsSEtE1GtRuIo4bzwcodmZP1sSXPo2DxfB8XfEmulmV8HZ4ooMiRFIjZukTh6jIO40bRVG1RzPZvrNeMgKVW0MFm10eLSYMQWLi2EiFKsc4ZWjt8dWi6uV/Rtz+pqiZ0dxSpDG0W6iNFxRJImmDhGhzGZB3FjaY89Vy+Davj5inmYWF4uAE+xLM5KWWOEYBMHu7AsQBJEcdwH1WrP8molMIFNjtGarExFPZsnRHECRsbQTo7NszVtPXDxfEN77Fk9XzP2E8uLhThwrAtRXJapuKXEEVmZorU4/YzdJGNYC6+0r/vAGnVnF5t8kRNHoraMMhmDJEuxoxUQQzty9eoyQCbWkg5eFzjvyJYZKlLhu4vyWRxvnLjyjDMXLzY0h5arV6KaXF2JavfkfJMWachACBBEG312Fio3BcOxk884tqyfrRh7caBxXj5DGU2+kDFMs5gk2Plly4x5tKyvVnRVx8WzFfWxZXlRCuv5skRpT1ImRGlMViai+owM+SLDO3EWkvO/oD60XL7Y0NU9i8sw/ktRb2fL7OxlGeURRKJGnUfL6nrF0ArzuasGVtdLpsGy2CzQSpEtUlE+hzVkIiOWW94Jj7YbJBuzb7l4vmboRpaXCzxKXHy0Ji9zdGRE/Zok4nhSivJ5ebmgq1quX4nyfvN8zTSK8t57WcM6NuSrIuzEDVmZoxQsNiVDM7F5saE/9qyeremrQe4hsyNbpphIky3ioJ5PRP1somBjJ2uoqweuXqxpD/IZUzex2BSAJ1sW6EgTFynGaOIoJlukKCXj29dDUAuLermrOlbPVngrDizGaJIyxiQRWZ7KOjZGvEtnS7Ep6dqBy1dr2vCzYz+yWImbUhqUz9lpDaUxWZGcXZnm0YpquRLlb1/3rK7XknFbpiitRL0b5n+Uip9qFrxTy4uSLtxDm33zpd3rnx6kP8HQkQ47tyg0k3v6bsJZx9jNzKMVFVw/oozi8HAkXSTs7/eS4tpWpKnU9hSKvh5QgUZjrWceZyHfaCW0lDLj+CDkn93dgXQhaZI4juiaHqUUUzvhvDREu9nhZ0JdNKJ6kIb4/e2BcikUnzSPpe8NGNoRb73slpxjnqykJlG0x5a0CFCHQJlJiph232Biw9CMoBR9K5xhgQpIY/3QT0RJRPUotdv9fSWN2A+iQO0q6Tvsmh7vpPnbWVE+Cq4O2qNAvPcPFeUqY/dwCNShBpMauqrHeVE8egtzP2GnCT85SZmlhnpfsVwLoSZfZVQPR7JFKkAGhfQfOsfYSTP7OEwCmEAJECGL2D8chdR0eyRfZDS7liiV2hJKi2p3dsyDuKtIv+aESTTNrha18P2RfC0Uq6xIaUPP3NCMKAQIYGfLNMzM4fhd3WGy8LPh+md5QvUYgAT1IECIcP5Tb5lngUoMvaSM631Dusg4PgiYYn93JMlj2mOHMpqhGQCYerlu8yC7Xrz0DZos5vgg1273cKBY5lTbhjiPBYhgpc/YOydOQeN0BhNID2JNmifsbg8sN6Wwj5cZ7aFDR0Z6lL0XIIPzTJ0AGXACGjGhFzVfZuzvj0KCeqzJMiHneIXMP+eE9zvZ0Os8YbShPbbkRcbh7sjiUurxSRnT7Fq0NrR1j1cwBqjH2EmmZbaevhuJMkP1WAfF6ZZiKTCBJJXzV1rRN2MY/wlvvUBBpgmFojm2ZEXC8f4ogPqHI2mZhr5zLdfQSabLW3cGc5yUzEkmCt9iJde/WGYcH44kWSKZC6UZWlH+Tv2It5ZhEKgBQFf1pGXK/r4KqvEDWZlKr2aosftw/b315x5rH1yfosTQ7hq5d9zX5EshcaV5QlOLqravB0CIVjjHOEjGA+XpDh1RYjjcHykvcnb3h0Bx+jCG3qsAhFD4yeKs3EMlda5p9hVpEcs8eFLt/skIY6RPUXSzJ8Wu/NXJfzM6GfYajTGi8jQmkpqH0kGYqNCxDspMUXp651BGFKF40EFwYIxGx8FIWH9Q4CkVXO1jE5iwItDTWoQi3kMUaSIdXOtVUKqeVHYGdHRilBphuGp9ZoIaY4T5Gku9SUdGDHx1IIIGk+UoFrNirQJ/NChunRexhTIEAdbpnJwoU03451qhY4NCzLZFyavORt4mGDlHWhPFMsaiVJa6ThRFKAUmUmA0Kpbv55woMmUMlZiQG4NzwrJVRo6NBhXMo8X4W8SYJpEvGEWnsfHB1B1hvGrCd5AfiBJNALFiYi3nED4PPEZpEfFofb4WSvmzghR8MNkWJajWBuWD0tKo0KsZyXUWMaX8XSzXTJ9+NzK3lBbDbVF6apQRE2kTGVFgqxPzNXBTg3JUa4Bg+O3ls8BjtJbPjgzay7w5fa+TAtlERuZy4DdHp/EMvGAd68CjBu9tGMcw7xTh+spcUUFwZKKgHg9qaRO+z+layHxQGA1GKeI4Rkc6zE8NCC8ZNCY2RGEt6nBsTVBEazGzV0Y+SwXGbZQY6XHMYkwU5l+45koJ/1kpL/xeH3jUQbVrjMEHdbMKcz0y5swQ1kadx8CrH2FJGyWG9mFOaiX3Erl++jzuPnB0daTQkXj3mpNhulIy/v5kpK4xiSYOawgnc06hgpjZg0GU65H8sl6hk0iYu1rJOtJa1ovSmMA3Bs5Pnig2YXw1OhLhoTYa7yDShigYmZ+U0UoFRrn3eCNqYaUVOpF1d8oynL7DlxVPD9KfYNhJ0pJewWJToOOIokylMB9r0jzBes42XpcfSUp382wpKa3rJdNoKdc5SinyMkPHOqSmUoyJhIdqYfNsydAObF6u6aqe1fWKsZ9YXC0kbbIUc904i0Mzv6SWnXUs1qL0XF4v6epO0kNNz/r5imkStaJCkRXph2b+3GBiQ7YQe7blZUnfifXWSXDQVQOLTYH3jmKZn3mdSZaS5ClZnqK0ZrHOmfuJ8qKg3fVsXmwYmoH1VckUlI7eebKFAAmS1JDkkl5chLTn8nrJ1E6snq/pmo7F1YKh7llciIl4sSxRCJBApwYdSWoMD8vLAjtISqmrB9YvNvTtyGJTMvYzxToDj6S2tSZODHEmKaofNXGeu4n1yzVD3bN5ccHQjiyulvjZU65KlNYkWYqJNSaOBVKgFMUyE7us6yX9ceDyo0u6ZpTUbjeKzRQ+pOUFJpDkKTqKKBYpHsXismDsRkkLVh2LyyVdM7K8FBu3PMyhOE3QiSEKMA9tNMUiE1Xy9Yq26li/XNNXkhYc24F8mQOKcpljooi8zCS9n8hnOC9G69MgP9NVY/iMgfKiFOPltRgv52UmKd1EwCIgzfx2Esu5vh24fHkp3+PFhrET43lQUp4wiiSXlz2daPIyxntYXpRMjaR0+2MvYIZmZHGxYAz2hUr96PET4jzBawFyzLNjeb2gq0cuP7qgqwQmMjQD5aWsnWKZg5H5LybqwXBdKZabkrETo/WulpR6V7esrldMvaVYyrXOloWUFpJE0pKRrGHrPMvrBWM7cfHygr4auHi+om16lpsCbwW6orQiDeegjCYrErCeclkwdTPLZyIO2rxY09eDpHaHiXyRglfkywwdgDBxKg/7rBQj8MXVgqHrWL9Y0R1a1tdLulBasNZSBJhFnCfykhFKG97DYlkEqIqkp9fP1zL/rhZM3cBinUt5apULmCWNpbRhIjGzd471s6VYML7cMHRi39jVA4uLEhugIiqYy8dJTBxFZIuCKDaUC0ltLy+XdFXPs69eU22fUrt/IiLOE7qqJcljugAQ7wIEvW8lnYZHJPbBrqjYlBy3orSrt7Uof1tpWO8CqHxoR7QR5au1liig8U7tCYtNwXErqY3u0BHnoqaL44i+DYrbdgItPX0n5Vx9aEgKUb4uLkqqx4p8IbQVkxhRXsaGvh2IjWFsx3Pv1tAKIL47tJTrkmbfCKnn2JEUAjmPk4ihnTFaUrxo6Y0TFWbMUA3ka4EoFBtJi2VlQl/36ESA2SrSjM2INoppnGQHZWBsBpIyoj1IW0y9r8k3Be2hJy0Ffm1iUfpGxjB0o+y4rWOeZtIipds3AhB/OJItMppDQ7lKRbWaRvRVUM8OE3FsGPvp3Is6dhNxHonpwKbk+HBksSpp9w3pIqFvBuJIxi4yRs4l7KjtNKONoTsKkPz4cKRYp9TbOng/DiRxLADxyDC0PVorppDiwnvGbibOYuptTVZm4rW5lHNIipShHoMyd8QoI+lc5QUsMbuz4jQvBOJQbHLq7ZF8mdFWHVEaMbaimu6anshopn5Ga2l6nPpZUtiHlnyRUt1XAS5fky0y+rqTNqJuFIVu+H2ep5BlMcJ6zVOO2yOLTUH1ICn27thJarGdpM2qFaXp1EzgNTgpN8R5TL1vyJYFx111BqSXi4Lu2KJjSQ/r0KpkjJL0ZHC/GZuRtExk/FcZ9WNFcVHQHcU/uK974kiuu4kUYy9z2U5eFNx5THuU8622FfmqEOX9IqVvB3RimLqBKNYMg7R+SfuW7ELHViD/9a4iX2eieF0XNEdZw30zEiURfSOWbfMobTMOf1bBd4eObBmOH1K72UJ8hJNUftbEmnkQFfHYD6HnVjHUPXGe0mxrinVJvWvku4eUb99OGC1zKIoM8yCKdztZpknm31B3ZAux7yvWBfWuIV9J7TXJIoZqwETSKhTHmqEbglOOjH9SxnLfKRO5l61P95BE2vliw9DKNRz7CaOQFkAn3QBt8Ck93B1ZXj6xdv9EhA7pGpwmSkxIbUpjexRBfErvZtEZn4WzJGUq7QR5DAri2JxTb1ESydtgJKmeJIux3snu0lvSQt48pYDvPrRcxAYVaZJEUjlaa5IkBqNI8xSlFMUyx+iADvSOpEhReHQUYUyESQxaG7GpMlpSN7E0xmdlhsYTZzGEVgC8/Fl5ULGkbqJYoYzBGEWSiVAjySKcVyRlAk7cKPBejq81cRClJHkiIqc4pACROrR1ijiPcRbZcSlNkguSzAQxjo71+U38lDYziaSc4iRimqV9RkeatEyJjCbJU0CH4xmi1EhD/ikFpQX5CNJ64MJ3986TLmQXGWcJ3nl0JI38gkaU3fwphZ0WKcYoslUu1yhP0EoEMdZ6TByJbVgaUq1J9CFVmkjuNsljyVosBcWYL0SYE2UxRsm/M3EktmCRkhSvkXRbnMTgPEkuqcpsmYFVpIWIgNJMzlHHkpqLYgORjEWURBDGQQHZIkYZRVqm4dom4SZnzqlMSRuHMQgpPZTMO6c8adg9xWmE8ghKURlM/CE9rI3BJLKu0Jq0kDmcFglKeWkLU4okT1HKEyWG6DT+kawbHQRzWZHIbj1LUF5QdUbJPLCzJUoFA6iMQod0t1IabZDsQnQqmXjyheze4zRBI9/dIwYWWgmg5FR60JGsAx16maMskaxFkaBQRKlY+8VpjFdakIBxJOcWYAly3jJnvBbxn9KKpEjD7jlB4YnjD/NUKxk/j6T75dqI2EcryBY5WkGayZjqcI1NGoU1LLthpSBJBdWZF7IzTcsMgiuSxssa8tLyp9BhHUrq2IUXKJNK+5NJIrAyhlpJ5sUDcR4LFOWUBjYaFYUSVhjXKI4laxbETAKB+fIQCU8P0p9gnNBrfdNjZ0/X9NjJMjY9ChEigQgwbLBba6s+4PjEqLg79oKWqwXF1lUtzkNTya6kCZBqMWuesYMVHJhXtPsOlDhuOOsYGgFvD82INgR4ONSHJhhmC65OAc1Ovlt77ILzSBfA472g1uoeY0TEY60VWX4342cB2uMFKYhDANNBkOOdOJV45QXS7YOrxyzCqT443LT7Fq/ETNp5cReZx3B85+nrEaU01b5FnVomhgnnLPW+RQVsn9Hq3NbQNx3eSXuRMXJugi0bRLDQCS7Rh9YUrUNLhPL0bYezjj5ch74V8Ui1lWON/cTcC6i+Obb4WVqU8J722OOtow3Xv20ErN9WPSag18QFZqCrRNBUbcWEQL6zpatOJtC9APWbAa2UGLd7xNWkn+Qa1gI7l3YGqPcfWoO8Q5BsnvObfVu1WOcFSl71MHuaSto52qrHEVxrAp7OoRjrQQzj9x3ah7aDYWbqrIDzvaPedWitGdtRds3tiAvHBQK8XXaHdhbRyNiOMHqafYtShubYyxg2Hd6K4E2hpP3EyRgqRUAfSntJe+zQxoTPgOrQoLUJzic2GHRb2rqHMA/BMwzSamRHmUOg6I4yH08ozq6Rayl/9vL9wlq3gwi3ukpMKZpDg9KSaXB2lvH3jr4WB57uKALAtpLPnLqBsRkFJXhowTqafTABOAges6s7ae+oewjrn7BObHCj6avQ3rNrMEYHoZun7wJisBHBz9DIGurqHo3M+aETSH5z6OT6H8T5pz92oXVlwOMZ2h6vBTwPUO1qER/2E33Vhxa5Dq9O9wPEeMN5yYZ52YGr0Drng6vM2EvbWnuUe2e1a4IZh5gR9O0AHoZwnzgG0/f60GKduDo1+4ZimZ/vr19GPD1If4KhtZKHmvJi+WMddnIM04RHyY1Ma7pjR7pMOdwfyEJqLSkkxRXFEW01BPrPzDy5c7+ic+JUkmRG1HFFyvFRlKaHe2G+ymKWSXpKgUzTLDfSZgTEvijJ47NK8Hh/JFmIajRKI1noQek4TxbrHWM3in1X3RHFhmZbky4T9g9HYbw+iHpOXCJOLxOWeRK1r3JIalILfzMuEg4PFdkqZ3+3J1tm1PdHkszQ1x1ayfnbcA7jMKJCetNkmmbXkBYp+7uKbJWxvztQLDKO20bSQUEtOw02qH5l/JXR9FVHkkSSSlzk7APzd397IMkS+qO83AztyDzLd5jGSVSHbY+KguJ2mXG8D+f/WJOXGdW+IUq0cH1nsX6bhwlnvViaeeiajjiJON4fyXNRTSZFyuFBjt81A0p9sM+yVo5vnbjcEHpRsyJhf38gD6rFJE+odw1RKqppcQMJ1mtOlJ42vNgkQS2ZL4LiuZBrmOQJ3bEFpYLlmMUNE8MwYkPfIBF0VRvYugeKRSoWfEV8Zh2f3Eim/mR9Fm6KytMfu8B0PZCVHxTXh/sDeRnTHFqhb3WDuKFMcg7ygOvDS1tDVqRUD+LXur87kC0SDg9HkjQRG0MravF5tHgvD23vxVrOxOLCk4V1ly9TDneyhup9g1GKoZ+YrWOarahVwwOW8GDPFqJazgphzIpH6IEkkbSs82I9N88z1nnGcQKvGJqeKIuC128qvNgy5fBYk+SyhqJYh2snCMJxnMHJS4nSirZqA9u5krF7ENbv7m5PlBraakA5Ob6dLNY6hn6Ql8RaYAn1riEvJLWdlrGsx1JoUsaYMG+dWMENM1gYml5ehpqBNBNecr7IzmN3vDuIavcoL9dDNzFPU1D8j/JQbAbhMR8a8jJlf38gKYUbnZcp9a7CpDL/XFhD0zSL+rkbz/fSKDGB9Ztz/+YhtPx8ORF9aUf6X2N4JG2GCsxQDcZjvEBHtTZ4K+7wYzeRZDHOSkp1HidB5E1WUmk6KPYIKlQ8KAtGqD7ybyfSQoQbWZExDTNRHOOtE7WdDrBTJ+o7gqI2iiJm60R0MFnpaxwmsjzBzjao/AIzViu0lHQQPrCQVkwSYUcnyLfJCqpvtCIoQhSxzFq+t3fC0AxMUa2MoBCzBNtLvXLqJ0EV9lYYndbjtdRBPASmrheW6GCF+DTMpFmCG624gQTykbMWOLFpfeDn+nONVBktJumLDDtOZLkIF9JScH8mjlA6pPCUASM8WS/SYqElJRFjP0k/2yRuLGM/Cs0qsGyFHyscWVGQivrUGCEtJVnKPNsw7jNFWZxbMwis0+jEjkUFNJ7GWUWcpYzjRF5kTJMPvblz6G8UNq05qUWVEt6tV2e83zyH852sjPs4i4H8KOhKHeTJ2ogq26BEmRsJYUcbwzAIGm+exUjeTV7mkvdBaS2pNi0STLSXlCZGY6eJKBET+KzIQu9xztTPxGkiaeGTsvbEH9YarfQZLzeert0kZu1jP5EVGfMktV2l5NyVUkE5LIp2tMJNMnfsZAWzOMhamgcrBKZwTI3CO4sOc1Bwtx4TRQz9TFokTLMlzhLsOAnGchaaj9Kn9LaWn3fgkfVvx1kQoZMVEtc4hd7QD7hFZx3GyJgJ1tfinbCUIyMIwjQTrGKxzJnGkXxRMM9CIHKclOCBkRxY3EorwZjmKdPkSIsUO3vyMmXowxqShYpSJjCMFcoIJc0rUQvPkwtrJ3z3YSIvpDc0iiTFbZT/ES6xpF+VVszWCZJ0smRFKuKiPGUcBBXppg8MZh/4y1oHJrSWz5xHS5omeOvJ8oR5frJR+xMR1jmi1OCdDw9UaU85gdy1ESxWlEW42ZGGiZOExRCd6oyJQStEim4UkYnQcYT3YkflZ3mQudkHN/mAMJsFvwZSEwKFigwmikCDCQ8QExvsOBEnMeM4Cw5tFPGInT1JmJzSnuClthMbCC0M82xJAqorzRPGcSZKBaEnUnQ5f60UJo7OtSmpX3qSIsFOjrRMwgNFHuBRFmOd1I59qAd5j7QEaHmY6VCbjLOIeZ7JyoR5ciR5jDvVt7zUYYFQm9QoHZ1vrnF42EaRZpqsCBvGiTiJBJAdCZZM2oAUcSQtDgKFkJtRnMb42ZGkMXYSUYS1Xr6HhySLz20yUt+VlifnPHFgqcZZJMKnRco0Wkxq8E4waKCIYyMg+CjUSL20D3jn0JGg65IsYh5Gklx4xUqJAYG0THFusYqiDzXIKI7wsyNOwvELYatGacw8u1DP8vJCF1pyCC0rxhgAqdHPUk+d+4koM1grnF7lPkD0ozQCg7RCxEZqs2mCn728QE0yZ+1o0ef5GUk7RGh3OdWbPR4TG8FuZvF5zcyjPSMt4zQSjm1oi4liuW5aaVS4dlEqN12TRj+CzrMkRYy1wol1zoeWNU2cxmfjAcHbOeIslnkX+MBZIUhDHRncDHFiwFv5HWnx0FF4nCUR1opWwk2C/bRhLrnpNIel/u3xZ+MKncTEeQRe1ruz8hCeJxk7Z6Xtx82EtjNHkobWttAeo071fe8wscbNM0kqL6VRHAcMoyAdTWRABRMLpfGhRcjP8iIhojW578RxLBjGzJz/HhRRmsjvoT6stCJODMrJw9hNljSLBdeYxXJfzGL5fokcP4rjcxuUieS+l2SpnH+ZMk6BuduPX9q9/gla//viDxNa///9//wdHt5uyVc5PtSI8lVOvW3kjW224Q1bHmpd07O8LLl/s+Wjn3nFw+sHLl6sxURb63Oqrrwo6aqeOI3Oi8WOwkzdPx558bVrbj+759U3n/P4fk9xOn43UaxySX+scuwwyw3Jy0NiaAYWVyWPb3d8/KdecvP5PdcfX1LtmiD2EVWo+Gb24QEkApI5gPIPD0euPr7k/vUjL7/xjMd3O8pNcVbnlsuMw70oCmW3Ky8aJjH0VUe5XvD47pGP/9Qr3v/wjuuvXlJvG+LYEGVi6ba8EFVwUqQ4K32f82SDwXjD1ccX3H/xwKs/9YKH11vxJJ1mptGdm9SzVS5Kzyg635xO3pe7mx0vP3nO3eePXH/lkuqxkr5AY6gPQutpD2J5JX2m8kJkIkWz77h4teH+80c++hk5/uqZtDU470PaWxrup35CRfKSpIOSuVjl7G73vPrkBTef3fP8a9eSnsyFAtU3PcUqp9rVZEUm1w5xzzGxoT00bF5uuP/ikY9+5iV3n9+zfrZi6iesdWRlJuCLTSlK6/ASobRi7CaBOdzuefXJc24+u+Pl15+zvTuQl2mAYnSU6/Lc+D+PTtSv1hFFRjw4r5bcv9ny8c+85O7zBzYvhLajlLRQHR6rYFowEMfRuQ9UdvSSUn/2tWfcf3HPy288Z3ezJ12kKETlWW4KsZxbZkyB9+qtvOA1h4b1sxUPbx559a2XPLx5FH/XY4f4ASdUu4bFRSkM2SQKvYuKcZAd7fHhyPVXr7n74oGPvvmch7c7ad9CIAzFOqd6FHiJnYRdfPq9Dx68j2+3fPwtuYYnb1YTRec1VJzUqJm076AQ6HsaU+9qnn3lktvXW1598ozHd3vKi1JALr3stqtdLeM/SMbEhbXUNz2Ldcnj+x0fffM5t1/cc/3xNdVWDMCjLKHdN2Srgu4o1oPeORRgrTy0Do8Vlx9f8fD6gZffesHjm0eWlwvmQTB9xTKleqjJVwXTKCp45zzaSA273MjxX30zrKGvXlI91MSpCN7aY0e5KWh2DXGeSnZOKXmJzcVy7uLlhvvXj7z6VljD1wspC0w2rOGKYl0ynRjWoRd36EbKdc72Zs8//9f+GcrV/3Ll7v+cZ8FTavcnGH/h//znf9pf4Sme4ime4il+wvGU2n2Kp3iKp3iKp/gx4ulB+hRP8RRP8RRP8WPE04P0KZ7iKZ7iKZ7ix4inB+lTPMVTPMVTPMWPEU8P0qd4iqd4iqd4ih8jnh6kT/EUT/EUT/EUP0Y8PUif4ime4ime4il+jHh6kD7FUzzFUzzFU/wY8fQgfYqneIqneIqn+DHi6UH6FE/xFE/xFE/xY8TTg/QpnuIpnuIpnuLHiKcH6VM8xVM8xVM8xY8RTw/Sp3iKp3iKp3iKHyOeHqRP8RRP8RRP8RQ/RjzZqP2+ONmzHo/Hn/I3eYqneIqneIqfVpyeAf8wlt1PD9LfF1VVAfDVr371p/xNnuIpnuIpnuKnHVVVsV6v/8B/o/w/zOP2f0XhnOPdu3csl0uUUj/tr/MHxvF45Ktf/SqvX7/+Bzq4/1GOp/P4oxd/Us7l6Tz+aMUfp/Pw3lNVFR999BFa/8FV0Kcd6e8LrTVf+cpXftpf439WrFarP/KT8h8mns7jj178STmXp/P4oxV/XM7jH7QTPcWT2OgpnuIpnuIpnuLHiKcH6VM8xVM8xVM8xY8RTw/SP8aRpim/+Iu/SJqmP+2v8mPF03n80Ys/KefydB5/tOJPynn8/ngSGz3FUzzFUzzFU/wY8bQjfYqneIqneIqn+DHi6UH6FE/xFE/xFE/xY8TTg/QpnuIpnuIpnuLHiKcH6VM8xVM8xVM8xY8RTw/SP+YxDAP/2D/2j6GU4jd+4zd+z3/74osv+Of+uX+Osiy5vr7m3/w3/03GcfzpfNH/kfjss8/4hV/4BT755BPyPOdb3/oWv/iLv/g/+I5/1M/jFP/xf/wf88knn5BlGT/3cz/Hf/1f/9c/7a/0B8av/Mqv8Of+3J9juVzy/Plz/oV/4V/gO9/5zu/5N957fumXfomPPvqIPM/5i3/xL/Lbv/3bP6Vv/A8Xv/Irv4L6/7d3ryFR7V0YwJ+ynNI6klmNGmmRMYbdRRQksSIrPwTBUJKkdKHCMaUou1KEmklBYGZpIpKl0Y2yFNGgJMos7TLlh24mpZlE4SSROc46H6J9msze5p33PbP3Oc8P5oPr/1fWM4Mut+49e8AApKamKjWt5GhtbUV8fDxGjhwJDw8PTJ8+HQ0NDcq6FnJYrVbs3LlT+b6eMGEC9u7dC5vNpuzRQg6HCGnahg0bZOHChQJA7t27p9StVquEhIRIdHS0NDY2SnV1tfj5+YnJZHJdsz+orKyUxMREqaqqkufPn8vFixdl9OjRsmnTJmWPFnKIiJSVlcngwYOloKBAmpqaJCUlRTw9PaWlpcXVrfUrJiZGioqK5NGjR3L//n2JjY2VcePGSVdXl7InKytLhg8fLufOnROz2SxLly4VX19fsVgsLuy8f/X19RIYGChTp06VlJQUpa6FHO/fv5eAgABJTEyU27dvS3Nzs9TU1MizZ8+UPVrIkZ6eLiNHjpTLly9Lc3OznDlzRoYNGyaHDh1S9mghhyM4SDWsoqJCDAaDPH78uM8graiokIEDB0pra6tSKy0tFZ1OJ52dnS7o9vdkZ2fL+PHjlY+1kiMsLEzWrVtnVzMYDLJ161YXdeS4jo4OASDXr18XERGbzSZ6vV6ysrKUPZ8/fxYvLy85evSoq9rs18ePHyUoKEiqq6slKipKGaRayZGWliaRkZH9rmslR2xsrKxcudKutmTJEomPjxcR7eRwBP+0q1Fv377FmjVrcOLECXh4ePRZv3XrFkJCQuDn56fUYmJi0N3dbfenIrXp7OyEt7e38rEWcnz58gUNDQ2YP3++XX3+/Pm4efOmi7pyXGdnJwAoz39zczPa29vtcul0OkRFRakyV1JSEmJjYzFv3jy7ulZyXLp0CaGhoTAajRg9ejRmzJiBgoICZV0rOSIjI3H16lU8efIEAPDgwQPcuHEDixYtAqCdHI7gm9ZrkIggMTER69atQ2hoKF6+fNlnT3t7O8aMGWNXGzFiBNzd3dHe3v43deqY58+fIycnBwcPHlRqWsjx7t079Pb29ulzzJgxqunxPxERbNy4EZGRkQgJCQEApfef5Wppafnbe/yVsrIyNDY24s6dO33WtJLjxYsXyMvLw8aNG7F9+3bU19djw4YN0Ol0WLFihWZypKWlobOzEwaDAW5ubujt7UVGRgbi4uIAaOf1cASPSFVkz549GDBgwC8fd+/eRU5ODiwWC7Zt2/bLr/ez28CJyP/99nC/m+N7bW1tWLBgAYxGI1avXq2KHI76sR819tgfk8mEhw8forS0tM+a2nO9evUKKSkpKCkpwZAhQ/rdp/YcNpsNM2fORGZmJmbMmIG1a9dizZo1yMvLs9un9hynT59GSUkJTp06hcbGRhQXF+PAgQMoLi6226f2HI7gEamKmEwmLFu27Jd7AgMDkZ6ejrq6uj7vVxkaGorly5ejuLgYer0et2/ftlv/8OEDenp6+vwm+L/2uzm+aWtrQ3R0NCIiIpCfn2+3z5U5fpePjw/c3Nz6HH12dHSopsdfSU5OxqVLl1BbW2t3C0G9Xg/g6xGEr6+vUldbroaGBnR0dGDWrFlKrbe3F7W1tTh8+LByJrLac/j6+mLy5Ml2teDgYJw7dw6Adl6PzZs3Y+vWrcrPgClTpqClpQX79u1DQkKCZnI4xGX/naX/WktLi5jNZuVRVVUlAOTs2bPy6tUrEfnrJJ22tjbl88rKylR3ks7r168lKChIli1bJlartc+6VnKEhYXJ+vXr7WrBwcGqPtnIZrNJUlKS+Pn5yZMnT366rtfrZf/+/Uqtu7tbdSeFWCwWu+8Hs9ksoaGhEh8fL2azWTM54uLi+pxslJqaKhERESKindfD29tbjhw5YlfLzMyUoKAgEdFODkdwkP4DNDc393v5y9y5c6WxsVFqampk7NixqrpspLW1VSZOnChz5syR169fy5s3b5THN1rIIfLX5S+FhYXS1NQkqamp4unpKS9fvnR1a/1av369eHl5ybVr1+ye+0+fPil7srKyxMvLS86fPy9ms1ni4uI0cZnC92ftimgjR319vQwaNEgyMjLk6dOncvLkSfHw8JCSkhJljxZyJCQkiL+/v3L5y/nz58XHx0e2bNmi7NFCDkdwkP4D/GyQinw9co2NjZWhQ4eKt7e3mEwm+fz5s2ua/ImioiIB8NPH99Se45vc3FwJCAgQd3d3mTlzpnIZiVr199wXFRUpe2w2m+zevVv0er3odDqZPXu2mM1m1zX9m34cpFrJUV5eLiEhIaLT6cRgMEh+fr7duhZyWCwWSUlJkXHjxsmQIUNkwoQJsmPHDunu7lb2aCGHI3gbNSIiIifwrF0iIiIncJASERE5gYOUiIjICRykRERETuAgJSIicgIHKRERkRM4SImIiJzAQUpEROQEDlIigs1mg8FgQFpaml29qqoK7u7uOHPmjIs6I1I/DlIiwsCBA7Ft2zbk5eXhw4cPAL7ekNloNCIzMxNGo9HFHRKpF98ikIgAAFarFZMmTUJCQgJWrVqF8PBwLF68GLm5ua5ujUjVOEiJSHHs2DFs374d/v7+CAwMxIULF+Dm5ubqtohUjYOUiBRdXV0YNWoUJk6ciLq6Onh6erq6JSLV4/9IiUhhMpkAAO/eveORKNFv4iAlIgDArl27cOXKFdTV1cFqtaKwsNDVLRFpAgcpEeH48eM4ePAgysvLMW3aNKSmpiI7Oxs9PT2ubo1I9ThIif7lKisrkZSUhJKSEoSHhwMAkpOTYbFYcOLECRd3R6R+HKRE/2INDQ0wGo3Izs7GkiVLlPoff/yB5ORkZGVlobe314UdEqkfz9olIiJyAo9IiYiInMBBSkRE5AQOUiIiIidwkBIRETmBg5SIiMgJHKRERERO4CAlIiJyAgcpERGREzhIiYiInMBBSkRE5AQOUiIiIidwkBIRETnhT7y+NEW5PI81AAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 500x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
@@ -1128,7 +858,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+   "version": "3.12.5"
   }
  },
  "nbformat": 4,
diff --git a/example_notebooks/III-pyhelios_sim_and_vis.ipynb b/example_notebooks/III-pyhelios_sim_and_vis.ipynb
index 46d6f63ac..b37346088 100644
--- a/example_notebooks/III-pyhelios_sim_and_vis.ipynb
+++ b/example_notebooks/III-pyhelios_sim_and_vis.ipynb
@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -38,7 +38,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -48,7 +48,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,15 +70,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Sim context.\n",
     "# Set logging.\n",
-    "pyhelios.loggingQuiet()\n",
+    "pyhelios.logging_quiet()\n",
     "# Set seed for random number generator.\n",
-    "pyhelios.setDefaultRandomnessGeneratorSeed(\"123\")"
+    "pyhelios.default_rand_generator_seed(\"123\")"
    ]
   },
   {
@@ -90,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -112,22 +112,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 0.01529679998930078 seconds\n",
-      "Simulation has started!\n",
-      "Simulation is paused!\n",
-      "Sim is not running.\n",
-      "Simulation has resumed!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Start the simulation.\n",
     "sim = simB.build()\n",
@@ -167,35 +154,19 @@
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "3 flight strips simulated and saved to file:\n",
-      "output/custom_als_toyblocks/2024-05-28_18-55-45/leg000_points.las\n",
-      "output/custom_als_toyblocks/2024-05-28_18-55-45/leg002_points.las\n",
-      "output/custom_als_toyblocks/2024-05-28_18-55-45/leg004_points.las\n",
-      "\n",
-      "Number of measurements : 1783377\n",
-      "Number of points in trajectory : 30\n",
-      "Trajectory starting point : (-50.0, -50.0, 80.0)\n",
-      "Trajectory end point : (40.4488749992435, 50.000015918644785, 80.0)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Create instance of PyHeliosOutputWrapper class using sim.join(). \n",
     "# Contains attributes 'measurements' and 'trajectories' which are Python wrappers of classes that contain the output vectors.\n",
     "output = sim.join()\n",
     "\n",
-    "print(\"{n} flight strips simulated and saved to file:\".format(n=len(output.outpaths)))\n",
-    "for strip in output.outpaths:\n",
+    "print(\"{n} flight strips simulated and saved to file:\".format(n=len(output[3])))\n",
+    "for strip in output[3]:\n",
     "    print(Path(strip).as_posix())\n",
     "\n",
     "# Create instances of vector classes by accessing 'measurements' and 'trajectories' attributes of output wrapper.\n",
-    "measurements = output.measurements\n",
-    "trajectories = output.trajectories\n",
+    "measurements = output[0]\n",
+    "trajectories = output[1]\n",
     "\n",
     "# Get amount of points in trajectory and amount of measurements by accessing length of measurement and trajectory vectors.\n",
     "print('\\nNumber of measurements : {n}'.format(n=len(measurements)))\n",
@@ -203,16 +174,16 @@
     "\n",
     "# Each element of vectors contains a measurement point or point in trajectory respectively. Access through getPosition().\n",
     "# Get starting and end point of trajectory from first and last element of trajectory with getPosition() method.\n",
-    "starting_point = trajectories[0].getPosition()\n",
-    "end_point = trajectories[len(trajectories) - 1].getPosition()\n",
+    "starting_point = trajectories[0].position\n",
+    "end_point = trajectories[len(trajectories) - 1].position\n",
     "\n",
     "# Output individual x, y and z vals.\n",
     "# Accessed through x, y and z attributes of points from getPosition() method.\n",
     "print('Trajectory starting point : ({x}, {y}, {z})'.format(\n",
-    "    x=starting_point.x, y=starting_point.y, z=starting_point.z))\n",
+    "    x=starting_point[0], y=starting_point[1], z=starting_point[2]))\n",
     "\n",
     "print('Trajectory end point : ({x}, {y}, {z})'.format(\n",
-    "    x=end_point.x, y=end_point.y, z=end_point.z))"
+    "    x=end_point[0], y=end_point[1], z=end_point[2]))"
    ]
   },
   {
@@ -278,18 +249,7 @@
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Matplotlib figure.\n",
     "fig = plt.figure()\n",
@@ -348,7 +308,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+   "version": "3.12.5"
   },
   "toc": {
    "base_numbering": 1,
diff --git a/example_notebooks/IV-live_trajectory_plot.ipynb b/example_notebooks/IV-live_trajectory_plot.ipynb
index e1412fb5d..e917f71fb 100644
--- a/example_notebooks/IV-live_trajectory_plot.ipynb
+++ b/example_notebooks/IV-live_trajectory_plot.ipynb
@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -37,7 +37,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -47,7 +47,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -68,7 +68,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -78,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -87,12 +87,12 @@
     "    global tpoints\n",
     "    \n",
     "    # Store trajectories in variable.\n",
-    "    trajectories = output.trajectories\n",
+    "    trajectories = output[1]\n",
     "    # Add current values to list\n",
     "    try: \n",
-    "        tpoints.append([trajectories[len(trajectories) - 1].getPosition().x,\n",
-    "                        trajectories[len(trajectories) - 1].getPosition().y,\n",
-    "                        trajectories[len(trajectories) - 1].getPosition().z])\n",
+    "        tpoints.append([trajectories[len(trajectories) - 1].position[0],\n",
+    "                        trajectories[len(trajectories) - 1].position[1],\n",
+    "                        trajectories[len(trajectories) - 1].position[2]])\n",
     "        \n",
     "    # At the beginning of each new simulation leg, trajectories can have the length 0.\n",
     "    # When indexing with [0 - 1] an indexing issue can occurr that is caught in this block.\n",
@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -118,12 +118,12 @@
     "# Set logging.\n",
     "# pyhelios.loggingVerbose()\n",
     "# Set seed for random number generator.\n",
-    "pyhelios.setDefaultRandomnessGeneratorSeed(\"123\")"
+    "pyhelios.default_rand_generator_seed(\"123\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -147,18 +147,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SimulationBuilder is building simulation ...\n",
-      "SimulationBuilder built simulation in 0.014994400000432506 seconds\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "sim = simB.build()"
    ]
@@ -172,7 +163,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -197,7 +188,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -238,20 +229,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbMAAAGXCAYAAAA50L6nAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d3wc5bU+/sz2viuteu+yJRe5WzLGdAIEkktLgPwgJCHkmnBDSSCBkJgbYr6QXC65CSnkEuAmOJQQSgjFhhh3Gxur995XZZu2t5nfH6sZ7652pe0qnufz0Qe8OzPvO7Mz7zPnnOecQ1AURYEFCxYsWLBYxuAs9gRYsGDBggWLWMGSGQsWLFiwWPZgyYwFCxYsWCx7sGTGggULFiyWPVgyY8GCBQsWyx4smbFgwYIFi2UPlsxYsGDBgsWyB0tmLFiwYMFi2YMlMxYsWLBgsezBktl82LMHkMlCf08QwC9/6f3/a68FystDb/u733m37+o6t2+wPx4vbtOPBEVFRfjud78bl2N9/etfx5o1a5h/f/rppyAIAmfOnInL8SMZOxADAwMgCAJ/+9vfmM8uuugiEAQBgiDA4/GgVquxY8cO/OxnP4NWqw15rAceeAAEQWDPnj1Bv/c9LofDQV5eHq6//nq0t7eHdS4nT57EVVddhaysLIjFYhQVFeHGG2/EqVOnmG327NkD2Xz3aAKw0DUOhT179uD48eNzPo/nvTcf6N9+ob9PP/006jESdS5vv/02fvvb38b9uNGiqKjI75kpLS3F7t27MT09zWwT7/tkISzOyrkScdttwC23AKdPA1u2zP1+3z5g82agouLcZ/feC9x6q/92BJHYeS4CNm7ciBMnTmD16tWLPRVkZ2fjxIkTqPD9HQDs2LEDv/zlL0GSJHQ6HY4fP45nn30Wv/3tb/HRRx9h3bp1ftuTJInXXnsNAPDKK6+EJDTf47a1teHHP/4xLr30UrS2tiIlJSXkPI8ePYqLL74YX/jCF/D73/8eCoUC3d3dePvtt/HZZ59h27ZtAIBvfetbuOaaa2K4IsnD448/DplMhrq6Or/P33rrrXmvRbxA//Y0xsfHcf3112Pv3r24+OKLmc+rqqqiHiNR5/L222/jzJkz2L17d9yPHS1uvPFGPPjgg3C5XDh58iT27NmDxsZGHDlyBBxO9HZSqPtkIbBkFi9cd53Xitu3by6ZDQ0Bx44Bzzzj/3lBAbB9e/LmuEhQKBTYvkTOUygUBp2LSqXy+/yLX/wivvOd72Dbtm24+eab0dbW5veAHjx4EGNjY7jyyivx0Ucf4bPPPsPWrVvnPW5dXR1kMhluueUWfPjhh7jllltCzvN3v/sdioqK8Pbbb4PL5QIALrnkEtx9990gSZLZLi8vD3l5eZFfiCWEDRs2JGWcwN9+YGAAAFBeXh7y/qQoCk6nE0KhMKwxknUuscJms0EsFsd0jMzMTOa67dy5E3a7HT/5yU9w9uxZbN68OR7TjAismzFekEiAL38ZeO01wGexAQD89a9ei+srX4nrkLQZ/8EHH2DNmjUQiUTYtGkTTp48yWzzwAMPoKCgwG8BBID9+/eDIAg0NTX5ff6b3/wGhYWFUCqV+PKXv4ypqSm/7w0GA3bv3o3s7GwIhUJs2rQJ+/fvn3eewdyMdrsdDz74IHJzcyEUCrF27Vrs27fPb7/W1lZcffXVUKvVkEgkqKysxNNPPx3RNQpEMDdjKBQUFOCxxx5DZ2cnPv74Y7/vXnnlFcjlcrz44osQCARz5h4K69evBwAMDQ3Nu53BYEBGRgZDZL7wJdVANyN9rT/88EPccMMNkMlkyM/Px1/+8hcAwP/8z/+goKAAKSkp+Na3vgWHwxHyWDRkMllIyxPwWjjf+MY3UFJSArFYjPLycjzyyCN+xyZmPQ4/+MEP5rjzgrnm3n77bWzYsAEikQhZWVm45557YDab55zn/v37ceutt0Iul6OwsDDm+4N+pt5//32sX78eQqEQ7777LiwWC7773e+isrISEokERUVF+M53vgOj0ei3f7BzOXHiBC655BJIpVIolUrceuutmJyc9NvG4XDgxz/+MUpKSiAUCpGXl4c777yTmdPLL7+M1tZW5tp9/etfj/ha/fOf/8SNN94IhUKBm266KeK1YSFs2rQJANDf3x9ym5aWFnzhC1+ATCaDQqHAl770JfT09DDfz3efLASWzOKJ224DxseBwIu/bx9wySVAdrb/5yQJuN3+fx7Pue8HBrwkuMBCsnv3bvzgBz/A66+/DqFQiCuvvJJ5WO666y4MDw/jwIEDfvv96U9/wubNm/3cZ++++y7+8Y9/4LnnnsOvfvUrfPrpp7j33nuZ751OJy6//HK89957+PnPf453330XVVVVuOaaa9Dc3BzJlcJtt92G3/72t3jggQfw7rvvYvPmzbjtttvw5z//mdnmuuuug16vxwsvvIB//vOf+P73vw+LxRLROLHiiiuuAAA/95TD4cDf//53/Nu//Ruys7Nx1VVX4dVXX4XH97cLAZrESktL591u06ZNOH78OB577DF0dHREPO/du3djw4YNeOutt1BbW4s77rgDDz/8MD766CP8/ve/x89+9jP83//9H/7rv/4r4mMHYnp6GqmpqXjmmWfw4Ycf4qGHHsLLL7+Mf//3f2e2oa/fvffeixMnTuDEiRPYuHFj0OO9++67uP7661FRUYG33noLjz32GP785z/jy1/+8pxt//3f/53Z7pprrsHDDz+MDz/8MKbzGRsbw/e+9z088MAD+PDDD1FTUwOr1QqPx4Of//zn+OCDD/DEE0/g0KFD+Ld/+7d5j3XixAlcdNFFUCqVeO211/D888/j9OnTuO666/y2u+GGG/DMM8/gG9/4Bv75z3/iF7/4BUwmEwDgsccew9VXX42SkhLm2j322GMRX6u7774bZWVleOutt/Dggw9GtDaEA5rEcnJygn4/PDyMnTt3YmJiAi+//DL+93//F11dXdi5cyfz0hzJfTIHFIvQ+OlPKUoqDf09QFG/+MW5f7tcFJWRQVHf+ta5z9ravNu9+OLcfYP97dp1bpv+fu9nP/1p0OHvuOMOCgD1ySefMJ/p9XpKJpNRP/rRj5jPLrjgAurmm29m/q3T6SihUEj97ne/Yz4rLCyk8vLyKLvdznz26KOPUnw+n/J4PBRFUdSf/vQnisfjUa2trX7z2Lp1K3XTTTf5zau6upr598GDBykA1OnTpymKoqjGxkYKAPXcc8/5HeeKK66gCgsLKYqiqKmpKQoA9e677wY991AIHDsQ/f39FADqjTfeYD7btWsXdc011wTd3m63UwCo73znO8xnf/vb3ygA1IcffkhRFEW9/vrrFADqo48+8tt3165d1NVXX025XC7K4XBQDQ0NVE1NDbVp0ybK4XDMex4zMzPU5ZdfTgGgAFCpqanUrbfeSh0+fNhvu5/+9KeU1Ocepa/1ww8/zHxmMBgoLpdL5efn+417ww03UDU1NSGPRUMqlVI/9bkHF7rGLpeLeuWVVygej0dZLBbmcwDUL3yfl1kUFhZS99xzD/PvDRs2UFu3bvXbZt++fRQA6uDBg37n+YMf/IDZxuPxUPn5+dQ3v/nNkHPzRbB7gX6mTp06Ne++LpeLOnr0KAWA6uzsDHkuF154IVVXV0eRJMl81tLSQhEEQf3zn/+kKIqi9u/fTwGg9u3bF3K8UNc8kmu1e/fuOfuHszYEQ2FhIbV7927K5XJRVquVOnjwIJWTk0OVlJRQNpst6Jzvv/9+SiKRUJOTk8xnAwMDFJ/P97u/Qt0nC4G1zOIJHg+4+WbgzTcBp9P72SuvACIRcP31c7f/3ve8ghHfvz/84dz3RUVeipvHMlMqlbjkkkuYf6tUKlxyySV+rsa77roL77zzDnQ63eyUXgGHw5kTs9m1a5dfbKCqqgoul4ux8vbv34+1a9eioqICbreb+bv00ktx+vTpMC8ScOTIEQDAVwLcrrfccgsGBwcxPDwMtVqNwsJC/OhHP8LLL7+MkZGRsI8fT1Cz7f4IH2HOK6+8goyMDFx22WUAgGuvvRYKhSKoq/H9998Hn8+HUChETU0NxsbG8Pe//x0CgWDeceVyOfbv349Tp07hJz/5CWpqavDGG29g165d+N///d8F503PDfDeIxkZGbjwwgv9xq2oqMDw8PCCx1oIFEXh2WefRVVVFcRiMfh8Pm677Ta43W709fVFdCyz2YyGhgbcfPPNfp/fdNNN4PF4zL1Dg7acAa/7ddWqVTHfK2lpaUHjn3/+85+xYcMGyGQy8Pl8XHDBBQCALlqhHACr1Ypjx47hpptugsfjYZ6XyspKZGdnM8/MJ598AolEgq9+9asRzTPSa3X11VfPOUa4a0Mw/Pa3vwWfz4dEIsHFF1+M3NxcvPnmmxCJREG3P3LkCC655BKkp6cznxUWFqKurm7OXKMBS2bxxm23AXo9QLs6/vpX4ItfBBSKudvm5XkVjr5/lZURDed7Y9DIyMjA+Pg48++bbroJYrGYiZu88MILuPHGG6FUKv32U6lUfv+mFz673Q7A606qr68Hn8/3+3vyyScjWhT1ej0jgfdFVlYWAECn04EgCHz00UdYvXo17rnnHuTn52PTpk04fPhw2OPEA/TCSM/NaDTi/fffx7XXXguTyQSDwQC73Y6rrroKf//732Gz2fz2v+CCC3D69GkcP34cv/jFL2AwGHDLLbfMiVOEwtatW/H444/jk08+QWdnJ/Ly8vDQQw8tuF+w3zLYZ/RvGwueffZZPPjgg/jSl76Ed955B5999hmee+45AIj4+AaDARRFMdebBn2/0IsujUScU0ZGxpzP3nrrLdx+++3YunUrXn/9dZw8eRJvvfUWgNDnqNfr4fF4cP/99895ZsbGxphnRqvVIjs72++FKRxEeq2CnVe4a0Mw3HzzzTh9+jQaGhqg1Wrx2WefoaamJuT2er1+zlwB77MVONdowKoZ443t24GSEi+JZWQAfX1AHOISoRAo0ACAyclJZPvE58RiMW677Tb86U9/woUXXoiGhgY8++yzEY+VmpqKdevW4YUXXohlykhNTYXb7YZOp0NqairzuUajYb4HgMrKSrzxxhtwuVw4fvw4HnnkEVx77bUYHR1NWm7VRx99BACMTPhvf/sbHA4HXnjhhaDX4R//+Iffm7JSqWSUXbW1teByuXjggQfwxhtvzLFMF0JxcTFuuukmPPPMM5iYmEBmZma0pxUUIpEILpfL7zOHwwGr1Trvfm+88Qauu+46PPnkk8xnbW1tUc1BpVKBIAhMTEz4fe52u6HVav3ul0QhGKm88cYbqKmpwR98PCeHDh2a9zj0uTzyyCNBY1hpaWkAALVajfHxcVAUFRGhRXqtgh07lrUhPT09ItViamrqnLkC3uc+Hr8ra5klArfeCrz7LvDHPwIqFRDEvI8XjEYj/vWvf835N52HROOuu+5CY2Mjvve976GsrAwXXnhhxGNddtll6OvrQ05ODjZv3jznL1zQ7pnXX3/d7/PXXnsNhYWFyM/P9/ucz+dj165d+OEPf4iZmRmMjY1FPPdoMDQ0hJ/97GdYvXo148p95ZVXUFRUhIMHD875y8nJWVDV+N3vfhdFRUV+C38wBHvoAa9LSygUzrFI4oG8vDw4nU709vYyn3388ceMqzUUbDbbHLfpK6+8Mmc7Pp+/oNUkk8lQU1Mz595488034Xa7sXPnzoVOIyEI9xx9IZVKUVtbi/b29qDPS1FREQDvc2W1Wuecsy+CWZzxulbxWBvCwQUXXIBPPvnErxDB8PAwjh8/7jfXcO6TYGAts4Xg8QDBZNzBEqNp3HYb8MQTwIsvAt/8JhAqPjI0BPjEthhs2AAIhcDgIFBaCvzkJ96/IEhNTcU3v/lNPP7441CpVPh//+//AQDuu+8+v+3Wr1+PLVu24PDhw9i7d2/ELg0AuP322/GHP/wBF110Eb7//e+joqICBoMB9fX1cDqdCy7QNNatW4cbbrgBDzzwAKxWK6qrq/H666/jww8/xP/93/8BAJqamvDggw/iK1/5CkpLS2E0GvHkk0+iqKhoQSXgzMxMUOn9rl27Qu5jMBhw8uRJUBTFJE3//ve/h1AoxOuvvw4Oh4OxsTEcOnQIP/7xj3HRRRfNOcZtt92GX/3qV9Dr9SETZ/l8Ph555BF8+9vfxocffogvfOELQbe766674Ha7ccMNN6C8vBwzMzN488038d577+G+++4LO+8pElx11VWQSqW466678PDDD2NkZAS/+tWvFozvXX755fjVr36F3/zmN6ioqMArr7ziJ7emsXr1arzzzjvYuXMnpFIpKisrIZfL52y3Z88efPnLX8Ytt9yCO+64A319ffjRj36ESy+9NOh1TwYuv/xy3HPPPfjP//xP1NXV4YMPPsAnn3yy4H6/+MUvcMkll+ArX/kKvvrVryIlJQUjIyM4cOAA7rzzTlx00UW47LLLcPXVV+Mb3/gGent7sW3bNuh0Orz55pt49dVXAXiv3Z/+9Cf89a9/RXl5OdLS0lBUVBSXaxWPtSEc3H///XjxxRdxxRVX4NFHH4XH48FPf/pTpKam4p577mG2C/c+mYOIJSPnE37609CqwxdfnKtm9MXGjd7v//Wv4N+HOi7gVTFSVFhqxurqauq9996jVq9eTQkEAmrDhg3UsWPHgm6/d+9eisvlUqOjo3O+C1RhURRFvfHGGxQAqp+eD0VRRqORuv/++6mCggKKz+dT2dnZ1NVXX0299957c+ZFI1DNSFEUZbPZqAceeIDKzs6m+Hw+VV1dTf3lL39hvp+YmKC+9rWvUSUlJZRQKKQyMjKoG264gerq6gp+PX3GxqwCMPDv4MGDIdWM9DZcLpdKTU2lamtrqZ/97GfU9PQ0s90vf/lLCgDV09MTdOyWlhYKAPWHP/yBOW4wlaTT6aSKioqoXb7K1QB8+OGH1K233kqVlJRQYrGYUqvV1NatW6kXXniBcrvdzHah1Iy+15qigv++wdSLH374IVVdXU2JRCJq+/btVENDw4JqRpPJRH3961+nUlJSqJSUFOquu+6i/vGPf8yZx5EjR6iNGzdSYrHYT20XbG5///vfqZqaGkogEFAZGRnU7t27KZPJtOB5XnPNNfNeV1+EUjMGUw263W7qwQcfpNLT0ym5XE7deOON1MmTJ+fsX1hYSH33u9/12/f06dPU1VdfTSmVSkosFlPl5eXUd77zHWp4eJjZxmazUT/84Q+Z5yovL4/6xje+wXxvNBqpr371q5RaraYAUHfccUfM18oX860NwRDsNwtEsGvZ1NREXXHFFZREIqFkMhl17bXXznmmQ90nC4GgqAV8CCyWLL7+9a/jzJkzaGlpCWv7Cy+8EEqlEv/4xz8SPDMWLM5PqNVqfPe738Xjjz++2FOJCCthbWDdjOcBzpw5gyNHjuDIkSNzEiRZsGAROwYGBvDuu+9Cp9Nhy3whiCWGlbQ2sGR2HmDLli1QKpV47LHH/PKPWLBgER/86le/wl/+8hfcd999y6bwM7Cy1gbWzciCBQsWLJY9WGk+CxYsWLBY9mDJjAULFixYLHuwZMaCBQsWLJY9WDJjwYIFCxbLHiyZsWDBggWLZQ+WzFiwYMGCxbIHS2YsWLBgwWLZgyUzFixYsGCx7MGSGQsWLFiwWPZgyYwFCxYsWCx7sGTGggULFiyWPVgyY8GCBQsWyx4smbFgwYIFi2UPlsxYsGDBgsWyB0tmLFiwYMFi2YMlMxYsWLBgsezBkhkLFixYsFj2YMmMBQsWLFgse7BkxoIFCxYslj1YMmPBggULFsseLJmxYMGCBYtlD5bMWLBgwYLFsgdLZixYsGDBYtmDJTMWiwKKohZ7CixYsFhB4C32BFicX6AoCi6XCzabDVwuFzwej/kvQRCLPT0WLFgsUxAU+4rMIkkgSRJOpxMkScLhcADwkhtBECAIAjwej/njcrksubFgwSJssGTGIuGgKAoejwcul4shL6fTCQ6Hw3xPkiQoimK+53A44HK54PP54HK5LLmxYMFiXrBkxiKhoN2KHo+H+WxgYAAjIyNQKBRISUlBSkoKRCKR3z7ByM3XamPJjQULFr5gyYxFwkBbYyRJgsPhwOl0orm5GWazGUVFRbBarTAYDDCZTBCJRFCpVAy5CYVCAOeEIiy5sWDBYj6wZMYi7qAoCm63G263GwBAEAS0Wi2ampqQmpqK1atX+8XK3G43DAYD9Ho9Q24SiQQpKSkMwQkEAubYAEtuLFiw8AdLZiziCpIkGWsM8JJPT08PhoaGsHr1auTm5oKiKDidTobMAuFyufzIzWw2QyqV+pEbn89njk//kSSJ8fFx8Hg8ZGVlseTGgsV5BJbMWMQFNJn4uhVtNhsaGxvh8XhQU1MDmUwG4JyqMRSZBcLpdDLkptfrYbVaIZPJGJekSqUCj+fNMuno6ACfz0dRURFDqLTlRotJeDweOBwOS24sWKwgsGTGImYEijwIgsDExARaWlqQk5ODyspKcLlcZvtIySwQDofDj9xsNhvkcjlSUlIYK668vJyZm6/lRs+PJjfacmPJjQWL5Q2WzFjEBNoa83g84HA4IEkS7e3tmJiYQHV1NbKysoLuEwuZBcJutzPkNjk5CY/H46eUVCqVDJmGIjfaYmPJjQWL5QmWzFhEBTp3rLe3F9nZ2RAIBDCbzWhsbASPx8P69eshFotD7utwOOJGZr7o7OwEAMjlcobgnE6nH7kpFAqW3FiwWGFgy1mxiBi+bsWOjg6kp6djYmICnZ2dKCoqQmlpKZMQHQqJJAYul4ucnBzk5OSAoijYbDZGTDI2Nga32x2U3Lhcrh+xORwO2O12cDicOWpJltxYsFhaYMmMRUQIzB0DgLa2NpjNZmzcuBFqtXpR5xdIMARBQCKRQCKRMEpKq9XKkNvIyAg8Hg+USiVDbnK5fI7l5vF44PF44HA44Ha7YbfbkZaW5ldXkiU3FiwWDyyZsQgLvrljFEWBw+HAYDAA8MbAduzYweSCLWUQBAGpVAqpVIq8vDxQFAWLxcKISYaGhkBRFJMCoFKpIJfLGbUkRVEwGAzo7u7G5s2bGRILdEuy5MaCRXLBkhmLBUGSJNxut59asa+vD319feBwOFi9evWSIrJIwsAEQUAmk0EmkyE/Px8URcFsNjPk1t/fD4Ig/KqT0ETF5/MZy83tdsPlcoUkt4XcrixYsIgNLJmxCAnf3DG60obD4UBzczNsNhu2bt2KM2fOLPY0/RCrNUQQBORyOeRyOQoKCkCSJENuWq0WfX19zLYjIyNISUmBRCLxs9xCkZtv0WSW3FiwiC9YMmMRFMFyx6anp9Hc3Iy0tDRs2LCBiRWtZEEsh8OBQqGAQqFAYWEhSJLE6OgoBgYGMDU1hZ6eHvB4PD/LTSwWhyQ3+piB1UlYcmPBIjawZMZiDgJzxyiKQmdnJ4aHh1FVVYXc3Fxm26VIZomcD4fDgUQiAZ/Px4YNG0CSJIxGIwwGAyYmJtDV1QWBQDCH3Hzb3dAvCk6nkzkmS24sWMQGlsxYMKBVe263m1ErWq1WNDY2AgDq6uoglUr99llqZJbs+XA4HIa0iouL4fF4GHIbHx9HZ2cnhEKhH7mJRKI5vdxcLhdjufk2KmW7cLNgER5YMmMBYK5bkcPhYHx8HG1tbcjNzUVlZWVQa4EgCCbZeKlgMcmVy+UiNTUVqampALypDAaDAQaDAaOjo+jo6AjZ7gbwJ7e+vj7w+XxkZ2ezXbhZsFgALJmxYMpL0daYx+NBe3s7JicnsW7dOmRkZITc93xdVMM9by6XC7VazeTf+ba7GR4eRltbG9Puhk4FoJWhdrudIWbaLcl24WbBIjhYMjuPQVEU7HY77HY7hEIhOBwOTCYTGhsbIRAIsGPHDr8O0MEQrWWWKHfgUl/UeTwe0tLSkJaWBsC/3c3AwIBfuxubzcYQFg1fy82X3Nh2NyzOd7Bkdp6Czh0bHByEXq9HTU0NhoaG0NXVheLiYpSWloa1IC61mBmwuG7GSMHn85Geno709HQA/u1uTCYTDAYDdDpd0HY3vo1KnU4nU++SJTcW5yNYMjvPEJg7RrsVGxoaMDMzg02bNjHxnnBAqx1ZxAcCgQAZGRnIyMiA2+2GUCiEXC6HXq9Hd3e3X7sbuiMAS24sWLBkdl7BtyQV4LWq6CK8aWlpqKuri7iSx1KzzFbaIs3j8ZCZmYnMzEwA/u1uOjs74XA45pCbb11JAEzR5PlSAVbadWNx/oEls/MEvrljdFWK3t5eDA4OQiwWY8OGDVEtaEuNzIDEuxmTdb501RVfiEQiZGVlMX3ifDsCtLe3z2l3Q5Obb0cAugUPTW4ulwsCgYBJ9mY7ArBYjmDJbIUjWO6Yw+FAY2MjnE4nysrKMD09HfXitRTJbCVhod9FLBZDLBbP2+5GqVQyqQDB2t309/dDIBCgsLCQ7cLNYtmCJbMVjGC5Y1NTU2hubkZGRgY2bdqEqampmPLElhqZraRFN9LrGm67G5VKxZCbXC4HACY5myY4u93OHJNtVMpiOYAlsxWKwNwxkiTR0dGBsbExVFVVIScnB0DsZLTUyAxYXmrG+RDMzRgJwm13w+VyIZPJYDKZIJfLmTw230alLLmxWOpgyWyFgXYr+qoVLRYLGhsbQRAE6urqIJFImO1poosWS7ECSDKQrMU7nuOEanfT3t4Ou92O+vr6Oe1upFJpUHJju3CzWGpgyWwFIVil+7GxMbS1tSE/Px8VFRVzSlKtNMtsJS2iib6udLsbsVgMlUqF3NzcOe1uOByOH7lJJJI5RZN9u3AHSwVgyY1FMsCS2QoBbY35lqRqbW2FVqtFTU0Nk5QbiFjzxGLZP1Y32nzHXSlIBgnQv0Owdjcmkwl6vT6idje04Ijtws0imWDJbJkjMHeMw+FgZmYGjY2NEIvFqKurm7ckVaxuwmgsM6fTiZ6eHvD5fKjVashkMnZxC4LFTAEAvPeSUqmEUqlEUVFR1O1u6F5udI5cfn4+S24s4g6WzJYxSJKEwWDA0NAQKisrAQADAwPo6elBSUkJSkpKFlwkYrXMIiUzg8GAhoYGSCQSEASBwcFBP1dWamoqxGJxTKkCKwWJslwDQZJkWOPE2u6GThfIzs5mu3CziDtYMluG8C1J5XA4oNFoUFpaiubmZphMJmzevBkpKSlhHStZlhlFURgcHER3dzfKysqYvCgAjCtrcnKSsdjoxTA1NdWvRUo4WClJ08lCtKQZbrsbuqYk7QIP1YWbJje2USmLaMCS2TJDoMiDy+XC7Xbj2LFjUKlU2LFjB/h8ftjHS4Zl5nK50NzcjJmZGWzevBkqlcpPbenryqLf9vV6PUZGRtDe3s60SElNTYVKpZr3/FjLbPHGWajdjclkAofDQWdnp1+7G7YLN4t4gCWzZQTfklQ0CQ0PD8Pj8WDVqlXIy8uLeFFKtJrRaDSioaEBMpmMqf043/a+b/ulpaV+LVJ6e3thtVqZWoSpqal+tQhXIpYTmQUisN3NyMgIRkdHQRDEnHY3NLnx+fygXbjpdjes5cYiFFgyWwYIVpLKbrczJakIgkB+fn5Ux06Um5GiKKalTGlpKYqLi6NaMANbpDgcDibpl65FqFQqGXKj3+4TjWSRTDKQLAuQw+FAIBCgoqICgH+7G/pFRSaTBW13Q8+TJjeXywUAc8iNx+OtKOucRfhgyWyJI1hJqomJCbS0tCA7OxuFhYU4evRo1AsSbeFFu38wMnO5XGhpaYHBYAgav4tlsREKhUyhXd9ahLRb0uPxgMfjYXh4mEn6Xa6L23JzMy4E+kWMhm+7G8D7okKTW3d3N+x2ux+5+ba7oecdrFEp24X7/ARLZksYgbljJEmivb0d4+PjWLNmDbKysuBwOABEvyDR+8Syv69lR7sVpVIpduzYEbKlTDwWmGC1CHt7e6HVaqHT6ZikX9pqo6XjywkriczoGGkoCIXCqNvd0Menya2/vx98Ph/Z2dlsu5vzBCyZLUH45o75lqRqaGgAj8fzK0lFP5iBb73hwjc+EQ1oMqPjd52dnWGnBcQbBEFAKBRCLBZj3bp1IEkSMzMz0Ov1ftJxX3KLtH9bMrHS3IzhpgDQCKfdjW9HAF9ys1qtEIvFoCiKbVR6noAlsyUGkiThdrv9SlKNjIygo6MDhYWFKCsr8yOteJBRrPt7PB40NjZCr9dH3Kk63vBdmOj8NZVKxeRF0W/6g4ODaG1thVQqZYgtMEazFHA+WWYLIZJ2N3a7HVKpNGijUpbcViaW1pN7HsPXRUIvLm63G62trdDr9diwYQOjCvMFvThEK+LwteyigcvlwsTEBJRKJerq6iLOCUsmAqXjLpeLibfRMRq5XM6Qm1KpDLr4JtNiStY4yVAERmqZzYeF2t0YjUYmxYN2S8pkMrYL9woGS2ZLAMEKBBuNRjQ2NkIqlc5LErGSUbSWHe1WHB0dhUwmw+bNmyN66BO5QIR7Lnw+30+AYLfbodfrodPp/N70abekXC5fFNdporFcLLP5ENjupr6+nrG0aUucoii/6iQ0uc3XhZtuVEorJdmiyUsXLJktMgJzxwCgv78fvb29KCsrQ1FR0bwPD517E6ubMRIypC1GrVbLuHyWygMeyzxEIhGys7ORnZ3t96av0+kwNDQEAEwulMfjSfh5r8SYWbJywiiKglgsRlZWll+7G9oS7+/vD6vdTWCjUrYL99IFS2aLBDp3bHR0FJOTk1i7di2cTieamppgtVqxdetWKJXKsI4VS0+ySMnQZDKhoaEBQqEQO3bswOjoKEwmU8TjLvWSUMEaW5pMJuh0OkxMTMBqteLYsWN+YpL5CjpHg5UmzU+WOxOYS5x0uxu5XI6CggKQJBl2uxuW3JYHWDJbBPi6Fd1uN2w2G7RaLZqamqBWq7Fhw4aIhAjJaLBJURRGR0fR3t6OoqIilJWVxWwVJgqJmA9BEEx7FIlEgsHBQZSVlUGn0/nVIaSJLSUlJaKyYvONm2gk0zJLlsBmISsw2nY3wcits7MTHA4HBQUFbBfuRQRLZkkGraaiHzZadl9fX4/Vq1cjNzc34ps/HmQ2HwG43W60tbVhenp6jhBlqZFZshYOgiCYRQ44V4dQp9Ohv78fLS0tkMlkfkrJSMtuJeu6xlOYsRTGoceKxAqMtt0N4BUSCYVC5jlku3AvDlgySxJot6JvgV2bzYaenh643W7U1dVBJpNFdexYCWW+YsO0W1EgEATtjbbUyAxYHBdmYB1Cp9PJxNvohF+FQsGQm0KhWHCxZd2M0SPW+Fy47W5SUlJgsVj8CiYDbBfuxQBLZklAYO4Yh8OBRqNBa2srk5MVLZHRx0uEm3F0dBRtbW1B89t8911qZLYUIBAI/KpZ0DlROp0OIyMjIElyjrJusRa1pZo0HetY8STOwHY3brebkf5brVbMzMxgcnKSscJTUlIYaw0ITW60W9K3riRLbtGBJbMEIljumMfjQUdHByYmJrB27Vrw+Xw0NzfHNE6sZBZomXk8HrS1tWFychI1NTVMkd9giLVQcbyxVBeCwIRfi8XCkFt/f7+fJUC7sJJBMvTvzlpmkYHH4zE5iyaTCWlpaRCLxUy7m7a2NqZ10XztbgJ7uQXG3FhyCx8smSUIviWpAO9iYTab/Vx2YrEYBoMhZjKIp2VGz5HP52PHjh0LKvSitcyWs6Q91uMTBAGZTAaZTIb8/HxGfEArJen4jMvlgk6ng1gsTlgyejLJbDlbZguNJRAI/NzMvq2Lwm13E4rc+Hw+xsfHoVaroVAoknJOyxEsmSUAvrlj9E1J1y0sKipCaWkpcxPHSkRA/HqSjY2NobW1FQUFBSgvLw9rMYi1uScLf/GBb3ymqakJk5OTGBgYgEQi8ROTxEMpCaxMy4z2iCSLzHxzRGkEti4Kt91NKHK77bbbcPfdd+OOO+5IyjktR7Bd7eII+uZzOp3MDe52u9HQ0IDe3l5s3LhxDknEg8ziYZkNDAygvb0dNTU1qKysDHshWGoxs5XgkqHjMzweD1VVVdi5cydKS0uZrgBHjhzB6dOn0dvbC51Ox8Rio8FKtMzoZyGZltlCSlW63U1lZSW2b9+OHTt2oLCwEB6PB93d3cxv2tPTA61Wy6wfPB4PfD4fFosFUqk0qvkdPnwY1157LXJyckAQBN5++22/7ymKwp49e5CTkwOxWIyLLroIra2tfts4HA7ce++9SEtLg1QqxXXXXYeRkZGo5pMosJZZnBCs75jBYEBjYyPkcnnIdigcDiemxYg+RrRkZrFYYLPZAIBxfUaC89HNmCzQ5xGsQalOp2MalLpcLj+lpFwuD3shX4mWWbLJLJhlthDCaXejUCjQ19cHoVCImZmZqEViFosF69evx5133okbbrhhzvdPP/00nnnmGbz00kuoqKjAE088gcsvvxydnZ2Qy+UAgPvuuw//+Mc/8Oqrr0KtVuPBBx/EF7/4RXz++edLptM7S2ZxQGDuGAD09fWhr68P5eXlKCwsDLlY+BYKjvbhi5bMxsfH0dLSAh6Ph7Kysqh6fS01yyxZWEzJvFAo9Cu7ZbPZGHIbGhoCRVF+YpL5GpTSv12ySGYlklk4ltlCCNXu5q233sJf//pXTE1N4Uc/+hFOnjyJiy++GNu3bw87jnrVVVfhqquuCvodRVF49tln8eijj+L6668HALz88svIzMzEvn37cPfdd8NoNOKFF17An//8Z1x22WUAgL/85S/Iz8/Hxx9/jCuvvDKmc48XWDdjDKDdig6Hg3lQHQ4HTp8+jdHRUWzbtm3B2oqxVr0HIlcUejwetLa2oq2tDevXr4dEIomptuNSIrOV4Gb0xULnQ1ePz8vLw9q1a7Fz505s3LgRSqUSWq0WZ86cwbFjx9Da2oqxsTHGCqeRbMssme7MpWyZLQRa+frEE0+gq6sLUqkU1157Lbq6uvDVr341brGz/v5+aDQaXHHFFcxnQqEQu3btwvHjxwEAn3/+OVwul982OTk5WLNmDbPNUgBrmUUJ2q14+vRpVFRUQC6XY2pqCs3NzUhPT8fGjRvDKt0TDzKLRIRhsVjQ2NgIgiAYt+LAwMCikFmk+1kcbjx9oA88LoHtxSpsLVRBKZ4rhFjqasZEjuNbg5Au00TnQ/km+9IuSbrJazKQTMssWS81tNgkka42giBgs9lw++23o6ysjCmaHA9oNBoAYNydNDIzMzE4OMhsIxAImGo3vtvQ+y8FsGQWBehKHnSxUpfLhY6ODoyMjKC6uho5OTlhHyteZBbO/hqNBi0tLcjNzfUTecSSKxbtvtG0nHnsvS4c6JgGALx+dhwEgOpsObYXq1BbnIKaPMV5Z5ktBN/8NeBc2S26LQq9KPb09CS8QWkyBSDJdDECSCiZ2Ww2kCTJxK/oF5Z4IvB3CceKXkrdMgCWzCJCYO4YXYqmtbUVPB4PdXV1ESuO6GMkksxIkkRHRwfGxsawdu3aOW9hscjrk3Uzv3RyBAc6psHjEPjSukw0jMygd9qKlnETWsZN+N/jwxDxOFiTKUaJ1AVZnhkVmVJwltDDFikSYQEGlt0yGo04e/Yso6qz2+1QKBQMAYZqUBoNkikASTaZJXI8q9UKILYqQaFAx+g0Gg2ys7OZzycnJ5l1IisriynP5mudTU5Ooq6uLu5zihYsmYUJOneMvnkJgsD4+DhsNhsyMjJQU1OTdAEHjflcfVarFQ0NDQC8asVgbqVYyDQeqQUL4dSAHs8e7AcA/PCKUnxlk9fynZhx4NSAASf69TjZb8C0xYkzoxacAfB611mkSvjYVqRiLLdsZXxbtCQDiX5ZoHObVq1aBeCc8ECv1zMNSn3LbsXSoHQlWma+6uVEwWw2g8PhxL3FEAAUFxcjKysLBw4cwIYNGwB4c+IOHTqEp556CgCwadMm8Pl8HDhwADfffDOAc+Kxp59+Ou5zihYsmS0A35JU9ENCl3uampqCRCJBdnZ2zEVNE2GZTUxMoLm5GTk5OVi1alXIOcba3DPSfenmnlarlal3F0pOrpmx46G3OkBSwHVrM3DzxnNvj5kKIa5bl4nr1mV6c7CmrTjQPIKj3VPoNgI6qwsftE3hg7YpAEBhqthLbEUp2FKkgkK0tG//ZMTmAgkmsOyW1WpllJJ0DMVXKSmRSMImqGRaZsmSi9Pij0SSNJ1jFu0YZrMZPT09zL/7+/vR0NCA1NRUFBQU4L777sPevXtRXl6O8vJy7N27FxKJBLfeeisAQKlU4pvf/CYefPBBqNVqpKam4vvf/z7Wrl3LqBuXApb207zICJY7NjMzg8bGRohEIuzYsQNNTU2LnvQcmKtGkiQ6OzsxOjqKNWvWMK6E+fZPFpn5NvfMzMyEwWBgCu/SjS5TU1MhFovh8lB48M126KwurMqU4rGrykM+0ARBoCxdCuXaVGyWz6Bm4yY0jZpwsl+PE/0GtIzNYFBnw6DOhtc+HweHANZky7Ft1mpbn6uAgLe0xL3Jqs043zWlG5TSZbfMZjN0Oh3T84vP5/uR23zWw0q0zJJBnGazOaZC1GfOnMHFF1/M/PuBBx4AANxxxx146aWX8NBDD8Fms2H37t3Q6/XYtm0b9u/f7xeX++///m/weDzcfPPNsNlsuPTSS/HSSy8tmRwzgCWzkPAtSUU/GIODg+ju7kZJSQlKSkoY+e9iJj3T+7tcLgBet2JjYyMoikJtbW1YMbxYBSDhkhldLquoqAhFRUVwu91zujj7LpJ/H+SjacwOhYiLZ26ogogf3oNDURT4XA42FSixqUCJe3YBJrsbZ4aMsy5JPfq1NjSNmdA0ZsIfjw1DzOdgY74StcUp2F6sQkVG9G/C8cRiklkgfBtaFhUVMWW39Ho906BULBb7kRtddosuz7TSYmaJkOUHwmq1xqQ6veiii+Z9RgmCwJ49e7Bnz56Q24hEIvz617/Gr3/966jnkWiwZBYAuk2D2+1mHgqXy4Xm5maYTCZs3rzZLwjK5XIX3TKjCWVychLNzc3IysrCqlWrwn5rSrRl5itAWb9+PTIyMvxeAHy7ONOL5KunBrC/fxQEgFuKnBjvboZj1mpTKpUhzy3UwiwX8XBxhRoXV6gBAJoZB07263FywICT/XpoLS4c69PjWJ8eAJAq9cbbaotTUFusQpZibh+3RCKZ8v9ozyVYWxQ63kY3KJXL5YxKElhZydn0WIm2TmJ1M54vYMnMB8HcijqdDk1NTVCpVKirq5tTkmqp1FakO+JWV1f7qZLC3T9Rlpndbkd9fT0oigopQAlE15QN/31kHADw7zsL8c3t2XPKNymVSmYhjcYFk6UQ4svrs/Dl9VmgKArdU9ZZl6Qenw8ZobO48EHrFD5o9cbbitRibC/yWm1F4tgs8UiwlCyzhcDj8eaU3aLJrbOzEwDQ1NQEtVoddoPSaLDSLDPazchifrBkNgvf3DHaUunp6cHAwAAqKyuRn58f9KHncrmL6ma02WwYHh6G2+0O260YiEQJQLRaLRoaGpCZmYnVq1eH9QZrtLlw/5ttcLhJ7CxNxd07C8AhCKbUT6AoYWBggMmloi2ESM+FIAhUZEhRkSHF7dvy4PKQaBiZwcl+A04O6NEyZsKA1oYBrQ2vfj4GDgEUKzm4zDSA7cUqrM9VgM+N74KWrMociYzLCYVC5ndzOp04evQoMjMzYTQaE9qgNNlklgzLjCWzhXHek5lv7hjt07fb7WhqaoLT6cT27dvnTVBcTMuMditKpVLweLyoq2rH281IURRTm3L16tXIy8sLul8gSIrCw293YNRgR55KhCe/VDknTyyYKGFmZgY6nQ7j4+MwGo0gCAKdnZ1MlYtIk4D5XA62FKqwpVCFe1GEGbsbpwcNXnLr12NAZ0OvgUTv0SH84egQxHwONhecSwEoSw9f4RcKy8HNGOk4AJCbm4v8/HymioWvWzJYg9Jo5pZsN2Oix7JYLEmt1LJccV6TGUmScLvdfm7FyclJtLS0IDMzE5s2bVpwIYyXACSSY5Akie7ubgwNDaG6uhoejwcTExNRj093wI52Xzq4TxCEX3xx69atUCqVYR/rd4cHcaxPDyGPg2dvrApaqioQHA4HKpWKiclMTk6iu7sbBEGgt7cXNpuNSQJOTU2NyrWlEPFwaWUaLq30Jho3dg/hYNs4xigFTvUboLO6cKRXhyO9OgCAWsrH9tlY27aiFGQpom+suZwts8BxgHPn41t2q6CggHkp0ev1TINSoVDoR27hFtZlLbPzE+clmdG5Y4ODg1AqlZBKpX4ihUjiTlwul6kIEi0isczsdjsaGhoYt6JMJsPo6GjSajsGgl6caEVifX09ZDIZ6urqFmwg6buIHurW4vdHhwAAP7mqHJWZ0T28XC4XXC4XFRUVALzXS6fTQafTMdeJXhxTU1MjypOikSHj48J8PjZuXA2SotA9acHJfgMTb9NaXPhnyyT+2TIJAChWi2dVkinYUqiETLjwY5dMyyyZooz5ukfQLyV0g1K67Nbw8DDa2tr8OjXPZ3GvRAEIS2YL47wjM1+Rx8DAAEpLSwEAjY2N4HA4YYsUaCTTzTg1NYWmpiZkZGSgqqqKeYjiISCJpQIIAEaa7Zu2EC6G9Tb86F2vQOArm7Jx3brMBfYIjcBxRSIRcnJymCRgOk9qenoavb29TJ4ULSYJ1nNuPnAIApWZMlRmynDH9jw43SQaR2dwos+rlGwdN6Ffa0O/1oZ9Z8bAJYC1uQpsL1Jhe3EK1uXK5423rSTLLJJxuFwu1Go11Gqv+tTlcjEuSdrippWSdNkt+nlYaQIQi8Uyp8gvi7k4r8gsMHeMy+Vienoazc3NKCgomNMFOhwkI8+MJEn09PRgcHAQVVVVyM3N9fs+1jYssexPz7urqwsbNmxgav6FC5vLg/v+1gaT3Y11uXI8fHlpVPMIB4EV5ek8KZ1Ox7z9y2QyJtamUqkifusW8M7F2/4DXkHL6UEjo5Qc0tvRMDKDhpEZ/H423ral8Fy8rTRNktS2OslsyxLLos/n85GRkYGMjAwAXoubJjdfhWtKSgrsdntUvfmiQTIsM6vVivz8/ISOsRJwXpBZsNwxj8cDq9UKk8mEmpoaRk4cKRKdZ2a329HY2AiXy8W4FSPZP9zxo1k8rVYr6uvrAQBbt26NuJI3RVH4z/e70TVpQaqUj2eur4qLKjDccwnMk6KLqep0OnR0dMDpdDJqO7rklm/MJxwoxXxctioNl63ykvyowY5TA96qJKcGDNBbXTjco8PhHm+8LV0mwPZiFbbkKwDn+WuZLQSRSOTXoNRqtTLkNj09DYIgYLVaw2pQGguSETMzm81Ri7vOJ6x4MgtVkqqhoQEURaG4uDhqIqOPF6tlFooQp6en0dTUhLS0tHnFKIvhZqRdnpmZmTCZTGEH533x2tlxvNcyCS4B/PLfViMzBqEEjVgWLIFAwLSy9+3grNPpMDg4CIIgkJqaGtNvnqsS4fqabFxfkw2SotA5YWGStz8fMmLK7MQ/mifxj+ZJADy8NFiP2lmrbXOBEtIw4m2RYLlYZvPBV+Gal5eH5uZmCIVCCIVCaLVa9Pb2gsfjzVFKxgMkSUbsmo4UbMwsPKxoMiNJEk6n0+9BGhgYQHd3N8rKyjAzMxPzAxYPyyyQTHxz3EJJ232RTMvMd27V1dXIysrCyMhIxJZd/bARv/jYWwn//ktKsKVQFem0551jrKA7ONNdnEmSZEpuaTQa2Gw2nDhxgnFJ+pZuChccgsDqLBlWZ8lwZ20+HG4SDSNGnOw34HivDu0TZvRNW9E3bcUrp8fA4xBYlytnkrfX5MwfbwsHyayXmMyGmWKxGPn5+SEblIpEIj9yi5aQkmGZWa1W1jILAyuSzGi3osvlYtRaTqcTzc3NsFgs2Lp1K1QqFVpaWha9riJ9DFoR6XA40NjYCIfDsWCOG414xMzCOQen04mmpiZYrVZmbvS4kYw/ZXLgvjea4SYpXLE6Dbdvy114p0UGh8OBUqmEUqmEUCiERqNBQUEBdDod+vr6GEECTW7R9AET8jjYVpSCbUUp+E5dDvZ/egzCgrVM8vaw3o6zwzM4OzyD3x4ZhFTAxZZC5WwaQAqK1ZHnZSXTzbhYuV8LNShtbW2FTCZjtomkQWmy8sxYy2xhrDgyC5Y7ptVq0dzcjJSUFD/J+GLkiAUDl8uF0+mEVqtFY2Mj1Go1Nm7cGPYDlch+aDSMRiPq6+uhVCpRW1vLXENfaX44cHlI3P9GMyZNTpSoxfjPayriupgm6+2fIAi/Jpe0IEGn02FsbAwejwcqlYoht0hjNhRFQcoHLl6VhitWe93gIwYbTvUbZuNtehhsbnzarcOn3d54W8ZsvG17cQq2F6mQLl/YbZtMN2OyfpuFCCawQSkdK9Xr9ejq6oLD4Qi7QWmiLTOKomCxWOLeWXolYsWQmW/fMfoBpSgKXV1dGBoawqpVq5CXl+f3QMUjRyxebkaj0QiNRhN0ngshkW5GiqIwPDyMzs5OlJWVoaioaM7cIrEM/+tAD04PGiAVcPHMDavjHgOi55xsBAoSLBYLdDqdX8yGFpuEkwAcrJxVnkqMvA1i3LDBG2/r0JiZQslnh2cwaXbi3eZJvNvszW8rS5d4rbYiFTaFiLetVMssEoLxjZUC8zcoDawFmqyq+axltjBWBJn5lqQCvAuAzWZDY2MjPB5PSBUgl8uFw+GIaexYyczhcGB0dBQOhwPbtm2DQqGI+BiJEoB4PB60trZienoamzZtYlR/4e4fiPdbJvDiCW9i9N4vr0axOv4lepZCZXGCICCTySCTyZjqFoEpAFKplCG3UCkA850LhyBQlS1HVbYc35iNt9UPG3FywIATfXq0a8zombKiZ8qKv3w2ei7eNluZZE2OAjwOcV5aZgshsEGpxWJhyG1gYAAEQTBWm9vtToqbkY2ZLYxlT2a+uWN0fzGNRoOWlhZkZ2fP2wolXrL6aN2MOp0OjY2NEAqFEIvFUREZEHvMLJhlZrFY0NDQAB6Ph7q6unmbLoYzfvekGY++0wYA+NaOQlyxOgNOpzPqOS8n+MZsSktLmQRgnU6Hzs5OOBwOvy4AvrHIcCHkcbzuxeIU3HdxMQxWF04Neq22k/0GjBh84m2HByETcrG5QIVKJYkKJYXqBJPaYsbMYoHviwldC9RkMkGv12NychJWqxUdHR2YmppiLLdolL2hQJIkGzMLE8uWzILljpEkiZaWFmg0mrA6LMer4n2kx/AtxFtZWQmCIKDRaGKag299xEgRaFlNTEygubkZeXl5qKioWHBhWEgNaba78d1Xm2B1erC9OAX3X5q4xGhgcdyMkSAwAZjOkdLpdBga8lqu9IuNzWaLSkaukvBx5ep0XDkbbxvW2xghyakBA4w2Nz7t1uLT2e0zPzs1S4YqbC9KQZosvnLzlVL811cIVFRUhKNHj6KwsBBOpxMjIyNob2+HRCJhiE2lUkWscvWF1WoFRVFszCwMLEsyC5Y7Zjab0djYCB6Phx07doS1AMRLvBEJkfgqAmm3Ii0YiBb0gxttNQLasvItYLx27doFXwYC9w8GiqLww7dbMaC1IkshxDM3rgWPG7sCdL65JAPxHIdOAcjNzWVqXGo0Guh0Opw8eRJCodAv3hbN4pifIkZ+ihg3bcyGh6TQMWHGiX49DraNo33KgQmTE+80TeCdJm/B6vIMKVNya3OBEhJBbCKHZLkzgeQTp0qlglwuZ6xuWinZ19fHiDdocpuvsWwwWK1WAGDdjGFg2ZEZXV377NmzqK2tBUEQjEChsLAQZWVlYd/I8bLM6HktdJPq9Xo0NDRApVL5KQLjIeAAordIaFI/c+YMnE5nyBhjKMxHZn88OogD7VPgcwn8+ivroI7zG/9KA911m8vlYnx8HDt27GAWR9/uzTS5RZMCwOUQqM6WozpbjoszXbA4XDCLMhmXZPuEGd2TFnRPWvDn2Xjb+jwFameVktXZcvA4kRHTSrHMgo3l+9zz+fyQDUrb29vhdDqZslu0S3m+uVosFvB4vLi6Llcqlg2ZBeaOmUwmuFwutLW1wWAwYOPGjUxR0nARr5gZML9El6Io9Pf3o7e3FxUVFSgoKPB7S42HgANA1MewWCyw2+1QqVQRpQT4jh+MzE706fDfn/QAAH58VSXW5YXfDiYWJNrNmAw3Jm3JBMrIHQ4H05i0tbWVUdrR5BZNCoCIx8G6khTUlXjzsHQWJz4bNOBEn9ctOWZ04PMhIz4fMuI3hwYhF3Jn60l6xSSFqQvnty0nAUi4oL0Z873E+jYopavK0OQW2KA02O9Hl7JKFjkvZywLMgt0K9IWzYkTJyCXy7Fjx46oMvjjYZn5VuoOBjpZ22w2h+zvFS/LLNJjUBSFwcFBdHV1gcfjYf369VHH3AIX+DGDHfe/0QySAq6vycZXNicnMXopqBnjgVCEKRQK56QA0PG2/v5+cLlcvy4A4aQABF6zVKkAX6jKwBeqMrypGXr7bKFkA04NGmCyu/GvLi3+1aUFAGQphIzVtq1IBbV07rOYLAEITTDJGMs3zBEOfKvK0C7l+RqUulyuuCsZ3W439uzZg1deeQUajQbZ2dn4+te/jh//+Md+Hp7HH38czz//PPR6PbZt24bnnnsO1dXVcZtHIrDkyYy2xnxvUDpInpubi7KysqgXsHjEzAiCCNncUq/Xo7GxEUqlct7+XvGwzCKtr+h2u9HS0gK9Xo+qqip0dnZGfR0DyczpJvEfrzdBb3WhKluOn35x1YohmWRioWsWTGlHpwDQLXkCxQiBVvdCJEMQBApSxShIFePmTTnwkBTaNd5428l+PepHZqCZceCtxgm81eiNt1VmSBmrbWOBEmI+N2mWGX0fJqtHG4Cok6bna1A6NDSEL33pSxCLxXC73Xj11Vdx6aWXMqKhaPHUU0/h97//PV5++WVUV1fjzJkzuPPOO6FUKvG9730PAPD000/jmWeewUsvvYSKigo88cQTuPzyy9HZ2bmkhShLlswCc8c4HA4cDgeam5ths9nA4XCQnZ0d0wMSDzdjsONQFIWBgQH09PSgvLwchYWF884z0ZX3A2E2m1FfXw+hUIi6ujo4nc64tpB54v1ONI/OQCnm4X++sg4ifmJr1wViqasZw0E05xBYtsm3B1h3dzfsdjsUCsWcFICI+oxxCKzJkWNNjhx37SiAzeXB2aFz+W2dkxbm7+VTI+BzCWzIU6BcQWJtBh/lJAVuhPG2SEA/A8m0zOJF0oENSnt6evDkk0/i9ddfxy9+8Qt87WtfQ3V1Nf7v//4PNTU1UY1x4sQJfOlLX8I111wDACgqKsJf//pXnDlzBoD3vnv22Wfx6KOP4vrrrwcAvPzyy8jMzMS+fftw9913x+VcE4ElSWZ07hh9YxIEwfQdU6vV2LBhAw4fPhwXF2GsxwD8iYR2K5pMJmzZsgUqlSqi/aNFuLlm4+PjaGlp8RPL+F7rWMf+29lRvPb5KAgC+OUNa5Cfkpy+Ur5zWSmI9VwCUwDoLgB092bA+wxIpVJYrVaIxZHXdhTzudhRmoodpanApYDW4sSp2aokJ/oN0Mw48NmgEZ/Nbv/zYyewzad/W36KKK6/WTLJjI6XJeqeUygUWLNmDRobG3HkyBFotVocPHgQBQUFUR/zggsuwO9//3t0dXWhoqICjY2NOHr0KJ599lkAQH9/PzQaDa644gpmH6FQiF27duH48eMsmYUL35JUtFuRoih0dnZieHgYVVVVyMnJAUEQcYt3kSQZs2yYdlcaDAY0NDRALpejrq4u7DheLJ2efeewUIPPzs5OjI6OYt26dUzpHnrfeCRdt4zN4PF/ejtG33tRCS4sj6xR53JCMvqMxRtisRi5ubl+KQAdHR2wWq04deoUhEKhX7wtmhQAtVSAq6szcHW1N942pLfjRJ8eB5qH0TLlhMnuxsed0/i4cxoAkKMUonY2v21roQqpQeJtkSDe1tJCYyWjlJVE4q2Uo1arceONN8Z0vIcffhhGo5EpJuHxePDzn/8ct9xyCwAw+a6+6wP978HBwZjGTjSWDJkFyx2zWq1obGwERVFz5OLxlNV7PJ6IFXyBxxkfH8fY2FjI+oXzIR6kulCDz4aGBqa0V2BAmbasYkm61lud+I+3uuB0k7i4Ig3/fmHxvPtYLBaMjo4ybpV4Lgorwc0IJHZBplMA6D5g+fn5MBgMTO+21tbWmPKj6DEKU8UoTBVjvdQIHl8AmzgdJ/sNONGvR8PIDMaMDrzZoMGbDd5F9MC925AVQ187+iU4WSW6ktGYM57VP1577TX85S9/wb59+1BdXY2Ghgbcd999yMnJwR133MFsF3j9kpknGC2WBJn5lqSib8SxsTG0tbUhNzcXFRUVc26aZCgRw4HL5YLT6YRGo8HmzZuZeEUk8FURxZvM6Er8aWlpqK6unrcGYLTjUwB+9vEIRg12FKSK8fT11eDMExehK4zQCeNut9vPIpBIJDGJUVYCkt0BmsvlQq1WM+ktTqeTaUza3t4Ol8sVsthuOCBJEnweF+W5CqzLVeDbFxTA6vTg7LBxVkxigM3liYnI6HGSJWNPRi+zeJey+sEPfoAf/vCH+OpXvwoAWLt2LQYHB/Hkk0/ijjvuYAol0EpHGpOTk3OstaWGRSWzYCWpPB4P2tvbMTk5iXXr1oVU78Sj4r2vZRYNjEYjGhoaAAAVFRVREZnvPGJ5EANjZr65bQtV4o816frIqBunh70Fm3NVYhzt1aK2JBUpEn+XUWBjT7VazbS81+l0mJ6eRm9vLwQCQcwVL5Y7kmVdhiJNgUDglx9F/0Y6nQ4DAwPgcDjM75Oamjpv7U56nMB7WyLg4oLSVFxQ6i1gbXPFHr9eacnZ8ZbmW63WOXP2FaAVFxcjKysLBw4cwIYNGwB4X2wOHTqEp556Km7zSAQWjcyCuRVNJhMaGxshEAiwY8eOeR+QeFhm0cbeKIrC0NAQurq6UFpaiqmpqZhjbkBsFqKvZeZyudDc3IyZmZmQuW2+8E26juZNM03MhYhHwO6mcKJPhxN9OhAEsDZHgQvK1LigTI2qTAnaWrzNUbdv3w6pVAqn0zmnwjwde6Tzpmh3l1qtDqtiArAykqaB5FiZ4ViABEH4uSNpCTndu62zsxNisdiv63ag2z4cab44DqrXZFtmySAzOmE+Hrj22mvx85//HAUFBaiurkZ9fT2eeeYZfOMb3wDg/a3vu+8+7N27F+Xl5SgvL8fevXshkUhw6623xm0eicCikBlFUXA6nX43A00OxcXFKC0tXfDGj5cSMdLjuFwutLS0wGAwMG5FvV6/KEnPgcegK3rX19dDIpGELUKJ1TJbl8HHW/9fHsY9Uhzt0eJojxZdkxY0jc6gaXQGvz3UDzEPWJPGx9Ubi1Dq4SHUu2agu8tutzMWAa3Ao60BtVo954WHdTMmfhxfCXlJSQncbjeTuN3b2wubzRY0BSBZCsOV5mYsLp4//hwJfv3rX+Oxxx7D7t27MTk5iZycHNx99934yU9+wmzz0EMPwWazYffu3UzS9P79+5d0jhmwSGRGt2qhrbOWlhYYjcZ5e2YFgsfjxU1WH+5xjEYjGhsbIZFI/KqOLEbScyB8O2qH+0LgOz4QPZkSBAE+l8COIjV2lKrx8JXAxIwdR3t1+LhlFCcHDLC6CZzWuHD6/W7g/W4UqyWoLVZiR0kqNheqQhayFYlEyMnJYXpLmUwmaLVaaDQadHV1MRYBbRWsFCy2mzES8Hg8v3qEvi8gdMkmDocDHo8HlUoVU0x0ISxmXcZEwGq1xtXNKJfL8eyzzzJS/GAgCAJ79uzBnj174jZuMrBobkaCIKDX69HU1ASFQhFxSapkWma+3ZZLSkpQUlIyp7biYrSSoUGSJKxWK2ZmZlBTU8MsKuHCVwASDYLluGXIhVgjMUGZbcRjl63FlEeMI7NWW9PoDPq1VvRrrdh3Zhx8LoGN+UrsmK0PWJERvL4grcBTKBQoLi5mLAKtVsu0u5fL5YyFGqlIYalhqVpmCyHwBcRsNjMl3U6fPg0+n+8Xb4umFF0orEQ3I9vLLDwsGpn19/ejs7MzaOHdcMDlcuFyuWKex0LVN3zLPoWyHJNdwcMXNpuNkd2XlJRETGTAOcswFjLznbvT6URjYyPsdju2b98OmUyGHADr85T47kUlmLG5cLxXi8PdUzjeZ8D4jAOnBgw4NWDAM//qR7pMgNqSFFxQkoLa4hSoJMEFIL4WAV3EVaPRMF0VuFwuY7XFe9FcjnlmocZJdAqAXC6HQCBAQUEB1Go1U3JraGgIbW1tkMlkfl0AYrF2VpplxnaZDh+LRmZKpZLp5xUNuFwu7HZ7zPOYzzKbmZlBQ0MDxGIx6urqQhZtjUcFj2iOMT09jcbGRmRlZUEgEMSUKxeLm9N3MZyZmUF9fT3kcjlqa2uDzkkh5uPK6kxcVKYCAAzo7Djep8exPh3ODBoxZXbi3aYJvNs0AQJAdbYcdSUp2FGagnW5iqDtR+girtnZ2RgcHMTOnTuZRXN4eJhZNGkhSTStU5KN5WqZzTeO7wsG4H3xoeNtdAqAb9ftaFIAEk0wNFjLbGlh0chMrVbHJK2PZymqwONQFIWRkRF0dHSEFX+KVwJ3uGRCURR6e3vR39+Pqqoq5Obmor6+Pi5VPKIBbdWNjY2htbU17Jgd/X1JmgQlaRJ8bWsuHG4SZ4eNs+SmR/ekBS3jJrSMm/D8sSHIhFxsK1J5ya0kFbmquYpXWmxAK+tKS0v98qZaW1vh8XiY1ilqtTqqUk6JRDIts8UUZggEAmRmZiIzM5NJAaDJjU4BoN2RKSkpCzbdTbZlFssL5EKguyIsdeHFUsGSSJqOBvHIM6OP40tEbrcbra2t0Gq1YfdIo+sbxoJwySxYp+pI9g+FWC2ziYkJmM1mrF+/PqbK3kIeB7XFXvfig5cCkyYHjvfpcbxPjxP9ehhsbnzSqcUnnd72I0Wp4lliS8HmQhU4IQgpMG/KYrFAq9VienoaPT09cenmHG+sRMtsPvimAOTl5TGxT51Oh/HxcXR2dkIkEvn9TsFSAJIZM4un6zoY4i0AWclY1mQWLwEIvYibTCY0NDRAKBRix44dYXd3jYcAJJy4G52kTbvwfBfcePREi8YaoC0euuRYvB+8DLkQX16fhS+vz2Lajxzr0+F4nx6NIzMY0NkwoLNh35kx8LkE1ufKkQMCORoTKjODu6h8c9sKCwv9ctv6+vrmSMsVCoXfcZLZnHOljBMNyXA4HCiVSiiVSkbwQ/9OdAqAb9dthUKxImNmrJsxPCyqmjEWxFvNODIygvb2dhQVFUXcIy0eApCFLKPh4WF0dHSgtLQUxcXFc+YXD8ss0kXaaDSivr4eHA4HWVlZCX+D9G0/cvcFhTDZ3fhswIBjfXoc79Nh1OjAmaEZAFy8+0I90qQC1JWoUFeSitri0EVsfXPbysvLg+a2+QpJkoGVIgChEY9+ZoFdt+12O+OSbG5uBkmSEAgEEAgEsFgsCU0BABKfZ0arlFkyCw/L1jKLV54Z4K1D5nK5sGHDhqiy7RMpAPF4PGhra8PU1NS8bs9Y1Ij0/pGcw+joKNra2lBaWgqr1boo8Sa5iIdLV6Xh0lVp3q7ZOhsOdU3h/bP96LPwMG1x4t3mSbzbPAkCwOosmVf+X5qC9bkK8LnB3+ADpeV0tQva1cXn85m8PpVKlbAFbSVZZomIzYlEIr+u22azmUnRoFMAfGt+xtslmGgBiMViAQA2ZhYmli2ZxcMyM5vNmJiYAIfDQV1d3YL15RI5l2DWndVqRX19Pbhc7oLzS5abkSRJdHR0YHx8nCH/tra2Ra9UTxAEitQSZG/MQr6tF3UXbEfjmMlrtfV6m0a2acxo05jxx+PDkAq42FqkYnLbQvVdIwjCz9XlcrnQ09MDvV6Pzs5OOBwOPyGJVBo8Ry5SJOt6JqsDdKLHoVMAZDIZVCoVioqKYDQamd5ttJrVt+t2rC8hiXYz0mTGxszCw3nrZqQtC4VCAbFYHDWRAfFLmvYlo8nJSTQ1NSE3NxeVlZULvgHGKkIJxzJzOBxoaGiA2+1GbW0t02cpVqswnqDvKwGPg21FKdhWlIIHLgGmTA4c7/cqJE/2G6C3unCwS4uDXV4hSUGKCHUlqdhRkoKtRaErkvD5fMhkMrhcLqxduxY2mw1arZZR38Urt22lxcySrZr0/R1oNSvddZt+CfFNAZDL5RFfh2RYZrTblMXCWPaWWaQPI+22m5ycRE1NDcxmM4xGY8xziZebkaIodHd3Y3BwEGvWrPFrwxDO/rGMPx8hGQwG1NfXIzU1FWvWrPF7I11KZBYK6XIhvrQuC19alwWSotA+bsax2dy2plEThvR2DH0+hlc/HwOPQ2BDvoKR/1dmSueoJOlEc4lEAolEwhTgDUwI9hUoLMXctuUUMwt3nHBSAHy7bg8NDQGAn0tyoRQAeqxEWmZmszlulv75gGVNZpE2lDSbzWhoaACPx2Oq8lut1qTmiM13DKfTiTNnzsBut89pRroQEhkzo8Un5eXlKCwsnHO949EpO96Y71pwCALVOXJU58jx7QsKYHa4cWrAwOS2jRrsOD1oxOlBI351cABqKR+1xV53ZF1J6PqP4eS2BS6Yoe7dlWSZ0ffGUik07PsSEpgCMDExga6uLiYFgP49g6VqJMMyo70fLBbGsnYzAt68sHDMcDqht6CgAOXl5cxNGK+E51iP4XK5MDExgbS0tJCVMxaaQ7zVjCRJoq2tDRMTEwuKT5YKmUVzX8mEPFxamYZLK71CkiG9Hcd6vfL/zwYN0FpceK9lEu+1TAIASlMFqE7lwK4woCYvtJAkMLfNbDZDp9NhamoK3d3dTG6bWq0OmjO1UsiMvq+WCpkFYr4UgP7+frS0tEChUPh13aaft0THzJZ7fdFkYllbZsDCjTXpZp8TExNBE3rj4SKM5Rh0b7Tp6WmkpKSgpqYmqps3Hm5G3/3tdjtTVaSurm5et8tycDOGC4IgUJgqRmFqLm7dkgunm0TDyAwj/++YsKBX50SvDni3pwkSARdbC5VMvK0gNbSQRC6XQy6XM7ltodqmqNXqpL0cJNMyS8aiHA9rKTAFwOFw+FnYdGd0t9sNu92eMFcgW5cxMiwqmcVa3HYhi8hisaChoYFRAwZbkJNdisoXdLURnU6HzMxMCASCqB+KeLgZ6f31ej0aGhqgVqtRXV294NtntAnXiSTBeB1XwONga5EKW4tUuP+SYkybnXjvTA9ODsygXU9BZ3Xh024dPu3WAQDyVCJGIbmtSAWpMPgjxuVy/RZMOoZD57bRpZLGxsbC6uQcLVjLbGEIhUK/FAC6eoxWq0VLSwt4PJ5fF4Bwiy0sBDZhOjIsW8sMmD/XbHx8HC0tLcjPz0dFRUXIGzxesvpIj0HH7/h8Purq6jA4OAin0xn1HOJlmQ0NDUXczWApWWaJXpjTZAJcUiLDJrUH1WvWoENjZmJtDSMzGDHY8drZcbx2dhw8DoH1eQqG3FZnyUKW2xKLxcjNzUVubi5IkkRvby+0Wi3TyVkikTCxtnjmtq00yyzRFUDo6jEikQi9vb2oq6uDxWKBTqfD6Ogo2tvbIZVK/eJt0f5WbMwsMixrMgtGIh6PBx0dHdBoNGHVCYyXrD4SMYpGo2GIlo7fxdtNGA3GxsZgs9kiapIKLC0ySyY4BIGqbDmqsuX41o4CWBxufDZoZMptDevt+HzIiM+HjPifTweQKuFje7EKO0pSUVeSgjRZ8Fgvh8OBSCSCRCLBunXr4HK5GJdkR0cHU1me7gAQi5srWZYZrf5MNJJVzopeM3g8HkNaAPx+KzqBW6lUMlZbYGm0+cBaZpFh2boZgblkZrVa0dDQAIIg/PKgFjpGPJSIgPcGn0+4QZIkurq6MDIygjVr1iArK8vvGItFZjabDXq9HjweL6rk8aVIZosxH6mQh4sr1Li4wiuUGdbbcKzXa7V9NmiAzurC+61TeL91CgBQmSFFXam3SPKGPCUEPP9FmF70+Hw+MjIykJGRwVSWp12SfX19jJsr0ty2ZLn/kiXLp8dKljuTDnX4wve3Aua6jwH4dQGYb40ym80smUWAFWOZ0dZOuEnGwY4RyzwAzEsmdrsdjY2NcLlcQQvyLlahYK1Wi8bGRvD5fOTk5EQVm1lKZLaUlF/5KWJ8dbMYX92cA5fHKyShXZLtGjM6Jy3onLTgxRMjEPM52FKoYjoAECHuBd/K8nRuG628izS3jf7NkmGZraTiv0D4QhNf9zFFUXNSAObr1mC1WuPqZhwdHcXDDz+MDz74ADabDRUVFXjhhRewadMmAN7f6fHHH8fzzz8PvV6Pbdu24bnnnkN1dXXc5pBILHsyczqdaGtrw9jYGNauXYvMzMyIj0EnK0f7UNM3dSgy0ul0aGxshFqtxqZNm4Jab8lu4UJRFAYHB9Hd3Y1Vq1ZBr9cvmvhkOSLSa8XneslqS6EK37u4GFqLEyf69Ux7G63FhcM9Ohzu8QpJMqU8rEnn4lr+NLYWqSAXBX9UORyOXwFkh8MBvV7PiBNIkvTLbfNdHJNFZivVMouUNAmCgEKhgEKhQFFRkV+3BjoFQC6Xw+PxQKvVwmg0Ijc3Ny7z1ev12LFjBy6++GJ88MEHyMjIQG9vL1QqFbPN008/jWeeeQYvvfQSKioq8MQTT+Dyyy9HZ2fnsqgPuehuxljR19cHgUCAurq6qN5iwnURzodQykqKojAwMICenh5UVlYiPz8/5Dkn083o8XjQ0tICnU6HzZs3IyUlBUajMebmnEsJS20+gVBLBfjimkx8cU0mSIpC14SFkf+fHZ7BhMWNCYsbnwy0gUsA6/POVSSpyg4tJBEKhUFz2yYnJ5ncNjrWRi9QK80yS1bMLNZxfLs1AOdeRD744AM8/vjjMBgMKCkpQUZGBi6//HKsXbs26t/qqaeeQn5+Pl588UXms6KiIub/KYrCs88+i0cffRTXX389AODll19GZmYm9u3bh7vvvjv6E00Slq1lNjExAb1eD6VSia1bt0Z9Y4XjIgwHgWTidrvR3NwMo9GILVu2+L0BhbN/rOOHAl28mI6P0TLiWJtzLhXyWEpuxnDBIQisypJhVZYM36zLh9XpwXufdeGzIRM6jAQGdTacHZ7B2eEZ/ObQIFRiHmpn3ZF1xSlIlweXgoeT2wYAQ0NDSEtLi6o+YThIFsFQFLWkLbOFQL+I3HnnnbjjjjtwzTXXID09HQcPHsRPf/pTVFZW4vPPP4/q2O+++y6uvPJK3HTTTTh06BByc3Oxe/du3HXXXQCA/v5+aDQaXHHFFX7z2bVrF44fP86SWSJAkiQ6OzsxOjrKqIhiuXl9LbNY4Bt7M5lMqK+vh1gsRl1dXVgB+ViFKOHEzKanp9HY2Ijs7GysWrXK77pFG3Oj94107k6nk4kZqNVqttKBDyQCLrbmibEmlUJVVRVGDDYcnxWSnBowwGBz44PWKXwwKySpyJAy8v+N+XOFJDQCc9tmZmZw5swZmM1mjIyMgCAIxiWpVqvjli+VLDdjMvPZEt3LjC6WfNVVV+Hb3/42nE4nBgYGoj5eX18ffve73+GBBx7AI488gs8++wz/8R//AaFQiNtvvx0ajQYA5oRpMjMzMTg4GMupMHj//fdxzTXXhPz+pptuwuuvvx718ZeVm9Fms6GhoQEkSaK2thZDQ0MxkxBBEHFNnKbLZkXa5DORMTOKotDf34/e3l6sXr0aeXl5Ee0fztiREOHMzAzOnj0LqVQKu92OwcFBpso57QILVgsvEiTSUkxWp2kaeSoxbt4kxs2bvEKSplETI/9vGzeja9KCrkkLXjzpFZJsLlBhR6mX3IpSQ9d/pMlq7dq1jDiBzm3r6Ohg8qVizW1LZsV8IHlkluhxLBYL4woWCASoqKiI+lgkSWLz5s3Yu3cvAGDDhg1obW3F7373O9x+++3MdoH3SjxTNy6++GKMj4/7febxeHDnnXeivr4ejz32WEzHXzaW2eTkJJqbm5GVlYVVq1aBy+WCy+XG1PaERjxyzQiCQH9/P/R6/bz5bU/v74bTTWJXRRq2Fqog5HOZOSTCzeh2u9HS0gKDwYCtW7dCqVSGnH8yYmYajQbNzc0oLi5Gfn4+s5/RaIRWq8XAwACjyKPjCZG4v1aSdRfsXPhcDjYVKLGpQIn/uKgYeqsLJ2Zb25zo02PK7MSRXh2O9HqFJDlKIRNr2xYgJPFNZvbt21ZSUsLkS2m1Wia3je7bFmluWzIr5gPJqzSSaNVkPMtZZWdno6qqyu+z1atX48033wQAJk1Io9H4deqYnJyMWFQXCmKx2K8Kk8fjwde+9jXU19fjX//6F9auXRvT8Zc8mdG5WcPDw3NaonC5XNjt9pjHiNXFZ7PZ4HA4mDqGoYQoHpLCm2fHYLC58OdTwxDxOagtTsXOcjVqMvhxJzOLxYL6+noIBALU1tbO6zaKxc0YDplRFIWenh4MDAxg3bp1yMjIgMvlYt7aaZdxWVkZHA4HUy5oeHgYBEH4WW3nQ3+ncH+LFAkfV1dn4Opqbw5a16SFkf+fHTZizOjA3+o1+Fu9BlwCWJerYOT/RUpuSJIJN7eNLpI832+SbMtsudSAnA/0NY+XinDHjh3o7Oz0+6yrqwuFhYUAgOLiYmRlZeHAgQPYsGEDAG8o4NChQ3jqqafiMgdf0ER24MCBuBAZsMTdjDabDY2NjfB4PEFbosTDPRjrcbRaLVP/saysbF5FJUVR+PmXVuNQtxaHuqcxMePAwa5pHOyaBgBkSYCrHV24sDwNmwpUIWMfwRBYhWRqagqNjY1h590l0s3odrvR1NQEk8mE7du3Qy6Xz7u9UChETk4OcnJyQJIkZmZmGGILtNpCVVRYKoKUWBDpokwQBCozZajMlOHOWq+Q5MyQEcf7dDjWp8eA1ob6kRnUj8zgucODUIi4KJVyYEjRoK4kBZmK0EKSULltg4ODaG1tnTe3Ldm9zJI11nKyzO6//37U1dVh7969uPnmm/HZZ5/h+eefx/PPPw/A+xvfd9992Lt3L8rLy1FeXo69e/dCIpHg1ltvjcscaHg8Hvx//9//hwMHDuCTTz7BunXr4nLcJWuZTU1NoampCZmZmVi9enXQG4fL5cLtdsc8VjRkRlEU+vr60NfXh9WrV2N8fHzBBZTH5eCy1Rm4bLX3bbdzwozDs8RWP2SAxgr86fgQ/nR8CBIBFztKU7GrPA0XlquRqZg/mZl+gEmSxMDAAPr6+lBdXY2cnJywzidRlpnVasXZs2chFApRW1sbsVXF4XCgUqmgUqmYHmF0Z+fGxkYA8LPa4iVaWGzEI1YhEXBxYVkqLizz5qCNGe041uvNazs1oMeM3YN6O4H6f3YBAMrSJUyprU0FSghDvEwFy22jrbZguW3J7jKdDCQrZhavCiBbtmzBW2+9hR/96Ef4z//8TxQXF+PZZ5/Fbbfdxmzz0EMPwWazYffu3UzS9P79++OaY0YT2f79+/HJJ59g/fr1cTv2kiMzkiTR3d2NoaGhBRfjxbLMXC4XmpqaYDabsW3bNigUCkxMTERk2RAEgVVZcqzKkuPbO4ug0Rrx0ocnYZTk4XCPFtNmJw60T+FA+2zpo0wZdpWnYVeFGjV5SvACemjRD1ZDQ4PfvCKZT7wtM9pqzcnJiagqy3wQCAR+FcxnZmb8irzSD7/RaIRAIEjYgpOsSvPxRI5ShJs2ZuOmjdlwkxROdWvwzqlujHjkaBkzoWfKip4pK14+NQIRzxub21HqjbcVq+cXkvj+JmazGVqtlslt4/F44HK5mJqaCtq3LV5IJpkl2jLzeDyw2+1xLWf1xS9+EV/84hdDfk8QBPbs2YM9e/bEbUxf0ET20UcfxZ3IgCVGZoElnxb6IeNFZpEIQGZmZlBfXw+ZTIa6ujpGdReriEQpEaBGTeHKK6tAUUCbxoRDXdM43K1F46gRnRNmdE6Y8fzRAShEPOwoVWNXhRo7y9RIkwmZnCG32x2VBRRPAYhvdZFQ6sl4wFe0UFxcDJfLBa1Wi7a2NnR1daGjo4OxDtRqddzaqCTLhZlIwuRxCKzNloIsJrBz5wYYrC6cHNAzltuk2Yljs7E3oA9ZCiF2lKTgm3X5yE+Zv7cdndtWVFQEt9uN7u5u6PV6v75tvonb8TrPZFhLvmPFqridD2azGQBWTG1Gj8eD22+/HR999BE+/vhj1NTUxH2MJRMzo92KGRkZqKqqCuutJ56WWThWycjICNrb21FSUoKSkhK/+ccjTww498a3JkeBNTkK3HNRCXQWJ472anG4W4sjPVoYrC580DqBD1onAACV6WKUiGxYpQR2XrguKoFEvNyMJEmitbUVU1NTTHWRZIHP5yMrKwvt7e3YtGkTUxZIo9Ggq6uLaaOiVquhUqmStvBFg2TJ/+l7WCXh4wtVGfhCldcF3jNlxfE+PY706nBqwADNjANvNmhgdXrw9L+tDnsMHo8HiUQCkiRRXV3tV3h3aGiIyW2Lh5s4mZVGPB5PwnrMAV4XI7AyyIwkSdx+++14++238be//Q3Z2dlMXhuN9PT0mC3dRbfMSJJET08PBgcHUVVVFVEtsvn6mUWChUjRt1v1hg0bmKRTX8RDWg8Ed1+kSgW4bl02rluXDQ9JoXl0Boe6p3Goaxqt4yZ0TtnQCeCDYR5e7D2FC8q87sgLStVIlYZHbPFwMzocDtTX14MkyQWr7yejJYivheArNW9ra4PH4/FLEJ6vk/ZiIVmtWYKNW54hhcXpwfutk8znxWoxvlGbH/E4vgKQwL5tgW7iWHLbVpKb0WKxQCQSJcwlm0ycPn0a+/btAwBcffXVQbfR6/ULVklaCIt6pZxOJ06fPg2n08mo3CJBMmJmvm1lQnWrjsdcFipWzIzDIVCTr0R1lgQXKA0Y0/FhkuXj1LAZhzomYLC58V6zBu81a0AQwPpcJS4sV2NXRRqqsuTgcELXhoylAojH48GJEyeQkpKCNWvWJKVyeSQIlJrT3YLpuI5YLPaz2hZ7/smwMkKR2ZTJgf8+2I9/NHuJTCbk4t93FuKWzTngcyOfU6hz8RX3xCO3LdlklsixaCXjSsib3LZtW1I8DYtKZnSuSnFxcVRvIImOmdGuz2Dln8I9RiRzAMKrEUmXy5JKpfjCRd643a21wEf7P4Y4fzVOj9hwqHsanRNmNIwY0TBixP8c7EOaTICdZWpcWJ6GC0pToRCf8/nHYplNT0/D5XKhuLgYxcXFi/4ALjQ+3S1YJpOhsLAQbrc76CJKy//F4tDih+WMQJJxukn85fQo/nB0CFan917+t/WZ+I+LikM2Eg0H4UrzQ+W2abVa9PX1gc/n+/VtC4xZJTtmlsgXHrPZzHaZjhCLSmZcLhfl5eUx7R+P4qKBpOib4BuuvJ3D4cDpdEY9B9rtthCh0BU0gpXL4nEJ1OTKceHqXDx4eRk0Rjsj/T/ep8O02Ym3GsbxVsM4uBwCG/KVjPRfGYUAhKIodHV1YWhoCBwOByUlJVGdeyIQybnweDykp6cjPT2dWUS1Wi2mp6fR09PD1I+kE4STgWR2gAaAwz06PH2gF4M6r5BoXY4cP7yiFGtzw1fEzjdOpM9nYG6bx+OB0Wick9tGx9oUCsWKkubTsvyV+BKVKCy6QzYWFR39ZuR2u2OqCkH3RQO8rs/GxkbYbLaIXJ/x6Fg93zFo4hgeHsa6deuClpgJjNtlKUW4eXMubt6cC6ebxOdDBhzunsahbi16pyw4M2jAmUED/uvjHqRLeahKoWBWTaK2JBUy4fy3Bp2eYLFYsH79eibnKxIsxQfVdxEtKCjwqzTf3d0Nu90OkUgELpcLs9mcMFdQsgQgk1YK97zWwvRRU0v5uP+SYly7NjNkm5lIEY/4El27M1huW3NzM0iSZGK0Npst4THQZMTM4pUwfb5g0cksFtA3U7wq3huNRtTX10OpVKK2tjYi6W2sApD5jkETrN1ux/bt20MqnOabg4DHQW1JKmpLUvHwlcCw3obD3V7p/8l+HaYsbhyyAIdebQKfS2BTgWo2ry0NJWkSvwXbYrHg7NmzEIvFqK2thdPpXFIVN+JJLoGV5q1WK7q7u2E2m3HmzBnw+Xw/qy2eAftEkr3F4cYfTk7gjSYnPJQOPA6Br23Nxd0XFCz4IhMpSJKMu4w9MLfNZDKhr68PJpMJJ0+ehEgk8uvgHG8hRTIsM5bMIsOyJrNQTTGjOY7ZbMZnn32GsrIyFBUVRbyQxLPyvi/ovDa5XI7a2tp5H8pICDU/RYzbtubjtq35sLs8+LhpEO+fHUC3VYghnQ0n+/U42a/HU/u7kasSMcRWKvOgs60Z+fn5qKioAEEQTI3FSLEcK9tLJBIolUrw+XxUVlYyZZ3oHCqlUskISWJxEyVq/hRF4b2WSfz3v/oxZfZ6I3aUpOChy0tRkpaYGE2iXaZ0B2elUslUlzcYDNBqtejp6YHdbmd+l3jltrGW2dLDopNZrI0dYyURj8cDjUYDi8WCLVu2MG6MSJEIy4xuJ1NcXIzS0tKwhA3RXEsRn4vaIiXkZi527dqBAa11NmF7GqcG9Bg12LHv9Aj2nR4Bj6CwIVeGK2RiiHQ2FKolzLjJiPMsBdDX2LdTcHl5OZNDpdVqY25rk4hr2Tpuwv/b34uGkRkAQLacj5vLOfjmF9Yk9HdLdsNMHo/nZ0375rYNDg76leOKNrctWTEzFuFj0cksVsSSa0ZXlacoiimUGi3iaZnRnQJGRkbmbScTav9ox6YX6SK1BEW1BbijtgBWpwfHe6bxzukenBm1QecgcHrEgtMjXfj5B10oUkuwo1gFhYXARS4PRILFv6UWi1ADc6gC29ooFAqG3MKxDuJ1HjqLE//z6QD+3qABBUDM5+DbOwpweQEX2qmJpAhNFrM2Yzi5bfQLh1KpXNDiokVnibbMWDKLDIu/8sSIaElkYmICzc3NyMvLQ0pKCnp6emKaR7wsM4fDgTNnzsDpdKK2tjYiV0MscwilpOSQLkiNfbi1goOnb96BUZOHqfr/+aABA1orBrRWAFy89PRhbC85Vxw5V7V4iciLHcOLta1NPObv8pB4/ew4njs0AJPD+4xcXZ2O+y8pQZZCiLGxsaRVmE/WOAvFxoLlttFWW3t7u19um1qthkQimTN32guRaDJjpfmRYdHJLNabPFIy8y1kvHbtWmRlZWF6ejouVlWsxyBJEp2dnUhNTcXGjRsjDlrH4rINljRtMBhQX1+PtLQ0VFdXg8PhoEwMlGXI8M0dhTDb3TjRr8PBjkl83DoOo4vEwc5pHOz0trQpS5fiwtniyBvzI2tps9IQaVsbILZn49SAHv9vfy96pqwAgFWZUvzoyjJszD/XnDVZbuHFtszmA5/PR2ZmJjIzM/3SMui+bcFy2+jnPNFuxkiqIbFYAmQWKyIhM4fDgcbGRsbqoc34RMvqw8Ho6CjMZjMyMzNRU1MT1SITT8uMrkNZXl6OwsLCoPORiXi4fHUGLi5PxU7RCPLXbsfxfoO3pc2wET1TFvRMWfCn44OQCrnYUZKKC8NsaRMLlnrcLpy2NnQOpcPhiCimM2qw478+6cOBDu8LhUrMw70XFeGGmmxwOXMtjJVmmcVCMMHSMnxdxa2trVAoFBF1o4gWrJsxcqwIMgunp5ler0dDQwNSUlLmWD2JUiKGA5Ik0dHRgfHxcaaaeLQPfqxkRscCOjs7MTY2FrIOZbB9CQKoyJBgTZ4K395ZBKPNhWO9Okb+r7U4sb99CvtnW9qsypJhZ2kq6oqVqMlXgReizFa0WGw3YyQI1tamvb0dRqMRx44dg0wm84vpBFuwbS4PXjwxjD+dGIHDTYJDAF/ZlIN7LiyEUhxceMJaZvMjVG7b5KS3zNexY8f8rLZ45rbFs8v0+YJFJ7NEuxl925FUVFSgoKBgzpjxILNojuFwONDQ0MC0beno6Ii5WHEsAhCSJPH555/D4XBg+/btYcfr6OvpSyBKMR9Xr8nE1WsyQZIUWsdNDLE1jhrRoTGjQ2PGH48BchEPdcUp2Fnm7Z0VS+mk5Q66rY1UKoVKpUJWVhZjtdGNL33b2giFQhzomMYvP+7D+IwDALClUImHLy9FZeb8b/asZRYZ6Nw2uVwOg8GADRs2QKfTYWJiAl1dXRCJRMxLh0qliim3jS1nFTkWncxixXwk4na70dLSAr1eP287EtpFGMvDHSmR0PGo1NRUpjBvrCKSWGJmVqs3tsLhcLB9+/aIHsRgZOYLDofA2lwF1ub6t7T5tHMKR3t0MNrd+Kh9Ch/NWm3V2V6rbWdZKqqz5XPcY+HOJ5FIVnNOuq1NVlaWX+NLjUaDT+u78PYQDx1677ZZCiG+f1kJrliVFtb8WMssOtB1GWmXI923LbBSTCw5h6xlFjlWLJmZzWbU19dDKBSirq5u3rgD/QB4PJ6o36ZoAUU4D9Tw8DA6OjrmxKPi0UYmmv0nJyeZWE1NTU3EKq2FyCwQdEuba6ozYHc40aqx4EiPDkd7dWjTmNE67v37/dEhqMQ87ChNxc7SVOwoSYFKEl6u1nJMyA5E4OJHN74keSL8tdON15os8FAU+Bzg8nzgshw7Ml3jGB11hNXWJpkksxIsM99xAp8R3/qeAJgiydHmttGl0liEj0Uns1hvch6PB5fL5ffZ+Pg4WlpaUFhYiPLy8gXHoG/MWIjE9xihHiiSJNHW1oaJiQls3LgRarXa7/tkkxlFUejr60NfXx9WrVqF1tbWuHWbDhdcDoGaPAVq8hS496IiTJudONqrw5FeHU706WGwufHPlkn8s2USHAJYm6PABaUp2FmWitVZsqD1A5e6ACQcBLuWHpLC3xs0+J9P+2GweePEl1Wm4cHLipGrFEXc1iaZbsaVaJnNB4lEAolEgry8PD/1Ki2skslkDLEF5rbRqkpWABIZFp3MYgWXy4XdbgdwTto+OjoacbIxEFuNx4VauNjtdiZBO1RftGSSGe2CNRgM2LZtGyQSyaKQWSDSZAJ8eX0Wvrw+Cy4PicbRGRzp8XY87p60oHF0Bo2jM3ju8CDUUj4umHVH1hanQCFa9rezH3yJpn7YiCc/6kX7hBkAUJomwcNXlKK2+JzrPNK2NqybMTnjBFOv0i7JtrY2uN1uplGsQCBAWlpawspZPfnkk3jkkUfwve99D88++ywA7+/z+OOP4/nnn4der8e2bdvw3HPPobq6Ou7jJxLL/umn3Yx2ux0NDQ3weDyoq6uLKHhKEETcmmsGOwatpFSr1aiurg75VhfrHMLtSWaz2XD27FnweDzU1tZCKBQy4yaTzBwOBxwOR8iHls/lYHOBCpsLVLj/kmJoZuw42qvH4R4dTvbrobW48E7TBN5pmgCXAGryldhZmgq5mUJVjKkWiw2aaCZmvI0y/9niVdDJhVzsvrAIX9mUPW+jzHDa2vB4PAgEgoT35kqWmzFZ/cxivV4CgcAvt81isTBl0H74wx+iu7sbBoMBx44dQ1lZWdzaDp0+fRrPP/881q1b5/f5008/jWeeeQYvvfQSKioq8MQTT+Dyyy9HZ2fnsorbLTqZxUPNaLPZcPz4cSa5N5obLdakZ7rosS+ZUBSF4eFhdHZ2hlRSBs4h0GUaCcI5B51Oh4aGBmRkZKCqqop5+Ol5xaMcVjjQarWor6+Hx+OBRCJhLIZQ0nMAyFKIcOOGbNy4IRtON4mzw0Yc6dXhSI8O/VobPh8y4vMhIwDgDx0d2Fmmxs6yVGwvUkEa50rwiYbTTeK1Jj3+2tQHm4sEAeD6mizce1ER1NLI1J6h2tr09fXBaDTi8OHDjNUWTkfnSLHSLLN4kqZvo9iCggL87W9/w4cffohvfOMb+P3vf48HH3wQW7ZswSOPPILrrrsu6nHMZjNuu+02/PGPf8QTTzzBfE5RFJ599lk8+uijuP766wEAL7/8MjIzM7Fv3z7cfffdMZ9jsrC8nvAAUBQFrVaLmZkZVFdXIy8vL+qHMF6J0zSZeDwetLW1YWpqCps2bQqr7mM83IzzkSEtPKmsrERBQYHfd5GKOAIRSafqoaEhdHZ2orKyEikpKUxiamtrKzweDxPnoaXnwSDgcbC9OAXbi1Pwg8tKMWKw4eisO/JEnw6TZhfebNDgzQYNeBwCmwqU2FnmFZIUq5du52iKonC4R4f/PGLBpNXrUlyfq8CPrihFdU583pLptjY6nQ4pKSnIzc2d09E5nm1tzgcBSLwgk8lwySWXAABOnjwJi8WCAwcOhB0yCYV77rkH11xzDS677DI/Muvv74dGo8EVV1zBfCYUCrFr1y4cP36cJbNkwOVyobm5GQaDARKJBPn5+TEdL56J0zabDfX19SAIAnV1dUzTwHD3j3X8QPgmZoci1nA7XYdCOG5G33ls3rwZUqkUTqeTqXBOt+KZnp7G2NgYOjs7IZVKkZaWxpR5CrUo5qnE+OpmMb66OQefHjkGuyIf9RonjvTqMKy349SAAacGDPjlx33IVYkY6f+WQiXE/MS52CJBv9aKpw/04mivHgCQKubi+5eX4Zo1GXFrlOkL2mLyFSt4PJ64t7VhLbPIYLFYAIDJNfz6178e0/FeffVVnD17FqdPn57znUajAYA5zX4zMzMxODgY07jJxrIkM5PJhPr6ekgkElRVVaGrqyvmY8aLzPR6Pfr7++e48cLdP95k5nQ60dDQAJfLhdra2nljiZG6Cn2xEJm5XC40NDQwCdlisRgulwsupxVDbUcglqdDmVYCiUyNwsJCFBcXw+l0MhYDnTpAWwxqtTpkSxUhj4P1BXJ8YX0KfgRgUGfDkR4dDvdocWbIiFGDHa9+PoZXPx+DkMfB5lmr7cKyVOSnJL84stnhxvNHh/Dnz0bhJinwOASuKOTh7gsKUVIwt6N4vBBMABJOWxvaHRlOWxu6KG+iSSbctJh4IBkV8yUSSVzGGB4exve+9z3s379/3pfqYMWUl6r3IhQWncwivWCjo6Noa2tjenwZDIaYSQiIPWZGURQ8Hg+6u7uxevXqqCzFeCdNm0wmnD17FgqFIqzCxbEoEufbl+5MLZFIsG3bNhAE4RXtWKbRV/93OKxG6DVtGO36FEKJCgp1MeTqYijUhcjIyGAShn2L87a3tzPFedPS0uZYDL5zKUwVo3BrLr62NRdWpwefDRiYWNv4jAPH+vQ41uctzFuUKsYFs+7IzQXKkMWR4/GgkxSF95q9jTKnLd5GmTtLU/HQ5SXQDrRDIkg8ASx0HrG2taF/h2QlmSeSZGgkwzILVq0/Gnz++eeYnJzEpk2bmM88Hg8OHz6M3/zmN+js7ATgtdCys7OZbSYnJ+dYa0sdi05mQPguqvb2dmg0GtTU1DDJibH0M/NFLDEzj8eDlpYWuFwulJeXR+3yjJVQfclQo9Ggubk57MaeQGRxr2D7BvsNdTod6uvrkZubi4qKCob0Z7R96G/6BzxuF7MwUBQFt2MG2tEGTI/Ug8PlQ5ZSAIW6GIq0EshkSsjlcpSUlPi1VBkaGvKzKOa7lyQCLi6qUOOiCu92fdNWhtjODs9gQGfDwGej+MtnoxDzOdhWpGJcktlKETPPWNE6ZsLe/T1oGjUBAApSRHj48lJcWO7NPZzuT/ybcaRv39G0taHvp0RbTPQ4yVJNRtPQM1zEU5Z/6aWXorm52e+zO++8E6tWrcLDDz+MkpISZGVl4cCBA9iwYQMArzfn0KFDeOqpp+Iyh2RhSZDZQrDZbGhoaAiaoxUP92Asx7FaraivrwePx4NCoQg7PhYM8XAz0tbhwMAA1q1bF9HbVbzdjLTgZNWqVUw8hiRJTA6ewWj3oTnbexcib9FiAKAoEiZtP2am+0B1fAyRLI0hNrkqF1lZWUxLFdpi6O/vh91uR09PD7KyskL2pKLHK02XojRdiq9vz4fZ4cbJfgOO9HiTtqfMTnzarcOn3ToAQFm6BDtLU1EidqBMFd2iqbU48T8HB/BWo7dRpkTAxd0XFOBrW3LnWIFLjcwCEU5bm3jJyhdCskiTHiuR49DVP+Lx+8vlcqxZs8bvM7oZKf35fffdh71796K8vBzl5eXYu3cvJBIJbr311pjHTyaWPJlNTU2hqakJWVlZWLVq1Rw3At0qI9YbLBoym56eRmNjI7Kzs7Fq1Sp8/vnnMZNRLG/9JEnCZDLBZrNh+/btEeeIxMsyoygKHR0dGBsbw8aNG5GSkgKPxwO324WRjo8xPdq8wNHOHdNXZemy6TA1pMXU0GlweSLIUgugUJdAmVYChUIBpVKJsrIyHD9+HEqlkpGfCwQCP3VeKFeUTMjDZavScNmqNFAUha5Jy2ysTYfG0Rn0TFmZ/mBiHoEL2tu8ZbZKU5Ahn/9N3eUh8ernY/jd4UGmUea1azNw38XFQfdNRsmseMZFQrW1mZry1ts8fvy4n9UWb8smmWSW6Ly8ZFf/eOihh2Cz2bB7924maXr//v3LKscMWCJkFuytnqIo9Pb2or+/H1VVVSEb1dE3Vax+7EjIjKIo9Pf3o7e3F6tXr0ZeXh6A+LgJo93farWir68PFEWhtrZ2TuficMeP1TJzu91obGyE1WplKot4PB64XTb0NbwDk3446uMDBOg1hCJdmJnqhnGyG8MAxPJMKNKKoVAXM+6u9PR0Rp2n1WrR1dUFp9PpVwkjlCCGIAhUZspQmSnDt3YUwGhz4US/Hkd6dDjUNQ2jg8SBjmmmb9iqTCnjjlybq/BraXOi3xuP65v2EuHqLBkeubIUNXnKoGP7n3PikMggP93WRqVSYXp6GuvXr4dWq8Xo6ChTzmmhtjaRgH6ZTVYKQCLJLNF1GT/99FO/fxMEgT179mDPnj0JGzMZWBJkFgin04mmpiZmQZyvGR59U7nd7gWVVfMhXBefbxmorVu3Qqk8tyDFmqsWrZtRq9WioaEBKpUKdrs9KiIDYrfM7HY7Tp48CZFIhG3btjHkbLdo0VP/dzishqiOHWo8gvD+9hRFwWGZxIRpAgNtB6HVzUCGbSDtVVCmFUOlUiElJQXl5eVzKmGIxWKG2FQqVchFVSnm4wtVGfhCVQa6e3rQOWnDsFuBo706NI+Z0DFhQceEBX88PgyFiIcdJSmoLU7BoR4tPunUAgBSJHx876IifHl91oKdAJKhJkuWypDD4UCpVEKpVKKkpIRRqQa2taHJLRpXfbKUjEByBCBskeHIseTIzGg0or6+HgqFArW1tQsSFF15Ixn9yCwWC+rr6yEQCFBXVzeHNBajUPDQ0BC6urqwevVqCIVCRp0UDWJRM3o8HnR2diIvL48RepAkCZNuEP1N78LtckQ9r4VAW21W6wymp6ehVqfBMTOAodZ+ABxIVTlMrE2qyEBeXh4KCgr86he2t7czNfJocgu1qHIIAuVqAb5YWYh/v7AQOosTx/q8CdvHevWYsbvxQdsUPmjzuti4BHDL5lx8Z2dByEaZi4FkEGawhGmBQBC0rc34+Dg6OzuZijB0X7BwiCOZZJYMaT5bZDhyLBkyoygKIyMj6OjoQGlpKYqLi8N+0OLVXNPpdIb8fmpqCo2NjcjNzUVlZWXQByce9R3DJTO6Av/k5CTTq216ejqmWEu0bsaRkRFYLBbk5uZi1apVjNBjeqQBwx3/AkUluk4iBZ1Oh5mZGWRlZfsJhCiKgm1mDBbDKMZ6jkAgUnil/2nFUKoLoVarmfqFvr3Curq6mEA5nbAdarFMlQpw7dpMXLs2E26SQsvYDA736HCq3wC1TID/uKgIZemRvWknyzJbbOuPbmsjl8tRVFQEl8vFvGC0tbXB4/EwRXjna2uzkiwztmJ+dFgSZEaSJFpaWjA1NRW0NcpCSGSnaN82KdXV1cjJyQl5jGRZZg6HA/X19SBJErW1tcwDHo88tUgtw66uLoyMjDDKNY/HA4/bjdHug5gcqo96LuHPgcTk5BQcDgdyc3PB58+1ljlcPjhcPggOFxRJwqTrg3G6F6MEF0KpN69NmV4KidRbl5BeVOlk4ebmZlAUxSyo891rPA6BmjylNx52USzntbwEIKEQaSkrPp+PjIwMZGRkMEV4w2lrs5IsM7aXWXRYEmTW2toKi8USUeknX8Qj1yyYq9LtdqOpqQkmk2nB2B19DLfbHfUcwom50W7YlJQUpkO17/jJUlPS18ZsNmPbtm1oa2uD2WyGw27BYMs/MaMdiHoe4cLj8UCj0YDgcFBYVAo+XwhwOAAoUCQJ0uOEx+2Cx+2Ex33O6uYJROAQXlGKywaMdR+aTdhOYUQk8tQCpKenM5XNTSYTpqenMTIyApPJBD6fz6gkgyULxwMrwTKLhWR8i/Au1NYmWeIPIPFqRovFgrS0tIQdf6ViSZDZqlWrmNhXNIiXZeZLBHSnapFIFLY6cCFX5UKgySTUIkM3HQ3lhk2WZUa3kBEIBNi+fTtTuLavuwXNR/4IAdfF1PvjcuNxixHgcvng8LzWFQA47HaMa4Yg4AuRnp4KinTB6Vi44wBfKIXHZQdJerwxQtIJHo8HkiThdhihHanH9PBZcLgCJmFbmV4CqVQBmUyGkpISdHZ2wmKxwGKxMMnCtDsynBJP4SAZllkyCgDHU2QyX1sbg8EAAOjs7FwwBSNWJNoKZGNm0WFJkJlQKIzZoomnm3FychJNTU3Iz89HRUVF2A98PKT5wFw3Bu3OGx4enrfpaKwNMsPZX6/Xo76+HpmZmVi1ahVT0UMlBVRED/hqGaxWK2ZmTJiamoZQKJglNimEQgGA4NeSIDjg8gXgcHgAMVsRhPSA9LhBup3weLx/AGCzWTExMQGFQonU1JSQxwyEUKSA024ChXPn6HG7IBAp4LTPwD9h2wOTthcz070Y7qAglqXPWm0lIAgCEokEq1atClniiS6OHG3y60qJmSWKMAPb2oyNjTEvFt3d3bDb7XNSMOIxD/p+Z2NmSw9LgsxiRbzIzO12M9Uz1q5di6ysrIiOEQ83H+BPZi6XC01NTbBYLNi+ffu8N3miY3ZjY2NobW1lerPRQg/dWAuG2g+AJL1lfoRCIRM/s1qtsFqtMBjGvOWp5ArI5UpIpFJwCAIk6QLpdoEkPXA77QvO0WTyKhbT0tIjSuoUiBVw2GaCfud2WUEQHD+hSqD032nTYnJwGuN9JzGtNSAlswwaiR2qgIRtu93OlHjq7++PqZ3KSiCzZFXMB7wvxRUVFQC8hJCItjb085FoNyMbM4scK4bMYrHsAO9NarVaMT4+HlX1DHoe8SIz4FyBXrFYHFaaQqJiZhRFobu7G0NDQ9iwYQMjgvB4PBjrOYyJgdnWEgQBLk8IDocHgvDGrkQSJVSkCx6XAzabDVarFRPjg3C53BCLRZBIpJBIJGG45kIrFucDQRDgC2VwhiAyACA9bgjEipDb0NJ/inJhYmICfD4PfFKH4baPMAxAosiCXF3srfqvyER2djZTmJdO2O7p6WGsBdpqm6+DwfkqAIllHF/STFRbm2SQmdlsXnbVN5YClgSZxaPbdCyWmclkQkdHBwCERRqJmodvt+fp6Wk0NDQgLy8PlZWVYRcKBqJfpIK5Gd1uN5qbmxkRjFQqhdvthsftxHDnv2DSDYEvlMDjdoL0uOFx2RHqCojFYiZJ2eVyzVptXrUan89j3JEikSigAv78isWQ58PlgccVwGk3Lbit22EBweWB8gR/KXI4HNBoxmfl+ml+19punoB1RgNN33HwhVLIU4ugSCuGMq0YSqUSKpXKL2GbJjeRSOSXsB24QLKWWfiYL44Vz7Y29POdqHOiY4GsZRY5lgSZxYpYSISuLp+dnQ2NRpOUKiKhQNciHBoawtDQ0LxlvEKND0QvHQ4UgNBCDx6Ph23btjGqUadtBr0Nf4fbZYPTbgZPIAZfIIHH4wzLVQh4Jdh0VQi6oanVasHk5AQoioJYLJ6NswmZ+n65ublhnxeX543PuZzWsLYnSU9I68xq9cboUlK8tQd9Y3SBZbZItx2GiTboNa0gCA4kylyviCStBBJFOnJzc5Gfnw+PxzNHmZeSkoK0tDSkpqayMbMIEUkcK5a2Nskom8UKQKLDiiGzSN2MvqKKdevWQSaTYWxsLKZ5xCoAofcdHR3Fli1bZhfOyMYHoiczXzejwWBAfX090tPTsXr1aqaih9kwhr7Gt+FyeLvh8vhCuJ02uGEDAHB5fHB5Im9hYKcFCMNdxuFwmGA+QMHhcMJqtcBoNMDpdILD4UKhUMDtdoPL5WAhwQdfKIHH5QBJRvZbuOwmcLh8kJ5zqkg6Rpeeng6ZbGHXT2CszTYzCothBGM9hyEQexO2vdL/QqSmpiItLQ0VFRVMPtXExATTbHZ4eBg5OTlxqV0YDOeLZTYfIm1rk2jxB8DGzKLFkiCzWB8oHo8HhyP8ckl07Ue6urxMJoPNZgNJkjE94LHEzOx2O+rrvUnGa9asiZjIgLkxt0hBW2Z0CkB5eTkKCgpAkiRIkoR+ogODrR+A9CFsDlcA+JSq8uZ1uZjj8YQyEBwO3C47SHc4aQsEhEIhSNIDo9EIpVIJgUAAq9WKsTEjOByCibOJxeI5C4tAJIPLYYkq5kRRFPgCEZw2F7wxOj1mZowRxej8zsTHaqMoCh6nBbqxJsxM98HtskOmyvXG2tJLIZamID8/H4WFhXC5XDh+/Dg8Hg9aW1vh8XiYBVWtVset4vxKssziJZdfqK2NRCIBRVEwGo1QKBQJOTeLxcLGzKLAkiCzWBGJm3FmZgb19fWQy+Wora1lVE2+lQSiDe5G62akrSC1Wg273R610so3jhPt/jqdDkNDQ6ipqUFaWhoj9ND0H8d474k5+7jsZnB5Qnjcc18mKIqCy2Fm/s3lC8HlCUG6XXC7bCHn4V1A/BWLcrnCG5+y22G1WqDTaWdFJGIm2C9TqEMqFsOFy2YGhyeAZmwEdrsNOTm5URdu9gX92wjFKjjtJhCgYNYPwaQbxGjXQYikqbPdtYshT80HQRAoLi6GTCaDyWSCVqvF2NgYOjo6mA7bdJmtaBfUZBYaTjQSUZUjWFuboaEhjI6OorGxEQDi3tbG6XTC7XazbsYocF6RGS0tLykpQUlJid8i4NtKJhYyi9TNODo6ira2NpSXl6OwsBBHjhyJybKKtvK9x+OBVquF0+lkhB7e1i0ODLZ9CL0meAFjChS4PEFQMpszhssBz6wVx+HywON7rR230zrrEpxfsUgQhI+IBHC5nIyIxGC0gqPRMMQWKCIJ+zqQbkxr9HA6nbMxuvg9Ir4xuTm92uwGaEfOYnr4c3hIAgaDB9MZPHDzqiCVyiGTyVBcXMxUnNdqtWhsbPRzg6nV6ohivivNMotHsvp8EAgEUKlU0Ol02LJlC2O1jY6OoqOjg6nlGUtbG7PZ+/LHklnkWBJklmg1I0mSTA3BmpoapKenz9mGvvFiiXlF4mb0ndOGDRuY8jXJrrwPeF2cZ8+ehcfjQWZmJtODzGk3o6/xLViMmnn3dznMc2JNC4H0uOH0eFWGBAhw+WJMTEzCZnOGrVjk8wVISREjLSMXDpsJNps3p+2ciETiU4lk4RcUt9sNjWYcXC4PBYWlID3xqfTvTQ+QLij9Jwjvb6HRjEMul2N64DCmB45AJEufrfpfDJkqFxkZGcjKyvJzgw0NDaG9vR0KhYIhtoUk50u9nNVSHId+2SUIIiFtbcxmM5OUzyIyLAkyixXzCUCcTicaGhrgdDpRW1sbMrBKEERcqt57PJ4FFwmXy4WGhgbY7fY5c0o2mRmNRpw9e5ZR0blcLm/O3YwGvQ1vhyVrpygKAr4YjgjIzBdujwuaUW+wPScrCwKhGFy+CBTpgdtpDek25fAE4BAcuByWWRGJDFKpDF4RiWO2EokRU1NTEAqFDLEFq0TidDowPu617NLS0sDl8eNCZhwOF1yeEE67ecFtrVYLJiYmoVanQqHw9smjKApO6zQmzVOYGDgFHl8EubqIKbMll8uhUChQWlrqJ17wlZzTC2qg+3qlCUASmftFI5QAJF5tbWhZfrISzVcSlgyZxVKKKRQJ0UV5lUolNm7cuGAsKlYioR+m+RYJs9mMs2fPQiqV+sXsfI+RrGLBdFpCWVkZCgsL0d/fj+HhYZi0fbBPn4VIyAOHE94C4XSaweHwQJKRqUqdTic0mnGIRCKkp2eAIAi/wsAEhwOBUAqAgNtlAzmbB8YTiEF5XHAHFZUQEApFEApFSElJhcfj9qlEYgCHw2GITSIRw263Y2JiAkqlCikpKgAEXA4z+EIJXI7wpP3BwJBtGOkBXtWkFhkZ6bOEPHsmQTpsGyc7YZjoAMCBRJHlLbOVVgKZ0ruY0uIFOmG7r68Pra2tc8o7rTQ341IhzVja2pjN5riV3nryySfx97//HR0dHRCLxairq8NTTz2FyspKZhuKovD444/j+eefh16vx7Zt2/Dcc8+huro65vGTjSVDZrEgGJnRsahIeqPFwzIDQj9YdM3HgoIClJeXB51TMooF+7a1Wb9+PdLT0+HxeJCfnw+nsRsDbUdhsZjhdLogEokglUpmq3SEdv1RJAmBWBaRAIOusahUKpGSErzGIkWSflYNTyAGlycC6XHCHSLBORBcLg9yucJHRGKbLXekxcSEGwAFmUwGuVwWdA7RgMcXgaI8cLsWyrujoNcbYDQakJWVtaBqMlD6bzdrYJ0Zx3jvMfCFMsjVRVCmlUChLmLEC3SiMG219fX1QSAQMIQnFAoTZtUsdWl+pIhGmh9uW5uhoSE4nc64yfIPHTqEe+65B1u2bIHb7cajjz6KK664Am1tbcwYTz/9NJ555hm89NJLqKiowBNPPIHLL78cnZ2dy05RuSLIzLcFDEmS6OjowPj4uF8sKhzESma+IhJfi8uXPNasWYPs7OyQx0i0m9Hj8aClpQV6vR7bt28/J/RwuzDcvh/G8VYm78bt9lbpsFis0Gp181bpADDr7uOGld8VTLEYDrhcPhxWvfdcuXzwBCKAouByWkGFcd28IhJa1s+FwWCATCaH2+3C0NAw+Hw+Y7VRFMVI/SMBTyAB6Q4nz43C9PQ0LBYrcnJyIBBEpoabm7Btg0HTCv14CwiCA6kq71yZLXkacnJymPJOer0eTU1N6O/vR1dXl1+H7WjSEEIhWe6/pWSZzYdQbW0mJiZwzz33MC7xX//617jqqqtQVlYWtZX24Ycf+v37xRdfREZGBj7//HNceOGFoCgKzz77LB599FFcf/31AICXX34ZmZmZ2LdvH+6+++6oz3MxsGTILB5uRofDgYaGBrjdbtTW1kYcRI1nOSoaHo8Hzc3NMBgM2Lp1K5RK5bzHSCSZORwOnD17FgRBYPv27eDz+fB4PHA5LOhrfAdmw6jf9jweHwqFEgpFqCodEkilEojFkln3aOgqGudAQavVwWQyITs7GyJR+AtnYLFg0uOazQk7J7LgcLhwuxzzqispisL09BSsVhtyc8+RiPcc/UUkUlkKREJu2CISgUgOl8O84L3sLdE1CafThdzcHPB4sSvxAq02i2EEZv0wxroPQShWeqX/acVQpBYyeYybNm1ilKxTU1OMpeBbZisWkmAts/nh29amvb0d//Vf/4WXX34Z7733Hn7wgx8gLy8PBw8eREFBQcxjGY1GAN50AgDo7++HRqPBFVdcwWwjFAqxa9cuHD9+nCWzxQCXywVFUTh+/DhSU1PnNK0MF7FW8KB7stHHsNlsqK+vB5fLRW1tbVh5KIkqFjwzM4OzZ88iNTUVVVVVAGYXb9MUehvfhsNqWPC4/lU6HLBYrDAYjJicnIJIJIREIoXMTYLH5wHU3HOgF3CHw4nc3JywayyCICCYRw3oPTblZ0Hx+CJweAKQHtdsiS2KOeeJiQl4PG7k5ub6WdChRCRmK4mpqUFGRCKVSmZzz/zfmM+1kpkfJOltKkpRQE5OTkIsF1p4QnC53nlSFEzTPZjR9oEguOAK5LAbLbBZVkOhykBeXh4KCgrgdrsZ6T8d34klYft8jJlFCw6HA7VajbKyMuzfvx8WiwWffvppRCXtQoGiKDzwwAO44IILsGbNGgDemDkAZGZm+m2bmZmJwcHBmMdMNlYEmdE/SkFBwZz8sUgQq/jC9xh036+MjAxUVVWF/aAlImY2MTGBpqYmlJSUoLi4mOnJZNL2o6/pH35dmMMchRFYpKamwu12M/leer0OfJECYgFm873EXlGHx+3tCk0QEdVY5HB54HD5YakBfeF22YHZeBWHwwVPIIHb5cboWB84BIWcnNwFfpNz58jlCeF0KGG1WuaISKRS7zmKpaqw4oW0/J/H4yEzM3O2u0B04HB54HIFIDjcWc8GCZL0gPS4QHrc3sR0H4EpXyiF22WDw+HAxGAfeIQH3Z9NQyRNO9dhOyUfaWlpTHwnUJVH51LRCdsL3dcr0TKLtqhBOPCtyyiVSnHNNdfE5bjf/e530dTUhKNHj875LnC9TIYwKBFYMmQWzcUjSRLt7e0MmeXm5sb0I8SjLxqHw8H4+DiGhoZQWVmJ/Pz8iOYUjwafNJlRFIX+/n709vZi3bp1yMjIYHqQTQ2fxUjnp349vKIFj8eDQqGAQqEARZFwOFwwmU2YnJwCSZIQiYRwOJwQi0XIyMgM+3pw+SKAIuF2hq4WEg5I0gPzjNarmhSLkZNTCA6P51VNusJI9nY7IJZ5OxcHikimp7WgCAEEvAlGKBPKZUgrN8ViMdLS0sO4DgS4PIGX0AnurIFFersTeLxdCsgwRTB8kRxuh3k2BWEcUrkK6hTlbMK2HlNDOkwNnQGHJ4Q8pZDJa5NI5JBKpYwqjxaRNDc3g6IoP+l/sEopKzXPLFFIRJHhe++9F++++y4OHz6MvLw85nO6X6NGo/GL409OTs6x1pYDlgyZRQq73Y6GhgaQJIm6ujocOXIk5p5msRIJSZLweDwYHh7Gxo0boVaro5pDPGJmJEmipaUFOp0O27Ztg0wm85amcrsx3Pkxpkeaoh5jPhAEByKREApVGpz2GSapl8PhwmKxYmxsjFn0g7nqaPCFUnhc9oiLBQeDzWbDxISGUU36WixcniCsnDaPy8bEdWkRiUQiQ2a2CDaLweuONFswPa0Fn89nzlEo9AplvMnQmtmK7D7KTZ8ecBwOBxR8Omx7nPC454//hQM6julw2DE+PjuHFAWETAzSV/rvxsx0N4xT3QAw22G7BHJ1MWSqHCZhm6KoOXULfRO26WrzyXrLXwluRiC+RYYpisK9996Lt956C59++imKi4v9vi8uLkZWVhYOHDiADRs2APC+cB06dAhPPfVUXOaQTCxLMtPr9WhoaEBaWhqqqqrA5XLj1m062mPQydkkSaKqqioqIgPiE7dzuVz47LPPQFEUtm/fDoFAMFuayoahtgOwGMe81e7DsEqihcftwMxsTUG64vw5d6QVer0eXC7Xr2gwvegJxHK47AuLKMKB2WzC1NQU0tLSIJcrgswzVE6b3a+iicft8hO3cHl8EAQXbqcVfL4ASqUASqUKJOmBzWaDxWKFRjMBgIJQKIbd6UF6Rq73vqAokKQHHo8LpMc1bw+4WEHPmSb0lJQUKJUqAMHVp4EiEod1GhMDU9D0nwRPIPbp1VYym84gR0lJiV/C9tDQELhcLlJTU2G325PSaHS5CkACEc8iw/fccw/27duHd955B3K5nPFgKZVK5nm77777sHfvXpSXl6O8vBx79+6FRCLBrbfeGpc5JBPLisz+//beO8yN+s4ff01V12p7ce/d4AKmBfCF2IANNhD6j5aEEvpxuSRcLiQklC9HyHFcgABJgIPLhYAdmikG02Na3HDBBRuXLVptUW/TPr8/RjOSVm2k1dprM6/n8cPDSiuNtNK85/1+vwohBAcOHMCOHTtyRnjVKmaVdEXhcBjr16+H2+2Gw+EY1EydpmkIQrk7rDQURcGePXtQX1+vL3plWUYi2o/dG1YiGQ+AolkosgiGtYBlLVCIBDEZh0aSGDwIfN1diMblLMbiwHGkljzd29sDWVZgt9tQU9sMWfZXwRORIBAIwO8PoLm5xRCzNUfTliKREFmCKMQgCTFQFA2G5UAIydKQ0QyX2u+xsDlqUVtPoMgienxe+P39YFkWPu8BBP0+Q51pNaAVsmg0Ap9PK+jpE2Up9mmOYFsWEPRtR6D7SwA07DWtelabo6Y5S7CtZYTF43Hs3LkTPp9P79ocDkfVu7UjqTMrJt0pB48++igA4NRTT836+ZNPPokrr7wSAPDjH/8Y8Xgc119/vS6aXr169WGnMQOGUTEr9eGWZRnbtm1DT08P5s+fnxLZppGpNasUlRREjVwxbtw4TJgwAZ999tlB91bU4PP54Pf7UVdXh9mzZ+tEj4j/APZsekk/+fK8Dcm4mDXC0kgSIER12qhwvJemnAsYOXIMaArIVyQpik51ZSo7UkiKSEpAX08nkskkLBYedrujIHOw+DEQ9PX1IhqNoq2trWI38ywSCcOBszhAKAaUIoEQ1WA5vb8SB3hTpsXQbW1qQc/uTANgmLQTiXqlXK2TMQXe6oQQD+nOIs3NTan3OhtiPGy4S88RbIe7EAt2omv3R+CsLrjrxsLdMB7u+jH6SDcQUMXgFEWhr68PX3/9NTiOQ0NDA+rr61FbWzvo4qBFNx0JnVk1U6aNdMQUReGXv/wlfvnLX1blOQ8lhk0xKwaN4k5RFE444YS8pp3V6syMdkWEEOzevRtff/01Zs2apS9Tq0ngMApCCPbu3YuvvvoKHo8HdXV1+t6sr+ML7P/y7SyiR77xkqLIug8jBVWzRdGMOgIzyHbMZCy2tY0ATRHwVldJf0eaZuFwOcALMbgcI/LaT2ndTKmTvqIo8Pm6IYoa9d64fouiaTCMSrhA6jmIxg6URBBFgiSqgaMMZwFNMyBEySPWzi+Gzu5MVRJJNKqSSGQ5O86mUt2ZbmqcCCMQCCAQ8KO1taWgno+AgKJZAOWNnHME22IMfu8W9HdtBkUxcHjUhO1kPAqOG4XGRjVlW5Zl3WZr165dSCQSWYLtSgx2te/LkdKZmcGclWHYFzMt6qIUxf1g7swkScLmzZsRCoVw3HHHZbXk1fBWLOf3FUXB1q1b0dvbi2OPPRb79+9HPB6HKAjo2vMhfPvW5fkduWiRIRio2VJzyGRZSjELc6/40h6LNjQ2ppl6pZz0GZZX93wZ/oX57KfUk34vZFlOnfQdqZN++iMsyxK6urygaRojRrTl9ZWkaAYsawFFMwCl6q/UgiWor09JZNHZNWSO4waO5ljOApq1gCgShIQqKi8lhk47kdgBEIiiiGg0TSLh+bQTiUYiKYW0qXEYfX39iETCaG0t3ZmKySg43qEmg1eIfIJt74Ft6O/vB5/YhljrFFW0XTdaL16A2on09fWht7cXX331FaxWq17YamtrDRWog1nMDkc24zcFw6aY5dM67Nu3D7t27cLUqVMxatSoor9fLVp9qUISi8WwYcMGcByH448/PoeOfDBd7wVBwIYNGyDLMo477jhYLBZ4PB7s2L4NO//xV7AkmDrp23JO7JKYMOy6IolJfQyljyORziHTHDPyeSxKYkIdeeXRiWm2T3KRkWb2Sb8egiAiFosiEgmjt7cXPM/ro8je3j5YrVa0tI0EmyJoqAUrpb+SBCiKbMj4NxOWAc4jYiKsCrJTHaskJgFRta/ydvtAMxaMHT8eRBYMGi9T4DgeHo+al6W+p+o+USORpI2R7XmLNM2woGkWQjKK3t4exONxtLUZF6YTIkP9uw1+b0pRFEKhEPx+P1paWkCTBPo6NqK3fQN4qwdWZz1cdWNR0zgBVnsNRowYgVGjRunWTn19fdi+fTtEUcwSbBeKUdE+w0eCBMAsZpVj2BSzTGj+gVoInma9UwwHozPr6+vDxo0b0draiqlTp+b9UA92zGi0s4tEIli3bh3cbjdmzZoFQH3fat1WNHB7wbmBaJRDIOCHz+eDzWbVuxmOU7PHeJsLQrx0xEsmssaRFIVoXERvXxiNzW1w2PJ3APn2b5ruqTymGwWe52GxWNDQ0AIFFGKxOILBEALhIGhKZbVGQgHY7dXYQam7p4FiaEIIOM4CIWP8KkkSurq6wHEsmhs9kEW1YLK8DQzDQZaFlBNJadA0o/v3AQSJRDI1cs10W0mTSBhWPcmLQky3yGprG1EWEUm96Cg9Ei6N9K6wtbUVFot6bBSF1B4vgnBfEKHePWjfsQZWZ4OqaasfB1ftSNTX16OxsVE35O3t7YXX68XOnTv1GJX6+vqs8EtZlrPCTocSQ9mZEUKqujP7pmHYFTOt82FZFieccILh5X2xTDOjKFTMMlmUpbrEgzFm7OnpwaZNmzBmzBhMmDBB349Fg53Ys/FFiEJsgEOHOsKKxVS3bk0H5XITsEyl4agEvb19CIfDaGlphtVqyWH/aZCEODiLQx9dlvZvRIo1aAHFsKApCgQERFFUKrskQEoRVyQhilikT09Z1sZWPl/mDqp8hilF02A5W8GTuxiPpBK2hQwxtJqFlvl+SkIcElTRN8NyYFirKlQW1N2bgSOB1WqF1TrQbUWVN7CcDXa7DRaeRSgUBCEoOGItBUmIGTaKzg81KTwcDucYJ+t/cwqqABwpC7J4P3r296Fn/+eqYLtuDNz14+FuGAebzYnRo0frgm3NZmvLli0ghOhdm9VqPShdGSFkyDuzSCRyWDIJhwOGTTGjKAq9vb3YtGlT0c6nEIaqM1MUBdu2bYPP58vLohyIoSSAZI5eZ8yYgdbWVt3Rw+/dhn1b38x7ImJZTk/FzRxhdbTvBcPZYeUpfRxppJshREF3tw+iqKVCq3uhbPYfC5azgQCQktqJO82y0+5DMzxo3Y6JQFEkfRw40I5pwFEgEAjC7/en0rHVq1mbzY76+swdVCRjB6WyI9ULpMIFXLPQKuaWT0DAsBZEIyF4vV1FY2w0yJIIWUobI7MWJyiaVjVtBkk2mSQShrMhEg4gEg7C5+sHoJo/q5lY5RfwUrvU4lBJL7FYLGe8OXBMqyE3q01CqGcXgr6UYNvVlAohnQC7uwWNjY1obm4GIQThlIaxo6MDoVAIFEXpkhS32z0kXZr2vTR3ZsMTw6aYhUIhbNiwAdOnT6/IWLMandnAQqS58MuyjOOPP95QNAbDMBDFyhKXtWPIV8wyi+oxxxwDt9utOnrIMrp2fwTv158afPz0CIsQAkmhEQr0or8/s5vJJVdoSJMsVMZioS+2IksQ5PQ4EhQNi7MOkCWwnLVsO6ZsqF1hNBpBW1t6lJVGvh2U2s10dXXpsfR2uyMVBZMu4AyrnoSNWGj5+7zo6Quiri6dDG34FRACMZneIzIpko0iiWoRLwHNZ5FjaSQSCTgcdng8tYjH43lIJA5YrcULuAYxEQHLWvTO1+hr6enpQSKRQFtbNullYNJBMeQItqM96A77UoJtO9z1Y1ORNuPgcDjgdDoxbtw49PT04Msvv0QsFkN7ezsoisqy2dIutgYL7dwwVJ2ZNmY0i1llGDbFzO1246STTqo4S4llWSSTg3O0yBwRai7zHo8Hs2bNMm6MOwSdmeYuIooijjvuOFit1pQ1lYC9W15DIHUlWy4oigLHEDS3joIkxCCKQqqbySZX2O0OWCx8apzmzWEslnwemgVRJCQj6smb4SzgLU4oA8aRRjCwKzRCYVcLuAtOpyvFjkzo4ZyimB5Huj31uvdhKWhWTm0jxsDCD/7kJotJ3SdS62qBNMkmE7xVdUhJaj6LDnsqt4/SSUDZJBLV+cFutxUlkQApqj7DAQaLGSEkJYVQ2ZuZYncj4+RCyBVsJxHo/hJ+7zYANByetpR/5HhQFAeO4zBz5kwoiqL/bfbt25djs+V0Oivu2oaaNZlIJCDLslnMKsSwKWYqa63yUMBqjhm7urqwZcsWjB8/vmwX/mrvzCKRCNavXw+Xy4U5c+boxVJIhLF740rEQr6Kn0t/ztTry+xmZFnrZqIIBIK6G7/T6URjY4Ph94TlU76HGW4ZA0/cHGdT5QAlAjZlWU7p2FRT6Ur2QtrnTMvsEkUBsVgMCUFB/55dAwJI83UzBH6/H8FgEK2tLbDwNDiLHWKyvKJcDFldbYbmTxETYDgrkgN9Futyx5uFSSSBASQSB3iey/p9MRnJ2nEWAiEKvN5uKIqMtrbsPd1gClk+DOza4qFORAMd6PzqQ8QSMiSqBj2dtaipHwO32w2Px4MJEyYgkUjoNlv79u0Dy7Koq6tDQ0MDamtryxrFaoLpoSKaRKPq+20Ws8owbIrZYFGNYqb5Gm7duhVHHXUUmpqayn6MalLze3t7sXHjRowePRoTJ07UjYxjIS/2bHqx7FiUQhCSUZ3MoEF1iHfB5XIhGAygr68fNpsViUQce/fuS13lO4qGVmqjsGIFSpElJDPGkdqJe+AeSRQFdHV5YbFY0NTUWDW3DI7j0dhcDzERgVzvztPNpANIaZpCT4+2FxqR1yW+2sjU/FlsblUmobDw+vwpn0Uj481CJJJohkemNna1gqJoEKU4VV/LZAMotLa2ZXQr2XvRoUBm1xYMBtDf70dzs4y9X7yoCrZrR+q7NpujDq2trRgxYgQURdEF27t370Y8HofH48kSbBcrVEMtmI5EIqBpuqpJ398kDKtiVo206UohSRK2b98OAFiwYEHFjKJqjRn37duHnTt3Yvr06Whra9OJHgHfTuzd8lqFu6bCYFhLHqcPgr6+PoTDEbS1taV0PgSCoI4jQ6EgenryX+XzNjfEeBikDN1SvoBNhuURjYTQ0dEJl8uF+vo6VNPPMJPwMHCfmExq40g/RNGXuioHmpqaswqZmIyBtzghJKtzcZH3OFO7J9Vn0YeGhka4a2rA8XaAoiAJccOfiVyPzESGR2ZalO6pa4Yi5e7vtOkFwzBoaUlnsmW6jxwMaA4nmXtTQgii/gOI9O9Hx873YLHXprPa6kbrDjmTJk3Sma99fX3Ys2cPeJ7XbbY8Hk9O4TpYVlaHY5bYcMCwKmaDwWCKWTQaxfr163UZQCWWOpnHMdiAT1mWsXv3bsyfP18f+SmKAu+eteja8/GQuJCLyQhohtVPiIUYi6rWywKet6hxKjlX+SxqapvBx7thtRpzrigESUwgGOiDz+dDY2Mz6hqbQZRyaO3FkOogCpx4KYqC1WqD1WqDx+NBZ2cXFEUGy3IpPRmnd20Wi9WgOLqCo6QocBa109F2QRp7s5AxspqubSwDTvXItKc+85ooXd2b9vX7wXNcSqNoh9VqgSzL6OzsAs9z2dl0FAWWd1RtWlAK6VFvtsNJpt6MEAIpGUTvgQ3o79gC1mKH3d0Gp2ckahrHwWJz64JtWZZzBNuZNls2m23I3T8ikYhZzAaBI6qYVcJm1OQAI0aMwIQJE7BmzZpBfWgH05lpI04AOPbYY2G321PRLQL2b3sD/d7tFT2uERBCwPN2JOOhVBqyZgtVfDeVdZUPQJSAoN+HQEzNBtM6tnwuJKUQDAbR39+PpqYmOBx2XeBN0TRY3gGKpiGLcZ3ubhgUBd5gB5EWQ3Nobm4DRamdczwey4h5UckV7tom8IxS0S4v72FmaN0CAT8CgUBRn8WBxsgsbwVI6V1kxjOC53nwfJoFKiosgv3e1EiRgBCkROvpval2nOIQdqZpaDvLENraWrO0bGqQKZcOMlUUKIpqBE0UBbIQRTSwDxH/XhzYvjqV1TYO7vrxcNaO0HdpkydPRjQaTekVfdi1a5dOEhpKrZnpyzg4DKtidjDHjJmaLU0OoD33wXDwGIhoNIp169bpXaGWQSYmI9i75Q3EI75BvT9GICajEEQJXZ0dsNnKYyzSNAua5UAhjsbGJgAEyWQS0WisoAtJYWSON3Op90RRsk6cLG8DzXCGaO0Uw4JhOEMdhCAI6Orqgt2eLYZWjY+dcDiyyRV9PT4kE1FYrVa9azNqJzUQNM2AZnmIyYjuszhQiFwMiixCiKc1bRzvAM0wkETjYZ80zcDKAI620YjFwujs7ATHsVAUGfv27YfVaoHD4YbL7QFRIhjKOBsNgUAEkaiIseOnwMJboBAFiiJCSeXSFTLF1t5PrWO1OTwQ4n3w7etF997PwHJWuOrGwNUwDp6G8bDZHBg1ahTGjBkDSZLQ39+P9vZ2JBIJfPjhh1k2W5WmMgyEVszMzqwyDKtiNhiUEwEjyzK2bt2Kvr6+LLssiqIGvXurhACi2WSNHDkS48aNwzvvvINgMAiOSmDPFy+lRcY0A463pXYkuZTtwSISCaOnLwS3243aWg+MnpxY1gICMmC0RRlyIRnIGsyMkMkebxaG+rwZLhucDVAUiEI0q/gzrAUUZUxDpiZDGxFDp8kVAEAxNgT9XkSjMfT39w9gRxo0DGY40DQDMRmryGdxIHTHkRR0pxaldI4dIQSCpKCzsxNutwt1derOUpJExBMC4vEk+vfuGhC0aq2YoKN+B9UOS08uIGpyga+7C5GIeoEDJYlkwnhRzixkgJoczjA8KCo1VldEBHt2IuDbgQOgYHe3pDRt4+GoaUFDQwMkSQJFUZg4cSJ6e3vR2dmJ7du3w+l0or6+Hg0NDYMSbJud2eBwxBQzo0UokUhgw4YNAIDjjz8+x7y0GmzEcorh/v37sWPHDkybNg0jRoyAJEloaWnBZx+tQsz3OWxWCxwOO6xWm+qLmOpIdOYfRUOSkoYdJAohFAqir68fzS1tsNtUoocRaGbBpQprfheSKLzetIjZarUhFFILdzFBdjFkuWzQNDjero4GiQwiCYZG0dFoNBUmWb4YmqYk1NR44HbXpMaR6uv0+bpBiOrQobEj870+TbQtCrHUzrJ8n8VSyBpH0kxa05Ynx04t6l+jvrENLkeGPZXFDovNCZczCdLgGRC0KsNmSxsj5xw7RYFhLaombUDUjm5VltU9DnQXMS6CzlfIgFy3k5ystkg3YiEvvHvWgrM44Kobi4TiAOCCw+GAw+HAuHHjIAiCbrO1adMmAMgSbJfDeI1EIiYtfxAYVsVsMO01wzAl59nBYBDr169HfX09ZsyYkf9kMsjOzOiYUVEU7NixA52dnZg3b55OpgCABkcUca4Dtrra1ImwB4QoqRNhev+Uj/knS0KWpqs00iM9NRXaUpQYkQne6oJYtllwLmswkUioXWFPDzRLpmg0WtCFJD8o0CwHhuHUeBdAdcuXRIDlIYtJMCwPC28vavqrkSzUPV35V8myJOoaK3Uc6Ug9TubYNdMw2JEyDObUCwNZhCSq4nRCSMU+i0aRdYEECpzFDppmIUkCIiE/vF4v6uvrUOupSSUnqDZeANG1gjlBq4KIeCyOWDyJ/kAEFos19bm1gufUlHNZTKBEOlAKBD09vXp3WlY+XSpJoFAnLiTCYHk7pAHC/ZysNimBnvZN8Hq9cLs92C7s1BO27e5GNDU1oaWlBYQQhEIh9Pb2Yv/+/VmC7YaGhpKCbbMzGxyGVTEbDLTCVIg+29nZia1bt2LixIkYO3ZswQ9VNcaMpX5fFEVs2rQJiUQCxx13nM6UkmUJ7dvfQm/HlgzLJTsaGgrvnxwONchREhN6EdNGbUSRIQmxgsVGDbLMZSyWyiADqieKpSgKNE0hFouhpkbNMNPYdANdSKwWKxiOB0Vz+hhLHUGl/BxT/7KOM6PgZpv+8mA4a8Z7pGSJoQuRLIxAEmKqVotkXtQMHLtmskD7wVmcsFlZWC28zgptbW2pYvp0aaiaNvXEHotF4evpR+uIsXA5nZDEGHirE4osqMbWspgyg+ZB06xqiw+1w6IZATzPowbq9zEejyEWC6C/NwYg/bkuRQrSbLKSSc0my/jpiqZThazUhR1RSu6iVUJUN5xOJzweN2LBDkQD7ej86gPwNrfu+u+uHwOXy4WamhpMmDAByWRSp/7v378fDMNkdW0DX49pZTU4HJHFLHMMQQjBjh070N7ejqOPPhqNjY0lH2cwY0bt9wkheQtmLBbDunXrYLPZsGDBAr34SUIMuze9hIi/Pc+jZp8IRVHN9NIYVwNtpzJHbTTNgLNk548BKMpYlMREQQeITKp4NRCLRdHd7UNdXS1qajzqVb7TDYrmoMgKotEIwuEgurw+UFD016kmThfv5ItF3GSRBSgK/kAMkZiMESNHg2MH1wkpslTQXFdDJguU5R0IBXsRCYfQHQgAABwODpFItKgofagQiUTQ0+NDU1MTbFYWhCjgrC7QNA+aVuODpFRGXKliwTDZVmKadk+7KNPIMlp3mt6dEn132taWbZNVClq2m5EJhSQmin5ORFFEZ2cnnE5HKlCU0uo2CCGQhSj6O79AX8cmUDQLp2ekumtrnACboxYtLS1oa2uDoigIBoO6pm3r1q2oqanRC5vD4dCp+UOJRx55BPfffz+6urowY8YMPPjgg/jWt741pM95sDCsitlgxozqFT6dtRPROqB4PI7jjz/e0AelGqJnAHmLWX9/PzZs2IC2tjZMmTJFj26JR3qxe+PfkIwFDD0Hx3GoqfGgpiZtohuNqrZTDEPrHZu+Z9P2AilrJEEQ0entgM3Co6GhEGMx90qVphkwnHXQoliKYcHQHILhMPr6IxgxahwcdjtkOQlFllMjQPVEZOUpWOs9aKirGbCXUYq6kPBWY50jIQq6vepuqrW1FSzLqHs2hlULXlkj2zSEZAQ0zZbUn2k+iyzDIB5PwOVywe12IRZLi9ItFkuqiNtTO5jqst1omtHTC4KhMPr8YYwYORZWC6cWLCUOlqIgJaOqliwZBstZU2NRyZAxMpCt3aurq4ckiRlxNv1gGFbv2EKhMCRJTBUy48WcYVXiSDmjdjGPAw6Qv5ANfD3qf9O7toh/P8L9+9Cx811YHXVqunb9OLjqRulkookTJyIej+td26pVq/Db3/4WTqcTs2fPRiwWG5TWtRCee+453HrrrXjkkUdw4okn4rHHHsMZZ5yBbdu2YfTo0VV/voMNigwl17tMyLI8KOf7NWvWYP78+aipqdE9DR0OB2bPnm14afz555+jtbUVI0eOrOgYJEnC22+/jW9/+9tZz9ne3o4vv/wSU6dOxciRI3VrqnD/Xnz9xSt6kvNgQAjRCQfRaCzvnk3rhGprPahvaAHDWQqKbFnepv+cYXmVbGLwJMGwHGhtf0UoAJlpzyrVORQKo6WlpWCCcJFXqruQxGJRJJOC7kLisDthd9Ua0jylLZmgJiLnGXnljiONf11KjWI1AkIxn0VZllKvM4Z4PFYxa1CLtdFHgilDZUUW9W49GAzC7+9P/U3SY1bOYockJkAUdSRHM1zWiX9g3E/2eNUYVCeSuG50nSbLFE5wyH2NnHpBW8F3ibM4sz4zpQpZKaifEwJFUf9LM7xK/U/t2iw2l34BHolE8Oabb+LOO+9EIBBAPB7HwoULce655+Lqq68u+7UUwoIFCzB37lw8+uij+s+mTZuG5cuX4957763a8xwqDKvObLDQ9l1aeOXo0aMxadKkso2Cq9GZaaNKbczZ0dGBuXPnoq6uTnf06G3fiAPb36noy58PpfZsHMdCFCU9qVeW0pojVWSbvWfTTu4sbwORRUhZV64UGIbTRzqaSFVWxBQrTcwrZtbGR8lkEiNGVEo3L+BCEk8gEOoB7e3KoP3np8Nni6GbChaFzHGkOrK1AaAginGQEvZRYiKsOnLkYZpqY8h4XBVe19XV5fVZZJh81lNRvTu12Ww6O5K32sEwLCg69bVWZMhKqmAVjdvR0qGDWenQAMBbnFkSB0LUE3NmMRsY98NZ7KAoFrKUKKj7GgiKUj0Jg8EQeJ5HfX29TgzSdqdpx5VcA2ia5UGBqviiUExGUsSnyKALmfp6Brj+Exmh3q8Q6t0DhuXB8pP1+1qtVpxzzjlYuXIlTjzxRCxfvhyvvfYaDhw4UNFryQdBELBu3Tr89Kc/zfr5okWLsHbt2qo9z6HEsCpmgxULMgyDjo4OeL1ezJw5E62trWU/xmDHjNpr0LrMTZs2IRaLZRM9JAntO99Bz4GNFT+PgSPJ2LPVoqenB5FIBDzPp9iL4aw9W5bINkVpB2hwNjcoQgCaBcOpJzOiqBRqWVb/GYXaCXWDEAUjRlRGvc8HlmXhqWtAHUVDFGI67V+jww90ISkkhjZy/JrYWmP+UTQLRUrmPYkSQsBxFggDLgIsVmeWz2JjYyOcztJeoBTFwOWuRU2tarScFJKIhMOIhEM5AaTGx5EkQ5Sd7ahRiK1azFVf9ddMswNZzgKatYAoEiQhXrCzJURBV5fqMqIZF6tWYrU6iSQaVfPoNBKJWsRtqvYSMCwGLwRVFiAPupDlg9qFcRg3awlqW6aq+7bURa32b+fOnTj66KMxZcoUTJkypSrPq6G3txeyLKO5uTnr583Nzfp04nDHsCpmg4EsyxAEAT6fD8cee6xBN/FcDLYz04TXsVhM93tcsGCBLuqWxAS+/uIVhPr2Vvwc5UBlLHZDFCWMHDkKHMdl7NliCAS7wLIWuNw1cDrdsNltQEqkynAMKKIy1Ci6vCvtgZAkEV1dXnAcq9tCVQssZwUh6ntLUYXo8Gp3yvM8RFGAy+VGQ0PlJ6tM5h+gCrJZ1gKFZAuRxXhE38doThzJRDjHZ1GDNsbThNMEaserX0BkdNMUAJfDApejEbJcq++fAoFAShZgT40jCyWIF06H1nZ5hYyiS7nqa5DEJKDF/WidLVGJF9o+UVEUeL1qkWptbc051kIkkv5+PyS5H1abDTYLl3JcyY6zKQeJeBTdPYGqFzJA/buOnXkG6tum6z/TLuYURcHjjz+OvXv3VrzeKOc4MlGIqHY44ogoZolEAuvXrwchBBMnTqy4kAHVMQoGgI0bN+pED+0qLBHzY8+GlYhH+wf9+EagMRZZlsPosRPAcjxoigYhBBabCzU1gurkkNqzdRxI69k8dc3ghLi+UCcpLY7uHlFGsGYymYTX2wWHw6GHSFYLnMUOWSwk2s5mgYZCQfT2qu4joVAIiUS87CTmQsga2dIMWN4OpFxRGNYCRZbA8jYIyTACwSCCwQhGjZkIh8ORKljqBYQiiShmy1QIDMPC5VKlDap2T90/aVfkAxPEc2nvGenQVjeERHHyjMoCLE+ekdnZAur4GmBw4MDXoCg6y4G/EDJJJI1NrRBFEZFwANFoNolEI0AZPVGnR4tONLW06Rq6aoCiKIydcToaRszMuY0Qgqeffhq//OUvsXr1apx88slVe95MNDQ0gGGYnC7M5/PldGuHKw77Yub3+7FhwwY0NTWB5/lBG4AOtjPr6OiALMsYO3ZsFmMxGmjH7o0vliloNg6aYVV7ntSeK5FMoCuVCt1QXwciCxDzjARz9myCiISgoKf7AARBhM1mRU1tC3hW1vVsmnsEw7BgeBuIohQkR8RiMXR3d6O2thYeTw2qHd9iVLStO5w0N8PhcBR0IdHGkYPpHDUhMstawPI2UAwLzl4HyAL8gTBCKS0bS8tF6fuVQg0gVfdoaSf8aNb+iRAFhCBHv1VKUpAJSYiBppmKbdWERASdnV1gWQatI0aB420gRFEvkkr8TVWnFAKaInC7a+B212SRSHy+HihKeqeoMl7zn+6yd2R1oCkG1TKKoygKY6YvQsPI2Tm3EULw7LPP4qc//SlefvnlIStkgOr1Om/ePLz11ls455xz9J+/9dZbWLZs2ZA978HEsCpm5ba7GkNw8uTJGD16NDZt2lSVtGlBKH+URgjBzp07ceDAAd1VXJuJ93VuxoEv3x60l2La4UL9sxFFBlFkyLKQteDPZCyqvpPG3leG5eHg7bAIcdQ4R+l+isFAD+LxGPgMP0WLhYcsS5AznOx53gFQgCSoIyR1lNaLxsamqotBjZ90SV4xdD4XEs030ueTcjqZfNBEwxTDqp9dohYyJfX3kMQEGMKDkkWAotHVsQ+JpISxE6aCoZGSIAw1mTjTCb8WkiTC6/VClmUQAnR0tOuv01PXXFZxVWSpYvG8monWCY5To2SIIqUlJBmpCANDWgGkxrlKjrg/14lEy90Lo6cnU4CfJpHkI3uIQqxqpgCjp52GxlFH5/ycEILnn38e//Iv/4IVK1Zg4cKFg36uUrjttttw2WWXYf78+Tj++OPx+OOPY//+/bjuuuuG/LkPBoZVMTOKTCuouXPnpj6ElcfAZKISAogkSfjiiy8QiURw3HHHYePGjRAEQc1++uoDdO/93NDj6PsSWqW0U0CWK7giqWOoYtBiU1RSgfECwnBWgChZFP1MP0WGsyPo707tnzpz9GxQlKxwymA4jmA4gREjx4LnqutiwRssZIRk7oQKJ0OrnYwNNpsN9fUEoijqFPG+vn5YrHY4XTVwOl2wWPiU64igauLEBFDgT6JT+sUEurt9UAiD1pYmECkOCZnjSAyJcfRAKIoMn88HmmYwevQIUBSFRCKhahRDCfh8X+hRJ3a7wxAdXkyE82q0ikGWpVQmGo+mpqbcPc7AVATdqk0EgZIayZb6nmczXmVZ1neKwWBXalxpRTwe142CMy/6pGTUkE6wGEZP+zaaRs/Ne9uLL76IG264Ac899xwWL15c8XOUgwsvvBB9fX341a9+ha6uLsycOROvvfYaxowZc1Cef6gxrHRmhJCSXZEgCHqxmDt3bpa4cNu2baBpGlOnTq34GPbt24e+vj7MnZv/QzgQ8Xgc69evB8dxOOqoo8BxHDZv3oyuznaQ8BYwcn/2iSHTZBU01IwoRd+XlJPMnA2C3t4+RCKRsrVbnMUBWUwUPZlqJxP1eAvp2VSyQV9fPxKJOFpaWsHzPBjOou6NDES0FIPuPmJAtJ0OF9XE0IVPzFosDE0zKQ0WUXOwJNUnUbOdisXiqSJe2oVEM2DWOiFCCEaNHg9Fzr+LoSgKLG8HRTGDItoUQqF0aEBzSgnpRTwWiyKRSGaxI/PR4TUUYjbmgyqJ6ITFYi0rYghIXXABYBh1v1fpBQAhBNFoBD09vaAoKjWOTDuRaESYTCPicjFqykK0jDs2722vvvoqrrrqKjz77LNZIz8Tg8Ow6sxKfbDD4TDWr18Pt9uNuXPn5pygqtGZlbMz0/Z1zc3NmDo1TbedMG4EZP9n8EeTiMQBf6AHvIWD3WaBzWoBTxTIYvV2R9mMxRFlmbGWYq1pkCVB/3IX0rP5/QH4fD5QFA2PxwOaTskUxKS+UKcZFhxnAwGBkDSeGF2O+4iiyOjq8oKioBv1Zu0UMwqWIqVGggWu9BmGgcvlgsvlyijixV1IOIsDkhiHJIp6AWltbYEiJ8FbnFkdrAaV0p4npqUMok0hpDuhAenQWtp2PAyAAsfx8HjSwZxaJ9PV1ZX1N7fZ7Fm7aTEZNVTQJElEZ2cXbDZrylbO+HeA5dQ0b0WWdFcWzdGGohkoYmKADrLYcUjo6+uH2+1CfX09JCktTO/r6wfLsqlxZAyumnrDqd0aRk4+pWAhe+ONN3DVVVfhT3/6k1nIqoxh1ZkBKvMtH7q7u/HFF19g7NixmDhxYt7Ct3v3bkSjUcyenbtsNYquri7s27cPxx13XNH7acbFkydPxqhRo3SiRyzYhb3b3oQsxlQ6u5iAkIzrllOqiwOboo/bUx1U5YVNYywyDI3m5uayHNbLWfYD2Y4g+Y+jCzTNwG63IR6PIx5P5PhGZr7WtJ6NgiTEC450GJYDRTElyTM0w0EhFDpSI6zWlhaAyHrScHWR34XE7WkCz6mv0uvtAs9bskZpLGctmwQ0GIeNzAKSaV2mRQgZCSlN7xTV1yqKkj6O1Iyu1deluurngyiK6Orq1LV95RUymzpqLzFaZFgLGFYltxQiJJUSRBOipIhBanEjFAObhUtdtBQmkWgYMfEktE08Me9t77zzDi666CL8/ve/x6WXXnrEUOKHC4ZVZwYgx8GaEILdu3fj66+/xqxZs9DS0lLwdwfLRNQeoxg1nxCCXbt2Yf/+/Tj66KOziB7+7u3Yt/V1KLIMlrdCTBUKi9UBm7MWtbIIMRnNYNF1AwAcDtW2p7AeKD9UyrsXdrutiMdiLrRxXblMOkmIg7PYs/RVACAISXR1ebNEyB5PbbaerdCeLeNkyvF20AwLOUOEzHIW1fFey9/SSDAUo35WFEUdCcoCEvGoLoZurHNCEoyNvipDrguJINMI+X2IxdT3h+c5uN3ZYmhJTJQ9vsp12FBz7FQ5QOFuRBQFdHZqkoiME3dqpGmkkGnPmd4p1kPMGL2qRtcc7HY7amqbwVAiBhYI7Tgq0W+xvC1lgVb6e52lwaNp8BYH1CDbOBRZMuTsMVCnKAgCkhKFkL9H98nUOtSBo9e2CScULGQffPABLr74Yjz00ENmIRsiDLtilglJkrB582aEQiEcd9xxcLmKuyRUo5gVI4AMPB673Z6KbpHh3fN3dO35JONxOGhmuZl0dpazora+Bp46GUIihkQinrIn6tXHVpofXbEuq1LGIsWwYFl+EGbB2c8Tj6vUe48n9zhUxmBa7JoOquzJ2rNprzVznMZyFtCcHRQodc9EUUVJMIlEHF6v10Ay9NDA7qoDGw+BqfUgkYinRnEUfD5fjguJWoBKC47zId84kmF59WSd8f4JQhKdnV05fo8URasXWgZ3XPnAcTxqavgMo2u1k2nf/zXUPDqrvj+VJJW16HKlU6qNopxCNhBkwIUSAYPunh64a+rgqXEaPA71gsVipeFxj4eQjOWQSLTCNm76QoyYlN99fu3atbjgggtw//3346qrrjIL2RBh2BazTGLF8ccfbyixtVqdWb7H0ITZDMPguOOOA8dxakcmi9i79XX4vTuy7i8K0bwanExBLMMwqKltgttDIAoxCMm47n7v8/VkZJZlM8s0xmJTUyMcjjIYiywPiqJyOqtyICaj+qgsHA6jt7fHkB1TYd/IwIDXqo6taIaDGA+A4WxQZAEsZwPDcBCFWM7IULWF6kF9fT3cbnfFr61SaA79+X0W82fRuWubYWGVsvab+ZCZY6ftI2PxGDq7uuDx1MDjqdXvqxFdBvP3H4hMiQNAIINDsL8b/f1+iKIPAGCz2VIXouUUMmMJ5kagdmT74HQ6UOtxgmZ4sLwVICTv52kgiKKA5ric/ak2ek1SzdjVoaA3tg4NDQ2or6/XmcSfffYZvvvd7+Luu+/GtddeaxayIcSwK2YURaGvrw8bNmxAa2srpk6dalgIPVTFLBAIYMOGDWhsbMS0adMAqF2amIxi98aViIW6cx6HKAq4Ek4KWfEsFAWHqw5OdwMkIQ5BUMWfAzPLBEF17FBToctgLKYSluVBEmQAdTfl93UiGAyipaUVNlu5QZYDgyrTLLq+vj7YHB5Yeb+6k+FsecZsTlWDJMQQ8Pehr6+/4mTowSDNrizms5j/tYaDfeiORcBzXNVcSBRZQiDiU9OhG+pR39AKik7tGolSNHW5OqDAUjIam1rhiIZ11iJAcOBAO7jUa1XZkfkNoIHUZ7WqhSx7tJjlQ5o1thUK+jtmGhFrv2ez2TB26rcwetq3U6SgXvT29mL16tW4//77MWvWLHz44Yf4+c9/jhtvvNEsZEOMYUcA+eqrr7B9+3ZMnToVo0aNKut3e3t7sW3btkEp6SORCNauXYtFixYBUAkhW7ZswaRJkzB69Oh0Blm4G7s3vlh0XMdylopdvDnervshah2b398PWZZTbCu1YzNCICnHKaMUNO1WPCGgpbnRUMdcDljegUC/V2eX0TQNV00dbBZmgD0RQX+/H+FoAiNHjQHPMRVnj1WElM+imIxk+Cw2ZfkslgLDOxDs707R/mODdiHRRs8NDQ1ZI3mGtaTSDRjIBeJ+qgmZsDiwbxc8ntrU6Fll3GpmwepOMdcAGsiOmxksKnG/Z1kLaE41Rs702ARUIpKiyPqxNY2eizHTv5PzGKFQCA8//DDuu+8+/YJz0aJFOOuss3D55ZebRW2IMOw6s2QyiXnz5qXm6+WhmgQQRVGwe/du7N27F0cddRQaGxt1okew5yt8vfnVkuwqSUyWpcHJROb+g2Z4ROJBWGxONNR5kEwmDRNIquVkAKgnpO7ubsiyhLHjJ0MZhGZsIDI1ZAP3bEkRuj2RNqqMx2NIJBJobWkFAxGyKKrZY6xK4VZP2ENznUbTDBjWAjEZRiAQQCAQyHIXMQoiJ+FyuQflQqIhMx06c/Ss2T5lfgbVuB8riEIgCsblEUaQSCTg9XahoWkEnPb0hY5qfOxMHRtBIpHMSZx2e+phlSRDYu1SqDTGRZKSQAGPTVkSdd/KxlFHYfS00/I+Rnt7O37/+9/j3/7t33DHHXdg48aNWLVqFT744ANcccUVg35tJvJj2HVmkiRVXJDC4TA+/fRTnHZa/g+ZEQiCgHfeeQfNzc0IhUKYO3cunE6nXsi6936Kzq8+MtzlZI4mKkGasagyBdmUAJkQlUCSTHVt0WgMsizpV7sOhwNWR03BOPhyoVHvGYZBc3MLGJZVyRlVGAVRNA2WsxUt+gxnQSyijvOCwRAIUWC1WlMnSHvO7kk7EREAkhCtGjU/LRNQk4IjkQhaW7OjU8pBfnkEyREwWyxanpcjJ94lnIqAUR340yYCDGcFFAlykYsu9b23g6JpyGI8bwadUcTjKgmnvr4edfVNRan6mZAkEUkRCAX7EI/FwHFsxui18DiyEKqRRzYQFCiwvA00w8NdPxZjZizKe1w7duzAGWecge9973u4++67zS7sIGLYdWaDQTU6M1FUv8yJREInekiSKtbc/+Vq9HVuLe/xElFV/ySXf5JIMxbTJr0DCSRuTxNcNdkEklAojD5/GBbOm0WqqBSCIMDr7YLNlpYAEEUBZ3MNulhqCciluleG4cGyLOLxBCwWHvX1DVmdDM9zKRZoKp9twD5S24tIYqKivwWgdTmAKMTR09ODRCKBtrYRhlPM80FIRvLYJmULmNNWTCo5KNOFRBCSeTtDo0zAHOso3qZ+Xst0a9HILw0N9XC53JDEBCxWN5Il3PcBwObwgBNicNhaUuPI7Dy6tLtMWpheCNUoZDTNqmSpHEeYJGoaxhUsZF999RWWLl2KSy+9FHfddZdZyA4yjqjOLJlM4t1338WiRYsqcs8PBoNYv349kskkTjrpJNhsNiiKAjEZxZ5NLyES6KjouMq3xSEIBkNlMRY1OyQaDBTIiEcD+pV9WrxcbnCjerXd3Z2f8s4wrLpDqPAjpBUHI9ZNkiSh29cLlkFKhJz++2bq2bQ9mzZ6zRcDkj5h5w/VzAeWt4LIEiRJQHe3D5IkoqWluE2WUZQzCs6UOEQiESiKAqtVZQtqLiTFY3GMg2E5MFx2+ng+aBddjY0NWeQXmmFThaDwcXAWR5HHJqmRuvq3FQRVmK6NXnk+O7usnEKWtjBjdW2r7ghT4HjrW6dh3Oyz8hapvXv34vTTT8fZZ5+Nhx56aNDpHSbKx7DrzAZzNaNdtcmyXPaHyev1YvPmzZgwYQJ27dqljxXj4R7s3vg3JOPBio9LFuM5YvBCIISgr68P0WgEbW3ZEfalfo8oCkRFAE0zsNlrYHfWQ5aSEIWYXtgCAX/KgcRekkASiYTR09OTIhTkUt5lWarYv05jV5Y2jE2Lst2eRtTW2HKOt5ieTduzZerZ1H2a2nUwLJ8yBM5d+OvHmioOkiSkkrIJ2traynJbKQYxEQbN8jnu8PmgkkRUhxWAQnNzMwRBRCgURE9PD+xOD2yWIOx226CCKgFAlkR97JhORaAgiXH97xaNqh1UvmQERZaKZqNxFlXYXvh7kWaC1tbWQZIkvUMdmF3GMCy6urKF2TTNgGZ50DRbloVZPtS1TMW4WUvznp/a29uxZMkSnHHGGWYhO4QYdp2ZLMsV+ysSQvDmm2/i1FNPNUxbJ4Rgz5492LNnD2bPno2mpiZ9Z+a2iej+ak1VTF+NnPQ1goUkSWreVTkeixYnRFHVzAy80mc4CxiGhyKLEIVYKvNJ3bMB0O2m0gw6ohMbmpubU7lY+cFwlrKDDDOPtRTSnaEHtbW1ZTq0EySTAqLRKGKxqJ7PVmj0muliL6Zso7QTrmqQm9+otxrgDY9s00kAra2tWenQFGNFKNCDaDSCeDyuX7RUunsqBpa3IRZLoLPjABobagvKIrQkiIF/M97qTL3HlZ1+9OyyeALxuABZAXiOQ11dHex2K0DkVBr24FHbPBkTjloGKk+R6urqwuLFi3HyySfjiSeeKDkGNTF0OKKKGQCsXr0aJ5xwgqH4E1mWsWXLFvj9fsydOxculwuyLKOnpwc7Nr2Frq8+BMMwGTT4ynVAHG8vahibTbAoz2ORt7ohJsK6WTBF0wXJGdmdSCyVSJwmkNhsdnW0KgqGiQ3lkFx4mxtiPH2sxaBpt+rrG3Qx9GDYmZl6NnX0mr1ny/KNpCjw9loQWUI8HkZn+z5YLBY0NuZGllQDFCjQbO5JPxNqOrQPyWQylQSQmQ7thJiI6u9r2mNQpf0PdCEZbFepdu29aG5ugstdmyIl5fdEHMjo5awuSAbMrTWouXGqvECbcGg5fslEHJ2dHbDZ1E40FoshmRRgsVj0brycsfpAeJomYsLRy/O+X93d3TjjjDMwf/58PP3002YhO8QYdsVMPZFWzqhas2YN5s+fn+HAkB/JZBLr168HAMyZMwc8z0NRFEiSiPYda9Db/oV+QlCv7GOgKGQUNuOR7BoYzppXC6UyFrtgtzt0b0OjKHRyN2IinEk9FpJRJOJx9PT4IEkSCEGKLViaQFKqUKeP1ThhREuGHiiGVq/02UGx7oDCezYt2sVir4EQD0EQBHR1dcFdU4fmlrZU6ObQ6LSKde+EkFTXrkbaZBreli7waSq8kQ61FFTnl160tOR27YXMo7WCViilgaLVoFOa5gCKAkUIFCJDkYSCbMxCOzJZTrvgq8bejL5ns9mshrtqT+METJhzTt5C1tvbizPPPBPTp0/Hn//856rsTk0MDkdcMXvvvfcwe/bsojq1UCiE9evXo7a2FjNmzNAzjSQxjj2bXka4f3/O76g6oLQrByGKTpW22+2GviD5TjrqziGbsWgIFAW+iOs5w3Iptw9jf15FUdDt84NmGTQ11EKWhDwEkvzUcEB1Ni98kqfA25yGx2j9/X6EQqq7SL5xcblu/yWfUf/bqh0qxVhh4VSj4GAwmEN+0fRshBQnRlSCfO8jIQq8Xi8URUFra2vWybXYTqoQ8nWo2sm+1PRBE4i3tLQYcn7heDsorfASAkWWQDMMKIoGAQGRZciyWDbD1CjZQx1HJvQOVZYV2Gw2vWsr5IJf0zAOE+ecq5JYBqC/vx9LlizB+PHj8dxzz1XdOMBEZTjiitlHH32EKVOmpPKScqFFyYwfPx7jxo2DoijqySzah90b/4ZE1G/gWTS/vSiiUXWfotKH1SvdQiMciqYBglSEB0l5LPrL9likaRY0y5V0cjBKzhBFtfuwWm1obGwETdEpxh8LSVQJJFqETSwW00evmbuYguLwDKeMUlDdRXoQj6eDPfOBommAokHKWOAbAwXO6kQk2ItgMIBIRD1mTbxceM+mntTVTmRwe5qB76OiyPB6vQAotLS0ZJELyul0CyFtFFzahSQYDMLv7y94kQGkOmctfJaiAaKGz6okDBoktcsazEVA5fT7zNieGJJJTb/nSLngqxdp7voxmDT3u3kLWSAQwFlnnYWWlhasXLky5ZxvYjjgiCtmH3/8McaNG5cTFUMIwddff43du3dj1qxZaG5u1hmLEf9+7Nn0UoXWUwSCIOqFTRCEggbBgFpgkvEQ+vp6EY1G0dLSYpixCKQjUYyQIIrlj2nQ3Obd7posd/Xs50zH1otCtCCBxOWuhSKnj0ujPxuxT1KToVXyixHKezWdTYDsfK9Mn0Wr1Zq3i3E48uzZQIG1pBiTYuVp0VrMjpYOzbLqHjU7Hbq6rx/IzC3L3KGqhVySJIRCwZQnqC2lw+J0UgTRgjPzvGat6GZS9bPINmLc8IVJNQXRsixlFPI4aJpGXfN4zDjuEjQ0NufswEKhEJYvXw63242XX365LG9UE0OPYVfMCFGvnirFZ599hhEjRmDEiBH6zxRFwZYtW9DX14e5c+fC7XZDllV9VG/7RnTv/QcURSoa6mcU2ggnGo0ikVAFvtqejeN4UAyHzvb9FTEWK9EPFdtnaRZImQSLUshPIEmNXikeFk7dK7pcHrAca+gCQZbV7oOikOo+Si/SaZpRiQBlBFUWApXqRMVktKjPYqk9W46ejbOqejbdXssYOIsd8WgIXV1qyGhmuCcwNIUsBxQgKxTi8SQCwRAkUQTHsXA6bLBZ+RyNVyEMPNZ8I2L1IsAGimaLav+GwtlDAyEENF8Le8sJ6OsPQBAE1NXVIZFIoKWlBY2NjTj33HPB8zxeffXVLKcVE8MDR1wxW7duHRobGzF69GgAKrliw4YNIIRkET1kSULHrvfg278+K/03vcAGxGRsUCdL1bkhmkqYjqdExgqsNhcaGzxlsZ8qNQvOP2okCASC8Pv9ZZvjZmIggUQUBMRiCcTiCSQSMVhSbMFiJANJEgectI1T3qtxUk93jzFdjtDSUtpnceCeLZ+eLRO6AFmWIYnFL5gkSYS3JwALS1Ljcu2kTaWYo9WxKAMoMKm4HfXiACBEjTVSJBEECvx+P4LBEJqbm1M6L7WLyXQhyVfIgfx/n0JU/UyoidEWEJLW/mlJ1Q5H9QsZADg9IzB5/vmp5yWIRqPo6enBgw8+iD/96U+wWq1oaGjAM888g5NOOsnUkg1DHHHFbOPGjaipqcG4ceMQDoexbt06eDwezJw5Uyd6yFISe754GaHevfrv5etgNFcNiqKzmFmVQBvn0TQDQvOglGTaQ7GEBmgwJ20KFCiGzViwE/T2qqLslpbWqs38tYsAmrVCTISQTMQyCnmaBp9JIFHF0FoScgPKPUHRKQeSSo1y6VS+mywmBumzqOrZtNdrTM+Wf8+mpTK7aupQW+PUPxeZY9DyQKksQYYFRTEApVpYKbKQKliF3juC/v5+hMNhtLa2Ze0vM0kV6UKeNkVmGKYoSYe3OCEY2KEC6nulUCzaD7TDZmNRX+tBtQuZo6YVU465EAyb+3dPJBJYtmwZOjo6cPTRR2PNmjVwOBz4t3/7N9x4441VPQ4Tg8OwK2aA2k1Vis2bN8NqtaKmpgabNm3CuHHjMH78eJ3okYwFsHvjSsQjfVm/Z4QskRnLUs4+JB9jMZEUEA4FEYtFQUh+5/tMJ/nBQCuG6l7KB1EUyx5xGnqeVPcIAjC8DTTN6g4kaQKJelVvsVgQi8Xg8XgGlQxdCZsP0HaPCiRR0H0WVRHy4N+TQmxBNccrmy2YuWeLRoJoP7BPT4fmUjR29aKqOIlGLVic6ieIVMFSRCiSUMHYnKSKexRtbdnC7Hz3VUkVUV3j5XDVw8IROBz2gi4k2l6wFLI7sgZwFsegd5KZcNS0YPL8C8FyufuvZDKJSy+9FD09PVi9ejVqa2shCAI++ugjWCwWnHjiiYN+fhPVw7AsZoJQyRdQxdatWxGJqBlTM2fOREuLal4qyzKiwU7s3vi3vPuLYkLjfEiTIor5+2UyFrP1UuluS126awQSWU6Nq1wuuN11UKTBZ3TRNJMa53WCoijDe6lyUKx7ZDkraFY1rxWFGPx+PwKBACiK1tlzKjuy/AwvmuFAFKmszwvL26DIIuQMn8WB2q1qIXPPFo/HQFH592xadEpdfTMam1qgyBIURYaiyGA5C8RkFDTLg2FY0BSrdlhESZEuklWUB2Q6jLSVXdxp1o5AvzdVyONg2fwO+Opov7irfqnRIsNZwLIWKEWsyIrB7m7ClPkX6V1yJgRBwOWXX479+/djzZo1qec3MZxxRBUzRVGwdu1axGIxLFiwQCd6KIqC/q6t2L9tddFiVek4j0nFsiiyAElQi4/qsViYsZhfB6Ze5cYTIiLRKJLxaEoT49D95yqBKAro7g2Bo+UcMkE1UM77FonE0BcIoaW5CRaOHlDI0xIHbVxlBEbd2YGUsW0q6kSlvBsnnQwWA7WK2p6N41gEg0HU1dWjtq5B3WExLGiKAQEFQIaYiA5qzG3wCNHT04t4PI62ttayO/eBo8VSLiRWu6fg1KHcHVkmO1ISYiUvSm2uBkw55mJ9P54JSZLwve99D9u3b8e7775bUOZjYnjhiClmgiBgw4YN+ujqqKOO0juyrt0fwfv1pyUfwwiVvRQYVmUsdrS3Q0hG0drSXPCkwFmcOaMjrWtQZCmVaaWe6JPJJKxWi753MnqiUa/4vfDUNqDG7ahqIaMoChxvh2AofFQTQ4dSBAsraIYFy9mgEUiEVOio+noFw69Xkw2UujLnrC5IyUiqS/UOmc9iKTAsB4rmIAgi/P4AwqEgCJFhtXKwpwS9fErnpxIypJReT3XWKIfKbhwEPl8PkskEWlvbyna0MO5CohY2QRBhdzjUixe7NevvO1iyhzqWtYGi1DG3LGVPTmzOerWQWXKJT5Ik4dprr8XGjRvx7rvv5kh8hgodHR34yU9+gtdffx3xeByTJ0/GH//4R8ybNw+AeiF055134vHHH4ff78eCBQvw8MMPY8aMGQfl+A4HDMtiJooilDLCFCORCNatWwe32w23241gMIhZs2ZBlgTs3bIKAd9Xhh+ruJNFaUipK36GYdHa1gbe4gSImuhbyrOOtzohCvkNeFWLnmhqXBXPS6gYCFUv1YP6+jq43TUVp17nA00zYDiLob2HETE0RdPgODtAqSdrMZnISyDJ56MIlN55at2bJIno7OyC1Tp0PouASk5hGDUTS48YkUXIsqD/fTPToS0WS3rPlhBhsVphs3BwOOxw1TRl7QW1oEiKYSFXYXdECIHP54MgCGhrK3/cWokji7ZXTIpAJNSn7xUtFh69vX1Vpd+rY24eRJbAcFZMPfZicJZckwJZlnHjjTdi7dq1eO+997LkPUMJv9+POXPmYOHChfjhD3+IpqYm7N69G2PHjsWECRMAAPfddx/uvvtuPPXUU5g8eTLuuusufPDBB9ixYwdcLleJZ/hm4LAvZj09Pdi0aRPGjBmDCRMmoKOjAzt37kRzowcx78dQxCDK+UJUGmkCAMmk2gVpy+rME2WWSDQj+ZhlLZCkZFknhPQeRnPkYHPMkNVdXba3YbWKGc3yoFNBl6VQrhgaSJMiKIqBLCUgCvEsfZdKC89mghZz79feW81nUWVPDv5ESaUKFj0gxNFIKGZazzYgHZq1QJFlhMN+fc9G01wqnNKalwafHnNLkAx4ZGZCLWTdKVJQW9lmuYOVR1AUBVAMwqEAIpGw7kLidDrzupAMBla7B5OPuRgWW66mUlEU3HrrrXjnnXfw7rvvYsyYMVV5TiP46U9/ir///e/48MMP896uRQ7deuut+MlPfgJAJac0Nzfjvvvuw7XXXnvQjnU447AtZoQQ7Nu3D7t27cKMGTPQ2tqaMgqWcODrrdj++fMIB3vBMHTGib5wdpcGmmagEKVsurfGWKyrq02ZHBcJBkyx0yia0u9X6QkhnxkywzAQRSknfRhQWXyVOZ2kfp+3QpFlQ156aTE0hZaW8pIAsp4zdWWtyALEpBZhE9OZoBqBxF3bCHnAyVzryLRxa02Nuyz2JE0zYFhLToelyGLF1lXBYAB+vz9Hz8ayFhAoWSbK2p4tKdIIBbrTBKECejZtdEtS04Bin+P0hYacIsAc3EKmP47FgWgkgK6uTp31qV28ZLqQ2O32ig19LXYPph57MXhr/kL24x//GK+++iree+89jB8/frAvqSxMnz4dixcvRnt7O95//32MGDEC119/Pa6++moAwJ49ezBhwgSsX78ec+bM0X9v2bJl8Hg8ePrppw/q8Q5XHJbFTFEUbNu2DT6fD3PnzkVNTY1O9Ah078Dera9DkaV05pFmIGvQ9b687iwtQB7IWCwFiqbB8g6AKKqWTUyUbbiaCc3HTxAE/cQ70Ax5MCegchxIBiOGLgaG5cGyVsiK2oVoBJJYLApZYWC1MKkTvRM2Rw2ERBjxeAxebzfq6urypimkQxwZ3U/QaIdVHoguQm5tzSYFqRcJUsGwUtU2ikIiHtP1XWrycuFkg0IO9oBmXtydMi8unwBTTbNnURTR7euHzcoMGC2qVnGa238ikfZSLCcx3WKrwZRjL4bFlvu3VxQFP/vZz/DCCy/gvffew6RJk6rymsqBZot122234fzzz8dnn32GW2+9FY899hguv/xyrF27FieeeCI6OjrQ1tam/94111yDffv24c033zzoxzwcMSxzC4rtMQRBwMaNGyGKIo4//nhYLBa9kHn3rEXXno/13RRF0akrOgcaGtKODT6fr6C2C4Bh1pi6C+pFLBYtKxUa0EgALMREOKvAsLxNdaQocxeidUEAMGrUaDAMrZsh9/f3w+fzwWazw+mMwOF0lj1gKydMMS2GdlZlnJcJWRL094VmWLg9jXB7GnQCSVIEQsFe9Pkj4NkusCyLSCSKpuZmeDwNeTOxFFmCMkjiT2kQ9PX1IxIJo60tW4TM8XbIUvGLBKIosFjdIIoMi8WSSl5O69n6+vpy9GxEUbJE1hxvB82wEIUE2g/sBUBSLvzlXWhYrNUtZF1dnXDV1MPjdiD7s0KB53nwPA+Px5Ny1NES0wP6uFmNdinsQjLlmIvyFjJCCH71q1/hueeeO2SFDFAL6vz583HPPfcAUCOptm7dikcffRSXX365fr+Br48QMmQ738MRw7KYFUIkEsH69evhdDoxZ84cMAyjFjJZwr6tr6Pfu73g71IUBZvNDpvNjoaGBiQSSUSjEfT29maMbtQvhiTES47jFEVGd7cPsixhxIgRZdGYWc6a8oFUT6BKRtGShDgkqD9nWQtozgJFEouSUkRRhNeb2wVpkfN1dfW6sDUQCKDXH4GFVQqaIQ9EOd2clgzt8Xjg8XhQbbeGTCiyBEFWO2iKpuF018NJs2hoaoaYTKDH14NQOAiKYhDw90NIJvMaBA89NMp7DG1tI7K0W5zFDklMGErdFpJhddya+rywLIeamhrU1NRk6dm6urry6tlEQXXr8Hq7QDMWjBw1FhQUQ1l0GvgyZBClkMlarK1xgLfVFP2cMQwDl8sFl8uV5ULS09OT14WEtzoxZf5FsNg9OY9FCMG9996LJ598Eu+++y6mTp1alddUCVpbWzF9+vSsn02bNg0rVqwAAJ1R6fV60draqt/H5/Ohubn54B3oMMdhU8x6e3uxceNGjBo1CpMmTdJp92Iygt0bX0Q02FXGo1GwWq2wWq2or69HMqme6P1+P3p61A7GU9cMnlXyjl8yGYttbSPKurLlLA7IYiLrKlwSE3lZlJKUBFK0Yt3gV5ayTj7JZAJdXV64XM6i7C/tCre2thYKoRAOBRCNqlf0A82Qs36vjEKmuc03NDTA5TJmXFw2KAosawHFcKB10oXaYUliXI8aCQT6EY1FMaKtFSxD9BN9Z2dnXgLJUCEzHbqtbUTWhQNncZRlbE0IAcdZIOTp2GmagdPpgtPpytKz9fb26BdrNpsV4XAYNM2guakOkqB2bZkSiUJsWqC6Bsf56PeSoIrKjfihqlMXdW/Y0JB2IQkGg+jp6YHd6cGUYxZDRi5zlhCC3/72t3j00UexZs0azJw5syqvqVKceOKJ2LFjR9bPdu7cqZNQtBSQt956S9+ZCYKA999/H/fdd99BP97himG5M5NlGZKUHvXt378fO3bswPTp09HW1qaPFRORHny18W9VdRDXrXniCSQTcdhsVjgcTl20XIyxWAq8zQ0xHs7rh1fOno5hWDCcDeFwCJ3tewvugooeS+r5Bpohs6xG+XfC5a4z7KGnsScHY1ysoVAmliILBROmVV89AllKIhCMIxjw6T6Lunu9LEAUEvoeVSWQEH00ZzRk1SiKpUNrmrdyv35UymtRkoySeFTfSNUVJwhCSGrP5sy/Z9PJSbQqPk7t8KqRnaahmI6sKubRNI/asd9GKCqjv78fVqsVHo8He/fuxWmnnYbHHnsM//Ef/4E333wTxxxzzCBfzeDx+eef44QTTsCdd96JCy64AJ999hmuvvpqPP7447j00ksBqNR8rZOcNGkS7rnnHrz33nsmNT8Dw7qYKYqC7du3w+v1Ys6cOfrcXFEUhHp34+vNrxY8uVUDFG1BwN+NSEQVLXMcB1EU4fF4CmZ/FUKpLylFUaAoxvC+LhQKoq+vH83NLfDUNYKAgpRB+S+FfAJxRVEQj8cQi8URT0gAEQx0MKohbSgU1sXQRkBRVJ5MLFm3mSoHbCqSRpJE3Wdx1OgJoJD72dBSohVFhCTEM/K7tJBVm65nK5fdl4l0OjTJIVjwKc/Fwia/xVGufETNResEx3Goq6vX906lfCMB9XPC8Q4IyQhkA1KMUigliDbiql8MLG/D1GMuhs2lunbIsoy+vj58/vnnuOaaaxCPx6EoCu644w7cfPPNhqOPhhqvvvoqbr/9duzatQvjxo3DbbfdprMZgbRo+rHHHssSTR/qrnI4YdgWs3g8jo0bNyKZTGLu3LmwWq1QFAWKosC373N07PqgqnH1+ZDWZanuFYFAADyvOjcUG81lohyzYGNXpYWLR6bw2IilT76kAC0ORBTiAzqYXMJMphhaNenNfh8oilJ1WIxasAgqL1jFXoMsJSHLoq5na21thdXuKZlunaaxq3sjUUjqzNdMxxW73VGWR2HxdOjqjOqMivtlWUJnZ/5cNC1lWu3K8/lG0uCtTpVlq0hgGB4Mp+nZyvdCNOrsocbclJsOoF7UTDnmItjduXskQgj+8Ic/4Pbbb8e5556LjRs3YufOnTj11FPNoM0jBMOymIVCIXz22Wew2+2YPXu2TvQAgEigA3u3vIZkLHBQjoVmOHR7OxGLRfXIlMzRXCwWB8dxcDpz3TgohgXL8IYX7KotU+GTPCFKynIoidbWluJFVBMe0wzklBfhQAy8wi+cYp1phqwmINtsNkiSavA7ctRY8BarGjGCVMFSxBIRI4MHb3FCFGMFfRZZ3qp7ZZaCeiFgA0BBEuMQhKROgdccVwolTGfiYKVDGxHAS5KErq5OWCxWNDY2Fh2JZ+7ZYjHV8NpV0wArr+r4bI7aLAajZgJAAEMTgXItqljeXpYAnOUsmHzMRXC4c+2nCCF49tln8aMf/Qgvv/wyFi5cCEDVb3344Ye44oorDD+PieGLYVnM+vr60NHRgUmTJqki1dQXRR3FqV+CWKgb/u4d8HfvzIlzqRYURUZvfwRCIlTQvUJRlBS5IJLlxlFTUweL1VJ2B5LPr1E7Fq/XC0IIWlrKF7hyvD3H/igz66y4hiwd4khRNGLxOLo6OyBLAhRZrIoZcrnQRnWSrPos5i0eFV7h63ZRNJOKsIlnCdPTBBJ7ll5RLR4HLx26WIyKZttls1kHBHwagwIOQX+3rmez2exwOJ2w2ywF9mx20BQDScq9cKrEazEzMLf0fS2YNO8COD1tObcRQvDXv/4VN910E1asWIHFixcbekwThx+GZTFTFAWCIOj7MYqiijIG45Fe+L074PftRCzkq8oxaGa0PG9FY2MDaLr0F1Bz44gnZUTCAVAgWe4jRsgiHO9QnRvyHAvHcWhuHrwAWXfUkATVs44QiMkIGIbTM7EoAihEAVHUkaD2MRkohpYkedBmyOVCyzAz4rM4WMcT9TFKE0isVgsCgQBsNltO8SjH1b8c5BsTA+nioTL9ygs9zRcCqunZEiIQDeXq2fLt2WiGhSKJiMfCFZsGG9kNMiyPyfMvgNOT30dx5cqVuPbaa/Hcc89h6dKlhp/bxOGHYVnMDhw4kNpFcaBpuizGYCLq1zu28uj6aaQZiyrdXQ+dNABNXKySKQbunBwZO6fCrylz3JhMJuH1Do0AGQB4u0ctXIpYcmxVSgxdiRly2ceb6nCM+iwOxmszHwYSSJLJBEKhMMLhMIB0xInWpVaTBZgPA1ObtaTqSox61RQER0EGKwUKhGYQSck6iuWzqcciwtvdA1dNHRrq68res9EMC6IoBan6DMth0rwL4Kodmff2V155Bd/73vfw7LPP4pxzzjH8vNXCvffei3/7t3/DLbfcggcffBCA6X4/lBiWxezyyy/HSy+9hDPOOAPLly/HaaedlmXGahTJeAiBVGGLBDoMEUY0p3mV7u4GQBkeVxUeJak7p0hE7WAIyRZpD+y0tM4jFouiuzs7obqaGJjSTDMcWN6W0rJln3jKFUMbMUMu+3hT768WZFlTU1PSZ5ECBToVolpt0AwLSabQ3n4ALrsFDqdD37Mlk0k4XLWwcJR+YTYUyBzHqQW+Ey6XC3V1dSi3kJVKswayR7f59mx2u01/vd3d3VkdmW62TVJ6NgN6skJJ4jTDYtK88+GuG533915//XVcfvnlePLJJ3HBBReUfgOqjM8//xwXXHAB3G43Fi5cqBcz0/1+6DAsi5miKPj000/xwgsv4MUXX4TP58OiRYuwfPlyLF68GE5nbnxDKQiJMAK+XfB370C4vz3PF6mwx6J6QmSLyAAo8DanwStwottMRSJqIGVmYaNpBjTNIBgMoLe3B42NTRW93mIwwrBMu/wT+Pu64fN1o6GhsaIvXD4zZI1MUapLHXi8sVgM3d3deqyNEVS7O9OgFVWPpxa1dXU6gUSWEiAUi0C/T9fvcRyn7xXzjeYGA97qRCTUh87OLrjd7rJlI0YLmYb8401VzxaLqZ9rURTAMCw8npq8I2dtz0ZRDCQpkeWCM/B+NJN9MUIzLCbNPQ/u+rF5f2fNmjW4+OKL8dhjj+GSSy456JZPkUgEc+fOxSOPPIK77roLRx99NB588EHT/X6IMSyLWSYURcH69euxYsUKrFy5EgcOHMBpp52G5cuX44wzzoDb7S77wyoKMbWweXcg3L8fsizpHosaY3EgChmrUhQNlrdVGK2Sdi6IRqMQBDF1cgcEiUZTgzvH9X6wKPd4g0G1wLeNHAun02WI8l8M6tV8Ol26VJdK0TRYTj1eLf+rsbERTqfxokpRFCiaHZSJ80Bo5sU5RTU1qgOIKnEQE5CERFaXStO0XtiKGV4bhSQTtB/Yl9GploFU6Gc5n99Cuzogva+z2WzgeUtZejaa4fJat2UyN2mGwcQ556GmYVze5//ggw9w/vnn46GHHsKVV155SLwLr7jiCtTV1eE///M/ceqpp+rFzHS/H1oMezsrmqYxf/583Yhzy5YteP755/Hb3/4W119/Pf7pn/4Jy5Ytw5IlS1BbW2uQZGFH48ij0DjyKMRjYfxj7esAD4yqL0z0yMes0nK9Ks8Io8DzFvC8ahwrCIIekkgzPPr7/XA4BEP+iUZAMyxohjN4vGk9W2trC3hW7W41ggBFM1kOEUahemTaYLPZ0NBQn9cMWStsLG8BkzreTJF4uSNnQgh4zoZklYqZNv5VbbvSRVW9ULDmdDi81QGrwwNPraDr92IxzfA6nWxgs9nLNv1V7cy60NA8Ek5bmaPMCgoZoF4MclYXxAHdbj7WYto3Un3Nmm9k+jWrxVzdp6lFTNtLEiJDEmIQk1GwvB2KlMSEo88pWMj+/ve/44ILLsADDzxwyArZX/7yF6xfvx6ff/55zm2afGSgn2JzczP27dt3UI7vSMawL2aZoCgKs2bNwqxZs3DnnXdi+/bteOGFF/D73/8eN910E0455RQsW7YMZ511FhoaSltNxeNxbNi4Gc76STj+1HNBQUGwZzf83TsR7N2dNVaUJSHripTlbap4VBq8KwKQkgH09gIAxowZDUKARFJGKNiX8k9MswQr2b8wrKpJG+j6kQ+qn2APEok4Roxoy9KzqczH9MmPs9hB02zZLv8qqBwz5FhMLVw9vf2wOxywWThIkoRwOKSKoSsUtwpCBDTNGnZYKYRIJIyenp7UKDo9/lWDOrm8VPnMEzXLWeCx16CmVoKQiEIQtGLuhyT59OwuIzIHbcxZW1sHt9MOokiGjQQyO95KQOR0zBBQnH6v+kY64XQ6C/hGpl8zTTPZyQg0A85iB8PwGDnzdHgaJ+Q9ns8++wzf/e53cc899+Dqq68+JIXswIEDuOWWW7B69eqin1PT/X5oMOzHjEZACMHu3bvxwgsvYOXKldiwYQNOPPFELFu2DGeffTZaWlpyPizBYBAbN25Ec3MzJk+enHNFLMsiQr174O/eiYDvK8iSoO9eOIsTkljYkLVcaPokjmPR1NSsH0umf6I2lkuzBJ0pliCHUvsRjrfrUSeloOVcybLxZGgNKuWfgyyJg7I+YlkLBFFAOORHIBCELEvgOB4ul7Ok40oxDDaDq1A6NM2wekEvBzTDguNsUAiBJGiFLabLHNIXMPac1xyPx+H1elFfX69bMhnVslE0DZa1luWWnw8aOaMSHZmKzDF7Zj6bPct1haJoTDj6bNQ2T8n7KOvXr8dZZ52Fn//85/jnf/7nQ1YYXnzxRZxzzjlZGlBZlnVp0Y4dOzBx4kRzzDhEOCKKWSa0BOoVK1bgb3/7Gz799FMce+yxWLZsGZYtW4aRI0fiqaeeQjgcxvLlyzF6dH42VCYURUaob69K9w90Ih7prdrxqnR3r64JyvwiUhQF0AxIRhHSWIKRiEqNZtk0SzDfLqKcwqtmoqljoMEkQwNqB0KzpeNrcn6Pt6XsrtI+i83NTfpJL9sMuTwyhfZ6Ktn5FUqHplkeFKhBsyWzgzRjEMV0YRtIIJFlNSG6oaE+K52gFJUdSI1CucEXMu35BCGJzo72inRkAyFJUobpdUK/aJs6/zyMmjg/b5H64osvcOaZZ+Jf//Vf8dOf/vSQdjjhcDhnXHjVVVdh6tSp+MlPfoIZM2agra0N//zP/4wf//jHAFQGalNTk0kAqQKOuGKWCUIIOjo6sHLlSqxcuRIfffQRmpub4fP5cPfdd+OGG24o+8NPFAVh//6USHvXIPZlKomgu7u7KN292NW2yhKM6Ve2DEMjTX+3grfVFHTpH4i0GNqS414xWDAsB4a1gRAJYrKw1khzIRnos5g5btPMkDPJFOXEuZTvxFE4HVob3VbLZ1KDZkU2kECinegJIbDZbPB4PDkEkmLdp5aobWTUbASiKKK7JwibBYMuZAOhKDLi8QSsDfMQV9xgGAYNDQ1oalLZvVarFdu2bcMZZ5yBG2+8EXfcccewHNVlEkAA0/1+KHFEF7NMCIKAq666CqtWrcLkyZOxceNGzJgxA8uXL8eyZcswadKk8gsbIYj423WRdjn073A4hN7e3pLMvFJ+jZnHop3ko9EYGM4BmwWpk3xxxtxQC7MzkTb3VUdr2sdPE5vLspTXZzEf1Ndc3Aw53/MTohgcEafToVtbs9OhGc4KKBLkMgkwlUBj+oUC/ejs2A+PpwaKoiAajWWxQW02OxiWBQU6Zzc4FIVMHS260NjUVDYRqBQoisLYmWeiYcRMKIqSyhrswbZt23DNNddg1qxZ+PLLL/G9730P//mf/zksCxmQW8xM9/uhwzeimBFCsHz5cuzfvx+vvPIKRowYgb6+Prz00ktYsWIF1qxZg8mTJ2PZsmVYvnw5pk2bVlFhiwY74e/eCX/3ziJGyNqVfhDNzS2w2UpT742YyqZBgbM6EPL3pApbJCOzywG7PfskfzCToQeCYTiwVhcoAMlYAJIkpEx62RyfxdLINUPWBLyafk+D0XQCLR26tbUti3SjjUKrfQIvBi34tLVtFNw19SCKBCGZvWcTRVXa4alrAc/Kekc7dIVMHS2qdl3V0/FRFIWxM05Hw8jZObcpioKVK1fi+uuvh8PhQF9fH0466SQsW7YMP/jBD8zu5huMb0QxA4CPPvoIRx11VM6HnRCCYDCIl19+GStWrMDq1asxZswYnH322TjnnHMwa9assunSABANeRHo3gm/dwfi0X79ubTIlJaW1qwr/WIoZD48ECpDzT7gvgSJRFIvbFrqsMPhACEKent7KxZDGwFF02AYC2iG1dlviiLpxcBic0OSkkjGY/D6+mCzO9BQ6wYhlWvZCun3tJ0Tz1uhKHJB5l9mOnRra1t2OnQqcmYwWrtyoTIoe3OCTzMjbCQhphe2WCyGpCCB5xg4XW64XDWgqeqQlQqRPcoxBi4GiqIwZvoiNI46Ou/te/fuxemnn45ly5bhv/7rv9DR0YFXXnkFq1atwl//+tcsswMT3yx8Y4qZUYRCIaxatQorVqzAG2+8gebmZr2wzZ07t6LCFg/3oLfzS2xZ/w4S0T60tLSUrRsrNW6kaRY0y5W4+lZdGqLRKMLhEGRZhsVigdtdo9OiK0FmMjRF0SAgILKsJkMX6V60/Y4gCPD6/LBbGTQ01IMCrcbXUDQkKVnQHcIoRFHMMUN21zbDwpIcmQMhCrq7ffnToS0OSGK8aixWIwiHw+jt7UVLSzNstsL6Oo1qr2u2GB4hfx9i8QQi4UCKQGIvSBQygmKsxfKmB4UxZvp30DR6bt7bDhw4gMWLF+P000/HI488UtF30cSRC7OYFUE0GsXrr7+OlStXYtWqVfB4PDj77LOxbNkyLFiwwHAMSyKRwIYNG2CxWDB5wkiE+/bA370D0aDX8LEU8qgDNCKCUUZdWgzd0NAASRIRiURTMR9WnUAyUONU3aBNze8yrGul6hpa4HZake8kq7tDiElIg2QNqmbIMcQTAqKRUJYZMsty6O4ulA6t7vQO5tdFkwK0tBgbR2t/I4rhwGhpCEIUkpDIIs1o5sBG9qkajNDvB1vQRk/9JzSPPSbvbV1dXVi8eDFOPvlkPPHEE4NKATdxZMIsZgYRj8fx1ltvYcWKFXjllVdgtVpx9tlnY/ny5TjhhBMKdlqRSATr169HfX09pk2blnU1mYwHVR2bASNklXadOxorZ3+TKYYemAytFbV4QkRSEGGz2eF0OeGw28HQFBRJqErQZmbEyECfxWI2SRoYzgKWtUCWxUHvgBjOgaDfq5/kAXW/1NjYCLtd9VkEUoUsER3SoNGBUG3E+tHSkisUZ9jURQXFACAgRFE/A6kwVIblAIqGnIq+Sev/BEhCQhctZ9qJ2e3abjG32zGqI2N5W8V/k1FTFqJl3LF5b/N6vTjjjDNw7LHH4qmnnjILmYm8MItZBRAEAWvWrMGKFSvw0ksvgaIonHXWWVi+fDlOPvlkfXS1bt06hEIhjB49GuPHjy96BSwkwimB9s4CRsi5YZPljL0URdHp7iNHjgFvVZOh1T2WAlkW1YJFSEaUi6b34fUk7UoFy0C2xints5g2Ui43TJNhebCsFbJSWWHTss7UdOhOqPZiHGKxuG6G7KlrBkvLB5UtFwgEEAyGMGLUGNjtTqjFQ4EiS5ClZImLHjU2qVCGG8NawLCWogSSzKDVcgXRlZg6j5x8MlrHH5/3tp6eHpx55pmYOXMm/vd//7cqtm5GcO+992LlypXYvn07bDYbTjjhBNx3332YMiUt3DbjXIYXzGI2SIiiiA8++ADPP/88XnrpJQiCgKVLl4LjODz77LN48cUXcfLJJ5f3mMkoAj1f6UbIGtkg88pXS1ou1C3QNAOGtYBiGMiSjPb2dlBQ0NxUX9aJWZa1KJdIlmDZ6SwvoyzTJSPts9ic47NYaZgmzbBqfI2ikiEM2zoxVuzfuysrHVozQ06KFIL+7hz6e7V2NRRFg+Es6jiTogFC0Nvrg7+vBy0tzXkNr4uhXAG3RiBBahyZJpBEkUgkwfM8JEmE3e5AU5OxtGqG5aHIouH3f8TEk9A28cS8t/X39+PMM8/EhAkT8Ne//nXIYnTy4fTTT8dFF12EY445BpIk4Wc/+xk2b96Mbdu26SQTM85leMEsZlWELMv48MMPcfvtt+PTTz+F1WrV6f6nnXaaob3HQEhiAgHfV/B370Co72vQNA+G5ZCMh1TKNcOnmYKKAoXIUCRBL4DqlXUXLJbBi6EVRRmQUcYYyihL7/QSuiwh3/gMqE5cC00zKsuPglrYCnSukiTC290HnqNzTtZp8XE6sicajUKSpCwz5FIjr0xyjPb4RJEhy0kociYjMi3ObmtrBc+XV8gGK+Ae6EASi0Xh9XaBpmnIspy6iDFGIDEqTG+bcAJGTPpW3tsCgQDOOusstLa2YuXKlYaZv0MFzY/z/fffx8knn2zGuQxDmMWsipAkCTfccANWrVqFV199FbFYTM9k6+npweLFi7F8+XIsWrSooowyWUrC37MH4d6vEfDtKkmFHkoxdHZGWTRFKsh14mA4a4ooIqC3tw/RaCRHgJwJNb+qWHZcedB2dAAFUYzr1mBaUrXT6UBL6xiIQpq4UOxkrJkhq8xIzUvQAbfbA95iB0XTACgQUg45RiXlhMO54mwjYFgLAFI1JxJJlODt6YfL5UatxwlJFAYQSKhUMc+fR2fENqx1/AKMnHxq3ttCoZDuV/jSSy9VbC5dTXz11VeYNGkSNm/ejJkzZ5pxLsMQZjGrInp7e/H9738fDz/8MEaOTEe5K4qCdevW6Zls7e3t+M53voNly5bhzDPP1I1iy0E+I+RMGLHKqhY0J/RIJNuJw+1pgNXCQpFl3Wexra01J6hxIIoxNwcDzSYqmRRxYP9uuJwO1NXVguXt6fFtkULGsBwomlM7Yai+muFQAOGgH/FEAhYLn5FsYLQgEfT19SESiaKtrbXsnWS1LbXy7chY3gaG4SBJAiQhnkMgyexUdZPsIu9jy7hjMWrKwry3RSIRnHvuueB5Hq+++mpFCfPVBiEEy5Ytg9/vx4cffggAWLt2LU488UR0dHSgra1Nv+8111yDffv24c033zxUh/uNhVnMDjIURcHmzZt1h//du3fj29/+Ns4++2wsXboUHo+n7FGgosgI9X4Nv28nAt27EPD3oqfHN6Ri6MJQ900JgSAU6IMsS6BpGhSFHCeNQqBpBoSQooa5lSIzHbqhqQU0zUGWkqBoFnQqo41hLXqHBRCVeCELRYk26m4xnWxgzAyZpEJhc11GjEAtZKRqXawRsgfDWsByFiiyRiAR9O48LU63w+FwgrfYc/Z3zWPmY/S0b+d9/lgshvPOOw+EELz22mtVT1ivFNq05aOPPtIvUrVi1tnZidbWVv2+V199NQ4cOIA33njjUB3uNxZmMTuEIITgyy+/1Avbtm3bcOqpp2LZsmVYunSpoUy2gdi792ts3/wJ2hpYKInuqghZy4WmyVKjbTohywooioIsS1mp0sVE2uUbApdGoXRoiqLAWd2goHY45bj854MxM2TNLituqFsdCJa1QElR8quBSmJcNNINFI1Aki5siUQSdmctrDz0TrVp9ByMmb4o72PF43FceOGFiMVieOONNyqaVgwFbrrpJrz44ov44IMPMG5cOhTUHDMOP5jFbJiAEIKvvvpKL2wbN27UPefOPvvslFdh4RMMIQS7du1CZ2cn5syZg5qamkEZIVcKbUQoy9IAn0UKgiAiGo3ksZhy5BApGJaDIhsPmyyFaFRNdm5sbMgydqYoCizvyLIAY1he3fXJ0qCjUvKZIdvtdkiSBEmS0NbWVjbdnOUsKRJJdbwhK88jSyM3wkZALBZDPCkhGvbD1TAVE45agqamJtTU1GR9lpPJJC655BL09vbirbfeSo3FDy0IIbjpppvwt7/9De+99x4mTZqUc7sZ5zK8YBazYQhCCPbu3atnsn322WdYsGCBnsk2YsSIrJOBoijYtm0b/H4/5s6dm9efzrgRcuXQuimNQWm1WtHY2Ji3COdaTKXdR7STezWYjUBmOnRz1ntjJG2ZYVgwnA2EyJCE+CCLK0E8nkBvbw9EUUpp2Yx1qvrxcFYQRaqayXE1CtlAqBcIdlXUTQFOz0g4mo9Bb28venp6QNM0BEFAMBjEd77zHVxzzTVob2/H22+/nTqGQ4/rr78ef/7zn/HSSy9lactqamp0VrIZnOiW2wAAKIlJREFU5zK8YBazYY7MTLYVK1Zg7dq1mDt3rh5dU1NTgx/84Ae4/PLLcfrppxvWJkVDXvi9OxDo3qkbIQ8GWkemho12wel0Gj45SlJapJ1IJPSEZbenHjQGZ+hbMB26Aid5mmbA8nYABEIyCpT51SGEwOfrhiiqvo+ZCeIDzZAH2okBqpOHMowL2UCCDCEKahonYOyM0/X7KIqCQCCAlStX4q677kJ/fz+cTifuu+8+XHTRRaipqSn8BAcRhaYgTz75JK688koAZpzLcINZzA4jEELg9Xrx4osvYsWKFXjvvffAcRzq6urwf//3f5g3b15FOrJ4uCfVse1ALNxT1u+q1Pdsn8WaGg9qaz2o5OSYeYKPx+Ow2lywWRmVUMBzZT1mwXRomgXNsINyeadoGhxnByh1rFbKRZ8Qgu5uLyRJThkYZ3dh+cyQtT0bx3FgORsUpXqxM1ohs9sdZck2coTeipJOQRjwHtS3TsO42Wfl/UxKkoRrrrkGn3zyCc4991y8/fbb2L59O8466yy88MILwzafzMTwhVnMDlPs3r0b3/nOd9DQ0ACPx4P3338fU6ZM0f0iK8lkA4BEtF8vbCWNkClK9VNMRnN8FqsBRZEhiEAw0INYLAaWZfVRZHHhbmY6dGtWt6oZJcsVuIwUQnqsRkMS4zkFhxAFXm83FEXJMTDOB80MOV3QnbDbLbDbrGW5rhRCqUKWaVhM0aoziaLIICVSEDJR1zIV42eflWKFDnx9Mm644QZ88skneO+993Rq++7du7F161acffbZg3p9Jr6ZMIvZYYhAIIBp06bhoosuwgMPPACKohAIBPRMtrfeegtjx47Vo2tmzpxZkQVTMSNkzS5L9VlUd1KZPovVBMvb9IKZyRDMFGmnT8iabitXnF1tcXEhcLwdFMNCFhOQxAS6urwACFpaWsv+O1CMBZGQH5FIKOW6wma87vKjXDILWVNzCxiWTxkWa0JvadCm0rXNkzHhqGV5C5miKLj11lvx7rvv4t1338Xo0aMrfh4TJjJhFrPDFJ988gkWLFiQt/sKhUJ49dVX9Uy21tZWvbDNmTOnosKWaYQcDXaruVklfBarhYEGxCpDMKanSmumwA6HQ/eQzEmHZi0gUKqmyTICRVHg6+kHxXBoaW4Ekcsroixvh5IRBKq5rqh6tuzXnc+JA0CG5RkDUZJwYP8B2O1W1NfWDImOz9M0EROOXp63+1QUBT/+8Y+xatUqvPfee1lUdxMmBguzmB3hiEQiWZlsdXV1usP/scceW1GchpCMIuDbhZ2bP0LXgW1oaW4ecsuhQuGkmilwNBpBOBwGISRlhOyC3W5Tnfp5q9pxVGnfZASKIqOrywuaptDS0qLumlgLGM4CxUB8TalE6/TrjiIaiwGg4XC64XbXwG63g6LUDlR7zZIkorOz/B1ZOahpHI+Jc84tWMh+9rOfYcWKFXj33XdzqO6HAo888gjuv/9+dHV1YcaMGXjwwQfxrW/l94o0MfxhFrNvEOLxOFavXo0VK1bg1Vdfhc1m08NGi2WyDQQhBDt27EB3dzeOnj0DYsyrGyFnm+dWD8Vo+lo6tCiKqK+v13VdsizD5a6D3cbDarUctGRiRZHR2dkFlmVSGrvc56UZLuXyL0NMxoCMsR5nsUMSEzmOIzTLgaE5UDQLUNnhqMlkQu9UJUljRjpht9tBiDL0haxhLCbOOQ90Hhamxvp75pln8O6772Lq1KlVf/5y8dxzz+Gyyy7DI488ghNPPBGPPfYY/vCHP2Dbtm3m6PMwhVnMvqFIJpNZmWwMw2Dp0qU455xz8K1vfaugtZKiKNi6dSuCwSDmzZuXlQQgSwKCPbvR370Dod49VR3pURQFimKgKNndlZrTli8dmkABi6C/D5FIOOsE73AY03RVAi0bjWW5kkJ3DZmUf1lR3VJoitaz5ozYaWVioBkyRUFPTSjXacQI3PWjMXHud8EwuY9NCMG9996Lxx9/HO+8886woa0vWLAAc+fOxaOPPqr/bNq0aVi+fDnuvffeQ3hkJirFEVHMVq1ahV/96lf44osv4HA4cPLJJ2PlypX67fv378cNN9yAd955BzabDZdccgl+85vfHPJYieECURTx/vvv6w7/oihi6dKlWL58OU499VSdDRgOh/HFF1+ApmnMnTu3qKatlBFyJUjHsqjQRnkUpY7yMjsvzuLIyjUTRdVqKRJRbZdsNmuG+0h1Ah9lWUJnZ1dWNlpeUBRY1qKyBSkqxRaUQNEsZCGmWkQRqMzIEpT/YpAkER0dneA4NX4mUbEZcmG46kZh0rzzCxayBx54AP/1X/+FNWvW4Oijjx7081UDgiDAbrfj+eefxznnnKP//JZbbsHGjRvx/vvvH8KjM1EpDk5s6xBixYoVuPrqq3HPPffgn/7pn0AIwebNm/XbZVnGkiVL0NjYiI8++gh9fX244oorQAjBf//3fx/CIx8+4DgOp512Gk477TT87ne/w0cffYQXXngBN910EyKRCM4880wsXLgQ//Vf/4XZs2fj0UcfLWmKyzAcapunoLZ5So4RcqX6LjEZBUXTIIqS6oDyj/I4qwtSMpLFvuQ4Hh4PD4+nFpIkpgpbBL29fbBaLRnuI5V1LpoPpcWSdj1hWEsqlJQBIQAhUmosKKrvQcb7wFkc+jFrZBctvoaiGUjJWE5XWvx41B2Zw5EeLWaaIfv9/rIyyvLBVTsSk4p0ZA899BAefPBBvPnmm8OmkAFquoUsy2hubs76eXNzM7zeEnIUE8MWh3VnJkkSxo4dizvvvBPf//73897n9ddfx9KlS3HgwAFdz/KXv/wFV155JXw+37AxNB2OkGUZn3zyCZ5++mk89dRTUBQFZ511Fr773e9i0aJFeW2zSoEoCsL+/fB7d8Dv21W2EbLF5kY03I+urvwdUKkE7oFQNV2aSDsBnufhdBrvXGiahUIodHR2wWazobm5CUQbCxr8ag3sIgvej7frYu9ina4RsocxM+TCcHraMHn+BSm5QzYIIfj973+PX//613j99ddx/PHHF32sg43Ozk6MGDECa9euzTq2u+++G8888wy2b99+CI/ORKU4OBvxIcL69evR0dEBmqYxZ84ctLa24owzzsDWrVv1+3z88ceYOXNmVubQ4sWLkUwmsW7dukNx2IcNGIZBa2sr1qxZg4suuggffPABJk+ejDvvvBNjx47FJZdcgueeew6hkHF3e4qm4a4fizEzFuOoU2/A1GMvQfOYeeCtxrzs4rEwOjs7YbVa0Nw8oJDZ3BAS4bI0UgzDwu2uQWtrG8aOHYOamhokEgm0t7fjwIED6O/vhyiIYDkLeIsTvM0F3uoCy9tA0wwEIY79+76ChSOo89hTaQHJMgqZ01AhAwBRiCEZD0GWBLC8DRabO6eYGGUtqjo9J5qamjFmzFg0NDTqdlv79u1DT49PzysbCEdNa9FC9qc//Ql33nknXnnllWFXyACgoaEBDMPkdGE+ny+nWzNx+OCw7sz+8pe/4OKLL8bo0aPx29/+FmPHjsUDDzyA1atXY+fOnairq8M111yDvXv3YvXq1Vm/a7FY8NRTT+Hiiy8+REd/eODmm28GwzB44IEH9J2Uoij44osvdIf/PXv24LTTTsPZZ5+NJUuWVJTJZsQIWUuHrqltgsedKZTO3aeVDwoMy6kOIRQDRZERiYQRCvoRjYTAMEyOWFkUBXR2qmnVlXgbalE5g/0KMpwFDGtBMhHD/r27s0aL5YMgkUjq3aosy7DbbboZssvThsnHXASWy5ViEELwzDPP4F//9V/x8ssvY+HC/AGcwwELFizAvHnz8Mgjj+g/mz59OpYtW2YSQA5TDMti9stf/hJ33nln0ft8/vnn2LlzJy699FI89thjuOaaawCoLL2RI0firrvuwrXXXlsw+ZXnefzP//wPLrrooiF7HUcCZFlOhWvmPzESQrBt2za9sH355Zc49dRTsXz5cixduhT19fUV2WpFQ14EunfC792BeLQfyaRqYOx2u9HY3AY5Y99UTvYZzbCgGQ40zepsQVkWVdeLAl8FTaysxbhQFA2r1Yp4PAaXy436+jqUWzg4qwtSGePQUtA6MqerBs2to0AUCZKQAAb1+ETPKItGo1AoB8bMWo6WtlFobGzMIgARQvDcc8/h5ptvxsqVK7FoUf7csuECjZr/+9//Hscffzwef/xxPPHEE9i6dSvGjBlzqA/PRAUYlgSQG2+8sWSRGTt2LMJhVXc0ffp0/ecWiwXjx4/H/v37AQAtLS349NNPs37X7/dDFEVzpGAApUTVFEVhxowZmDFjBu644w7s2rULL7zwAv70pz/hlltuwUknnYTly5fjrLPOMkxVBwCHuwUOdwtGTDoZ3o6vsG7tG2hus8HGK5DFhOoJKcRgseZ2ZKpAmVc1TxStswWVlIi4XPE0RaWtswghCIdVJ36AQjgchqLIKRcOu6HXV+5erxQyR4t1tTUQU3o8mmHBcTYQooZnln/dSoHnLeB5C9pGT8boGcvRHwijq6sL27dvR01NDT766CMsWrQIO3bswE033YS//vWvw76QAcCFF16Ivr4+/OpXv0JXVxdmzpyJ1157zSxkhzGGZWdmFKFQCE1NTXj44Yd1Aogoihg5ciR+/etf45prrtEJIO3t7Xq8+XPPPYcrrrjCJIAMIQgh+Prrr/VMts8//xzHHXecnsnW1tZm6MTf19eHTZs2YdKkSRg1ahQSUT/83TsQ7t+PZDwAWRJ1M1xCFNU1YwidPrQOsaamBrW1nrQLRzQKWVZ0dqDqwpG7kh7KQlZ8R8aolH9QqdGmcSsrm7MeU465GJwlTfhJJpPo6OjAD37wA3z++ecghOCCCy7A7bffjtmzZ5uu9yYOOg7rYgYAt956q94JjBkzBvfffz9eeeUVbN++HbW1tZBlGUcffTSam5tx//33o7+/H1deeSWWL19eETU/mUxiwYIF2LRpEzZs2JBFOTb1bPlBCEF7eztWrlyJlStX4u9//zvmz5+vF7YxY8bkPfn5fD5s2bIF06ZN0y9EMlHMCHkokEwm0NXVBY+nNk8aMkEymd41SZKUE7xZrbBRDZVaVGnp2hRNQRTiIEWKv81RhynHXgzOkt9A+vXXX8dll12G73//+/B6vXj99dfR3NyMp59+GieddFIlL8uEiYpw2BczURRx++2345lnnkE8HseCBQvw4IMPYsaMGfp99u/fj+uvvz6nyBgNsszELbfcgl27duH111/PKmZa0WxsbMQDDzyg69nOPfdcU8+WAS2T7W9/+xtWrFiBDz74ALNnz9YL28SJE0FRFP7yl7/A5XLhmGOOQVNTU8nHzTRCDve3V91EV8tqq62tMxAgSSAIWj5ZBIIgwulugJVHSqQ9ePeRanktUqDAWtRiKwpxKHLatcVq92DKsZcUZJquWbMGF198MR577DFccskloCgK8Xgcb731Fo499li0tLRUdEwmTFSCw76YHUy8/vrruO2227BixQrMmDEjq5iZerbyQQhBb2+vHjb67rvvYsqUKWhqasJHH32E5557Dt/5znfKflwxGUWg5yv4veo4cjAuGoDqaen1eivOaqMYK/x93ozgTWuGSLv8tfVQmgazvA0Mw4FmeUyaez4stvyf2w8++ADf/e538bvf/Q5XXHGFOVY0cchhFjOD6O7uxrx58/Diiy+ioaEB48aNyypmd9xxB1566SVs2rRJ/x2/34+6ujq88847w5qmPBxAiBqoef3112PFihWgKAoTJkzAsmXLcM4552DGjBkVGQVLYgIB31cVGyHH4zF4vd1oaKiHy1X+BclApqUkpUXaqr2UJcNeqrT7SDULGUXTYBhLiiiTttViWQsmH3MRLLb8hfvvf/87zjvvPPzmN7/B1Vdf/Y0uZJIkYcqUKViyZAkeeuihrNuuu+46vPXWW/j4448NTRdMDA6HtWj6YIEQgiuvvBLXXXcd5s+fn/c+Xq83hx1ZW1sLnudNixyDeOihh/D222/jk08+QU9PD/793/8du3btwj/90z/h6KOPxs9//nOsX78eikHDXQBgOSsaRszEpLnn4eiFN2PCUWejtmUKGAO2VbGYWsgaGxsqKmSWPJIBlmVRU1ODtrY2jBkzBm63C/F4HAcOHEB7+wH4/f0QBAH5KPWVFjKGtYCzOMBb3eCtLnAWBxiWA1EUSGIcQiIMIR6CkAiDpllMnn9hwUL26aef4rvf/S7uueeeQ17I9u7di+9///sYN24cbDYbJkyYgF/84hep9y+N/fv346yzzkrp7xpw880359ynUrAsi5/+9Kf44x//mGK4qrj33nvxwgsv4PXXXzcL2UHCsKTmHywY1bOtXbsWoVAIt99+e9H75vtiE0K+0VeuRkEIQX9/P95//31933nppZfi0ksvRSQSwWuvvYaVK1fizDPPRF1dHc4++2wsX74cxxxzjOEdFMPyqGudhrrWaSWNkKPRKHw+HxobGytKzzYi4mYYBi6XGy6XG4oi60nagUA7WDadKG2xWCBJUtFCRjEsGIZXu1eKBjS3fSmp/ysF3urElGMuhsXuyXv7+vXrce655+IXv/gFbrjhhkP+ud6+fTsURcFjjz2GiRMnYsuWLbj66qsRjUbxm9/8BsDB8Wa94oor8Otf/xoPP/ww7rjjDvzv//4vfv3rX+Ptt9/G5MmTq/IcJkrjGz1m7O3tRW9vb9H7jB07FhdddBFeeeWVrC+vLMtgGAaXXnopnn76aXPMeJAQi8WyMtkcDoeeyXb88cdXtIMaaIQcDPTC5/Ohqam5Iv/JckTc+aCKtNO+iRRFQ1EU2Ox2tI0YBZblQVE0CCEgigxZFgYtR+AsDkw55mLYnPV5b9+0aROWLFmCH//4x/jJT35yyAtZIdx///149NFHsWfPHgAHb5f9u9/9Dr/61a/w1FNP4bzzzsOzzz6L8847ryqPbcIYvtHFzCj279+f5T/Y2dmJxYsX44UXXsCCBQswcuRIU892CJBIJPRMtpdffhksy+qZbCeddJKhHdRAdHZ24It176OtnoWS9JVthDzYQgaowZ0Mq4ZwCoKA/fv2gqbV/R8FwG53wOl0wGq1VaWocLwdU469GDZnQ97bt27dijPOOAM333wzfv7znw/bQgYA//7v/4433ngD//jHPwAcvF12IpHAuHHj4PP58MADD+DWW2+tyuOaMI5v9JjRKAYmz2pjpwkTJmDkyJEAgEWLFmH69Om47LLLdD3bj370I1x99dVmIRsiWK1WLFmyBEuWLIEoinjvvffwwgsv4Hvf+x5kWc7KZDOi9evs7MT27TtwzAmLUV9fD0IIIv52+Lt3wN+9s6RGrJxCRlEUGM6qhoRSFEAARZFSom8Riizm7MgIgS7S9vl6QIiiO93b7ba8Iu1SYHkbphxzUcFCtn37dixduhTXXnvtsC9ku3fvxn//93/jgQce0H92sHbZVqsVCxcuxIEDB8xCdohgEkCqBIZhsGrVKlitVpx44om44IILsHz5cn12bwTDYaF9uILjOHznO9/BY489ho6ODrzwwgtwOBy44YYbMHbsWFx99dV49dVXkUjkz1Jrb2/H9u3bcfTRR6dMg9WC46obhdHTTsPsU36Iacf9f2gZd2zenVI+sodqXsyDszhgsbnB29zgLA7QDAdCCCQhDiERgRAPQ0iEIQlxPU06H9mDoijYbDY0NDRgzJjRaG1tBcMw6Ovrw969+9Dd3Y1IJGKYIMNyVkyZfyFsrsa8t3/11VdYunQpLr/8cvz6178+aIXsl7/8ZSpZvPA/rfPS0NnZidNPPx3nn38+fvCDH2TddrB22V988QUWLFhQ1cc0YRzmmHEY4Y033sBzzz2Hiy++OGuhfdlll2UttE1xtnHIsoyPP/5Yt9Xq7+/H6aefjuXLl+M73/kOHA4HHnjgATQ3N2PJkiWora019LjRkBd+7w4EundCVmQQWQTFMAAoQFH0LquSr1f5rMW0IXAkEoUoihlO9/lF2iyn0u8d7vzC5q+//hpnnHEGli9fjgcffLAiWUSlMLrLtlpV5/7Ozk4sXLgQCxYswFNPPZV1rAdrzBiPx+FyufDMM8+YSRyHCGYxG+Y4VAvtIxGKouDzzz/XC1tnZydGjRqFvXv34tlnn8WZZ55Z0ePGwz2p6JodiIV7BnWM1dCRiWLa6T6ZFGCzpUXaDMOCYXlMnn8hnJ62vL+/f/9+nH766Tj99NPxyCOPHNRCVi46OjqwcOFCzJs3D88++2xO4T5Yu+yPP/4YJ5xwArZv344pU6ZU5TFNlIfh+yk1AQAIBoOoq6vT/98MG60cNE1jwYIF+I//+A/s2LEDV155Jfbt24eWlhZcdtlluPDCC/G///u/CAQCZXVUNlcj2iaeiBknfg+zvnU1Rk4+BY6a8q2cqiWI5jgeHk8tRowYidGjR8FutyMSiWDfvv3o8vpgbzkBjCV/B9rZ2YmlS5fi29/+Nh5++OFhXcg6Oztx6qmnYtSoUfjNb36Dnp4eeL3erF1Y5i57w4YNWLNmzZDsstevXw+n04lJkyZV7TFNlAezMxvG2L17N+bOnYsHHnhA3wOYYaPVwS9/+Us8/PDDePvttzF79mxs3bpVz2TbsWNHViZbXV1dRfsVzQjZ792BaLCzaIEcSosqDQQ0akefilCcht/vh9PpRFOTmtY9btw4eL1enHHGGTj22GPx1FNPVcVDcijx1FNP4aqrrsp7W+Z7XU1vVhPDF2YxOwgwKs7OdBfp7OzEKaecglNOOQV/+MMf9J+bYaPVwR/+8Accf/zxWYbUgHoS3LlzJ1asWIGVK1di06ZN+Na3vqVnsmkn/3JRzAj5YBQymmExad75cNepzFxRFNHT04Ouri6cffbZcDqdiMVimD9/Pl599dWKZA0mTBxKmMXsIOBwXGibUAvbnj17sjLZTjjhBCxbtgxnn3224Uy2gcg0Qu7v3o2OjgNDX8jmngd3/di8t3/99ddYvHgxCCEIhUJobGzEueeeix/84AeYOnVq1Y/HhImhgFnMhhmGy0LbRDYIIThw4ICeybZ27Vocc8wxenTN6NGjyy5s8Xgcn326Fg4uhhprEqH+vWUbIZcCzTCYOOc81DSMy3t7IBDA0qVLMWLECKxYsQKKouDtt9/GihUrcOGFF+L000+v6vGYMDFUMIvZMII2Whw9ejT+53/+J6uQadlQ1Q4bNVE+CCHo6urSM9k+/PBDHHXUUXphmzBhQsnCFo/H8Y9//AONjY2YMmUKKIqCLCUR7NmD/u4dCPXugSyJRR+jFGiawYQ558DTOCHv7aFQCGeffTbq6urw4osv6pMBEyYOR5jFbBjhYC+0H3nkEdx///3o6urCjBkz8OCDD+Jb3/rWoF7DNw1aJptW2N59911MmzYNy5Ytw/Lly/VClYl8hWwgShkhlwJNM5hw9DJ4mvKz6yKRCM455xxYrVa8+uqrsNlsZT2+CRPDDWYx+4biueeew2WXXYZHHnkEJ554Ih577DH84Q9/wLZt23Lsu0wYg5bJ9tJLL2HFihV4++23MX78eD2Tbfr06di1axd+97vf4frrr8fUqVMNjSYHGiFLYn4XEw0URWPC0Wejtjm/3ikWi+kmuKtWraooFWCokEwmsWDBAmzatCkrLxBQL+JuuOGGnIs4I1ZlJo58mMXsG4oFCxZg7ty5ePTRR/WfTZs2DcuXL8e99957CI/syEEwGMQrr7yClStX4o033kBTUxN6e3txwgkn4IUXXqjI4Z8oCsL+/fB7d8Dv25VjhExRNMYfdRbqWvITN+LxOC688ELEYjG88cYbw27Hesstt2DXrl14/fXXs4qZ6XxjohTMYvYNhCAIsNvteP7553HOOefoP7/llluwceNGvP/++4fw6I5MbNmyBQsXLoTb7UZ3dzcaGxuzMtkqEScPNEIWkxGMm7UU9W3T894/mUzikksuQV9fH1avXg2PxzPIV1VdvP7667jtttuwYsUKzJgxI6uYmc43Jkph+Mr7TQwZent7Ictyjpt4c3OzmYo9BNi7dy+WLl2Kiy66CF999RV8Ph9++9vfoq+vD+eccw6mTZuGH/3oR/joo48gl8FmHGiEPOvkawsWMkEQcPnll8Pr9eKNN94YdoWsu7sbV199NZ555hnY7fac203nGxOlYBazbzAG7mvMVOyhgd1uxw9/+EM89NBDoCgKdrsd55xzDp599ll4vV48+uijiMfjuPjiizF58mTccssteO+99yCKxtmMFEXBYqvJe5soivj+97+vO8dk2qMNBxBCcOWVV+K6667LMg7IxMGKcjFx+MIsZt9ANDQ0gGGYnJOAz+fLOWGYGDyampoKpjNbrVYsXboUTz75JLxeL55++mlQFIWrrroKEydOxPXXX4+33nqr4ogfSZJw7bXX4ssvv8Tbb7+Nxsb8cS9DAaNRLv/93/+NUCiE22+/vejjHawoFxOHJ8xi9g0Ez/OYN28e3nrrrayfv/XWWzjhhBMO0VGZ4DgOixYtwuOPP46Ojg789a9/hd1ux/XXX49x48bhmmuuwapVqwpmsg2ELMu48cYbsX79erz99tsH/ULlxhtvxJdffln038yZM/HOO+/gk08+gcViAcuymDhxIgBg/vz5uOKKKwCoOsuBF19+vx+iKJoXYCYAmASQbyw0av7vf/97HH/88Xj88cfxxBNPYOvWrRgzZsyhPjwTGZBlGWvXrtVttQKBAE4//XQsW7YMixYtyrtjUhRFH1e+++67w1pusX//foRC6WDTzs5OLF68GC+88AIWLFiAkSNHms43JkqDmPjG4uGHHyZjxowhPM+TuXPnkvfff3/Qj3nPPfeQ+fPnE6fTSRobG8myZcvI9u3bs+6jKAr5xS9+QVpbW4nVaiWnnHIK2bJly6Cf+5sAWZbJxx9/TH70ox+RCRMmEIfDQZYvX06eeuop4vV6STQaJeFwmFx33XVkzJgxZM+ePYf6kMvG119/TQCQDRs26D+TJInMnDmTfPvb3ybr168nb7/9Nhk5ciS58cYbD92BmhhWMIuZiapi8eLF5MknnyRbtmwhGzduJEuWLCGjR48mkUhEv8//+3//j7hcLrJixQqyefNmcuGFF5LW1lYSCoUO4ZEffpBlmaxbt47cfvvtZMqUKcRqtZIlS5aQRYsWkba2NrJr165DfYgVIV8xI4SQffv2kSVLlhCbzUbq6urIjTfeSBKJxKE5SBPDDuaY0cSQoqenB01NTXj//fdx8skngxCCtrY23HrrrfjJT34CQNU/NTc347777sO11157iI/48AQhBFu2bMEzzzyDRx55BO+9915BZqAJE0ciTAKIiSFFMBgEAJ0O/vXXX8Pr9WLRokX6fSwWC0455RSsXbv2kBzjkQCKojBr1iz8x3/8B0KhkFnITHzjYBYzE0MGQghuu+02nHTSSZg5cyYA6Iw0U7A9dKjETcSEicMd5ZvDmTBhEDfeeCO++OILfPTRRzm3mYJtEyZMVBPmJZyJIcFNN92El19+Ge+++y5Gjhyp/1zLZTMF2yZMmKgmzGJmoqoghODGG2/EypUr8c4772DcuOyE43HjxqGlpSVLsC0IAt5//31TsG3ChImKYRYzE1XFDTfcgGeffRZ//vOf4XK54PV64fV6EY/HAajjxVtvvRX33HMP/va3v2HLli248sorYbfbcckllxziozcxWKxatQoLFiyAzWZDQ0MDzj333Kzb9+/fj7POOgsOhwMNDQ24+eabK7bqMmEiC4dQFmDiCASAvP+efPJJ/T6aaLqlpYVYLBZy8sknk82bNw/qee+55x4CgNxyyy05z2OKsw8OXnjhBVJbW0seffRRsmPHDrJ9+3by/PPP67drwueFCxeS9evXk7feeou0tbWZwmcTVYFZzA5zyLJMpkyZQn784x9n/fyNN94gHMeRv/71r4foyA4ePvvsMzJ27Fgye/bsrGJmirMPHkRRJCNGjCB/+MMfCt7ntddeIzRNk46ODv1n//d//0csFgsJBoMH4zBNHMEwx4yHOWiaxu23345HH30Ufr8fALBp0yacf/75uOeee3D++ecf4iMcWkQiEVx66aV44oknUFtbq/+cEIIHH3wQP/vZz3Duuedi5syZePrppxGLxfDnP//5EB7xkYn169ejo6MDNE1jzpw5aG1txRlnnIGtW7fq9zEzyUwMJcxidgTg0ksvRUNDAx566CG0t7djyZIluOyyy/CjH/3oUB/akOOGG27AkiVLcNppp2X93BRnH1zs2bMHgBr78u///u949dVXUVtbi1NOOQX9/f0AzEwyE0MLs5gdAWBZFj/5yU/w0EMP4cwzz8TcuXPx0EMPHerDGnL85S9/wfr163Hvvffm3GaKs6sDo5lkiqIAAH72s5/hvPPOw7x58/Dkk0+Coig8//zz+uOZmWQmhgqmaPoIwaWXXopbb70VhBD83//9HxiGOdSHNKQ4cOAAbrnlFqxevRpWq7Xg/Uxx9uBw44034qKLLip6n7FjxyIcDgMApk+frv/cYrFg/Pjx2L9/PwBVY/jpp59m/a6ZSWaiWjCL2RGCG2+8EQDQ29t7xBcyAFi3bh18Ph/mzZun/0yWZXzwwQf43e9+hx07dgBQOzQt/wowxdnloqGhAQ0NDSXvN2/ePFgsFuzYsQMnnXQSAEAURezdu1fPxzv++ONx9913o6urS/+brF69GhaLJevvaMJEJTDHjEcAfv7zn2PVqlX45JNPIEkS/vjHPx7qQxpyfPvb38bmzZuxceNG/d/8+fNx6aWXYuPGjRg/frwpzj6IcLvduO666/CLX/wCq1evxo4dO/DDH/4QAHQS0qJFizB9+nRcdtll2LBhA9asWYMf/ehHuPrqq81wTRODx6ElU5oYLJ544glis9nIxx9/TAgh5K677iKjR48mgiAc4iM7+DjllFNyqPk1NTVk5cqVZPPmzeTiiy82qflDCEEQyL/8y7+QpqYm4nK5yGmnnZaj6zMzyUwMFcxidhjjtddeIzzPkxUrVug/CwaDxOPxkD/+8Y+H8MgODQYWs2qLs9vb28mll15K6urqiM1mI0cddRT5xz/+kfN8pkjbhImDDzOc8zDFunXrcMopp+Duu+/GLbfcknXbHXfcgb/85S/48ssvvxH7s4MBv9+POXPmYOHChfjhD3+IpqYm7N69G2PHjsWECRMAAPfddx/uvvtuPPXUU5g8eTLuuusufPDBB9ixYwdcLtchfgUmTBzZMIuZCRMG8NOf/hR///vf8eGHH+a9nZgJ2iZMHFKYBBATJgzg5Zdfxvz583H++eejqakJc+bMwRNPPKHfboq0TZg4tDCLmQkTBrBnzx48+uijmDRpEt58801cd911uPnmm/E///M/AEyRtgkThxqmzsyECQNQFAXz58/HPffcAwCYM2cOtm7dikcffRSXX365fj9TpG3CxKGB2ZmZMGEAra2tWe4WADBt2rQsdwvATNA2YeJQwSxmJkwYwIknnqi7imjYuXOn7m5hJmibMHFoYY4ZTZgwgH/+53/GCSecgHvuuQcXXHABPvvsMzz++ON4/PHHAWQnaE+aNAmTJk3CPffcYyZomzBxkGBS802YMIhXX30Vt99+O3bt2oVx48bhtttuw9VXX63fTgjBnXfeicceewx+vx8LFizAww8/jJkzZx7CozZh4psBs5iZMGHChInDHubOzIQJEyZMHPYwi5kJEyZMmDjsYRYzEyZMmDBx2MMsZiZMmDBh4rCHWcxMmDBhwsRhD7OYmTBhwoSJwx5mMTNhwoQJE4c9zGJmwoQJEyYOe5jFzIQJEyZMHPYwi5kJEyZMmDjsYRYzEyZMmDBx2MMsZiZMmDBh4rDH/w/7h1IgO8CZmQAAAABJRU5ErkJggg==",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
@@ -319,7 +299,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+   "version": "3.12.5"
   },
   "toc": {
    "base_numbering": 1,
diff --git a/example_scripts/pysimulation_exhaustive_demo.py b/example_scripts/pysimulation_exhaustive_demo.py
index ab0783dc5..b87643d06 100644
--- a/example_scripts/pysimulation_exhaustive_demo.py
+++ b/example_scripts/pysimulation_exhaustive_demo.py
@@ -57,7 +57,7 @@
 
 tls_pos = np.array([[0, -10, 0]])
 
-pyhelios.setDefaultRandomnessGeneratorSeed("42")
+pyhelios.default_rand_generator_seed("42")
 # Build multiple simulations
 
 angles = np.arange(0, 90, 10)
@@ -106,30 +106,31 @@
     simBuilder.setFullwaveNoise(False)
     simBuilder.setPlatformNoiseDisabled(True)
     sim = simBuilder.build()
-
-    detector = sim.getScanner().getDetector()
+    
+    detector = sim.getScanner().detector
     detector.accuracy = 0.005
 
     for i in tqdm.tqdm(range(5)):
         sim0 = sim.sim.copy()
         sim0.start()
-        meas = sim0.join().measurements
+        meas = sim0.join()[0]
+        
 
         sim1 = sim.sim.copy()
         sim1.start()
-        meas1 = sim1.join().measurements
+        meas1 = sim1.join()[0]
 
         del sim1
         del sim0
 
-        points = [[meas[m].getPosition().x,
-                  meas[m].getPosition().y,
-                  meas[m].getPosition().z] for m in range(len(meas))]
+        points = [[meas[m].position[0],
+                  meas[m].position[1],
+                  meas[m].position[2]] for m in range(len(meas))]
         points = np.array(points)
         points = points[np.linalg.norm(points, axis=1) < 1, :]  # 1 m searchrad, "corepoint" at
-        points1 = [[meas1[m].getPosition().x,
-                  meas1[m].getPosition().y,
-                  meas1[m].getPosition().z] for m in range(len(meas1))]
+        points1 = [[meas1[m].position[0],
+                  meas1[m].position[1],
+                  meas1[m].position[2]] for m in range(len(meas1))]
         points1 = np.array(points1)
         points1 = points1[np.linalg.norm(points1, axis=1) < 1, :]
 
diff --git a/example_scripts/pysimulation_heavy_multirun_demo.py b/example_scripts/pysimulation_heavy_multirun_demo.py
index c53f2a4cd..a843954c8 100644
--- a/example_scripts/pysimulation_heavy_multirun_demo.py
+++ b/example_scripts/pysimulation_heavy_multirun_demo.py
@@ -21,24 +21,24 @@ def callback(output=None):
         global cycleMeasurementsCount
         global cp1
         global cpn
-        measurements = output.measurements
+        measurements = output[0]
 
         # Set 1st cycle point
         if cycleMeasurementsCount == 0 and len(measurements) > 0:
-            pos = measurements[0].getPosition()
-            cp1.append(pos.x)
-            cp1.append(pos.y)
-            cp1.append(pos.z)
+            pos = measurements[0].position
+            cp1.append(pos[0])
+            cp1.append(pos[1])
+            cp1.append(pos[2])
 
         # Update cycle measurement count
         cycleMeasurementsCount += len(measurements)
 
         # Update last cycle point
         if len(measurements) > 0:
-            pos = measurements[len(measurements)-1].getPosition()
-            cpn[0] = pos.x
-            cpn[1] = pos.y
-            cpn[2] = pos.z
+            pos = measurements[len(measurements)-1].position
+            cpn[0] = pos[0]
+            cpn[1] = pos[1]
+            cpn[2] = pos[2]
 
         # Notify for conditional variable
         cv.notify()
@@ -49,8 +49,8 @@ def callback(output=None):
 if __name__ == '__main__':
     # Configure simulation context
     # pyhelios.loggingVerbose2()
-    pyhelios.loggingQuiet()
-    pyhelios.setDefaultRandomnessGeneratorSeed("123")
+    pyhelios.logging_quiet()
+    pyhelios.default_rand_generator_seed("123")
 
     # Build reference simulation
     print('>> Creating base/reference simulation\n')
@@ -78,11 +78,11 @@ def callback(output=None):
         # Run the simulation
         print('>> Running simulation {i}'.format(i=i+1))
         sim_curr = sim0.sim.copy()
-        for j in range(sim_curr.getNumLegs()):
-            leg = sim_curr.getLeg(j)
-            leg.getScannerSettings().pulseFreq += i * 50000
-        print('Pulse frequency: {f} '.format(f=leg.getScannerSettings().pulseFreq))
-        sim_curr.callbackFrequency += i
+        for j in range(sim_curr.num_legs):
+            leg = sim_curr.get_leg(j)
+            leg.scanner_settings.pulse_frequency += i * 50000
+        print('Pulse frequency: {f} '.format(f=leg.scanner_settings.pulse_frequency))
+        sim_curr.callback_frequency += i
         cycleMeasurementsCount = 0
         cp1 = []
         cpn = [0, 0, 0]
@@ -91,25 +91,25 @@ def callback(output=None):
         # Join simulation thread
         with cv:  # Conditional variable necessary for callback mode only
             output = sim_curr.join()
-            while not output.finished:  # Loop necessary for callback mode only
+            while not output[4]:  # Loop necessary for callback mode only
                 cv.wait()
                 output = sim_curr.join()
 
         # Digest output
-        measurements = output.measurements
-        trajectories = output.trajectories
+        measurements = output[0]
+        trajectories = output[1]
         print('\tSimulation {i}:'.format(i=i+1))
         print('\t\tnumber of measurements : {n}'.format(n=len(measurements)))
         print('number of trajectories: {n}'.format(n=len(trajectories)))
-        p1Pos = measurements[0].getPosition()
-        pnPos = measurements[len(measurements)-1].getPosition()
+        p1Pos = measurements[0].position
+        pnPos = measurements[len(measurements)-1].position
         print('\t\tp1 position  : ({x}, {y}, {z})'.format(
-            x=p1Pos.x, y=p1Pos.y, z=p1Pos.z))
+            x=p1Pos[0], y=p1Pos[1], z=p1Pos[2]))
         print('\t\tcp1 position : ({x}, {y}, {z})'.format(
             x=cp1[0], y=cp1[1], z=cp1[2]))
         print('\t\tpn position  : ({x}, {y}, {z})'.format(
-            x=pnPos.x, y=pnPos.y, z=pnPos.z))
+            x=pnPos[0], y=pnPos[1], z=pnPos[2]))
         print('\t\tcpn position : ({x}, {y}, {z})'.format(
             x=cpn[0], y=cpn[1], z=cpn[2]))
 
-        print("Simulated point clouds saved to {folder}".format(folder=str(Path(output.filepath).parent)))
+        print("Simulated point clouds saved to {folder}".format(folder=str(Path(output[2]).parent)))
diff --git a/example_scripts/pysimulation_light_multirun_demo.py b/example_scripts/pysimulation_light_multirun_demo.py
index d6449e607..0aed303f7 100644
--- a/example_scripts/pysimulation_light_multirun_demo.py
+++ b/example_scripts/pysimulation_light_multirun_demo.py
@@ -17,24 +17,24 @@ def callback(output=None):
         global cycleMeasurementsCount
         global cp1
         global cpn
-        measurements = output.measurements
+        measurements = output[0]
 
         # Set 1st cycle point
         if cycleMeasurementsCount == 0 and len(measurements) > 0:
-            pos = measurements[0].getPosition()
-            cp1.append(pos.x)
-            cp1.append(pos.y)
-            cp1.append(pos.z)
+            pos = measurements[0].position
+            cp1.append(pos[0])
+            cp1.append(pos[1])
+            cp1.append(pos[2])
 
         # Update cycle measurement count
         cycleMeasurementsCount += len(measurements)
 
         # Update last cycle point
         if len(measurements) > 0:
-            pos = measurements[len(measurements)-1].getPosition()
-            cpn[0] = pos.x
-            cpn[1] = pos.y
-            cpn[2] = pos.z
+            pos = measurements[len(measurements)-1].position
+            cpn[0] = pos[0]
+            cpn[1] = pos[1]
+            cpn[2] = pos[2]
 
         # Notify for conditional variable
         cv.notify()
@@ -45,8 +45,8 @@ def callback(output=None):
 if __name__ == '__main__':
     # Configure simulation context
     # pyhelios.loggingVerbose2()
-    pyhelios.loggingQuiet()
-    pyhelios.setDefaultRandomnessGeneratorSeed("123")
+    pyhelios.logging_quiet()
+    pyhelios.default_rand_generator_seed("123")
 
     # Build multiple simulations
     nSimulations = 3
@@ -66,14 +66,15 @@ def callback(output=None):
     # finished with no interleaved work
     simBuilder.setFinalOutput(True)
     simBuilder.setCallback(callback)
+
     sim0 = simBuilder.build()
     sims.append(sim0.sim)
 
     for i in range(1, nSimulations):  # Copies of first simulation
         sim_curr = sim0.sim.copy()
-        for j in range(sim_curr.getNumLegs()):
-            leg = sim_curr.getLeg(j)
-            leg.getScannerSettings().pulseFreq += i * 50000
+        for j in range(sim_curr.num_legs):
+            leg = sim_curr.get_leg(j)
+            leg.scanner_settings.pulse_frequency += i * 50000
         sims.append(sim_curr)
 
     print('>> Running {n} simulations\n'.format(n=len(sims)))
@@ -85,31 +86,31 @@ def callback(output=None):
         cycleMeasurementsCount = 0
         cp1 = []
         cpn = [0, 0, 0]
-        print('Pulse frequency: {f} '.format(f=simulation.getLeg(0).getScannerSettings().pulseFreq))
+        print('Pulse frequency: {f} '.format(f=simulation.get_leg(0).scanner_settings.pulse_frequency))
         simulation.start()
 
         # Join simulation thread
         with cv:  # Conditional variable necessary for callback mode only
             output = simulation.join()
-            while not output.finished:  # Loop necessary for callback mode only
+            while not output[4]:  # Loop necessary for callback mode only
                 cv.wait()
                 output = simulation.join()
 
         # Digest output
-        measurements = output.measurements
-        trajectories = output.trajectories
+        measurements = output[0]
+        trajectories = output[1]
         print('\tSimulation {i}:'.format(i=i+1))
         print('\t\tnumber of measurements : {n}'.format(n=len(measurements)))
         print('\t\tnumber of trajectories: {n}'.format(n=len(trajectories)))
-        p1Pos = measurements[0].getPosition()
-        pnPos = measurements[len(measurements)-1].getPosition()
+        p1Pos = measurements[0].position
+        pnPos = measurements[len(measurements)-1].position
         print('\t\tp1 position  : ({x}, {y}, {z})'.format(
-            x=p1Pos.x, y=p1Pos.y, z=p1Pos.z))
+            x=p1Pos[0], y=p1Pos[1], z=p1Pos[2]))
         print('\t\tcp1 position : ({x}, {y}, {z})'.format(
             x=cp1[0], y=cp1[1], z=cp1[2]))
         print('\t\tpn position  : ({x}, {y}, {z})'.format(
-            x=pnPos.x, y=pnPos.y, z=pnPos.z))
+            x=pnPos[0], y=pnPos[1], z=pnPos[2]))
         print('\t\tcpn position : ({x}, {y}, {z})'.format(
             x=cpn[0], y=cpn[1], z=cpn[2]))
 
-    print("Simulated point clouds saved to {folder}".format(folder=str(Path(output.filepath).parent)))
\ No newline at end of file
+    print("Simulated point clouds saved to {folder}".format(folder=str(Path(output[2]).parent)))
\ No newline at end of file
diff --git a/example_scripts/pysimulation_multiscanner_demo.py b/example_scripts/pysimulation_multiscanner_demo.py
index 95507fac7..16d7c10d5 100644
--- a/example_scripts/pysimulation_multiscanner_demo.py
+++ b/example_scripts/pysimulation_multiscanner_demo.py
@@ -15,24 +15,24 @@ def callback(output=None):
         global cycleMeasurementsCount
         global cp1
         global cpn
-        measurements = output.measurements
+        measurements = output[0]
 
         # Set 1st cycle point
         if cycleMeasurementsCount == 0 and len(measurements) > 0:
-            pos = measurements[0].getPosition()
-            cp1.append(pos.x)
-            cp1.append(pos.y)
-            cp1.append(pos.z)
+            pos = measurements[0].position
+            cp1.append(pos[0])
+            cp1.append(pos[1])
+            cp1.append(pos[2])
 
         # Update cycle measurement count
         cycleMeasurementsCount += len(measurements)
 
         # Update last cycle point
         if len(measurements) > 0:
-            pos = measurements[len(measurements)-1].getPosition()
-            cpn[0] = pos.x
-            cpn[1] = pos.y
-            cpn[2] = pos.z
+            pos = measurements[len(measurements)-1].position
+            cpn[0] = pos[0]
+            cpn[1] = pos[1]
+            cpn[2] = pos[2]
 
         # Notify for conditional variable
         pyhelios.PYHELIOS_SIMULATION_BUILD_CONDITION_VARIABLE.notify()
@@ -44,8 +44,8 @@ def callback(output=None):
     # Configure simulation context
     # pyhelios.loggingVerbose()
     # pyhelios.loggingVerbose2()
-    pyhelios.loggingQuiet()
-    pyhelios.setDefaultRandomnessGeneratorSeed("123")
+    pyhelios.logging_quiet()
+    pyhelios.default_rand_generator_seed("123")
 
     # Build a simulation
     simBuilder = pyhelios.SimulationBuilder(
@@ -72,10 +72,10 @@ def callback(output=None):
 
     # Multiscanner stuff
     sc = sim.getScanner()
-    for i in range(sc.getNumDevices()):
+    for i in range(sc.num_devices):
         print(
             'ScanningDevice[{i}] has id "{iid}"'.format(
-                i=i, iid=sc.getDeviceId(i)
+                i=i, iid=sc.get_specific_device_id(i)
             )
         )
 
@@ -95,20 +95,20 @@ def callback(output=None):
     output = sim.join()
 
     # Digest output
-    measurements = output.measurements
-    trajectories = output.trajectories
+    measurements = output[0]
+    trajectories = output[1]
     print('number of cycle measurements: {n}'.format(
         n=cycleMeasurementsCount))
     print('number of measurements : {n}'.format(n=len(measurements)))
     print('number of trajectories: {n}'.format(n=len(trajectories)))
-    p1Pos = measurements[0].getPosition()
-    pnPos = measurements[len(measurements)-1].getPosition()
+    p1Pos = measurements[0].position
+    pnPos = measurements[len(measurements)-1].position
     print('p1 position : ({x}, {y}, {z})'.format(
-        x=p1Pos.x, y=p1Pos.y, z=p1Pos.z))
+        x=p1Pos[0], y=p1Pos[1], z=p1Pos[2]))
     print('cp1 position : ({x}, {y}, {z})'.format(
         x=cp1[0], y=cp1[1], z=cp1[2]))
     print('pn position : ({x}, {y}, {z})'.format(
-        x=pnPos.x, y=pnPos.y, z=pnPos.z))
+        x=pnPos[0], y=pnPos[1], z=pnPos[2]))
     print('cpn position : ({x}, {y}, {z})'.format(
         x=cpn[0], y=cpn[1], z=cpn[2]))
 
diff --git a/example_scripts/pysimulation_quick_demo.py b/example_scripts/pysimulation_quick_demo.py
index 235b35d54..b5c783e87 100644
--- a/example_scripts/pysimulation_quick_demo.py
+++ b/example_scripts/pysimulation_quick_demo.py
@@ -15,24 +15,24 @@ def callback(output=None):
         global cycleMeasurementsCount
         global cp1
         global cpn
-        measurements = output.measurements
+        measurements = output[0]
 
         # Set 1st cycle point
         if cycleMeasurementsCount == 0 and len(measurements) > 0:
-            pos = measurements[0].getPosition()
-            cp1.append(pos.x)
-            cp1.append(pos.y)
-            cp1.append(pos.z)
+            pos = measurements[0].position
+            cp1.append(pos[0])
+            cp1.append(pos[1])
+            cp1.append(pos[2])
 
         # Update cycle measurement count
         cycleMeasurementsCount += len(measurements)
 
         # Update last cycle point
         if len(measurements) > 0:
-            pos = measurements[len(measurements)-1].getPosition()
-            cpn[0] = pos.x
-            cpn[1] = pos.y
-            cpn[2] = pos.z
+            pos = measurements[len(measurements)-1].position
+            cpn[0] = pos[0]
+            cpn[1] = pos[1]
+            cpn[2] = pos[2]
 
         # Notify for conditional variable
         pyhelios.PYHELIOS_SIMULATION_BUILD_CONDITION_VARIABLE.notify()
@@ -42,10 +42,10 @@ def callback(output=None):
 # ----------------- #
 if __name__ == '__main__':
     # Configure simulation context
-    pyhelios.loggingVerbose()
+    pyhelios.logging_verbose()
     # pyhelios.loggingVerbose2()
     # pyhelios.loggingQuiet()
-    pyhelios.setDefaultRandomnessGeneratorSeed("123")
+    pyhelios.default_rand_generator_seed("123")
 
     # Build a simulation
     simBuilder = pyhelios.SimulationBuilder(
@@ -85,20 +85,20 @@ def callback(output=None):
     output = sim.join()
 
     # Digest output
-    measurements = output.measurements
-    trajectories = output.trajectories
+    measurements = output[0]
+    trajectories = output[1]
     print('number of cycle measurements: {n}'.format(
         n=cycleMeasurementsCount))
     print('number of measurements : {n}'.format(n=len(measurements)))
     print('number of trajectories: {n}'.format(n=len(trajectories)))
-    p1Pos = measurements[0].getPosition()
-    pnPos = measurements[len(measurements)-1].getPosition()
+    p1Pos = measurements[0].position
+    pnPos = measurements[len(measurements)-1].position
     print('p1 position : ({x}, {y}, {z})'.format(
-        x=p1Pos.x, y=p1Pos.y, z=p1Pos.z))
+        x=p1Pos[0], y=p1Pos[1], z=p1Pos[2]))
     print('cp1 position : ({x}, {y}, {z})'.format(
         x=cp1[0], y=cp1[1], z=cp1[2]))
     print('pn position : ({x}, {y}, {z})'.format(
-        x=pnPos.x, y=pnPos.y, z=pnPos.z))
+        x=pnPos[0], y=pnPos[1], z=pnPos[2]))
     print('cpn position : ({x}, {y}, {z})'.format(
         x=cpn[0], y=cpn[1], z=cpn[2]))
 
diff --git a/example_scripts/pysimulation_quick_demo_version_w_python_interface.py b/example_scripts/pysimulation_quick_demo_version_w_python_interface.py
new file mode 100644
index 000000000..2fd9706be
--- /dev/null
+++ b/example_scripts/pysimulation_quick_demo_version_w_python_interface.py
@@ -0,0 +1,54 @@
+import os
+import pyhelios
+import time
+import numpy as np
+from pyhelios.survey import Survey
+from pyhelios.primitives import SimulationCycleCallback
+
+# ---  M A I N  --- #
+# ----------------- #
+if __name__ == '__main__':
+    # Configure simulation context
+    pyhelios.logging_verbose()
+    pyhelios.default_rand_generator_seed("123")
+
+    # Build a simulation
+    survey = Survey.from_xml('data/surveys/toyblocks/als_toyblocks.xml')
+    survey.las_output = False
+    survey.zip_output = False
+    survey.final_output = True
+    survey.write_waveform = True
+    survey.calc_echowidth = True
+    survey.fullwavenoise = False
+    survey.is_platform_noise_disabled = True
+
+    
+    simulation_callback = SimulationCycleCallback() 
+    survey.callback = simulation_callback
+    survey.output_path = 'output/'
+    survey.run(num_threads=0, callback_frequency=10, export_to_file=False)
+
+   # survey.resume()
+    output = survey.join_output()
+
+    measurements = output[0]
+    trajectories = output[1]
+    print('number of measurements : {n}'.format(n=len(measurements)))
+    print('number of trajectories: {n}'.format(n=len(trajectories)))
+    p1Pos = measurements[0].position
+    pnPos = measurements[len(measurements)-1].position
+    print('p1 position : ({x}, {y}, {z})'.format(
+        x=p1Pos[0], y=p1Pos[1], z=p1Pos[2]))
+    print('pn position : ({x}, {y}, {z})'.format(
+        x=pnPos[0], y=pnPos[1], z=pnPos[2]))
+    # PyHelios Tools
+    npMeasurements, npTrajectories = pyhelios.outputToNumpy(output)
+    print('Numpy measurements shape:', np.shape(npMeasurements))
+    print('Numpy trajectories shape:', np.shape(npTrajectories))
+    coords = npMeasurements[:, 0:3]
+    spher = pyhelios.cartesianToSpherical(coords)
+    cart = pyhelios.sphericalToCartesian(spher)
+    print(
+        'Max precision loss due to coordinate translation:',
+        np.max(coords-cart)
+    )
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
old mode 100644
new mode 100755
index f3ba82083..e6470f33c
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -2,11 +2,12 @@
 requires = [
     "scikit-build-core",
     "setuptools_scm",
+    "pybind11[global]>=2.10.0",
 ]
 build-backend = "scikit_build_core.build"
 
 [project]
-name = "pyhelios"
+name = "helios"
 dynamic = ["version"]
 description = "The HELIOS++ Virtual Laser Scanning Simulator"
 readme = "README.md"
@@ -42,11 +43,14 @@ CMAKE_INSTALL_RPATH_USE_LINK_PATH = "ON"
 [tool.setuptools_scm]  # Section required
 write_to = "python/pyhelios/_version.py"
 
+[tool.cibuildwheel]
+# Super-verbose output for debugging purpose
+build-verbosity = 3
+# Testing commands for our wheels
+test-command = "PYTHONPATH=$(pwd)/python pytest {package}/tests/python"
+test-requires = ["pytest", "ruptures"]
 [tool.pytest.ini_options]
-markers = [
-    "exe: mark tests for the command line tool",
-    "pyh: mark tests for the python bindings pyhelios",
-]
 testpaths = [
+    "tests/python",
     "pytests",
 ]
diff --git a/pytests/test_demo_scenes.py b/pytests/test_demo_scenes.py
index 497875c7c..c06efb383 100644
--- a/pytests/test_demo_scenes.py
+++ b/pytests/test_demo_scenes.py
@@ -20,7 +20,7 @@
 WORKING_DIR = os.getcwd()
 
 
-def find_playback_dir(survey_path):
+def find_playback_dir(survey_path):    
     playback = Path(WORKING_DIR) / 'output'
     with open(Path(WORKING_DIR) / survey_path, 'r') as sf:
         for line in sf:
@@ -46,7 +46,7 @@ def run_helios_executable(survey_path: Path, options=None) -> Path:
 
 def run_helios_pyhelios(survey_path: Path, las_output: bool = True, zip_output: bool = False,
                         start_time: str = None, split_by_channel: bool = False, las10: bool = False) -> Path:
-    pyhelios.setDefaultRandomnessGeneratorSeed("43")
+    pyhelios.default_rand_generator_seed("43")
     simB = pyhelios.SimulationBuilder(
         surveyPath=str(survey_path.absolute()),
         assetsDir=[str(Path("assets"))],
diff --git a/pytests/test_gpsStartTimeFlag.py b/pytests/test_gpsStartTimeFlag.py
index 7e1291167..b260dfcfb 100644
--- a/pytests/test_gpsStartTimeFlag.py
+++ b/pytests/test_gpsStartTimeFlag.py
@@ -24,7 +24,7 @@ def sha256sum(filename):
 def run_helios_pyhelios(survey_path: Path, options=None) -> Path:
     sys.path.append(WORKING_DIR)
     import pyhelios
-    pyhelios.setDefaultRandomnessGeneratorSeed("43")
+    pyhelios.default_rand_generator_seed("43")
     from pyhelios import SimulationBuilder
     simB = SimulationBuilder(
         surveyPath=str(survey_path.absolute()),
@@ -61,10 +61,11 @@ def test_gpsStartTimeFlag_exe():
     r1_sum = sha256sum(r1 / 'leg000_points.xyz')
     r2_sum = sha256sum(r2 / 'leg000_points.xyz')
     r3_sum = sha256sum(r3 / 'leg000_points.xyz')
-    # assert r2_sum == r3_sum
-    # assert r2_sum == '41313dfe46ed34fcb9733af03a4d5e52487fd4579014f13dc00c609b53813229' or \
-    #        r2_sum == '984cfbbc5a54ab10a566ea901363218f35da569dbab5cd102424ab27794074ae'  # linux checksum
-    # assert r1_sum != r2_sum
+    assert r2_sum == r3_sum
+   # Comment for now, as the checksums are different
+   # assert r2_sum == 'b74ffe17e057020ce774df749f8425700a928a5148bb5e6a1f5aeb69f607ae04' or \
+   #        r2_sum == '984cfbbc5a54ab10a566ea901363218f35da569dbab5cd102424ab27794074ae'  # linux checksum
+    assert r1_sum != r2_sum
 
     if DELETE_FILES_AFTER:
         shutil.rmtree(r1)
@@ -90,10 +91,10 @@ def test_gpsStartTimeFlag_pyh():
     r1_sum = sha256sum(r1 / 'leg000_points.xyz')
     r2_sum = sha256sum(r2 / 'leg000_points.xyz')
     r3_sum = sha256sum(r3 / 'leg000_points.xyz')
-    # assert r2_sum == r3_sum
-    # assert r2_sum == '41313dfe46ed34fcb9733af03a4d5e52487fd4579014f13dc00c609b53813229' or \
-    #        r2_sum == '984cfbbc5a54ab10a566ea901363218f35da569dbab5cd102424ab27794074ae'  # linux checksum
-    # assert r1_sum != r2_sum
+    assert r2_sum == r3_sum
+  #  assert r2_sum == 'b74ffe17e057020ce774df749f8425700a928a5148bb5e6a1f5aeb69f607ae04' or \
+  #         r2_sum == '984cfbbc5a54ab10a566ea901363218f35da569dbab5cd102424ab27794074ae'  # linux checksum
+    assert r1_sum != r2_sum
 
     if DELETE_FILES_AFTER:
         try:
diff --git a/pytests/test_pyhelios.py b/pytests/test_pyhelios.py
index 9a775fee2..8941a5eb0 100644
--- a/pytests/test_pyhelios.py
+++ b/pytests/test_pyhelios.py
@@ -104,7 +104,7 @@ def test_open_output_xyz_stripid(test_sim):
     sim = test_sim(survey_path, las_output=False, zip_output=False)
     sim.start()
     out = sim.join()
-    access_output(out.filepath, '.xyz')
+    access_output(out[2], '.xyz')
 
 
 def test_open_output_xyz(test_sim):
@@ -113,7 +113,7 @@ def test_open_output_xyz(test_sim):
     sim = test_sim(survey_path, las_output=False, zip_output=False)
     sim.start()
     out = sim.join()
-    access_output(out.filepath, '.xyz')
+    access_output(out[2], '.xyz')
 
 
 def test_open_output_laz_stripid(test_sim):
@@ -122,10 +122,10 @@ def test_open_output_laz_stripid(test_sim):
     sim = test_sim(survey_path, las_output=True, zip_output=True, las10=True)
     sim.start()
     out = sim.join()
-    v_minor, v_major = get_las_version(out.filepath)
+    v_minor, v_major = get_las_version(out[2])
     assert v_minor == 1
     assert v_major == 0
-    access_output(out.filepath, '.laz')
+    access_output(out[2], '.laz')
 
 
 def test_open_output_laz(test_sim):
@@ -134,10 +134,10 @@ def test_open_output_laz(test_sim):
     sim = test_sim(survey_path, las_output=True, zip_output=True)
     sim.start()
     out = sim.join()
-    v_minor, v_major = get_las_version(out.filepath)
+    v_minor, v_major = get_las_version(out[2])
     assert v_minor == 1
     assert v_major == 4
-    access_output(out.filepath, '.laz')
+    access_output(out[2], '.laz')
 
 
 def test_start_stop(test_sim):
@@ -162,34 +162,34 @@ def test_start_stop(test_sim):
 def test_templates(test_sim):
     """Test accessing template settings defined in a survey XML"""
     sim = test_sim(Path('data') / 'surveys' / 'toyblocks' / 'als_toyblocks.xml')
-    leg = sim.sim.getLeg(0)
-    ss = leg.getScannerSettings()
-    assert ss.hasTemplate()
-    ss_templ = ss.getTemplate()
-    ps = leg.getPlatformSettings()
-    assert ps.hasTemplate()
-    ps_templ = ps.getTemplate()
+    leg = sim.sim.get_leg(0)
+    ss = leg.scanner_settings
+    assert ss.has_template
+    ss_templ = ss.base_template
+    ps = leg.platform_settings
+    assert ps.has_template
+    ps_templ = ps.base_template
 
     assert ss_templ.id == 'scanner1'
-    assert ss_templ.active is True
-    assert ss_templ.pulseFreq == 300_000
-    assert ss_templ.trajectoryTimeInterval == 0.01
-    assert ss_templ.scanFreq == 200
-    assert ss_templ.scanAngle * 180 / np.pi == 20
+    assert ss_templ.is_active is True
+    assert ss_templ.pulse_frequency == 300_000
+    assert ss_templ.trajectory_time_interval == 0.01
+    assert ss_templ.scan_frequency == 200
+    assert ss_templ.scan_angle * 180 / np.pi == 20
     assert ps_templ.id == 'platform1'
-    assert ps_templ.movePerSec == 30
+    assert ps_templ.speed_m_s == 30
 
 
 def test_survey_characteristics(test_sim):
     """Test accessing survey characteristics (name, length)"""
     path_to_survey = Path('data') / 'surveys' / 'toyblocks' / 'als_toyblocks.xml'
     sim = test_sim(path_to_survey)
-    assert Path(sim.sim.getSurveyPath()) == Path(WORKING_DIR) / path_to_survey
-    survey = sim.sim.getSurvey()
+    assert Path(sim.sim.survey_path) == Path(WORKING_DIR) / path_to_survey
+    survey = sim.sim.survey
     assert survey.name == 'toyblocks_als'
-    assert survey.getLength() == 0.0
-    survey.calculateLength()
-    assert survey.getLength() == 400.0
+    assert survey.length == 0.0
+    survey.calculate_length()
+    assert survey.length == 400.0
 
 
 def test_scene():
@@ -198,7 +198,7 @@ def test_scene():
 
 def test_create_survey():
     """Test creating/configuring a survey with pyhelios"""
-    pyhelios.setDefaultRandomnessGeneratorSeed("7")
+    pyhelios.default_rand_generator_seed("7")
     test_survey_path = 'data/surveys/test_survey.xml'
 
     # default survey (missing platform and scanner definition and not containing any legs)
@@ -247,33 +247,34 @@ def test_create_survey():
     pulse_freq = 10_000
     scan_angle = 30 * np.pi / 180
     scan_freq = 20
-    shift = simB.sim.getScene().getShift()
+    shift = simB.sim.scene.shift
     for j, wp in enumerate(waypoints):
-        leg = simB.sim.newLeg(j)
-        leg.serialId = j
-        leg.getPlatformSettings().x = wp[0] - shift.x
-        leg.getPlatformSettings().y = wp[1] - shift.y
-        leg.getPlatformSettings().z = altitude - shift.z
-        leg.getPlatformSettings().movePerSec = speed
-        leg.getScannerSettings().trajectoryTimeInterval = 0.001
-        leg.getScannerSettings().pulseFreq = pulse_freq
-        leg.getScannerSettings().scanAngle = scan_angle
-        leg.getScannerSettings().scanFreq = scan_freq
+        leg = simB.sim.new_leg(j)
+        leg.serial_id = j
+        leg.platform_settings.x = wp[0] - shift[0]
+        leg.platform_settings.y = wp[1] - shift[1]
+        leg.platform_settings.z = altitude - shift[2]
+        leg.platform_settings.speed_m_s = speed
+        leg.scanner_settings.trajectory_time_interval = 0.001
+        leg.scanner_settings.pulse_frequency = pulse_freq
+        leg.scanner_settings.scan_angle = scan_angle
+        leg.scanner_settings.scan_frequency = scan_freq
         # scanner should only be active for legs with even ID
         if j % 2 != 0:
-            leg.getScannerSettings().active = False
-    survey = simB.sim.getSurvey()
-    survey.calculateLength()
+            leg.scanner_settings.is_active = False
+    survey = simB.sim.survey
+    survey.calculate_length()
 
     # check length of survery and number of legs
-    assert survey.getLength() == 1200.0
-    assert simB.sim.getNumLegs() == 10
+    assert survey.length == 1200.0
+    assert simB.sim.num_legs == 10
 
     simB.start()
     output = simB.join()
     meas, traj = pyhelios.outputToNumpy(output)
     # check length of output
     assert meas.shape == (9926, 17)
+    assert meas.shape == (9926, 17)
     assert traj.shape == (6670, 7)
     # compare individual points
     np.testing.assert_allclose(meas[100, :3], np.array([83.32, -66.44204, 0.03114649]))
@@ -289,33 +290,33 @@ def test_create_survey():
 def test_material(test_sim):
     """Test accessing material properties of a primitive in a scene"""
     sim = test_sim(Path('data') / 'surveys' / 'toyblocks' / 'als_toyblocks.xml')
-    scene = sim.sim.getScene()
-    prim0 = scene.getPrimitive(0)  # get first primitive
-    mat0 = prim0.getMaterial()
+    scene = sim.sim.scene
+    prim0 = scene.primitive(0)  # get first primitive
+    mat0 = prim0.material
     assert mat0.name == 'None'
-    assert mat0.isGround is True
-    assert Path(mat0.matFilePath) == Path.cwd() / 'data/sceneparts/basic/groundplane/groundplane.mtl'
+    assert mat0.is_ground is True
+    assert Path(mat0.mat_file_path) == Path.cwd() / 'data/sceneparts/basic/groundplane/groundplane.mtl'
     assert mat0.reflectance == 50.0
     assert mat0.specularity == 0.0
-    assert mat0.specularExponent == 0.0
+    assert mat0.specular_exponent == 0.0
     assert mat0.classification == 0
-    assert np.round(mat0.kd0, 2) == 0.20
+    assert np.isclose(mat0.diffuse_components[0], 0.20, atol=1e-2)
 
 
 def test_scanner(test_sim):
     """Test accessing scanner configurations with pyhelios"""
     path_to_survey = Path('data') / 'test' / 'als_hd_demo_tiff_min.xml'
     sim = test_sim(path_to_survey)
-    scanner = sim.sim.getScanner()
-    assert scanner.deviceId == 'leica_als50-ii'
-    assert scanner.averagePower == 4.0
-    assert scanner.beamDivergence == 0.00022
+    scanner = sim.sim.scanner
+    assert scanner.device_id == 'leica_als50-ii'
+    assert scanner.average_power == 4.0
+    assert scanner.beam_divergence == 0.00022
     assert scanner.wavelength * 1000000000 == 1064  # has to be converted from m to nm
     assert scanner.visibility == 23.0
-    assert scanner.numRays == 19  # for default beamSampleQuality of 3
-    assert scanner.pulseLength_ns == 10.0
-    assert list(scanner.getSupportedPulseFrequencies()) == [20000, 60000, 150000]
-    assert scanner.toString() == """Scanner: leica_als50-ii
+    assert scanner.num_rays == 19  # for default beamSampleQuality of 3
+    assert scanner.pulse_length== 10.0
+    assert list(scanner.supported_pulse_freqs_hz) == [20000, 60000, 150000]
+    assert scanner.to_string() == """Scanner: leica_als50-ii
 Device[0]: leica_als50-ii
 	Average Power: 4 W
 	Beam Divergence: 0.22 mrad
@@ -328,12 +329,12 @@ def test_detector(test_sim):
     """Test accessing detector settings with pyhelios"""
     path_to_survey = Path('data') / 'test' / 'als_hd_demo_tiff_min.xml'
     sim = test_sim(path_to_survey)
-    scanner = sim.sim.getScanner()
-    detector = scanner.getDetector()
+    scanner = sim.sim.scanner
+    detector = scanner.detector
 
     assert detector.accuracy == 0.05
-    assert detector.rangeMin == 200
-    assert detector.rangeMax == 1700
+    assert detector.range_min == 200
+    assert detector.range_max == 1700
 
     scene_file = find_scene(path_to_survey)
     if os.path.isfile(scene_file):
@@ -348,7 +349,7 @@ def test_output(export_to_file):
     """Validating the output of a survey started with pyhelios"""
     from pyhelios import SimulationBuilder
     survey_path = Path('data') / 'test' / 'als_hd_demo_tiff_min.xml'
-    pyhelios.setDefaultRandomnessGeneratorSeed("43")
+    pyhelios.default_rand_generator_seed("43")
     simB = SimulationBuilder(
         surveyPath=str(survey_path.absolute()),
         assetsDir=WORKING_DIR + os.sep + 'assets' + os.sep,
@@ -369,10 +370,11 @@ def test_output(export_to_file):
 
     np.testing.assert_allclose(measurements_array[0, :3], np.array([474500.3, 5473580.0, 107.0001]), rtol=0.000001)
     assert measurements_array.shape == (2407, 17)
+    assert measurements_array.shape == (2407, 17)
     assert trajectory_array.shape == (9, 7)
     if export_to_file:
-        assert Path(output.outpath).parent.parent == Path(WORKING_DIR) / "output" / "als_hd_demo"
+        assert Path(output[2]).parent.parent == Path(WORKING_DIR) / "output" / "als_hd_demo"
         # cleanup
         if DELETE_FILES_AFTER:
-            print(f"Deleting files in {Path(output.outpath).parent.as_posix()}")
-            shutil.rmtree(Path(output.outpath).parent)
+            print(f"Deleting files in {Path(output[2]).parent.as_posix()}")
+            shutil.rmtree(Path(output[2]).parent)
diff --git a/python/helios/__init__.py b/python/helios/__init__.py
new file mode 100755
index 000000000..87ae8dfac
--- /dev/null
+++ b/python/helios/__init__.py
@@ -0,0 +1,9 @@
+# from helios.leg import Leg
+# from helios.platformsettings import PlatformSettings
+# from helios.scannersettings import ScannerSettings
+# from helios.platform import Platform
+# from helios.scanner import Scanner
+# from helios.survey import Survey
+# from helios.scenepart import ScenePart
+# from helios.scene import Scene
+# #from helios.util import * # change this to import only the necessary functions later
\ No newline at end of file
diff --git a/python/helios/helios_output.py b/python/helios/helios_output.py
new file mode 100644
index 000000000..9c7011f6e
--- /dev/null
+++ b/python/helios/helios_output.py
@@ -0,0 +1,26 @@
+# import _helios 
+
+# class HeliosOutput:
+#     def __init__(self, measurements, trajectories, outpath, outpaths, finished):
+      
+#         if isinstance(measurements, list):
+#             self.measurements = _helios.MeasurementVector(measurements)
+#         elif isinstance(measurements, _helios.MeasurementVector):
+#             self.measurements = measurements
+#         else:
+#             raise TypeError("Expected list or MeasurementVector for measurements")
+
+#         if isinstance(trajectories, list):
+#             self.trajectories = _helios.TrajectoryVector(trajectories)
+#         elif isinstance(trajectories, _helios.TrajectoryVector):
+#             self.trajectories = trajectories
+#         else:
+#             raise TypeError("Expected list or TrajectoryVector for trajectories")
+
+#         self.outpath = outpath
+#         self.outpaths = outpaths
+#         self.finished = finished
+
+#     def __del__(self):
+#         # Perform any necessary cleanup
+#         pass
diff --git a/python/helios/helios_python.cpp b/python/helios/helios_python.cpp
new file mode 100644
index 000000000..e3227ceb6
--- /dev/null
+++ b/python/helios/helios_python.cpp
@@ -0,0 +1,2208 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <pybind11/functional.h>
+#include <pybind11/stl_bind.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp> 
+
+#include <gdal_priv.h>
+
+#include <sim/comps/Survey.h>
+#include <sim/comps/Leg.h>
+#include <assetloading/ScenePart.h>
+#include <scanner/ScannerSettings.h>
+#include <platform/PlatformSettings.h>
+#include <scene/Scene.h>
+#include <platform/Platform.h>
+#include <platform/MovingPlatform.h>
+#include <platform/SimplePhysicsPlatform.h>
+#include <platform/LinearPathPlatform.h>
+#include <platform/GroundVehiclePlatform.h>
+#include <platform/HelicopterPlatform.h>
+#include <scanner/Scanner.h>
+#include <scanner/Trajectory.h>
+#include <platform/trajectory/TrajectorySettings.h>
+#include <scanner/FWFSettings.h>
+#include <scanner/Measurement.h>
+
+
+bool    logging::LOGGING_SHOW_TRACE,    logging::LOGGING_SHOW_DEBUG,
+        logging::LOGGING_SHOW_INFO,     logging::LOGGING_SHOW_TIME,
+        logging::LOGGING_SHOW_WARN,     logging::LOGGING_SHOW_ERR;
+
+
+namespace py = pybind11;
+
+using VectorString = std::vector<std::string>;
+
+PYBIND11_MAKE_OPAQUE(std::vector<std::string>);
+PYBIND11_MAKE_OPAQUE(std::vector<Measurement>);
+PYBIND11_MAKE_OPAQUE(std::vector<Trajectory>);
+
+#include <scanner/beamDeflector/AbstractBeamDeflector.h>
+#include <scanner/beamDeflector/OscillatingMirrorBeamDeflector.h>
+#include <scanner/beamDeflector/ConicBeamDeflector.h>
+#include <scanner/beamDeflector/FiberArrayBeamDeflector.h>
+#include <scanner/beamDeflector/PolygonMirrorBeamDeflector.h>
+#include <scanner/beamDeflector/RisleyBeamDeflector.h>
+#include <scene/primitives/Primitive.h>
+#include <scene/primitives/Triangle.h>
+#include <scene/primitives/Vertex.h>
+#include <scene/primitives/AABB.h>
+#include <scene/primitives/DetailedVoxel.h>
+#include <scanner/detector/AbstractDetector.h>
+#include <noise/NoiseSource.h>
+#include <noise/RandomnessGenerator.h>
+#include <scene/RaySceneIntersection.h>
+#include <sim/comps/SimulationCycleCallback.h>
+#include <scene/Material.h>
+#include <maths/Rotation.h>
+#include <maths/WaveMaths.h>
+#include <maths/model/BaseEnergyModel.h>
+#include <maths/model/ImprovedEnergyModel.h>
+#include <maths/model/EnergyModel.h>
+
+#include <DynObject.h>  
+#include <DynMovingObject.h>
+#include <DynScene.h>  
+
+#include <sim/core/SurveyPlayback.h>
+#include <scanner/ScanningDevice.h>
+#include <scanner/ScannerHead.h>
+#include <scanner/EvalScannerHead.h>
+#include <scanner/ScanningPulseProcess.h>
+#include <scanner/BuddingScanningPulseProcess.h>
+#include <scanner/WarehouseScanningPulseProcess.h>
+#include <scanner/MultiScanner.h>
+#include <scanner/SingleScanner.h>
+
+#include <filems/facade/FMSFacade.h>
+#include <filems/facade/FMSFactoryFacade.h>
+#include <filems/factory/FMSFacadeFactory.h>
+
+#include <scanner/detector/PulseThreadPoolInterface.h>
+#include <scanner/detector/PulseThreadPoolFactory.h>
+#include <scanner/detector/PulseWarehouseThreadPool.h>
+#include <scanner/detector/PulseTask.h>
+#include <scanner/detector/PulseTaskDropper.h>
+
+#include <adt/grove/KDGrove.h>
+#include <adt/grove/KDGroveFactory.h>
+#include <adt/kdtree/KDTreeFactory.h>
+#include <adt/kdtree/SimpleKDTreeFactory.h>
+#include <adt/kdtree/SimpleKDTreeGeometricStrategy.h>
+#include <adt/kdtree/MultiThreadKDTreeFactory.h>
+#include <adt/kdtree/SAHKDTreeGeometricStrategy.h>
+#include <adt/kdtree/SAHKDTreeFactory.h>
+#include <adt/kdtree/MultiThreadSAHKDTreeFactory.h>
+#include <adt/kdtree/AxisSAHKDTreeFactory.h>
+#include <adt/kdtree/AxisSAHKDTreeGeometricStrategy.h>
+
+#include <adt/kdtree/FastSAHKDTreeFactory.h>
+#include <adt/kdtree/FastSAHKDTreeGeometricStrategy.h>
+
+#include <sim/comps/ScanningStrip.h>
+#include <sim/core/Simulation.h>
+#include <assetloading/geometryfilter/WavefrontObj.h>
+#include <assetloading/Asset.h>
+#include <filems/facade/FMSFacade.h>
+#include <python/GLMTypeCaster.h>
+#include <python/ScannerWrap.h>
+#include <python/PyHeliosSimulation.h>
+#include <python/SimulationWrap.h>
+#include <python/NoiseSourceWrap.h>
+#include <python/AbstractDetectorWrap.h>
+#include <python/utils.h>
+#include <python/PrimitiveWrap.h>
+#include <python/AbstractBeamDeflectorWrap.h>
+#include <python/PulseThreadPoolInterfaceWrap.h>
+#include <python/ScanningPulseProcessWrap.h>
+#include <python/KDTreeFactoryWrapper.h>
+#include <python/EnergyModelWrap.h>
+
+using helios::filems::FMSFacadeFactory;
+
+namespace pyhelios{
+
+    PYBIND11_MODULE(_helios, m) {
+        m.doc() = "Helios python bindings";
+
+        py::bind_vector<std::vector<std::string>>(m, "StringVector");
+        py::bind_vector<std::vector<Measurement>>(m, "MeasurementList");
+        py::bind_vector<std::vector<Trajectory>>(m, "TrajectoryList");
+
+        py::implicitly_convertible<py::iterable, VectorString>();
+
+        logging::makeQuiet();
+        logging::configure({
+            {"type", "std_out"}
+        });
+
+        // Enable GDAL (Load its drivers)
+        GDALAllRegister();
+        if (GDALGetDriverCount() == 0) {
+            throw std::runtime_error("GDAL failed to initialize properly.");
+        }
+        
+        // Definitions
+        m.def("logging_quiet", &logging::makeQuiet, "Set the logging verbosity level to quiet");
+        m.def("logging_silent", &logging::makeSilent, "Set the logging verbosity level to silent");
+        m.def("logging_default", &logging::makeDefault, "Set the logging verbosity level to default");
+        m.def("logging_verbose", &logging::makeVerbose, "Set the logging verbosity level to verbose");
+        m.def("logging_verbose2", &logging::makeVerbose2, "Set the logging verbosity level to verbose 2");
+        m.def("logging_time", &logging::makeTime, "Set the logging verbosity level to time");
+
+        m.def("default_rand_generator_seed", &setDefaultRandomnessGeneratorSeed, "Set the seed for the default randomness generator");
+        
+
+        py::class_<Asset, std::shared_ptr<Asset>> asset(m, "Asset");
+        asset
+            .def_readwrite("id", &Asset::id)
+            .def_readwrite("name", &Asset::name);
+
+
+        py::class_<AbstractBeamDeflector, AbstractBeamDeflectorWrap, std::shared_ptr<AbstractBeamDeflector>> abstract_beam_deflector(m, "AbstractBeamDeflector");
+        abstract_beam_deflector
+            .def(py::init<double, double, double>(),
+            py::arg("scanAngleMax_rad"), py::arg("scanFreqMax_Hz"), py::arg("scanFreqMin_Hz"))
+            .def_readwrite("scan_freq_max",&AbstractBeamDeflector::cfg_device_scanFreqMax_Hz)
+            .def_readwrite("scan_freq_min",&AbstractBeamDeflector::cfg_device_scanFreqMin_Hz)
+            .def_readwrite("scan_angle_max",&AbstractBeamDeflector::cfg_device_scanAngleMax_rad)
+            .def_readwrite("scan_freq", &AbstractBeamDeflector::cfg_setting_scanFreq_Hz)
+            .def_readwrite("scan_angle", &AbstractBeamDeflector::cfg_setting_scanAngle_rad)
+            .def_readwrite("vertical_angle_min", &AbstractBeamDeflector::cfg_setting_verticalAngleMin_rad)
+            .def_readwrite("vertical_angle_max", &AbstractBeamDeflector::cfg_setting_verticalAngleMax_rad)
+            .def_readwrite("current_beam_angle", &AbstractBeamDeflector::state_currentBeamAngle_rad)
+            .def_readwrite("angle_diff_rad", &AbstractBeamDeflector::state_angleDiff_rad)
+            .def_readwrite("cached_angle_between_pulses", &AbstractBeamDeflector::cached_angleBetweenPulses_rad)
+            .def_property_readonly("emitter_relative_attitude",
+                                &AbstractBeamDeflector::getEmitterRelativeAttitudeByReference)
+            .def_property_readonly("optics_type", &AbstractBeamDeflector::getOpticsType)
+            .def("clone", &AbstractBeamDeflector::clone);
+
+        py::class_<OscillatingMirrorBeamDeflector, AbstractBeamDeflector, std::shared_ptr<OscillatingMirrorBeamDeflector>> oscillating_mirror_beam_deflector(m, "OscillatingMirrorBeamDeflector");
+        oscillating_mirror_beam_deflector
+            .def(py::init<double, double, double, int>(),
+            py::arg("scanAngleMax_rad"), py::arg("scanFreqMax_Hz"), py::arg("scanFreqMin_Hz"), py::arg("scanProduct"))
+
+            .def_readwrite("scan_product", &OscillatingMirrorBeamDeflector::cfg_device_scanProduct)
+            .def("clone", &OscillatingMirrorBeamDeflector::clone);
+
+        py::class_<ConicBeamDeflector, AbstractBeamDeflector, std::shared_ptr<ConicBeamDeflector>> conic_beam_deflector(m, "ConicBeamDeflector");
+        conic_beam_deflector
+            .def(py::init<double, double, double>(),
+            py::arg("scanAngleMax_rad"), py::arg("scanFreqMax_Hz"), py::arg("scanFreqMin_Hz"))
+            .def("clone", &ConicBeamDeflector::clone);
+        
+        py::class_<FiberArrayBeamDeflector, AbstractBeamDeflector, std::shared_ptr<FiberArrayBeamDeflector>> fiber_array_beam_deflector(m, "FiberArrayBeamDeflector");
+        fiber_array_beam_deflector
+            .def(py::init<double, double, double, int>(),
+            py::arg("scanAngleMax_rad"), py::arg("scanFreqMax_Hz"), py::arg("scanFreqMin_Hz"), py::arg("numFibers"))
+            .def_property("num_fibers", &FiberArrayBeamDeflector::getNumFibers, &FiberArrayBeamDeflector::setNumFibers)
+            .def("clone", &FiberArrayBeamDeflector::clone);
+
+        
+        py::class_<PolygonMirrorBeamDeflector, AbstractBeamDeflector, std::shared_ptr<PolygonMirrorBeamDeflector>> polygon_mirror_beam_deflector(m, "PolygonMirrorBeamDeflector");
+        polygon_mirror_beam_deflector
+            .def(py::init<double, double, double, double>(),
+            py::arg("scanAngleMax_rad"), py::arg("scanFreqMax_Hz"), py::arg("scanFreqMin_Hz"), py::arg("ScanAngleEffectiveMax_rad"))
+            .def_property_readonly("scan_angle_effective_max", &PolygonMirrorBeamDeflector::getScanAngleEffectiveMax_rad)
+            .def("clone", &PolygonMirrorBeamDeflector::clone);
+
+        
+        py::class_<RisleyBeamDeflector, AbstractBeamDeflector, std::shared_ptr<RisleyBeamDeflector>> risley_beam_deflector(m, "RisleyBeamDeflector");
+        risley_beam_deflector
+            .def(py::init<double, double, double>(),
+            py::arg("scanAngleMax_rad"), py::arg("rotorFreq_1_Hz"), py::arg("rotorFreq_2_Hz"))
+            .def_readwrite("rotor_speed_rad_1", &RisleyBeamDeflector::rotorSpeed_rad_1)
+            .def_readwrite("rotor_speed_rad_2", &RisleyBeamDeflector::rotorSpeed_rad_2)
+            .def("clone", &RisleyBeamDeflector::clone);
+
+           
+        py::class_<Primitive, PrimitiveWrap, std::shared_ptr<Primitive>> primitive(m, "Primitive");
+        primitive
+            .def(py::init<>())
+            
+            .def_property("scene_part", [](Primitive &prim) {
+                return prim.part.get();}, [](Primitive &prim, std::shared_ptr<ScenePart> part) {
+                prim.part = part;
+            })
+            .def_property("material", [](Primitive &prim) {
+                return prim.material.get();}, [](Primitive &prim, std::shared_ptr<Material> material) {
+                prim.material = material;
+            })
+
+            .def("incidence_angle",
+                [](Primitive &prim, const glm::dvec3& rayOrigin, const glm::dvec3& rayDir, const glm::dvec3& intersectionPoint) {
+                    return prim.getIncidenceAngle_rad(rayOrigin, rayDir, intersectionPoint);
+                }, py::arg("rayOrigin"), py::arg("rayDir"), py::arg("intersectionPoint"))
+            .def("ray_intersection", [](Primitive &prim, const glm::dvec3& rayOrigin, const glm::dvec3& rayDir) {
+                    const std::vector<double> &result = prim.getRayIntersection(rayOrigin, rayDir);
+                    return py::cast(result);
+                })
+            .def("ray_intersection_distance", [](Primitive &prim, const glm::dvec3& rayOrigin, const glm::dvec3& rayDir) {
+                    return prim.getRayIntersectionDistance(rayOrigin, rayDir);
+                })
+            .def("update", &Primitive::update)
+            .def("is_triangle", [](Primitive &prim) {
+                        return dynamic_cast<Triangle *>(&prim) != nullptr;
+                    })
+            .def("is_AABB", [](Primitive &prim) {
+                        return dynamic_cast<AABB *>(&prim) != nullptr;
+                    })
+            .def("is_voxel", [](Primitive &prim) {
+                        return dynamic_cast<Voxel *>(&prim) != nullptr;
+                    })
+            .def("is_detailed_voxel", [](Primitive &prim) {
+                        return dynamic_cast<DetailedVoxel *>(&prim) != nullptr;
+                    })
+            .def("clone", &Primitive::clone);
+
+        
+        py::class_<AABB, Primitive, std::shared_ptr<AABB>> aabb(m, "AABB");
+        aabb
+           
+            .def(py::init<>())  // Default constructor
+            .def(py::init<glm::dvec3, glm::dvec3>(), "Construct AABB from min and max vertices")
+            .def_property("vertices", 
+                [](const AABB& aabb) {
+                    return std::vector<Vertex>(aabb.vertices, aabb.vertices + 2); 
+                }, 
+                [](AABB& aabb, const std::vector<Vertex>& vertices) {
+                    if (vertices.size() != 2) {
+                        throw std::runtime_error("Vertices array must have exactly 2 elements.");
+                    }
+                    std::copy(vertices.begin(), vertices.end(), aabb.vertices); 
+                }, 
+                "Get and set the vertices of the AABB")
+            .def_property("bounds", 
+                [](const AABB& aabb) {
+                    return std::vector<glm::dvec3>(aabb.bounds, aabb.bounds + 2); 
+                }, 
+                [](AABB& aabb, const std::vector<glm::dvec3>& bounds) {
+                    if (bounds.size() != 2) {
+                        throw std::runtime_error("Bounds array must have exactly 2 elements.");
+                    }
+                    std::copy(bounds.begin(), bounds.end(), aabb.bounds); 
+                }, 
+                "Get and set the cached bounds of the AABB")
+            .def_property_readonly("min_vertex", [](AABB &aabb) { return &(aabb.vertices[0]); }, py::return_value_policy::reference)
+            .def_property_readonly("max_vertex", [](AABB &aabb) { return &(aabb.vertices[1]); }, py::return_value_policy::reference)
+            .def("__str__", &AABB::toString);
+
+
+        py::class_<DetailedVoxel, std::shared_ptr<DetailedVoxel>, Primitive> detailed_voxel(m, "DetailedVoxel");
+        detailed_voxel
+            .def(py::init<>())
+            .def(py::init<glm::dvec3, double, std::vector<int>, std::vector<double>>(),
+                py::arg("center"), py::arg("VoxelSize"), py::arg("intValues"), py::arg("doubleValues"))
+            
+            .def_property("nb_echos", &DetailedVoxel::getNbEchos, &DetailedVoxel::setNbEchos)
+            .def_property("nb_sampling", &DetailedVoxel::getNbSampling, &DetailedVoxel::setNbSampling)
+            .def_property_readonly("number_of_double_values", &DetailedVoxel::getNumberOfDoubleValues)
+            .def_property("max_pad", &DetailedVoxel::getMaxPad, &DetailedVoxel::setMaxPad)
+            .def("get_double_value", &DetailedVoxel::getDoubleValue, "Get the value at index")
+            .def("set_double_value", &DetailedVoxel::setDoubleValue, "Set the value at index", py::arg("index"), py::arg("value"));
+
+
+        py::class_<AbstractDetector, AbstractDetectorWrap,  std::shared_ptr<AbstractDetector>> abstract_detector(m, "AbstractDetector");
+        abstract_detector
+                 .def(py::init<
+                    std::shared_ptr<Scanner>, 
+                    double, 
+                    double, 
+                    double
+                >(), 
+                py::arg("scanner"), 
+                py::arg("accuracy_m"), 
+                py::arg("rangeMin_m"), 
+                py::arg("rangeMax_m") = std::numeric_limits<double>::max())
+      
+            .def_readwrite("accuracy", &AbstractDetector::cfg_device_accuracy_m)
+            .def_readwrite("range_min", &AbstractDetector::cfg_device_rangeMin_m)
+            .def_readwrite("range_max", &AbstractDetector::cfg_device_rangeMax_m)
+
+            .def_property("las_scale", [](AbstractDetector &self) {
+                    return self.getFMS()->write.getMeasurementWriterLasScale();},
+                [](AbstractDetector &self, double lasScale) {
+                    self.getFMS()->write.setMeasurementWriterLasScale(lasScale);})
+
+            .def("shutdown", &AbstractDetector::shutdown)
+                
+            .def("clone", &AbstractDetector::clone);
+
+
+        py::class_<FullWaveformPulseDetector, AbstractDetector, std::shared_ptr<FullWaveformPulseDetector>> full_waveform_pulse_detector(m, "FullWaveformPulseDetector");
+        full_waveform_pulse_detector
+            .def(py::init<
+                std::shared_ptr<Scanner>, 
+                double, 
+                double, 
+                double
+            >(), 
+            py::arg("scanner"), 
+            py::arg("accuracy_m"), 
+            py::arg("rangeMin_m"), 
+            py::arg("rangeMax_m") = std::numeric_limits<double>::max())
+            
+            .def("clone", &FullWaveformPulseDetector::clone);
+
+
+        py::class_<Triangle, std::shared_ptr<Triangle>, Primitive> triangle(m, "Triangle");
+        triangle
+            .def(py::init<Vertex, Vertex, Vertex>(), py::arg("v0"), py::arg("v1"), py::arg("v2"))
+            .def("__str__", &Triangle::toString)
+            .def("ray_intersection", &Triangle::getRayIntersection)
+
+            .def_property("vertices", 
+                [](const Triangle& tri) {
+                    return std::vector<Vertex>(tri.verts, tri.verts + 3); 
+                }, 
+                [](Triangle& tri, const std::vector<Vertex>& vertices) {
+                    if (vertices.size() != 3) {
+                        throw std::runtime_error("Vertices array must have exactly 3 elements.");
+                    }
+                    std::copy(vertices.begin(), vertices.end(), tri.verts); 
+                }, 
+                "Get and set the vertices of the Triangle")
+            .def_property_readonly("face_normal", &Triangle::getFaceNormal);
+
+
+        py::class_<Vertex, std::shared_ptr<Vertex>> vertex(m, "Vertex"); 
+        vertex
+            .def(py::init<>())
+            .def(py::init<double, double, double>(), py::arg("x"), py::arg("y"), py::arg("z"))
+
+            .def_property("position", [](Vertex &self) {
+                    return self.pos;
+                }, [](Vertex &self, const glm::dvec3 &position) {
+                    self.pos = position;
+            })
+            .def_readwrite("normal", &Vertex::normal)
+            .def_readwrite("tex_coords", &Vertex::texcoords)
+            .def("clone", &Vertex::copy);
+
+
+        py::class_<HeliosException>(m, "PyHeliosException")
+            .def(py::init<std::string const&>(), py::arg("msg")="");
+
+
+        py::class_<Trajectory, std::shared_ptr<Trajectory>> trajectory(m, "Trajectory");
+        trajectory
+            .def(py::init<>())
+            .def(py::init<double, glm::dvec3, double, double, double>())
+            .def_readwrite("gps_time", &Trajectory::gpsTime)
+            .def_readwrite("roll", &Trajectory::roll)
+            .def_readwrite("pitch", &Trajectory::pitch)
+            .def_readwrite("yaw", &Trajectory::yaw)
+            .def_property("position", [](Trajectory &self) {
+                    return self.position;
+                }, [](Trajectory &self, const glm::dvec3 &position) {
+                    self.position = position;
+            });
+
+
+        py::class_<TrajectorySettings, std::shared_ptr<TrajectorySettings>> trajectory_settings(m, "TrajectorySettings");
+        trajectory_settings
+            .def(py::init<>()) 
+            .def_readwrite("start_time", &TrajectorySettings::tStart)
+            .def_readwrite("end_time", &TrajectorySettings::tEnd)
+            .def_readwrite("teleport_to_start", &TrajectorySettings::teleportToStart);
+
+
+        py::class_<Measurement, std::shared_ptr<Measurement>> measurement(m, "Measurement");
+        measurement
+            .def(py::init<>())
+            .def(py::init<const Measurement &>())
+            
+            .def_readwrite("hit_object_id", &Measurement::hitObjectId)
+            .def_readwrite("beam_direction", &Measurement::beamDirection)
+            .def_readwrite("beam_origin", &Measurement::beamOrigin)
+            .def_readwrite("distance", &Measurement::distance)
+            .def_readwrite("intensity", &Measurement::intensity)
+            .def_readwrite("echo_width", &Measurement::echo_width)
+            .def_readwrite("return_number", &Measurement::returnNumber)
+            .def_readwrite("pulse_return_number", &Measurement::pulseReturnNumber)
+            .def_readwrite("fullwave_index", &Measurement::fullwaveIndex)
+            .def_readwrite("classification", &Measurement::classification)
+            .def_readwrite("gps_time", &Measurement::gpsTime)
+            .def_property("position", [](Measurement &self) {
+                    return self.position;
+                }, [](Measurement &self, const glm::dvec3 &position) {
+                    self.position = position;
+            })
+            ;
+
+
+        py::class_<RandomnessGenerator<double>> randomness_generator(m, "RandomnessGenerator");
+        randomness_generator
+            .def(py::init<>()) 
+            .def("compute_uniform_real_distribution", &RandomnessGenerator<double>::computeUniformRealDistribution)
+            .def("uniform_real_distribution_next", &RandomnessGenerator<double>::uniformRealDistributionNext)
+            .def("compute_normal_distribution", &RandomnessGenerator<double>::computeNormalDistribution)
+            .def("normal_distribution_next", &RandomnessGenerator<double>::normalDistributionNext);
+
+
+        py::class_<NoiseSource<double>, NoiseSourceWrap<double>> noise_source(m, "NoiseSource");
+        noise_source
+            .def(py::init<>())
+
+            .def_property("clip_min", 
+                        &NoiseSource<double>::getClipMin, 
+                        &NoiseSource<double>::setClipMin)
+            .def_property("clip_max", 
+                        &NoiseSource<double>::getClipMax, 
+                        &NoiseSource<double>::setClipMax)
+            .def_property("clip_enabled", 
+                        &NoiseSource<double>::isClipEnabled, 
+                        &NoiseSource<double>::setClipEnabled)
+            .def_property_readonly("fixed_value_enabled", 
+                                &NoiseSource<double>::isFixedValueEnabled)
+
+            .def_property("fixed_lifespan", 
+                        &NoiseSource<double>::getFixedLifespan, 
+                        &NoiseSource<double>::setFixedLifespan)
+            .def_property("fixed_value_remaining_uses", 
+                        &NoiseSource<double>::getFixedValueRemainingUses, 
+                        &NoiseSource<double>::setFixedValueRemainingUses)
+            .def("next", &NoiseSource<double>::next);
+
+
+        py::class_<RandomNoiseSource<double>, NoiseSource<double>, RandomNoiseSourceWrap<double>>(m, "RandomNoiseSource")
+            .def(py::init<>())
+
+            .def("get_random_noise_type", &RandomNoiseSource<double>::getRandomNoiseType)
+            .def("__str__", [](RandomNoiseSource<double> &self) {
+                std::ostringstream oss;
+                oss << self;
+                return oss.str();
+            });
+
+        
+        py::class_<UniformNoiseSource<double>, RandomNoiseSource<double>>(m, "UniformNoiseSource")
+            .def(py::init<double, double>(), py::arg("min") = 0.0, py::arg("max") = 1.0)
+        
+            .def_property("min", &UniformNoiseSource<double>::getMin, &UniformNoiseSource<double>::setMin)
+            .def_property("max", &UniformNoiseSource<double>::getMax, &UniformNoiseSource<double>::setMax)
+
+            .def("configure_uniform_noise", &UniformNoiseSource<double>::configureUniformNoise)
+            .def("noise_function", &UniformNoiseSource<double>::noiseFunction)
+            .def("get_random_noise_type", &UniformNoiseSource<double>::getRandomNoiseType)
+            .def("next", &UniformNoiseSource<double>::next)
+            .def("__str__", [](const UniformNoiseSource<double> &ns) {
+                std::ostringstream oss;
+                oss << ns;
+                return oss.str();
+            });
+        
+        
+        py::class_<RaySceneIntersection, std::shared_ptr<RaySceneIntersection>> ray_scene_intersection(m, "RaySceneIntersection");
+        ray_scene_intersection
+            .def(py::init<>())
+            .def(py::init<const RaySceneIntersection&>())
+            .def_property("primitive",
+                        [](RaySceneIntersection &self) { return self.prim; },
+                        [](RaySceneIntersection &self, Primitive* prim) { self.prim = prim; },
+                        py::return_value_policy::reference)
+            .def_property("point",
+                        [](RaySceneIntersection &self) { return self.point; }, 
+                        [](RaySceneIntersection &self, const glm::dvec3& point) { self.point = point; })
+            .def_property("incidence_angle",
+                        [](RaySceneIntersection &self) { return self.incidenceAngle; },
+                        [](RaySceneIntersection &self, double angle) { self.incidenceAngle = angle; });
+
+
+        py::class_<ScanningStrip, std::shared_ptr<ScanningStrip>> scanning_strip(m, "ScanningStrip");
+        scanning_strip
+            .def(py::init<const std::string&>()) 
+            .def_property("strip_id",
+                        &ScanningStrip::getStripId,
+                        &ScanningStrip::setStripId)
+            .def_property_readonly("is_last_leg_in_strip", &ScanningStrip::isLastLegInStrip)
+            .def("get_leg_ref", [](ScanningStrip& self, int serialId) -> Leg& {
+                Leg* leg = self.getLeg(serialId);
+                if (!leg) throw std::runtime_error("Leg not found");
+                return *leg;
+            }, py::return_value_policy::reference)
+            .def("has", py::overload_cast<int>(&ScanningStrip::has))
+            .def("has", py::overload_cast<Leg&>(&ScanningStrip::has));
+
+
+        py::class_<SimulationCycleCallback, PySimulationCycleCallback, std::shared_ptr<SimulationCycleCallback>> simulation_cycle_callback(m, "SimulationCycleCallback");
+        simulation_cycle_callback
+            .def(py::init<>())
+            .def("__call__", [](SimulationCycleCallback &callback,
+                            py::list measurements,
+                            py::list trajectories,
+                            const std::string &outpath) {
+                py::gil_scoped_acquire acquire;
+                auto measurements_vec = std::make_shared<std::vector<Measurement>>();
+                for (auto item : measurements) {
+                    measurements_vec->push_back(item.cast<Measurement>());
+                }
+
+                auto trajectories_vec = std::make_shared<std::vector<Trajectory>>();
+                for (auto item : trajectories) {
+                    trajectories_vec->push_back(item.cast<Trajectory>());
+                }
+                callback(*measurements_vec, *trajectories_vec, outpath);
+            });
+
+        
+        py::class_<FWFSettings, std::shared_ptr<FWFSettings>> fwf_settings(m, "FWFSettings");
+        fwf_settings
+            .def(py::init<>())
+            .def(py::init<const FWFSettings&>(), py::arg("fwfSettings"))
+            .def_readwrite("bin_size", &FWFSettings::binSize_ns)
+            .def_readwrite("min_echo_width", &FWFSettings::minEchoWidth)
+            .def_readwrite("peak_energy", &FWFSettings::peakEnergy)
+            .def_readwrite("aperture_diameter", &FWFSettings::apertureDiameter)
+            .def_readwrite("scanner_efficiency", &FWFSettings::scannerEfficiency)
+            .def_readwrite("atmospheric_visibility", &FWFSettings::atmosphericVisibility)
+            .def_readwrite("scanner_wave_length", &FWFSettings::scannerWaveLength)
+            .def_readwrite("beam_divergence_angle", &FWFSettings::beamDivergence_rad)
+            .def_readwrite("pulse_length", &FWFSettings::pulseLength_ns)
+            .def_readwrite("beam_sample_quality", &FWFSettings::beamSampleQuality)
+            .def_readwrite("win_size", &FWFSettings::winSize_ns)
+            .def_readwrite("max_fullwave_range", &FWFSettings::maxFullwaveRange_ns)
+            .def("__str__", &FWFSettings::toString);
+
+
+        py::class_<Rotation, std::shared_ptr<Rotation>> rotation(m, "Rotation");
+        rotation
+            .def(py::init<>())
+            .def(py::init<double, double, double, double, bool>(), py::arg("q0"), py::arg("q1"), py::arg("q2"), py::arg("q3"), py::arg("needsNormalization"))
+            .def(py::init<glm::dvec3, double>(), py::arg("axis"), py::arg("angle"))
+            .def(py::init<glm::dvec3, glm::dvec3>(), py::arg("u"), py::arg("v"))
+
+            .def_property("q0", &Rotation::getQ0, &Rotation::setQ0)
+            .def_property("q1", &Rotation::getQ1, &Rotation::setQ1)
+            .def_property("q2", &Rotation::getQ2, &Rotation::setQ2)
+            .def_property("q3", &Rotation::getQ3, &Rotation::setQ3)
+            .def_property_readonly("axis", &Rotation::getAxis)
+            .def_property_readonly("angle", &Rotation::getAngle);
+
+
+        py::class_<ScannerHead, std::shared_ptr<ScannerHead>> scanner_head(m, "ScannerHead");
+        scanner_head
+            .def(py::init<glm::dvec3, double>(), py::arg("headRotationAxis"), py::arg("headRotatePerSecMax_rad"))
+
+            .def_readwrite("rotation_axis", &ScannerHead::cfg_device_rotateAxis)
+            .def_property_readonly("mount_relative_attitude",
+                        &ScannerHead::getMountRelativeAttitudeByReference)
+            .def_property("rotate_per_sec_max",
+                        &ScannerHead::getRotatePerSecMax,
+                        &ScannerHead::setRotatePerSecMax)
+            .def_property("rotate_per_sec",
+                        &ScannerHead::getRotatePerSec_rad,
+                        &ScannerHead::setRotatePerSec_rad)
+            .def_property("rotate_stop",
+                        &ScannerHead::getRotateStop,
+                        &ScannerHead::setRotateStop)
+            .def_property("rotate_start",
+                        &ScannerHead::getRotateStart,
+                        &ScannerHead::setRotateStart)
+            .def_property("rotate_range",
+                        &ScannerHead::getRotateRange,
+                        &ScannerHead::setRotateRange)
+
+            .def_property("current_rotate_angle",
+                        &ScannerHead::getRotateCurrent,
+                        &ScannerHead::setCurrentRotateAngle_rad);
+
+        
+        py::class_<EvalScannerHead, ScannerHead, std::shared_ptr<EvalScannerHead>> eval_scanner_head(m, "EvalScannerHead");
+        eval_scanner_head
+            .def(py::init<glm::dvec3, double>(), py::arg("headRotationAxis"), py::arg("headRotatePerSecMax_rad"));
+
+
+        py::class_<Material, std::shared_ptr<Material>> material(m, "Material");
+        material
+            .def(py::init<>())
+            .def(py::init<const Material&>(), py::arg("material"))
+
+            .def_readwrite("name", &Material::name)
+            .def_readwrite("is_ground", &Material::isGround)
+            .def_readwrite("use_vertex_colors", &Material::useVertexColors)
+            .def_readwrite("mat_file_path", &Material::matFilePath)
+            .def_readwrite("reflectance", &Material::reflectance)
+            .def_readwrite("specularity", &Material::specularity)
+            .def_readwrite("specular_exponent", &Material::specularExponent)
+            .def_readwrite("classification", &Material::classification)
+            .def_readwrite("spectra", &Material::spectra)
+            .def_readwrite("map_kd", &Material::map_Kd)
+            .def_property("ambient_components", 
+                [](Material &m) {
+                    return std::vector<float>(std::begin(m.ka), std::end(m.ka));
+                }, 
+                [](Material &m, const std::vector<float> &value) {
+                    if (value.size() != 4) {
+                        throw std::runtime_error("ambient_components must have exactly 4 elements");
+                    }
+                    std::copy(value.begin(), value.end(), m.ka);
+                })
+            .def_property("diffuse_components", 
+                [](Material &m) {
+                    return std::vector<float>(std::begin(m.kd), std::end(m.kd));
+                }, 
+                [](Material &m, const std::vector<float> &value) {
+                    if (value.size() != 4) {
+                        throw std::runtime_error("diffuse_components must have exactly 4 elements");
+                    }
+                    std::copy(value.begin(), value.end(), m.kd);
+                })
+            .def_property("specular_components", 
+                [](Material &m) {
+                    return std::vector<float>(std::begin(m.ks), std::end(m.ks));
+                }, 
+                [](Material &m, const std::vector<float> &value) {
+                    if (value.size() != 4) {
+                        throw std::runtime_error("specular_components must have exactly 4 elements");
+                    }
+                    std::copy(value.begin(), value.end(), m.ks);
+                });
+
+
+        py::class_<Survey, Asset, std::shared_ptr<Survey>> survey(m, "Survey", py::module_local()); 
+        survey
+            .def(py::init<>())
+            
+            .def_readwrite("scanner", &Survey::scanner)
+            .def_readwrite("legs", &Survey::legs)
+            .def("calculate_length", &Survey::calculateLength)
+            .def_property_readonly("length", &Survey::getLength)
+            .def_property("name", 
+                        [](Survey &s) { return s.name; }, 
+                        [](Survey &s, const std::string &name) { s.name = name; })
+            .def_property("num_runs", 
+                        [](Survey &s) { return s.numRuns; }, 
+                        [](Survey &s, int numRuns) { s.numRuns = numRuns; })
+            .def_property("sim_speed_factor", 
+                        [](Survey &s) { return s.simSpeedFactor; }, 
+                        [](Survey &s, double simSpeedFactor) { s.simSpeedFactor = simSpeedFactor; });
+
+
+        py::class_<Leg, std::shared_ptr<Leg>> leg(m, "Leg");
+        leg
+            .def(py::init<>())
+            .def(py::init<double, int, std::shared_ptr<ScanningStrip>>(),
+             py::arg("length"), py::arg("serialId"), py::arg("strip"))
+            .def(py::init<Leg&>(), py::arg("leg"))
+            .def_readwrite("scanner_settings", &Leg::mScannerSettings) 
+            .def_readwrite("platform_settings", &Leg::mPlatformSettings)
+            .def_readwrite("trajectory_settings", &Leg::mTrajectorySettings)
+
+            .def_property("length", &Leg::getLength, &Leg::setLength)
+            .def_property("serial_id", &Leg::getSerialId, &Leg::setSerialId)
+            .def_property("strip", &Leg::getStrip, &Leg::setStrip)
+            .def("belongs_to_strip", &Leg::isContainedInAStrip);
+
+
+        py::class_<ScenePart, std::shared_ptr<ScenePart>> scene_part(m, "ScenePart");
+        scene_part
+            .def(py::init<>())
+            .def(py::init<const ScenePart&, bool>(),
+             py::arg("sp"), py::arg("shallowPrimitives") = false) 
+            
+            .def_readwrite("origin", &ScenePart::mOrigin)
+            .def_readwrite("rotation", &ScenePart::mRotation)
+            .def_readwrite("scale", &ScenePart::mScale)
+            .def_readwrite("bound", &ScenePart::bound)
+            .def_readwrite("is_force_on_ground", &ScenePart::forceOnGround)
+
+            .def_property("centroid", &ScenePart::getCentroid, &ScenePart::setCentroid) 
+            .def_property("id", &ScenePart::getId, &ScenePart::setId)
+            .def_property("dyn_object_step",
+                      [](const ScenePart& self) -> size_t {
+                          if (self.getType() == ScenePart::ObjectType::DYN_OBJECT) {
+                            return dynamic_cast<const DynObject&>(self).getStepInterval();
+                          } else {
+                              throw std::runtime_error("ScenePart is not a DynObject.");
+                          }
+                      },
+                      [](ScenePart& self, size_t stepInterval) {
+                          if (self.getType() == ScenePart::ObjectType::DYN_OBJECT) {
+                            dynamic_cast<DynObject&>(self).setStepInterval(stepInterval);
+                          } else {
+                              throw std::runtime_error("ScenePart is not a DynObject.");
+                          }
+                      })
+            
+            .def_property("observer_step",
+                      [](const ScenePart& self) -> size_t {
+                          if (self.getType() == ScenePart::ObjectType::DYN_MOVING_OBJECT) {
+                             return dynamic_cast<const DynMovingObject&>(self).getObserverStepInterval();
+                          } else {
+                              throw std::runtime_error("ScenePart is not a DynMovingObject.");
+                          }
+                      },
+                      [](ScenePart& self, size_t stepInterval) {
+                          if (self.getType() == ScenePart::ObjectType::DYN_MOVING_OBJECT) {
+                             dynamic_cast<DynMovingObject&>(self).setObserverStepInterval(stepInterval);
+                          } else {
+                              throw std::runtime_error("ScenePart is not a DynMovingObject.");
+                          }
+                      })
+
+            .def_property("primitives", &ScenePart::getPrimitives, &ScenePart::setPrimitives)
+            .def("primitive", [](ScenePart& self, size_t index) -> Primitive* {
+                if (index < self.mPrimitives.size()) {
+                    return self.mPrimitives[index];
+                } else {
+                    throw std::out_of_range("Index out of range");
+                }
+            }, py::return_value_policy::reference)
+            .def_property_readonly("num_primitives", [](const ScenePart& self) -> size_t {
+                return self.mPrimitives.size();})
+            .def("isDynamicMovingObject", [](const ScenePart& self) -> bool {
+                return self.getType() == ScenePart::ObjectType::DYN_MOVING_OBJECT;})
+            .def("compute_centroid", &ScenePart::computeCentroid, py::arg("computeBound") = false)
+            .def("compute_centroid_w_bound", &ScenePart::computeCentroid, py::arg("computeBound") = true)
+            .def("compute_transform", &ScenePart::computeTransformations);
+             
+        
+        py::enum_<ScenePart::ObjectType>(m, "ObjectType")
+            .value("STATIC_OBJECT", ScenePart::STATIC_OBJECT)
+            .value("DYN_OBJECT", ScenePart::DYN_OBJECT)
+            .value("DYN_MOVING_OBJECT", ScenePart::DYN_MOVING_OBJECT)
+            .export_values();
+
+        py::enum_<ScenePart::PrimitiveType>(m, "PrimitiveType")
+            .value("NONE", ScenePart::NONE)
+            .value("TRIANGLE", ScenePart::TRIANGLE)
+            .value("VOXEL", ScenePart::VOXEL)
+            .export_values();
+        
+
+        py::class_<ScannerSettings, std::shared_ptr<ScannerSettings>> scanner_settings(m, "ScannerSettings");
+        scanner_settings
+            .def(py::init<>())
+            .def(py::init<ScannerSettings*>(), py::arg("scannerSettings"))
+            
+            .def_readwrite("id", &ScannerSettings::id)
+            .def_readwrite("is_active", &ScannerSettings::active)
+            .def_readwrite("head_rotation", &ScannerSettings::headRotatePerSec_rad)
+            .def_readwrite("rotation_start_angle", &ScannerSettings::headRotateStart_rad)
+            .def_readwrite("rotation_stop_angle", &ScannerSettings::headRotateStop_rad)
+            .def_readwrite("pulse_frequency", &ScannerSettings::pulseFreq_Hz)
+            .def_readwrite("scan_angle", &ScannerSettings::scanAngle_rad)
+            .def_readwrite("min_vertical_angle", &ScannerSettings::verticalAngleMin_rad)
+            .def_readwrite("max_vertical_angle", &ScannerSettings::verticalAngleMax_rad)
+            .def_readwrite("scan_frequency", &ScannerSettings::scanFreq_Hz)
+            .def_readwrite("beam_divergence_angle", &ScannerSettings::beamDivAngle)
+            .def_readwrite("trajectory_time_interval", &ScannerSettings::trajectoryTimeInterval)
+            .def_readwrite("vertical_resolution", &ScannerSettings::verticalResolution_rad)
+            .def_readwrite("horizontal_resolution", &ScannerSettings::horizontalResolution_rad)
+
+            .def_property_readonly("base_template", &ScannerSettings::getTemplate, py::return_value_policy::reference)
+
+            .def("cherry_pick", &ScannerSettings::cherryPick, py::arg("cherries"), py::arg("fields"), py::arg("templateFields") = nullptr)
+            .def("fit_to_resolution", &ScannerSettings::fitToResolution)
+            .def("has_template", &ScannerSettings::hasTemplate)
+            .def("has_default_resolution", &ScannerSettings::hasDefaultResolution)
+            .def("__repr__", &ScannerSettings::toString)
+            .def("__str__", &ScannerSettings::toString);
+
+        
+        py::class_<PlatformSettings, std::shared_ptr<PlatformSettings>> platform_settings(m, "PlatformSettings");
+        platform_settings
+            .def(py::init<>())
+            .def(py::init<PlatformSettings*>(), py::arg("platformSettings"))
+       
+            .def_readwrite("id", &PlatformSettings::id)
+            .def_readwrite("x", &PlatformSettings::x)
+            .def_readwrite("y", &PlatformSettings::y)
+            .def_readwrite("z", &PlatformSettings::z)
+            .def_readwrite("is_yaw_angle_specified", &PlatformSettings::yawAtDepartureSpecified)
+            .def_readwrite("yaw_angle", &PlatformSettings::yawAtDeparture)
+            .def_readwrite("is_on_ground", &PlatformSettings::onGround)
+            .def_readwrite("is_stop_and_turn", &PlatformSettings::stopAndTurn)
+            .def_readwrite("is_smooth_turn", &PlatformSettings::smoothTurn)
+            .def_readwrite("is_slowdown_enabled", &PlatformSettings::slowdownEnabled)
+            .def_readwrite("speed_m_s", &PlatformSettings::movePerSec_m)
+
+            .def_property_readonly("base_template", &PlatformSettings::getTemplate, py::return_value_policy::reference)
+            .def_property("position", &PlatformSettings::getPosition, [](PlatformSettings& self, const glm::dvec3& pos) { self.setPosition(pos); })
+
+            .def("cherryPick", &PlatformSettings::cherryPick, py::arg("cherries"), py::arg("fields"), py::arg("templateFields") = nullptr)
+            
+            .def("has_template", &PlatformSettings::hasTemplate)
+            .def("to_string", &PlatformSettings::toString);
+        
+
+        py::class_<Scene, std::shared_ptr<Scene>> scene(m, "Scene");
+        scene
+            .def(py::init<>())
+            .def(py::init<Scene&>(), py::arg("scene"))
+
+            .def_readwrite("scene_parts", &Scene::parts)
+            .def_readwrite("primitives", &Scene::primitives)
+
+            .def_property("bbox", &Scene::getBBox, &Scene::setBBox)
+            .def_property("bbox_crs", &Scene::getBBoxCRS, &Scene::setBBoxCRS)
+            .def_property("kd_grove_factory", &Scene::getKDGroveFactory, &Scene::setKDGroveFactory)
+            .def_property_readonly("num_primitives", [](const ScenePart& self) -> size_t {
+                return self.mPrimitives.size();})
+            .def_property_readonly("aabb", &Scene::getAABB, py::return_value_policy::reference)
+           
+            .def_property_readonly("shift", &Scene::getShift)
+            .def_property("dyn_scene_step",
+                      [](const Scene& self) -> size_t {
+                        return dynamic_cast<const DynScene&>(self).getStepInterval();
+                      },
+                      [](Scene& self, size_t stepInterval) {
+                        dynamic_cast<DynScene&>(self).setStepInterval(stepInterval); 
+                      })            
+            .def_property("default_reflectance", &Scene::getDefaultReflectance, &Scene::setDefaultReflectance)
+
+            .def("scene_parts_size", [](Scene &self) { return self.parts.size(); })
+            .def("get_scene_part", [](Scene &self, size_t index) -> ScenePart& {
+                if (index < self.parts.size()) {
+                    return *(self.parts[index]);
+                } else {
+                    throw std::out_of_range("Index out of range");
+                }
+            }, py::return_value_policy::reference)
+            .def("ground_point_at", [](Scene &self, glm::dvec3 point) { return self.getGroundPointAt(point); })
+            .def("finalize_loading", &Scene::finalizeLoading, py::arg("safe") = false)
+            .def("write_object", &Scene::writeObject)
+            .def("translate", [](Scene &scene, double x, double y, double z) {
+                glm::dvec3 shift(x, y, z);
+                for (Primitive* p : scene.primitives) {
+                    p->translate(shift);
+                }
+            })
+            .def("new_triangle", [](Scene &scene) {
+                Vertex v;
+                v.pos[0] = 0.0; v.pos[1] = 0.0; v.pos[2] = 0.0;
+                Triangle* tri = new Triangle(v, v, v);
+                scene.primitives.push_back(tri);
+                return tri;
+            }, py::return_value_policy::reference)
+            .def("new_detailed_voxel", [](Scene &scene) {
+                std::vector<int> vi({0, 0});
+                std::vector<double> vd({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+                DetailedVoxel* dv = new DetailedVoxel(0.0, 0.0, 0.0, 0.5, vi, vd);
+                scene.primitives.push_back(dv);
+                return dv;
+            }, py::return_value_policy::reference)
+            .def("primitive", [](Scene &scene, size_t index) -> Primitive* {
+                if (index < scene.primitives.size()) {
+                    return scene.primitives[index];
+                } else {
+                    throw std::out_of_range("Index out of range");
+                }
+            }, py::return_value_policy::reference)
+            .def("build_kd_grove", &Scene::buildKDGroveWithLog, py::arg("safe") = true)
+            .def("intersection_min_max",
+                py::overload_cast<std::vector<double> const&, glm::dvec3 const&, glm::dvec3 const&, bool const>(&Scene::getIntersection, py::const_),
+                py::arg("tMinMax"), py::arg("rayOrigin"), py::arg("rayDir"), py::arg("groundOnly"))
+            .def("shutdown", &Scene::shutdown);
+
+
+        py::class_<StaticScene, Scene, std::shared_ptr<StaticScene>> static_scene(m, "StaticScene");
+        static_scene
+            .def(py::init<>())
+            .def("get_static_object_part", &StaticScene::getStaticObject, py::arg("id"))
+            .def("set_static_object_part", &StaticScene::setStaticObject, py::arg("id"), py::arg("part"))
+            .def("append_static_object_part", &StaticScene::appendStaticObject, py::arg("part"))
+            .def("remove_static_object_part", &StaticScene::removeStaticObject, py::arg("id"))
+            .def("clear_static_object_parts", &StaticScene::clearStaticObjects)
+            .def("write_object", &StaticScene::writeObject, py::arg("path"))
+            .def("shutdown", &StaticScene::shutdown);
+
+
+        py::class_<Platform, std::shared_ptr<Platform>> platform(m, "Platform");
+        platform
+            .def(py::init<>())
+            .def(py::init<Platform&>(), py::arg("platform"))
+           
+            .def_readwrite("last_check_z", &Platform::lastCheckZ)
+            .def_readwrite("dmax", &Platform::dmax)
+            .def_readwrite("is_orientation_on_leg_init", &Platform::mSetOrientationOnLegInit)
+            .def_readwrite("is_on_ground", &Platform::onGround)
+            .def_readwrite("is_stop_and_turn", &Platform::stopAndTurn)
+            .def_readwrite("settings_speed_m_s", &Platform::cfg_settings_movePerSec_m)
+            .def_readwrite("is_slowdown_enabled", &Platform::slowdownEnabled)
+            .def_readwrite("is_smooth_turn", &Platform::smoothTurn)
+            .def_readwrite("device_relative_position", &Platform::cfg_device_relativeMountPosition)
+            .def_readwrite("device_relative_attitude", &Platform::cfg_device_relativeMountAttitude)
+            .def_readwrite("position_x_noise_source", &Platform::positionXNoiseSource)
+            .def_readwrite("position_y_noise_source", &Platform::positionYNoiseSource)
+            .def_readwrite("position_z_noise_source", &Platform::positionZNoiseSource)
+            .def_readwrite("attitude_x_noise_source", &Platform::attitudeXNoiseSource)
+            .def_readwrite("attitude_y_noise_source", &Platform::attitudeYNoiseSource)
+            .def_readwrite("attitude_z_noise_source", &Platform::attitudeZNoiseSource)
+            .def_readwrite("scene", &Platform::scene)
+            .def_readwrite("target_waypoint", &Platform::targetWaypoint)
+            .def_readwrite("origin_waypoint", &Platform::originWaypoint)
+            .def_readwrite("next_waypoint", &Platform::nextWaypoint)
+            .def_readwrite("cached_end_target_angle_xy", &Platform::cached_endTargetAngle_xy)
+            .def_readwrite("cached_origin_to_target_angle_xy", &Platform::cached_originToTargetAngle_xy)
+            .def_readwrite("cached_target_to_next_angle_xy", &Platform::cached_targetToNextAngle_xy)
+            .def_readwrite("cached_distance_to_target_xy", &Platform::cached_distanceToTarget_xy)
+        
+            .def_property("position", &Platform::getPosition, &Platform::setPosition)
+            .def_property("attitude", [](Platform &self) {
+                    return self.attitude;
+                }, [](Platform &self, const Rotation &attitude) {
+                    self.attitude = attitude;
+            })
+            .def_property("absolute_mount_position", [](Platform &self) {
+                    return self.cached_absoluteMountPosition;
+                }, [](Platform &self, const glm::dvec3 &position) {
+                    self.cached_absoluteMountPosition = position;
+            })
+            .def_property("absolute_mount_attitude", [](Platform &self) {
+                    return self.cached_absoluteMountAttitude;
+                }, [](Platform &self, const Rotation &attitude) {
+                    self.cached_absoluteMountAttitude = attitude;
+            })
+            .def_property("last_ground_check", [](const Platform &self) {
+                    return self.lastGroundCheck;
+                }, [](Platform &self, const glm::dvec3 &position) {
+                    self.lastGroundCheck = position;
+            })
+            .def_property("cached_dir_current", [](const Platform &self) {
+                    return self.cached_dir_current;
+                }, [](Platform &self, const glm::dvec3 &position) {
+                    self.cached_dir_current = position;
+            })
+            .def_property("cached_dir_current_xy", [](const Platform &self) {
+                    return self.cached_dir_current_xy;
+                }, [](Platform &self, const glm::dvec3 &position) {
+                    self.cached_dir_current_xy = position;
+            })
+            .def_property("cached_vector_to_target", [](const Platform &self) {
+                    return self.cached_vectorToTarget;
+                }, [](Platform &self, const glm::dvec3 &position) {
+                    self.cached_vectorToTarget = position;
+            })
+            .def_property("cached_vector_to_target_xy", [](const Platform &self) {
+                return self.cached_vectorToTarget_xy;
+            }, [](Platform &self, const glm::dvec3 &position) {
+                self.cached_vectorToTarget_xy = position;
+            })
+            .def_property("cached_origin_to_target_dir_xy", [](const Platform &self) {
+                return self.cached_originToTargetDir_xy;
+            }, [](Platform &self, const glm::dvec3 &position) {
+                self.cached_originToTargetDir_xy = position;
+            })
+            .def_property("cached_target_to_next_dir_xy", [](const Platform &self) {
+                return self.cached_targetToNextDir_xy;
+            }, [](Platform &self, const glm::dvec3 &position) {
+                self.cached_targetToNextDir_xy = position;
+            });
+        
+
+        py::class_<MovingPlatform, Platform, std::shared_ptr<MovingPlatform>> moving_platform(m, "MovingPlatform");
+        moving_platform
+
+            .def(py::init<>())
+            
+            .def_property("velocity", &MovingPlatform::getVelocity, &MovingPlatform::setVelocity)
+            .def("apply_settings", &MovingPlatform::applySettings)
+            .def("do_sim_step", &MovingPlatform::doSimStep)
+            .def("init_leg_manual", &MovingPlatform::initLegManual)
+            .def("init_leg_manual_interactive", &MovingPlatform::initLegManualIterative)
+            .def("waypoint_reached", &MovingPlatform::waypointReached)
+            .def("can_move", &MovingPlatform::canMove)
+            .def("clone", &MovingPlatform::clone);
+        
+
+        py::class_<SimplePhysicsPlatform, MovingPlatform, std::shared_ptr<SimplePhysicsPlatform>> simple_physics_platform(m, "SimplePhysicsPlatform");
+        simple_physics_platform
+            .def(py::init<>())
+            .def_readwrite("drag_magnitude", &SimplePhysicsPlatform::mCfg_drag)
+
+            .def("prepare_simulation", &SimplePhysicsPlatform::prepareSimulation)
+            .def("prepare_leg", &SimplePhysicsPlatform::prepareLeg)
+            .def("do_physics_step", &SimplePhysicsPlatform::doPhysicsStep)
+            .def("do_sim_step", &SimplePhysicsPlatform::doSimStep)
+            .def("do_control_step", &SimplePhysicsPlatform::doControlStep)
+            .def("configure_step_magnitude", &SimplePhysicsPlatform::configureStepMagnitude)
+            .def("check_speed_limit", &SimplePhysicsPlatform::checkSpeedLimit)
+            .def("clone", &SimplePhysicsPlatform::clone);
+        
+
+        py::class_<GroundVehiclePlatform, SimplePhysicsPlatform, std::shared_ptr<GroundVehiclePlatform>> ground_vehicle_platform(m, "GroundVehiclePlatform");
+        ground_vehicle_platform
+            .def(py::init<>())
+            .def("do_control_step", &GroundVehiclePlatform::doControlStep)
+            .def("prepare_simulation", &GroundVehiclePlatform::prepareSimulation)
+            .def("set_destination", &GroundVehiclePlatform::setDestination)
+            .def("clone", &GroundVehiclePlatform::clone);
+
+
+        py::class_<LinearPathPlatform, MovingPlatform, std::shared_ptr<LinearPathPlatform>> linear_path_platform(m, "LinearPathPlatform");
+        linear_path_platform
+            .def(py::init<>())
+            .def("do_sim_step", &LinearPathPlatform::doSimStep)
+            .def("set_destination", &LinearPathPlatform::setDestination)
+            .def("clone", &LinearPathPlatform::clone);
+
+        
+        py::class_<HelicopterPlatform, SimplePhysicsPlatform, std::shared_ptr<HelicopterPlatform>> helicopter_platform(m, "HelicopterPlatform");
+        helicopter_platform
+            .def(py::init<>())
+            .def_readwrite("slowdown_distance_xy", &HelicopterPlatform::cfg_slowdown_dist_xy)
+            .def_readwrite("slowdown_magnitude", &HelicopterPlatform::cfg_slowdown_magnitude)
+            .def_readwrite("speedup_magnitude", &HelicopterPlatform::cfg_speedup_magnitude)
+            .def_readwrite("max_engine_force_xy", &HelicopterPlatform::ef_xy_max)
+            .def_readwrite("roll", &HelicopterPlatform::roll)
+            .def_readwrite("pitch", &HelicopterPlatform::pitch)
+            .def_readwrite("last_sign", &HelicopterPlatform::lastSign)
+            .def_readwrite("base_pitch_angle", &HelicopterPlatform::cfg_pitch_base)
+            .def_readwrite("yaw_speed", &HelicopterPlatform::cfg_yaw_speed)
+            .def_readwrite("roll_speed", &HelicopterPlatform::cfg_roll_speed)
+            .def_readwrite("pitch_speed", &HelicopterPlatform::cfg_pitch_speed)
+            .def_readwrite("max_roll_offset", &HelicopterPlatform::cfg_max_roll_offset)
+            .def_readwrite("max_pitch_offset", &HelicopterPlatform::cfg_max_pitch_offset)
+            .def_readwrite("max_pitch", &HelicopterPlatform::cfg_max_pitch)
+            .def_readwrite("min_pitch", &HelicopterPlatform::cfg_min_pitch)
+            .def_readwrite("slowdown_factor", &HelicopterPlatform::cfg_slowdownFactor)
+            .def_readwrite("speedup_factor", &HelicopterPlatform::cfg_speedupFactor)
+            .def_readwrite("pitch_step_magnitude", &HelicopterPlatform::cfg_pitchStepMagnitude)
+            .def_readwrite("roll_step_magnitude", &HelicopterPlatform::cfg_rollStepMagnitude)
+            .def_readwrite("yaw_step_magnitude", &HelicopterPlatform::cfg_yawStepMagnitude)
+            .def_readwrite("alignment_threshold", &HelicopterPlatform::cfg_alignmentThreshold)
+            .def_readwrite("speed_xy", &HelicopterPlatform::speed_xy)
+            .def_readwrite("last_speed_xy", &HelicopterPlatform::lastSpeed_xy)
+            .def_readwrite("rotation", &HelicopterPlatform::r)
+            .def_readwrite("dir_attitude", &HelicopterPlatform::dirAttitudeXY)
+            .def_readwrite("cache_turn_iterations", &HelicopterPlatform::cache_turnIterations)
+            .def_readwrite("cache_turning", &HelicopterPlatform::cache_turning)
+            .def_readwrite("cache_aligning", &HelicopterPlatform::cache_aligning)
+            .def_readwrite("cache_distance_threshold", &HelicopterPlatform::cache_xyDistanceThreshold)
+            .def_readwrite("cache_speedup_finished", &HelicopterPlatform::cache_speedUpFinished)
+            
+            .def_property("heading_rad", &HelicopterPlatform::getHeadingRad, &HelicopterPlatform::setHeadingRad)
+            .def("do_control_step", &HelicopterPlatform::doControlStep)
+            .def("compute_lift_sink_rate", &HelicopterPlatform::computeLiftSinkRate)
+            .def("compute_xy_speed", &HelicopterPlatform::computeXYSpeed)
+            .def("compute_engine_force", &HelicopterPlatform::computeEngineForce)
+            .def("compute_rotation_angles", &HelicopterPlatform::computeRotationAngles)
+            .def("compute_alignment_angles", &HelicopterPlatform::computeAlignmentAngles)
+            .def("compute_turning_angles", &HelicopterPlatform::computeTurningAngles)
+            .def("compute_slowdown_step", &HelicopterPlatform::computeSlowdownStep)
+            .def("compute_speedup_step", &HelicopterPlatform::computeSpeedupStep)
+            .def("rotate", &HelicopterPlatform::rotate)
+            .def("handle_route", &HelicopterPlatform::handleRoute)
+            .def("can_stop_and_turn", &HelicopterPlatform::canStopAndTurn)
+            .def("prepare_simulation", &HelicopterPlatform::prepareSimulation)
+            .def("init_leg_manual", &HelicopterPlatform::initLegManual)
+            .def("init_leg", &HelicopterPlatform::initLeg)
+            .def("waypoint_reached", &HelicopterPlatform::waypointReached)
+            .def("update_static_cache", &HelicopterPlatform::updateStaticCache)
+            .def("compute_turn_distance_threshold", &HelicopterPlatform::computeTurnDistanceThreshold)
+            .def("compute_non_smooth_slowdown_dist", &HelicopterPlatform::computeNonSmoothSlowdownDist)
+            .def("clone", &HelicopterPlatform::clone);
+
+
+        py::class_<SwapOnRepeatHandler, std::shared_ptr<SwapOnRepeatHandler>> swap_on_repeat_handler(m, "SwapOnRepeatHandler");
+        swap_on_repeat_handler
+            .def(py::init<>())
+
+            .def_property(
+                "baseline",
+                [](SwapOnRepeatHandler &self) {
+                    return self.baseline.get();  
+                },
+                
+                [](SwapOnRepeatHandler &self, ScenePart *baseline) {
+                    self.baseline.reset(baseline); 
+                },
+                py::return_value_policy::take_ownership
+            )
+           
+            .def_property_readonly("num_target_swaps", &SwapOnRepeatHandler::getNumTargetSwaps)
+            .def_property_readonly("num_target_replays", &SwapOnRepeatHandler::getNumTargetReplays)
+            .def_property("keep_crs", &SwapOnRepeatHandler::isKeepCRS, &SwapOnRepeatHandler::setKeepCRS)
+            .def_property("discard_on_replay", &SwapOnRepeatHandler::needsDiscardOnReplay, &SwapOnRepeatHandler::setDiscardOnReplay)
+            
+            .def("swap", &SwapOnRepeatHandler::swap)
+            .def("prepare", &SwapOnRepeatHandler::prepare)
+            .def("push_time_to_live", &SwapOnRepeatHandler::pushTimeToLive)
+            .def("push_swap_filters", &SwapOnRepeatHandler::pushSwapFilters);
+        
+
+        py::class_<EnergyModel, EnergyModelWrap, std::shared_ptr<EnergyModel>> energy_model(m, "EnergyModel");
+        energy_model
+            .def(py::init<ScanningDevice&>(), py::arg("device"))
+            
+            .def("compute_intensity", &EnergyModel::computeIntensity)
+            .def("compute_received_power", &EnergyModel::computeReceivedPower)
+            .def("compute_emitted_power", &EnergyModel::computeEmittedPower)
+            .def("compute_target_area", &EnergyModel::computeTargetArea)
+            .def("compute_cross_section", &EnergyModel::computeCrossSection);
+        
+
+        py::class_<BaseEnergyModel, EnergyModel, std::shared_ptr<BaseEnergyModel>> base_energy_model(m, "BaseEnergyModel");
+        base_energy_model
+            .def(py::init<ScanningDevice&>(), py::arg("device"))
+            .def("compute_intensity", &BaseEnergyModel::computeIntensity)
+            .def("compute_received_power", &BaseEnergyModel::computeReceivedPower)
+            .def("compute_emitted_power", &BaseEnergyModel::computeEmittedPower)
+            .def("compute_target_area", &BaseEnergyModel::computeTargetArea)
+            .def("compute_cross_section", &BaseEnergyModel::computeCrossSection);
+
+
+        py::class_<ScanningDevice, std::shared_ptr<ScanningDevice> > scanning_device(m, "ScanningDevice");
+        scanning_device
+            .def(py::init<ScanningDevice const &>())
+            .def(py::init<
+                size_t,
+                std::string,
+                double,
+                glm::dvec3,
+                Rotation,
+                std::list<int>,
+                double,
+                double,
+                double,
+                double,
+                double,
+                double,
+                double
+                >())
+
+            .def_readwrite("cached_dr2", &ScanningDevice::cached_Dr2)
+            .def_readwrite("cached_bt2", &ScanningDevice::cached_Bt2)
+            .def_readwrite("cached_subray_rotation", &ScanningDevice::cached_subrayRotation)
+            .def_readwrite("cached_subray_divergence", &ScanningDevice::cached_subrayDivergenceAngle_rad)
+            .def_readwrite("cached_subray_radius_step", &ScanningDevice::cached_subrayRadiusStep)
+
+            .def_property("energy_model", &ScanningDevice::getEnergyModel, &ScanningDevice::setEnergyModel)
+
+            .def_property("fwf_settings", 
+                    &ScanningDevice::getFWFSettings, 
+                      &ScanningDevice::setFWFSettings)
+            .def_property("received_energy_min", 
+                      &ScanningDevice::getReceivedEnergyMin, 
+                      &ScanningDevice::setReceivedEnergyMin)
+            .def_property("last_pulse_was_hit",
+                        &ScanningDevice::lastPulseWasHit,
+                        &ScanningDevice::setLastPulseWasHit)
+            
+            .def("set_head_relative_emitter_position", &ScanningDevice::setHeadRelativeEmitterPosition)
+            .def("set_head_relative_emitter_attitude", &ScanningDevice::setHeadRelativeEmitterAttitude)
+            .def("prepare_simulation", &ScanningDevice::prepareSimulation, py::arg("legacyEnergyModel") = false)
+            .def("configure_beam", &ScanningDevice::configureBeam)
+            .def("calcAtmosphericAttenuation", &ScanningDevice::calcAtmosphericAttenuation)
+            .def("calcRaysNumber", &ScanningDevice::calcRaysNumber)
+            .def("doSimStep", &ScanningDevice::doSimStep)
+            .def("calcAbsoluteBeamAttitude", &ScanningDevice::calcAbsoluteBeamAttitude)
+            .def("calc_exact_absolute_beam_attitude", &ScanningDevice::calcExactAbsoluteBeamAttitude)
+            .def("computeSubrays", &ScanningDevice::computeSubrays)
+            .def("initializeFullWaveform", &ScanningDevice::initializeFullWaveform)
+            .def("calcIntensity", py::overload_cast<double, double, const Material&, int>(&ScanningDevice::calcIntensity, py::const_))
+            .def("calcIntensity", py::overload_cast<double, double, int>(&ScanningDevice::calcIntensity, py::const_))
+            .def("eval_range_error_expression", &ScanningDevice::evalRangeErrorExpression);
+
+
+        py::class_<Scanner, ScannerWrap, std::shared_ptr<Scanner>> scanner(m, "Scanner");
+        scanner
+            .def(py::init<std::string const&, std::list<int> const&, bool, bool, bool, bool, bool>(),
+                 py::arg("id"),
+                 py::arg("pulseFreqs"),
+                 py::arg("writeWaveform") = false,
+                 py::arg("writePulse") = false,
+                 py::arg("calcEchowidth") = false,
+                 py::arg("fullWaveNoise") = false,
+                 py::arg("platformNoiseDisabled") = false)
+            .def(py::init<Scanner&>(), py::arg("scanner"))
+
+            .def_readwrite("intersection_handling_noise_source", &Scanner::intersectionHandlingNoiseSource) 
+            .def_readwrite("rand_gen1", &Scanner::randGen1)
+            .def_readwrite("rand_gen2", &Scanner::randGen2)
+            .def_readwrite("trajectory_time_interval", &Scanner::trajectoryTimeInterval_ns)
+            .def_readwrite("platform", &Scanner::platform)
+
+            .def("initialize_sequential_generators", &Scanner::initializeSequentialGenerators)
+            .def("build_scanning_pulse_process", &Scanner::buildScanningPulseProcess,
+                py::arg("parallelization_strategy"), py::arg("dropper"), py::arg("pool"))
+            .def("apply_settings", py::overload_cast<std::shared_ptr<ScannerSettings>>(&Scanner::applySettings))
+            .def("apply_settings", py::overload_cast<std::shared_ptr<ScannerSettings>, size_t>(&Scanner::applySettings))
+            .def("retrieve_current_settings", py::overload_cast<>(&Scanner::retrieveCurrentSettings))
+            .def("retrieve_current_settings", py::overload_cast<size_t>(&Scanner::retrieveCurrentSettings))
+            .def("apply_settings_FWF", py::overload_cast<FWFSettings>(&Scanner::applySettingsFWF))
+            .def("apply_settings_FWF", py::overload_cast<FWFSettings, size_t>(&Scanner::applySettingsFWF))
+            .def("do_sim_step", &Scanner::doSimStep, py::arg("legIndex"), py::arg("currentGpsTime"))
+            .def("to_string", &Scanner::toString)
+            .def("calc_rays_number", py::overload_cast<>(&Scanner::calcRaysNumber))
+            .def("calc_rays_number", py::overload_cast<size_t>(&Scanner::calcRaysNumber))
+            .def("prepare_discretization", py::overload_cast<>(&Scanner::prepareDiscretization))
+            .def("prepare_discretization", py::overload_cast<size_t>(&Scanner::prepareDiscretization))
+        
+            .def("calc_atmospheric_attenuation", py::overload_cast<>(&Scanner::calcAtmosphericAttenuation, py::const_))
+            .def("calc_atmospheric_attenuation", py::overload_cast<size_t>(&Scanner::calcAtmosphericAttenuation, py::const_))
+            .def("check_max_NOR", py::overload_cast<int>(&Scanner::checkMaxNOR))
+            .def("check_max_NOR", py::overload_cast<int, size_t>(&Scanner::checkMaxNOR))
+            .def("calc_absolute_beam_attitude", py::overload_cast<size_t>(&Scanner::calcAbsoluteBeamAttitude))
+            .def("calc_absolute_beam_attitude", py::overload_cast<>(&Scanner::calcAbsoluteBeamAttitude))
+            .def("handle_sim_step_noise", &Scanner::handleSimStepNoise)
+            .def("on_leg_complete", &Scanner::onLegComplete)
+            .def("on_simulation_finished", &Scanner::onSimulationFinished)
+            .def("handle_trajectory_output", &Scanner::handleTrajectoryOutput)
+            .def("track_output_path", &Scanner::trackOutputPath)
+
+            .def("specific_current_pulse_number", py::overload_cast<size_t>(&Scanner::getCurrentPulseNumber, py::const_), py::arg("index"))
+            .def("get_specific_num_rays", py::overload_cast<size_t>(&Scanner::getNumRays, py::const_))
+            .def("set_specific_num_rays", py::overload_cast<int, size_t>(&Scanner::setNumRays))
+            .def("get_specific_pulse_length", py::overload_cast<size_t>(&Scanner::getPulseLength_ns, py::const_), py::arg("index"))
+            .def("set_specific_pulse_length", py::overload_cast<double, size_t>(&Scanner::setPulseLength_ns), py::arg("value"), py::arg("index"))
+            .def("get_specific_last_pulse_was_hit", py::overload_cast<size_t>(&Scanner::lastPulseWasHit, py::const_), py::arg("index"))
+            .def("set_specific_last_pulse_was_hit", py::overload_cast<bool, size_t>(&Scanner::setLastPulseWasHit), py::arg("value"), py::arg("index"))
+            .def("get_specific_beam_divergence", py::overload_cast<size_t>(&Scanner::getBeamDivergence, py::const_), py::arg("index"))
+            .def("set_specific_beam_divergence", py::overload_cast<double, size_t>(&Scanner::setBeamDivergence), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_average_power", py::overload_cast<size_t>(&Scanner::getAveragePower, py::const_), py::arg("index"))
+            .def("set_specific_average_power", py::overload_cast<double, size_t>(&Scanner::setAveragePower), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_beam_quality", py::overload_cast<size_t>(&Scanner::getBeamQuality, py::const_), py::arg("index"))
+            .def("set_specific_beam_quality", py::overload_cast<double, size_t>(&Scanner::setBeamQuality), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_efficiency", py::overload_cast<size_t>(&Scanner::getEfficiency, py::const_), py::arg("index"))
+            .def("set_specific_efficiency", py::overload_cast<double, size_t>(&Scanner::setEfficiency), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_receiver_diameter", py::overload_cast<size_t>(&Scanner::getReceiverDiameter, py::const_), py::arg("index"))
+            .def("set_specific_receiver_diameter", py::overload_cast<double, size_t>(&Scanner::setReceiverDiameter), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_visibility", py::overload_cast<size_t>(&Scanner::getVisibility, py::const_), py::arg("index"))
+            .def("set_specific_visibility", py::overload_cast<double, size_t>(&Scanner::setVisibility), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_wavelength", py::overload_cast<size_t>(&Scanner::getWavelength, py::const_), py::arg("index"))
+            .def("set_specific_wavelength", py::overload_cast<double, size_t>(&Scanner::setWavelength), py::arg("value"), py::arg("index"))
+            .def("get_specific_atmospheric_extinction", py::overload_cast<size_t>(&Scanner::getAtmosphericExtinction, py::const_), py::arg("index"))
+            .def("set_specific_atmospheric_extinction", py::overload_cast<double, size_t>(&Scanner::setAtmosphericExtinction), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_beam_waist_radius", py::overload_cast<size_t>(&Scanner::getBeamWaistRadius, py::const_), py::arg("index"))
+            .def("set_specific_beam_waist_radius", py::overload_cast<double, size_t>(&Scanner::setBeamWaistRadius), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_max_nor", py::overload_cast<size_t>(&Scanner::getMaxNOR, py::const_), py::arg("index"))
+            .def("set_specific_max_nor", py::overload_cast<int, size_t>(&Scanner::setMaxNOR), py::arg("value"), py::arg("index"))
+    
+            .def("get_head_relative_emitter_attitude", py::overload_cast<size_t>(&Scanner::getHeadRelativeEmitterAttitude, py::const_), py::arg("index"))
+            .def("set_head_relative_emitter_attitude", py::overload_cast<const Rotation&, size_t>(&Scanner::setHeadRelativeEmitterAttitude), py::arg("value"), py::arg("index"))
+            
+            .def("get_head_relative_emitter_position", py::overload_cast<size_t>(&Scanner::getHeadRelativeEmitterPosition, py::const_), py::arg("index"))
+            .def("set_head_relative_emitter_position", py::overload_cast<const glm::dvec3&, size_t>(&Scanner::setHeadRelativeEmitterPosition), py::arg("value"), py::arg("index"))
+
+            .def("get_specific_bt2", py::overload_cast<size_t>(&Scanner::getBt2, py::const_), py::arg("index"))
+            .def("set_specific_bt2", py::overload_cast<double, size_t>(&Scanner::setBt2), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_dr2", py::overload_cast<size_t>(&Scanner::getDr2, py::const_), py::arg("index"))
+            .def("set_specific_dr2", py::overload_cast<double, size_t>(&Scanner::setDr2), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_device_id", py::overload_cast<size_t>(&Scanner::getDeviceId, py::const_), py::arg("index"))
+            .def("set_specific_device_id", py::overload_cast<std::string, size_t>(&Scanner::setDeviceId), py::arg("value"), py::arg("index"))
+            .def("get_specific_detector", py::overload_cast<size_t>(&Scanner::getDetector), py::arg("index"))
+            .def("set_specific_detector", py::overload_cast<std::shared_ptr<AbstractDetector>, size_t>(&Scanner::setDetector), py::arg("value"), py::arg("index"))
+
+            .def("get_head_relative_emitter_position_by_ref", py::overload_cast<size_t>(&Scanner::getHeadRelativeEmitterPositionByRef), py::arg("index"))
+            .def("get__head_relative_emitter_attitude_by_ref", py::overload_cast<size_t>(&Scanner::getHeadRelativeEmitterAttitudeByRef), py::arg("index"))
+
+            .def("get_specific_num_time_bins", [](Scanner &self, size_t idx) { return self.getNumTimeBins(idx); }, py::arg("index"))
+            .def("set_specific_num_time_bins", [](Scanner &self, int numTimeBins, size_t idx) { self.setNumTimeBins(numTimeBins, idx); }, py::arg("value"), py::arg("index"))
+
+            .def("get_specific_peak_intensity_index", py::overload_cast<size_t>(&Scanner::getPeakIntensityIndex, py::const_), py::arg("index"))
+            .def("set_specific_peak_intensity_index", py::overload_cast<int, size_t>(&Scanner::setPeakIntensityIndex), py::arg("value"), py::arg("index"))
+            
+            .def("get_specific_scanner_head", py::overload_cast<size_t>(&Scanner::getScannerHead), py::arg("index"))
+            .def("set_specific_scanner_head", py::overload_cast<std::shared_ptr<ScannerHead>, size_t>(&Scanner::setScannerHead), py::arg("value"), py::arg("index"))
+
+            .def("get_specific_beam_deflector", py::overload_cast<size_t>(&Scanner::getBeamDeflector), py::arg("index"))
+            .def("set_specific_beam_deflector", py::overload_cast<std::shared_ptr<AbstractBeamDeflector>, size_t>(&Scanner::setBeamDeflector), py::arg("value"), py::arg("index"))
+
+            .def_property_readonly("current_pulse_number", py::overload_cast<>(&Scanner::getCurrentPulseNumber, py::const_))
+            .def_property("fms",
+                [](Scanner &self) { return self.fms; },
+                [](Scanner &self, const std::shared_ptr<FMSFacade> &fms) { self.fms = fms; }
+            )
+            .def_property("all_output_paths",
+                [](Scanner &self) { return *self.allOutputPaths; },
+                [](Scanner &self, py::object paths) {
+                    std::vector<std::string> cpp_paths = paths.cast<std::vector<std::string>>();
+                    self.allOutputPaths = std::make_shared<std::vector<std::string>>(cpp_paths);
+                }
+            )
+            .def_property("all_measurements",
+                [](Scanner &self) { py::list py_measurements;
+                for (const auto &measurement : *self.allMeasurements) {
+                    py_measurements.append(measurement); 
+                }
+                return py_measurements; },
+                [](Scanner &self, py::list measurements) {
+                     auto measurements_vec = std::make_shared<std::vector<Measurement>>();
+                    for (auto item : measurements) {
+                        measurements_vec->push_back(item.cast<Measurement>());
+                    }
+                    self.allMeasurements = measurements_vec;
+                }
+            )
+            .def_property("all_trajectories",
+                [](Scanner &self) { 
+                    py::list py_trajectories;
+                    for (const auto &trajectory : *self.allTrajectories) {
+                        py_trajectories.append(trajectory); 
+                    }
+                    return py_trajectories;
+                },
+                [](Scanner &self, py::list trajectories) {
+                    auto trajectories_vec = std::make_shared<std::vector<Trajectory>>();
+                    for (auto item : trajectories) {
+                        trajectories_vec->push_back(item.cast<Trajectory>());
+                    }
+                    self.allTrajectories = trajectories_vec;
+                }
+            )
+            .def_property("cycle_measurements",
+                [](Scanner &self) { 
+                      
+                    py::list py_measurements;
+                    for (const auto &measurement : *self.cycleMeasurements) {
+                        py_measurements.append(measurement); 
+                    }
+                    return py_measurements; 
+                },
+                [](Scanner &self, py::list measurements) {
+                    auto measurements_vec = std::make_shared<std::vector<Measurement>>();
+                    for (auto item : measurements) {
+                        measurements_vec->push_back(item.cast<Measurement>());
+                    }
+                    self.cycleMeasurements = measurements_vec;
+                }
+            )
+            .def_property("cycle_trajectories",
+                [](Scanner &self) { 
+                    py::list py_trajectories;
+                    for (const auto &trajectory : *self.cycleTrajectories) {
+                        py_trajectories.append(trajectory); 
+                    }
+                    return py_trajectories;
+                },
+                [](Scanner &self, py::list trajectories) {
+                    auto trajectories_vec = std::make_shared<std::vector<Trajectory>>();
+                    for (auto item : trajectories) {
+                        trajectories_vec->push_back(item.cast<Trajectory>());
+                    }
+                    self.cycleTrajectories = trajectories_vec;
+                }
+            )
+
+            .def_property("num_rays", 
+                        py::overload_cast<>(&Scanner::getNumRays, py::const_),
+                        py::overload_cast<int>(&Scanner::setNumRays))
+            .def_property("pulse_length", 
+                        py::overload_cast<>(&Scanner::getPulseLength_ns, py::const_),
+                        py::overload_cast<double>(&Scanner::setPulseLength_ns))
+            .def_property("last_pulse_was_hit",
+                        py::overload_cast<>(&Scanner::lastPulseWasHit, py::const_),
+                        py::overload_cast<bool>(&Scanner::setLastPulseWasHit))    
+            .def_property("beam_divergence",
+                        py::overload_cast<>(&Scanner::getBeamDivergence, py::const_),
+                        py::overload_cast<double>(&Scanner::setBeamDivergence))
+            .def_property("average_power",
+                        py::overload_cast<>(&Scanner::getAveragePower, py::const_),
+                        py::overload_cast<double>(&Scanner::setAveragePower))           
+            .def_property("beam_quality",
+                        py::overload_cast<>(&Scanner::getBeamQuality, py::const_),
+                        py::overload_cast<double>(&Scanner::setBeamQuality))         
+            .def_property("efficiency",
+                        py::overload_cast<>(&Scanner::getEfficiency, py::const_),
+                        py::overload_cast<double>(&Scanner::setEfficiency))            
+            .def_property("receiver_diameter",
+                        py::overload_cast<>(&Scanner::getReceiverDiameter, py::const_),
+                        py::overload_cast<double>(&Scanner::setReceiverDiameter))     
+            .def_property("visibility",
+                        py::overload_cast<>(&Scanner::getVisibility, py::const_),
+                        py::overload_cast<double>(&Scanner::setVisibility))           
+            .def_property("wavelength",
+                        py::overload_cast<>(&Scanner::getWavelength, py::const_),
+                        py::overload_cast<double>(&Scanner::setWavelength))
+            .def_property("atmospheric_extinction", 
+                        py::overload_cast<>(&Scanner::getAtmosphericExtinction, py::const_),
+                        py::overload_cast<double>(&Scanner::setAtmosphericExtinction))
+    
+            .def_property("beam_waist_radius",
+                        py::overload_cast<>(&Scanner::getBeamWaistRadius, py::const_),
+                        py::overload_cast<double>(&Scanner::setBeamWaistRadius))
+            
+            .def_property("max_nor",
+                        py::overload_cast<>(&Scanner::getMaxNOR, py::const_),
+                        py::overload_cast<int>(&Scanner::setMaxNOR))
+
+            .def_property("bt2",
+                        py::overload_cast<>(&Scanner::getBt2, py::const_),
+                        py::overload_cast<double>(&Scanner::setBt2))
+            
+            .def_property("dr2",
+                        py::overload_cast<>(&Scanner::getDr2, py::const_),
+                        py::overload_cast<double>(&Scanner::setDr2))
+            
+            .def_property("device_id",
+                        py::overload_cast<>(&Scanner::getDeviceId, py::const_),
+                        py::overload_cast<std::string>(&Scanner::setDeviceId))
+        
+            .def_property_readonly("scanner_head",
+                        py::overload_cast<>(&Scanner::getScannerHead))
+
+            .def_property_readonly("beam_deflector",
+                        py::overload_cast<>(&Scanner::getBeamDeflector))
+            
+            .def_property("detector",
+                        py::overload_cast<>(&Scanner::getDetector),
+                        py::overload_cast<std::shared_ptr<AbstractDetector>>(&Scanner::setDetector))
+
+            .def_property("num_time_bins",
+                        py::overload_cast<>(&Scanner::getNumTimeBins, py::const_),
+                        py::overload_cast<int>(&Scanner::setNumTimeBins))
+                 
+            .def_property("peak_intensity_index",
+                        py::overload_cast<>(&Scanner::getPeakIntensityIndex, py::const_),
+                        py::overload_cast<int>(&Scanner::setPeakIntensityIndex))
+
+            .def_property("pulse_freq_hz", &Scanner::getPulseFreq_Hz, &Scanner::setPulseFreq_Hz)    
+            .def_property("is_state_active", &Scanner::isActive, &Scanner::setActive)
+            .def_property("write_wave_form", &Scanner::isWriteWaveform, &Scanner::setWriteWaveform)
+            .def_property("calc_echowidth", &Scanner::isCalcEchowidth, &Scanner::setCalcEchowidth)
+            .def_property("full_wave_noise", &Scanner::isFullWaveNoise, &Scanner::setFullWaveNoise)
+            .def_property("platform_noise_disabled", &Scanner::isPlatformNoiseDisabled, &Scanner::setPlatformNoiseDisabled)
+            .def_property("fixed_incidence_angle", &Scanner::isFixedIncidenceAngle, &Scanner::setFixedIncidenceAngle)
+            .def_property("id", &Scanner::getScannerId, &Scanner::setScannerId)
+            .def_property("FWF_settings", 
+                        py::overload_cast<>(&Scanner::getFWFSettings),
+                        py::overload_cast<const FWFSettings&>(&Scanner::setFWFSettings))
+            .def_property_readonly("num_devices", &Scanner::getNumDevices)
+            .def_property_readonly("time_wave", py::overload_cast<>(&Scanner::getTimeWave))
+            .def_property(
+                "cycle_measurements_mutex",
+                [](ScannerWrap &self) {
+                    if (!self.get_mutex()) {
+                        self.set_mutex(std::make_shared<std::mutex>());
+                    }
+                    return self.get_mutex();
+                },
+                [](ScannerWrap &self, py::object mutex_obj) {
+                    if (mutex_obj.is_none()) {
+                        self.set_mutex(nullptr);
+                    } else {
+                        auto mutex_ptr = mutex_obj.cast<std::shared_ptr<std::mutex>>();
+                        self.set_mutex(mutex_ptr);
+                    }
+                },
+                "A shared mutex for synchronized operations"
+            )
+            .def_property(
+                "all_measurements_mutex",
+                [](ScannerWrap &self) {
+                    if (!self.get_mutex()) {
+                        self.set_mutex(std::make_shared<std::mutex>());
+                    }
+                    return self.get_mutex();
+                },
+                [](ScannerWrap &self, py::object mutex_obj) {
+                    if (mutex_obj.is_none()) {
+                        self.set_mutex(nullptr);
+                    } else {
+                        auto mutex_ptr = mutex_obj.cast<std::shared_ptr<std::mutex>>();
+                        self.set_mutex(mutex_ptr);
+                    }
+                },
+                "A shared mutex for synchronized operations"
+            );
+      
+
+        py::class_<PyHeliosSimulation> helios_simulation (m, "PyheliosSimulation");
+        helios_simulation
+            .def(py::init<>())
+            .def(py::init<
+                    std::string,
+                    std::vector<std::string>,
+                    std::string,
+                    size_t,
+                    bool,
+                    bool,
+                    bool,
+                    bool,
+                    int,
+                    size_t,
+                    size_t,
+                    int,
+                    int,
+                    int
+                >(),
+                py::arg("surveyPath"),
+                py::arg("assetsPath"),
+                py::arg("outputPath") = "output/",
+                py::arg("numThreads") = 0,
+                py::arg("lasOutput") = false,
+                py::arg("las10") = false,
+                py::arg("zipOutput") = false,
+                py::arg("splitByChannel") = false,
+                py::arg("kdtFactory") = 4,
+                py::arg("kdtJobs") = 0,
+                py::arg("kdtSAHLossNodes") = 32,
+                py::arg("parallelizationStrategy") = 1,
+                py::arg("chunkSize") = 32,
+                py::arg("warehouseFactor") = 1
+            )
+            .def("start", &PyHeliosSimulation::start)
+            .def("pause", &PyHeliosSimulation::pause)
+            .def("stop", &PyHeliosSimulation::stop)
+            .def("resume", &PyHeliosSimulation::resume)
+            .def("join", &PyHeliosSimulation::join)
+            .def("load_survey", &PyHeliosSimulation::loadSurvey,
+                 py::arg("legNoiseDisabled") = false,
+                 py::arg("rebuildScene") = false,
+                 py::arg("writeWaveform") = false,
+                 py::arg("calcEchowidth") = false,
+                 py::arg("fullWaveNoise") = false,
+                 py::arg("platformNoiseDisabled") = true)
+            .def("add_rotate_filter", &PyHeliosSimulation::addRotateFilter,
+                 py::arg("q0"), py::arg("q1"), py::arg("q2"), py::arg("q3"), py::arg("partId"))
+            .def("add_scale_filter", &PyHeliosSimulation::addScaleFilter,
+                 py::arg("scaleFactor"), py::arg("partId"))
+            .def("add_translate_filter", &PyHeliosSimulation::addTranslateFilter,
+                 py::arg("x"), py::arg("y"), py::arg("z"), py::arg("partId"))
+            .def("copy", &PyHeliosSimulation::copy)
+            .def("callback", &PyHeliosSimulation::setCallback)
+            .def("assoc_leg_with_scanning_strip", &PyHeliosSimulation::assocLegWithScanningStrip)
+            .def("remove_leg", &PyHeliosSimulation::removeLeg)
+            .def("new_leg", &PyHeliosSimulation::newLeg, py::return_value_policy::reference)
+            .def("new_scanning_strip", &PyHeliosSimulation::newScanningStrip)
+            .def("clear_callback", &PyHeliosSimulation::clearCallback)
+            .def("get_leg", &PyHeliosSimulation::getLeg, py::return_value_policy::reference)
+
+            .def_property("final_output",
+                          [](const PyHeliosSimulation &self) { return self.finalOutput; },
+                          [](PyHeliosSimulation &self, bool value) { self.finalOutput = value; })
+            .def_property("legacy_energy_model",
+                          [](const PyHeliosSimulation &self) { return self.legacyEnergyModel; },
+                          [](PyHeliosSimulation &self, bool value) { self.legacyEnergyModel = value; })
+            .def_property("export_to_file",
+                          [](const PyHeliosSimulation &self) { return self.exportToFile; },
+                          [](PyHeliosSimulation &self, bool value) { self.exportToFile = value; })
+
+            .def_property_readonly("is_started", &PyHeliosSimulation::isStarted)
+            .def_property_readonly("is_paused", &PyHeliosSimulation::isPaused)
+            .def_property_readonly("is_stopped", &PyHeliosSimulation::isStopped)
+            .def_property_readonly("is_finished", &PyHeliosSimulation::isFinished)
+            .def_property_readonly("is_running", &PyHeliosSimulation::isRunning)
+            .def_property_readonly("survey_path", &PyHeliosSimulation::getSurveyPath)
+            .def_property_readonly("assets_path", &PyHeliosSimulation::getAssetsPath)
+            .def_property("survey", &PyHeliosSimulation::getSurvey, &PyHeliosSimulation::setSurvey)
+            .def_property_readonly("scanner", &PyHeliosSimulation::getScanner)
+            .def_property_readonly("platform", &PyHeliosSimulation::getPlatform)
+            .def_property_readonly("scene", &PyHeliosSimulation::getScene)
+            .def_property_readonly("num_legs", &PyHeliosSimulation::getNumLegs)
+
+            .def_property("num_threads", &PyHeliosSimulation::getNumThreads, &PyHeliosSimulation::setNumThreads)
+            .def_property("callback_frequency", &PyHeliosSimulation::getCallbackFrequency, &PyHeliosSimulation::setCallbackFrequency)
+            .def_property("simulation_frequency", &PyHeliosSimulation::getSimFrequency, &PyHeliosSimulation::setSimFrequency)
+            .def_property("dyn_scene_step", &PyHeliosSimulation::getDynSceneStep, &PyHeliosSimulation::setDynSceneStep)
+            .def_property("fixed_gps_time_start", &PyHeliosSimulation::getFixedGpsTimeStart, &PyHeliosSimulation::setFixedGpsTimeStart)
+            .def_property("las_output", &PyHeliosSimulation::getLasOutput, &PyHeliosSimulation::setLasOutput)
+            .def_property("las10", &PyHeliosSimulation::getLas10, &PyHeliosSimulation::setLas10)
+            .def_property("zip_output", &PyHeliosSimulation::getZipOutput, &PyHeliosSimulation::setZipOutput)
+            .def_property("split_by_channel", &PyHeliosSimulation::getSplitByChannel, &PyHeliosSimulation::setSplitByChannel)
+            .def_property("las_scale", &PyHeliosSimulation::getLasScale, &PyHeliosSimulation::setLasScale)
+            .def_property("kdt_factory", &PyHeliosSimulation::getKDTFactory, &PyHeliosSimulation::setKDTFactory)
+            .def_property("kdt_jobs", &PyHeliosSimulation::getKDTJobs, &PyHeliosSimulation::setKDTJobs)
+            .def_property("kdt_SAH_loss_nodes", &PyHeliosSimulation::getKDTSAHLossNodes, &PyHeliosSimulation::setKDTSAHLossNodes)
+            .def_property("parallelization_strategy", &PyHeliosSimulation::getParallelizationStrategy, &PyHeliosSimulation::setParallelizationStrategy)
+            .def_property("chunk_size", &PyHeliosSimulation::getChunkSize, &PyHeliosSimulation::setChunkSize)
+            .def_property("warehouse_factor", &PyHeliosSimulation::getWarehouseFactor, &PyHeliosSimulation::setWarehouseFactor);
+
+
+            py::class_<SingleScanner, Scanner, std::shared_ptr<SingleScanner>> single_scanner(m, "SingleScanner");
+            single_scanner
+                .def(py::init<double, glm::dvec3, Rotation, std::list<int>, double, std::string, double, double, double, double, double, int, bool, bool, bool, bool, bool>(),
+                    py::arg("beam_div_rad"),
+                    py::arg("beam_origin"),
+                    py::arg("beam_orientation"),
+                    py::arg("pulse_freqs"),
+                    py::arg("pulse_length"),
+                    py::arg("id"),
+                    py::arg("average_power"),
+                    py::arg("beam_quality"),
+                    py::arg("efficiency"),
+                    py::arg("receiver_diameter"),
+                    py::arg("atmospheric_visibility"),
+                    py::arg("wavelength"),
+                    py::arg("write_waveform") = false,
+                    py::arg("write_pulse") = false,
+                    py::arg("calc_echowidth") = false,
+                    py::arg("full_wave_noise") = false,
+                    py::arg("platform_noise_disabled") = false
+                )
+                
+                .def_property(
+                    "supported_pulse_freqs_hz",
+                    [](SingleScanner &self) {
+                        return self.getSupportedPulseFreqs_Hz(0);  
+                    },
+                    [](SingleScanner &self, std::list<int> pulse_freqs) {
+                        self.setSupportedPulseFreqs_Hz(pulse_freqs, 0); 
+                    },
+                    py::return_value_policy::reference_internal
+                )
+                .def_property("pulse_freq_hz", &SingleScanner::getPulseFreq_Hz, &SingleScanner::setPulseFreq_Hz)
+
+                .def(py::init<SingleScanner&>(), py::arg("scanner"))
+                .def("apply_settings", &SingleScanner::applySettings, py::arg("settings"), py::arg("idx") = 0)
+                .def("do_sim_step", &SingleScanner::doSimStep, py::arg("leg_index"), py::arg("current_gps_time"))
+                .def("calc_rays_number", &SingleScanner::calcRaysNumber, py::arg("idx") = 0)
+                .def("prepare_discretization", &SingleScanner::prepareDiscretization, py::arg("idx") = 0)
+                .def("calc_atmospheric_attenuation", py::overload_cast<size_t>(&SingleScanner::calcAtmosphericAttenuation, py::const_))
+                .def("check_max_NOR", py::overload_cast<int, size_t>(&SingleScanner::checkMaxNOR))
+                .def("calc_absolute_beam_attitude", py::overload_cast<size_t>(&SingleScanner::calcAbsoluteBeamAttitude))       
+                .def("get_specific_current_pulse_number", py::overload_cast<size_t>(&SingleScanner::getCurrentPulseNumber, py::const_))
+                .def("get_specific_num_rays", py::overload_cast<size_t>(&SingleScanner::getNumRays, py::const_))
+                .def("set_specific_num_rays", py::overload_cast<int, size_t>(&SingleScanner::setNumRays))
+                .def("get_specific_pulse_length", py::overload_cast<size_t>(&SingleScanner::getPulseLength_ns, py::const_))
+                .def("set_specific_pulse_length", py::overload_cast<double, size_t>(&SingleScanner::setPulseLength_ns))
+                .def("get_specific_last_pulse_was_hit", py::overload_cast<size_t>(&SingleScanner::lastPulseWasHit, py::const_))
+                .def("set_specific_last_pulse_was_hit", py::overload_cast<bool, size_t>(&SingleScanner::setLastPulseWasHit))
+                .def("get_specific_beam_divergence", py::overload_cast<size_t>(&SingleScanner::getBeamDivergence, py::const_))
+                .def("set_specific_beam_divergence", py::overload_cast<double, size_t>(&SingleScanner::setBeamDivergence))
+
+                .def("get_max_nor", py::overload_cast<size_t>(&SingleScanner::getMaxNOR, py::const_), py::arg("index"))
+                .def("set_max_nor", py::overload_cast<int, size_t>(&SingleScanner::setMaxNOR), py::arg("value"), py::arg("index"))
+
+                .def("get_specific_average_power", py::overload_cast<size_t>(&SingleScanner::getAveragePower, py::const_), py::arg("index"))
+                .def("set_specific_average_power", py::overload_cast<double, size_t>(&SingleScanner::setAveragePower), py::arg("value"), py::arg("index"))
+                
+                .def("get_specific_beam_quality", py::overload_cast<size_t>(&SingleScanner::getBeamQuality, py::const_), py::arg("index"))
+                .def("set_specific_beam_quality", py::overload_cast<double, size_t>(&SingleScanner::setBeamQuality), py::arg("value"), py::arg("index"))
+
+                .def("get_specific_efficiency", py::overload_cast<size_t>(&SingleScanner::getEfficiency, py::const_), py::arg("index"))
+                .def("set_specific_efficiency", py::overload_cast<double, size_t>(&SingleScanner::setEfficiency), py::arg("value"), py::arg("index"))
+
+                .def("get_specific_receiver_diameter", py::overload_cast<size_t>(&SingleScanner::getReceiverDiameter, py::const_), py::arg("index"))
+                .def("set_specific_receiver_diameter", py::overload_cast<double, size_t>(&SingleScanner::setReceiverDiameter), py::arg("value"), py::arg("index"))
+
+                .def("get_specific_visibility", py::overload_cast<size_t>(&SingleScanner::getVisibility, py::const_), py::arg("index"))
+                .def("set_specific_visibility", py::overload_cast<double, size_t>(&SingleScanner::setVisibility), py::arg("value"), py::arg("index"))
+
+                .def("get_specific_wavelength", py::overload_cast<size_t>(&SingleScanner::getWavelength, py::const_), py::arg("index"))
+                .def("set_specific_wavelength", py::overload_cast<double, size_t>(&SingleScanner::setWavelength), py::arg("value"), py::arg("index"))
+
+                .def("get_specific_atmospheric_extinction", py::overload_cast<size_t>(&SingleScanner::getAtmosphericExtinction, py::const_), py::arg("index"))
+                .def("set_specific_atmospheric_extinction", py::overload_cast<double, size_t>(&SingleScanner::setAtmosphericExtinction), py::arg("value"), py::arg("index"))
+
+                .def("get_specific_beam_waist_radius", py::overload_cast<size_t>(&SingleScanner::getBeamWaistRadius, py::const_), py::arg("index"))
+                .def("set_specific_beam_waist_radius", py::overload_cast<double, size_t>(&SingleScanner::setBeamWaistRadius), py::arg("value"), py::arg("index"))
+
+                .def("get_head_relative_emitter_attitude", py::overload_cast<size_t>(&SingleScanner::getHeadRelativeEmitterAttitude, py::const_), py::arg("index"))
+                .def("set_head_relative_emitter_attitude", py::overload_cast<const Rotation&, size_t>(&SingleScanner::setHeadRelativeEmitterAttitude), py::arg("value"), py::arg("index"))
+
+                .def("get_head_relative_emitter_position", 
+                    &SingleScanner::getHeadRelativeEmitterPosition, 
+                    py::arg("index") )
+
+                .def("set_head_relative_emitter_position", 
+                    &SingleScanner::setHeadRelativeEmitterPosition, 
+                    py::arg("position"), py::arg("index"))
+                    
+                .def("get_head_relative_emitter_position_by_ref", 
+                    &SingleScanner::getHeadRelativeEmitterPositionByRef, 
+                    py::return_value_policy::reference_internal, 
+                    py::arg("index") )
+
+                .def("get_head_relative_emitter_attitude_by_ref", 
+                    &SingleScanner::getHeadRelativeEmitterAttitudeByRef, 
+                    py::return_value_policy::reference_internal, 
+                    py::arg("index"))
+
+                .def("get_bt2", &SingleScanner::getBt2, py::arg("index") )
+                .def("set_bt2", &SingleScanner::setBt2, py::arg("value"), py::arg("index") )
+
+                .def("get_dr2", &SingleScanner::getDr2, py::arg("index") )
+                .def("set_dr2", &SingleScanner::setDr2, py::arg("value"), py::arg("index") )
+
+                .def("get_detector", &SingleScanner::getDetector, py::arg("index") )
+                .def("set_detector", &SingleScanner::setDetector, py::arg("detector"), py::arg("index") )
+
+                .def("get_device_id", &SingleScanner::getDeviceId, py::arg("index"))
+                .def("set_device_id", &SingleScanner::setDeviceId, py::arg("device_id"), py::arg("index") )
+
+                .def("get_fwf_settings", &SingleScanner::getFWFSettings, py::arg("index") )
+                .def("set_fwf_settings", &SingleScanner::setFWFSettings, py::arg("fwf_settings"), py::arg("index") )
+
+                .def("get_num_time_bins", &SingleScanner::getNumTimeBins, py::arg("index") )
+                .def("set_num_time_bins", &SingleScanner::setNumTimeBins, py::arg("value"), py::arg("index"))
+
+                .def("get_time_wave", &SingleScanner::getTimeWave, py::arg("index") )
+                .def("set_time_wave",
+                        static_cast<void (SingleScanner::*)(std::vector<double>&, size_t)>(&SingleScanner::setTimeWave),
+                        py::arg("time_wave"), py::arg("index"))
+                    
+                .def("set_time_wave",
+                        [](SingleScanner& self, std::vector<double> time_wave, size_t index) {
+                            self.setTimeWave(std::move(time_wave), index);
+                        },
+                        py::arg("time_wave"), py::arg("index"))
+                .def("get_peak_intensity_index", &SingleScanner::getPeakIntensityIndex, py::arg("index") )
+                .def("set_peak_intensity_index", &SingleScanner::setPeakIntensityIndex, py::arg("value"), py::arg("index") )
+
+                .def("get_scanner_head", &SingleScanner::getScannerHead, py::arg("index") )
+                .def("set_scanner_head", &SingleScanner::setScannerHead, py::arg("scanner_head"), py::arg("index") )
+
+                .def("get_beam_deflector", &SingleScanner::getBeamDeflector, py::arg("index") )
+                .def("set_beam_deflector", &SingleScanner::setBeamDeflector, py::arg("beam_deflector"), py::arg("index") )
+                
+                .def("get_max_NOR", &SingleScanner::getMaxNOR, py::arg("index") )
+                .def("set_max_NOR", &SingleScanner::setMaxNOR, py::arg("value"), py::arg("index") )
+                .def("clone", &SingleScanner::clone);
+
+            
+            py::class_<MultiScanner, Scanner, std::shared_ptr<MultiScanner>> multi_scanner(m, "MultiScanner");
+            multi_scanner
+               .def(py::init<std::vector<ScanningDevice>, std::string, const std::list<int>&, bool, bool, bool, bool, bool>(),
+                    py::arg("scan_devs"),
+                    py::arg("id"),
+                    py::arg("pulse_freqs"),
+                    py::arg("write_waveform") = false,
+                    py::arg("write_pulse") = false,
+                    py::arg("calc_echowidth") = false,
+                    py::arg("full_wave_noise") = false,
+                    py::arg("platform_noise_disabled") = false)
+                .def(py::init<std::string, const std::list<int>&, bool, bool, bool, bool>(),
+                    py::arg("id"),
+                    py::arg("pulse_freqs"),
+                    py::arg("write_waveform") = false,
+                    py::arg("calc_echowidth") = false,
+                    py::arg("full_wave_noise") = false,
+                    py::arg("platform_noise_disabled") = false)
+                
+                .def("on_leg_complete", &MultiScanner::onLegComplete)
+                .def("prepare_simulation", &MultiScanner::prepareSimulation, py::arg("legacy_energy_model") = 0)
+                .def("apply_settings", &MultiScanner::applySettings, py::arg("settings"), py::arg("idx"))
+                .def("do_sim_step", &MultiScanner::doSimStep, py::arg("leg_index"), py::arg("current_gps_time"))
+                .def("calc_rays_number", &MultiScanner::calcRaysNumber, py::arg("idx"))
+                .def("prepare_discretization", &MultiScanner::prepareDiscretization, py::arg("idx"))
+                .def("calc_absolute_beam_attitude", &MultiScanner::calcAbsoluteBeamAttitude, py::arg("idx"))
+                .def("calc_atmospheric_attenuation", &MultiScanner::calcAtmosphericAttenuation, py::arg("idx"))
+                .def("check_max_nor", &MultiScanner::checkMaxNOR, py::arg("nor"), py::arg("idx"))
+                .def("compute_subrays", &MultiScanner::computeSubrays)
+                .def("initialize_full_waveform", &MultiScanner::initializeFullWaveform,
+                    py::arg("min_hit_dist_m"), py::arg("max_hit_dist_m"),
+                    py::arg("min_hit_time_ns"), py::arg("max_hit_time_ns"),
+                    py::arg("ns_per_bin"), py::arg("distance_threshold"),
+                    py::arg("peak_intensity_index"), py::arg("num_fullwave_bins"), py::arg("idx"))
+
+                .def("calc_intensity", 
+                    py::overload_cast<double, double, const Material&, int, size_t>(&MultiScanner::calcIntensity, py::const_))
+
+                .def("calc_intensity", 
+                    py::overload_cast<double, double, int, size_t>(&MultiScanner::calcIntensity, py::const_))
+
+                .def("set_device_index", &MultiScanner::setDeviceIndex, py::arg("new_idx"), py::arg("old_idx"))
+                 
+
+                .def("get_device_id", &MultiScanner::getDeviceId, py::arg("idx"))
+                .def("set_device_id", &MultiScanner::setDeviceId, py::arg("device_id"), py::arg("idx"))
+
+                .def("get_pulse_length", &MultiScanner::getPulseLength_ns, py::arg("idx"))
+                .def("set_pulse_length", &MultiScanner::setPulseLength_ns, py::arg("pulse_length"), py::arg("idx"))
+
+                .def("get_beam_divergence", &MultiScanner::getBeamDivergence, py::arg("idx"))
+                .def("set_beam_divergence", &MultiScanner::setBeamDivergence, py::arg("beam_divergence"), py::arg("idx"))
+
+                .def("get_average_power", &MultiScanner::getAveragePower, py::arg("idx"))
+                .def("set_average_power", &MultiScanner::setAveragePower, py::arg("average_power"), py::arg("idx"))
+
+                .def("get_num_rays", &MultiScanner::getNumRays, py::arg("idx"))
+                .def("set_num_rays", &MultiScanner::setNumRays, py::arg("num_rays"), py::arg("idx"))
+
+                .def("get_last_pulse_was_hit", &MultiScanner::lastPulseWasHit, py::arg("idx"))
+                .def("set_last_pulse_was_hit", &MultiScanner::setLastPulseWasHit, py::arg("last_pulse_was_hit"), py::arg("idx"))
+
+                .def("get_scanner_head", &MultiScanner::getScannerHead, py::arg("idx"))
+                .def("set_scanner_head", &MultiScanner::setScannerHead, py::arg("scanner_head"), py::arg("idx"))
+
+                .def("get_beam_deflector", &MultiScanner::getBeamDeflector, py::arg("idx"))
+                .def("set_beam_deflector", &MultiScanner::setBeamDeflector, py::arg("beam_deflector"), py::arg("idx"))
+
+                .def("get_detector", &MultiScanner::getDetector, py::arg("idx"))
+                .def("set_detector", &MultiScanner::setDetector, py::arg("detector"), py::arg("idx"))
+
+                .def("get_fwf_settings", &MultiScanner::getFWFSettings, py::arg("idx"))
+                .def("set_fwf_settings", &MultiScanner::setFWFSettings, py::arg("fwf_settings"), py::arg("idx"))
+
+                .def("get_beam_quality", &MultiScanner::getBeamQuality, py::arg("idx"))
+                .def("set_beam_quality", &MultiScanner::setBeamQuality, py::arg("beam_quality"), py::arg("idx"))
+
+                .def("get_efficiency", &MultiScanner::getEfficiency, py::arg("idx"))
+                .def("set_efficiency", &MultiScanner::setEfficiency, py::arg("efficiency"), py::arg("idx"))
+
+                .def("get_receiver_diameter", &MultiScanner::getReceiverDiameter, py::arg("idx"))
+                .def("set_receiver_diameter", &MultiScanner::setReceiverDiameter, py::arg("receiver_diameter"), py::arg("idx"))
+
+                .def("get_visibility", &MultiScanner::getVisibility, py::arg("idx"))
+                .def("set_visibility", &MultiScanner::setVisibility, py::arg("visibility"), py::arg("idx"))
+
+                .def("get_wavelength", &MultiScanner::getWavelength, py::arg("idx"))
+                .def("set_wavelength", &MultiScanner::setWavelength, py::arg("wavelength"), py::arg("idx"))
+
+                .def("get_atmospheric_extinction", &MultiScanner::getAtmosphericExtinction, py::arg("idx"))
+                .def("set_atmospheric_extinction", &MultiScanner::setAtmosphericExtinction, py::arg("atmospheric_extinction"), py::arg("idx"))
+
+                .def("get_beam_waist_radius", &MultiScanner::getBeamWaistRadius, py::arg("idx"))
+                .def("set_beam_waist_radius", &MultiScanner::setBeamWaistRadius, py::arg("beam_waist_radius"), py::arg("idx"))
+
+                .def("get_head_relative_emitter_position", &MultiScanner::getHeadRelativeEmitterPosition, py::arg("idx"))
+                .def("set_head_relative_emitter_position", &MultiScanner::setHeadRelativeEmitterPosition, py::arg("pos"), py::arg("idx"))
+
+                .def("get_head_relative_emitter_attitude", &MultiScanner::getHeadRelativeEmitterAttitude, py::arg("idx"))
+                .def("set_head_relative_emitter_attitude", &MultiScanner::setHeadRelativeEmitterAttitude, py::arg("attitude"), py::arg("idx"))
+
+                .def("get_head_relative_emitter_position_by_ref", &MultiScanner::getHeadRelativeEmitterPositionByRef, py::arg("idx") = 0)
+                .def("get_head_relative_emitter_attitude_by_ref", &MultiScanner::getHeadRelativeEmitterAttitudeByRef, py::arg("idx") = 0)
+                
+                .def("get_time_wave", &MultiScanner::getTimeWave, py::arg("index") )
+                .def("set_time_wave",
+                        static_cast<void (MultiScanner::*)(std::vector<double>&, size_t)>(&MultiScanner::setTimeWave),
+                        py::arg("time_wave"), py::arg("index"))
+                    
+                .def("set_time_wave",
+                        [](MultiScanner& self, std::vector<double> time_wave, size_t index) {
+                            self.setTimeWave(std::move(time_wave), index);
+                        },
+                        py::arg("time_wave"), py::arg("index"))
+                .def("get_bt2", &MultiScanner::getBt2, py::arg("idx"))
+                .def("set_bt2", &MultiScanner::setBt2, py::arg("bt2"), py::arg("idx"))
+
+                .def("get_dr2", &MultiScanner::getDr2, py::arg("idx"))
+                .def("set_dr2", &MultiScanner::setDr2, py::arg("dr2"), py::arg("idx"))
+
+                .def("get_current_pulse_number", &MultiScanner::getCurrentPulseNumber, py::arg("idx"))
+
+                .def("get_pulse_freqs", &MultiScanner::getSupportedPulseFreqs_Hz, py::arg("idx"))
+                .def("set_pulse_freqs", &MultiScanner::setSupportedPulseFreqs_Hz, py::arg("pulse_freqs_hz"), py::arg("idx"))
+
+                .def("get_max_nor", &MultiScanner::getMaxNOR, py::arg("idx"))
+                .def("set_max_nor", &MultiScanner::setMaxNOR, py::arg("max_nor"), py::arg("idx"))
+
+                .def("get_num_time_bins", &MultiScanner::getNumTimeBins, py::arg("idx"))
+                .def("set_num_time_bins", &MultiScanner::setNumTimeBins, py::arg("num_time_bins"), py::arg("idx"))
+
+                .def("get_peak_intensity_index", &MultiScanner::getPeakIntensityIndex, py::arg("idx"))
+                .def("set_peak_intensity_index", &MultiScanner::setPeakIntensityIndex, py::arg("peak_intensity_index"), py::arg("idx"))
+                
+                .def("get_received_energy_min", &MultiScanner::getReceivedEnergyMin, py::arg("idx"))
+                .def("set_received_energy_min", &MultiScanner::setReceivedEnergyMin, py::arg("received_energy_min"), py::arg("idx"))
+                .def("clone", &MultiScanner::clone);
+
+
+            py::class_<Simulation, SimulationWrap, std::shared_ptr<Simulation>> simulation(m, "Simulation");
+            simulation
+            
+                .def(py::init<int, std::shared_ptr<PulseThreadPoolInterface>, int, std::string, bool>(),
+                    py::arg("parallelizationStrategy"),
+                    py::arg("pulseThreadPoolInterface"),
+                    py::arg("chunkSize"),
+                    py::arg("fixedGpsTimeStart") = "",
+                    py::arg("legacyEnergyModel") = false
+                )
+
+                .def_readwrite("current_leg_index", &Simulation::mCurrentLegIndex)
+                .def_readwrite("callback", &Simulation::callback)
+                .def_readwrite("is_finished", &Simulation::finished)
+
+                .def_property("sim_speed_factor", &Simulation::getSimSpeedFactor, &Simulation::setSimSpeedFactor)
+                .def_property("scanner", &Simulation::getScanner, &Simulation::setScanner)
+                .def_property("simulation_frequency", &Simulation::getSimFrequency, &Simulation::setSimFrequency)
+                .def_property("callback_frequency", &Simulation::getCallbackFrequency, &Simulation::setCallbackFrequency)
+
+                .def("start", &Simulation::start)
+                .def("pause", &Simulation::pause)
+                .def("stop", &Simulation::stop);
+            
+
+            py::class_<FMSFacade, std::shared_ptr<FMSFacade>> fms_facade(m, "FMSFacade");
+            fms_facade
+                .def(py::init<>())
+                
+                .def_readwrite("factory", &FMSFacade::factory)
+                .def_readwrite("read", &FMSFacade::read)
+                .def_readwrite("write", &FMSFacade::write)
+                .def_readwrite("serialization", &FMSFacade::serialization)
+                
+                .def("disconnect", &FMSFacade::disconnect);
+
+
+            py::class_<FMSWriteFacade, std::shared_ptr<FMSWriteFacade>> fms_write_facade(m, "FMSWriteFacade");
+            fms_write_facade
+                .def(py::init<>())
+                .def("disconnect", &FMSWriteFacade::disconnect) 
+                .def("get_measurement_writer_output_path", &FMSWriteFacade::getMeasurementWriterOutputPath);
+
+
+            py::class_<FMSFacadeFactory, std::shared_ptr<FMSFacadeFactory>> fms_facade_factory(m, "FMSFacadeFactory");
+            fms_facade_factory
+                .def(py::init<>())
+
+                .def("build_facade", py::overload_cast<const std::string&, double, bool, bool, bool, bool, Survey&, bool>(&FMSFacadeFactory::buildFacade),
+                    py::arg("outdir"),
+                    py::arg("lasScale"),
+                    py::arg("lasOutput"),
+                    py::arg("las10"),
+                    py::arg("zipOutput"),
+                    py::arg("splitByChannel"),
+                    py::arg("survey"),
+                    py::arg("updateSurvey") = true)
+                
+                .def("build_facade", py::overload_cast<const std::string&, double, bool, bool, bool, Survey&, bool>(&FMSFacadeFactory::buildFacade),
+                    py::arg("outdir"),
+                    py::arg("lasScale"),
+                    py::arg("lasOutput"),
+                    py::arg("las10"),
+                    py::arg("zipOutput"),
+                    py::arg("survey"),
+                    py::arg("updateSurvey") = true);
+
+
+            py::class_<SurveyPlayback, Simulation, std::shared_ptr<SurveyPlayback>> survey_playback(m, "SurveyPlayback");
+            survey_playback
+                .def(py::init<std::shared_ptr<Survey>, std::shared_ptr<FMSFacade>, int, std::shared_ptr<PulseThreadPoolInterface>, int, std::string, bool, bool, bool>(),
+                    py::arg("survey"),
+                    py::arg("fms"),
+                    py::arg("parallelizationStrategy"),
+                    py::arg("pulseThreadPoolInterface"),
+                    py::arg("chunkSize"),
+                    py::arg("fixedGpsTimeStart"),
+                    py::arg("legacyEnergyModel"),
+                    py::arg("exportToFile") = true,
+                    py::arg("disableShutdown") = true)
+
+                .def_readwrite("fms", &SurveyPlayback::fms)
+                .def_readwrite("survey", &SurveyPlayback::mSurvey)
+
+                .def("do_sim_step", &SurveyPlayback::doSimStep);
+
+
+            py::class_<PulseThreadPoolFactory,  std::shared_ptr<PulseThreadPoolFactory>>(m, "PulseThreadPoolFactory")
+                .def(py::init<int, std::size_t, double, int, int>(),
+                    py::arg("parallelizationStrategy"),
+                    py::arg("poolSize"),
+                    py::arg("deviceAccuracy"),
+                    py::arg("chunkSize"),
+                    py::arg("warehouseFactor") = 1)
+                .def("make_pulse_thread_pool", &PulseThreadPoolFactory::makePulseThreadPool)
+                .def("make_basic_pulse_thread_pool", &PulseThreadPoolFactory::makeBasicPulseThreadPool)
+                .def("make_pulse_warehouse_thread_pool", &PulseThreadPoolFactory::makePulseWarehouseThreadPool);
+                
+
+            py::class_<PulseThreadPoolInterface, PulseThreadPoolInterfaceWrap, std::shared_ptr<PulseThreadPoolInterface>>(m, "PulseThreadPoolInterface")
+                .def(py::init<>())
+                .def("run_pulse_task", &PulseThreadPoolInterface::run_pulse_task)
+                .def("try_run_pulse_task", &PulseThreadPoolInterface::try_run_pulse_task)
+                .def("join", &PulseThreadPoolInterface::join);
+            
+            
+            py::class_<PulseWarehouseThreadPool, PulseThreadPoolInterface, std::shared_ptr<PulseWarehouseThreadPool>>(m, "PulseWarehouseThreadPool")
+                .def(py::init<std::size_t, double, std::size_t>(),
+                    py::arg("_pool_size"),
+                    py::arg("deviceAccuracy"),
+                    py::arg("maxTasks") = 256)
+                .def("run_pulse_task", &PulseWarehouseThreadPool::run_pulse_task,
+                    py::arg("dropper"))
+                .def("try_run_pulse_task", &PulseWarehouseThreadPool::try_run_pulse_task,
+                    py::arg("dropper"))
+                .def("join", &PulseWarehouseThreadPool::join); 
+            
+
+            py::class_<TaskDropper<PulseTask, PulseThreadPoolInterface, 
+                       std::vector<std::vector<double>>&,
+                       RandomnessGenerator<double>&, 
+                       RandomnessGenerator<double>&, 
+                       NoiseSource<double>&>>(m, "PulseTaskDropper")
+                .def(py::init<size_t>())
+                
+                .def("add", (bool (TaskDropper<PulseTask, PulseThreadPoolInterface, 
+                                std::vector<std::vector<double>>&,
+                                RandomnessGenerator<double>&, 
+                                RandomnessGenerator<double>&, 
+                                NoiseSource<double>&>::*)(std::shared_ptr<PulseTask>)) 
+                                &TaskDropper<PulseTask, PulseThreadPoolInterface, 
+                                std::vector<std::vector<double>>&,
+                                RandomnessGenerator<double>&, 
+                                RandomnessGenerator<double>&, 
+                                NoiseSource<double>&>::add)
+                
+                .def("drop", (void (TaskDropper<PulseTask, PulseThreadPoolInterface, 
+                                std::vector<std::vector<double>>&,
+                                RandomnessGenerator<double>&, 
+                                RandomnessGenerator<double>&, 
+                                NoiseSource<double>&>::*)()) 
+                                &TaskDropper<PulseTask, PulseThreadPoolInterface, 
+                                std::vector<std::vector<double>>&,
+                                RandomnessGenerator<double>&, 
+                                RandomnessGenerator<double>&, 
+                                NoiseSource<double>&>::drop)
+
+                .def("drop", (void (TaskDropper<PulseTask, PulseThreadPoolInterface, 
+                                std::vector<std::vector<double>>&,
+                                RandomnessGenerator<double>&, 
+                                RandomnessGenerator<double>&, 
+                                NoiseSource<double>&>::*)(std::vector<std::vector<double>>&,
+                                RandomnessGenerator<double>&, 
+                                RandomnessGenerator<double>&, 
+                                NoiseSource<double>&)) 
+                                &TaskDropper<PulseTask, PulseThreadPoolInterface, 
+                                std::vector<std::vector<double>>&,
+                                RandomnessGenerator<double>&, 
+                                RandomnessGenerator<double>&, 
+                       NoiseSource<double>&>::drop);
+
+
+            py::class_<ScanningPulseProcess, ScanningPulseProcessWrap, std::shared_ptr<ScanningPulseProcess>>(m, "ScanningPulseProcess")
+                .def(py::init<std::shared_ptr<Scanner>>())  
+                .def("handle_pulse_computation", &ScanningPulseProcess::handlePulseComputation)
+                .def("on_leg_complete", &ScanningPulseProcess::onLegComplete)
+                .def("on_simulation_finished", &ScanningPulseProcess::onSimulationFinished)
+                .def("get_scanner", &ScanningPulseProcess::getScanner)
+                .def("is_write_waveform", &ScanningPulseProcess::isWriteWaveform)
+                .def("is_calc_echowidth", &ScanningPulseProcess::isCalcEchowidth)
+                .def("get_all_measurements", &ScanningPulseProcess::getAllMeasurements, py::return_value_policy::reference_internal)
+                .def("get_all_measurements_mutex", &ScanningPulseProcess::getAllMeasurementsMutex, py::return_value_policy::reference_internal)
+                .def("get_cycle_measurements", &ScanningPulseProcess::getCycleMeasurements, py::return_value_policy::reference_internal)
+                .def("get_cycle_measurements_mutex", &ScanningPulseProcess::getCycleMeasurementsMutex, py::return_value_policy::reference_internal);
+
+
+            py::class_<BuddingScanningPulseProcess, ScanningPulseProcess, std::shared_ptr<BuddingScanningPulseProcess>>(m, "BuddingScanningPulseProcess")
+                .def(py::init<
+                    std::shared_ptr<Scanner>,
+                    PulseTaskDropper&,
+                    PulseThreadPool&,
+                    RandomnessGenerator<double>&,
+                    RandomnessGenerator<double>&,
+                    UniformNoiseSource<double>&
+#if DATA_ANALYTICS >= 2
+                    , std::shared_ptr<HDA_PulseRecorder>
+#endif
+                >(), 
+                py::arg("scanner"),
+                py::arg("dropper"),
+                py::arg("pool"),
+                py::arg("randGen1"),
+                py::arg("randGen2"),
+                py::arg("intersectionHandlingNoiseSource")
+#if DATA_ANALYTICS >= 2
+                , py::arg("pulseRecorder")
+#endif
+                )
+                .def("handle_pulse_computation", &BuddingScanningPulseProcess::handlePulseComputation)
+                .def("on_leg_complete", &BuddingScanningPulseProcess::onLegComplete)
+                .def("on_simulation_finished", &BuddingScanningPulseProcess::onSimulationFinished);
+        
+
+            py::class_<WarehouseScanningPulseProcess, ScanningPulseProcess, std::shared_ptr<WarehouseScanningPulseProcess>>(m, "WarehouseScanningPulseProcess")
+                .def(py::init<
+                    std::shared_ptr<Scanner>,
+                    PulseTaskDropper&,
+                    PulseWarehouseThreadPool&,
+                    RandomnessGenerator<double>&,
+                    RandomnessGenerator<double>&,
+                    UniformNoiseSource<double>&
+#if DATA_ANALYTICS >= 2
+                    , std::shared_ptr<HDA_PulseRecorder>
+#endif
+                >(), 
+                py::arg("scanner"),
+                py::arg("dropper"),
+                py::arg("pool"),
+                py::arg("randGen1"),
+                py::arg("randGen2"),
+                py::arg("intersectionHandlingNoiseSource")
+#if DATA_ANALYTICS >= 2
+                , py::arg("pulseRecorder")
+#endif
+                )
+                .def("handle_pulse_computation", &WarehouseScanningPulseProcess::handlePulseComputation)
+                .def("on_leg_complete", &WarehouseScanningPulseProcess::onLegComplete)
+                .def("on_simulation_finished", &WarehouseScanningPulseProcess::onSimulationFinished);
+            
+            
+            py::class_<KDGrove, std::shared_ptr<KDGrove>> kdgrove(m, "KDGrove");
+            kdgrove
+                .def(py::init<size_t>(), py::arg("initTreesCapacity") = 1);
+
+
+            py::class_<KDGroveFactory, std::shared_ptr<KDGroveFactory>>(m, "KDGroveFactory")
+                .def(py::init<std::shared_ptr<KDTreeFactory>>(), py::arg("kdtf"));
+
+
+            py::class_<KDTreeFactory, KDTreeFactoryWrap, std::shared_ptr<KDTreeFactory>>(m, "KDTreeFactory")
+                .def(py::init<>());
+            
+
+            py::class_<SimpleKDTreeFactory, KDTreeFactory, std::shared_ptr<SimpleKDTreeFactory>>(m, "SimpleKDTreeFactory")
+                .def(py::init<>());
+            
+
+            py::class_<SimpleKDTreeGeometricStrategy, std::shared_ptr<SimpleKDTreeGeometricStrategy>>(m, "SimpleKDTreeGeometricStrategy")
+                .def(py::init<SimpleKDTreeFactory&>(), py::arg("kdtf")); 
+
+            
+            py::class_<MultiThreadKDTreeFactory, SimpleKDTreeFactory, std::shared_ptr<MultiThreadKDTreeFactory>>(m, "MultiThreadKDTreeFactory")
+                .def(py::init<std::shared_ptr<SimpleKDTreeFactory>, std::shared_ptr<SimpleKDTreeGeometricStrategy>, size_t, size_t>(),
+                    py::arg("kdtf"),
+                    py::arg("gs"),
+                    py::arg("numJobs") = 2,
+                    py::arg("geomJobs") = 2);
+            
+
+           py::class_<SAHKDTreeGeometricStrategy, SimpleKDTreeGeometricStrategy, std::shared_ptr<SAHKDTreeGeometricStrategy>>(m, "SAHKDTreeGeometricStrategy")
+                .def(py::init<SAHKDTreeFactory&>(), py::arg("kdtf"));
+            
+
+            py::class_<SAHKDTreeFactory, SimpleKDTreeFactory, std::shared_ptr<SAHKDTreeFactory>>(m, "SAHKDTreeFactory")
+                .def(py::init<size_t, double, double, double>(),
+                    py::arg("lossNodes") = 21,
+                    py::arg("ci") = 1,
+                    py::arg("cl") = 1,
+                    py::arg("co") = 1);
+            
+
+            py::class_<MultiThreadSAHKDTreeFactory, MultiThreadKDTreeFactory, std::shared_ptr<MultiThreadSAHKDTreeFactory>>(m, "MultiThreadSAHKDTreeFactory")
+                .def(py::init<std::shared_ptr<SimpleKDTreeFactory>, std::shared_ptr<SimpleKDTreeGeometricStrategy>, size_t, size_t>(),
+                    py::arg("kdtf"),
+                    py::arg("gs"),
+                    py::arg("numJobs") = 2,
+                    py::arg("geomJobs") = 2);
+            
+
+            py::class_<AxisSAHKDTreeFactory, SAHKDTreeFactory, std::shared_ptr<AxisSAHKDTreeFactory>>(m, "AxisSAHKDTreeFactory")
+                .def(py::init<size_t, double, double, double>(),
+                    py::arg("lossNodes") = 21,
+                    py::arg("ci") = 1,
+                    py::arg("cl") = 1,
+                    py::arg("co") = 1);
+
+
+            py::class_<AxisSAHKDTreeGeometricStrategy, SAHKDTreeGeometricStrategy, std::shared_ptr<AxisSAHKDTreeGeometricStrategy>>(m, "AxisSAHKDTreeGeometricStrategy")
+                .def(py::init<AxisSAHKDTreeFactory&>(), py::arg("kdtf"));
+            
+            
+            py::class_<FastSAHKDTreeFactory, SAHKDTreeFactory, std::shared_ptr<FastSAHKDTreeFactory>>(m, "FastSAHKDTreeFactory")
+                .def(py::init<size_t, double, double, double>(),
+                    py::arg("lossNodes") = 32,
+                    py::arg("ci") = 1,
+                    py::arg("cl") = 1,
+                    py::arg("co") = 1);
+            
+
+            py::class_<FastSAHKDTreeGeometricStrategy, SAHKDTreeGeometricStrategy, std::shared_ptr<FastSAHKDTreeGeometricStrategy>>(m, "FastSAHKDTreeGeometricStrategy")
+                .def(py::init<FastSAHKDTreeFactory&>(),
+                    py::arg("kdtf"));
+
+
+        m.def("calc_time_propagation", &calcTimePropagation, py::arg("timeWave"), py::arg("numBins"), py::arg("scanner"));
+
+    }
+}
\ No newline at end of file
diff --git a/python/helios/helios_simulation.py b/python/helios/helios_simulation.py
new file mode 100644
index 000000000..91d28a394
--- /dev/null
+++ b/python/helios/helios_simulation.py
@@ -0,0 +1,56 @@
+# import _helios
+
+# class PyHeliosSimulation:
+#     def __init__(self, survey_path, assets_path, output_path="output/", **kwargs):
+#         self.survey = _helios.Survey()
+#         self.survey.load(survey_path)
+        
+#         self.playback = _helios.SurveyPlayback()
+#         # Initialize playback parameters if needed
+        
+#         self.platform = _helios.Platform()
+#         # Initialize platform parameters if needed
+        
+#         self.scanner = _helios.Scanner()
+#         # Initialize scanner parameters if needed
+        
+#         # Initialize other attributes as required
+#         self.output_path = output_path
+#         self.assets_path = assets_path
+#         self.started = False
+#         self.paused = False
+#         self.stopped = False
+#         # Initialize other attributes from kwargs as needed
+
+#     def start(self):
+#         # Implement start logic using _helios bindings
+#         self.started = True
+
+#     def pause(self):
+#         # Implement pause logic using _helios bindings
+#         self.paused = True
+
+#     def stop(self):
+#         # Implement stop logic using _helios bindings
+#         self.stopped = True
+
+#     def resume(self):
+#         # Implement resume logic using _helios bindings
+#         self.paused = False
+
+#     # Implement other methods similarly
+
+#     def is_started(self):
+#         return self.started
+
+#     def is_paused(self):
+#         return self.paused
+
+#     def is_stopped(self):
+#         return self.stopped
+
+#     def is_finished(self):
+#         # Implement finished logic if applicable
+#         return False
+
+#     # Implement getters and setters as needed
diff --git a/python/helios/leg.py b/python/helios/leg.py
new file mode 100755
index 000000000..0a63dca05
--- /dev/null
+++ b/python/helios/leg.py
@@ -0,0 +1,26 @@
+# from pydantic import BaseModel, Field, NonNegativeInt
+# from typing import Optional, Union
+# from helios.scannersettings import ScannerSettings
+# from helios.platformsettings import PlatformSettings
+
+# import numpy as np
+
+# class Leg(BaseModel):
+#     scanner_settings: Optional[ScannerSettings] = Field(default=None)
+#     platform_settings: Optional[PlatformSettings] = Field(default=None)
+#     trajectory_settings: Optional[TrajectorySettings] = Field(default=None)
+#     length: float = Field(default=0.0)
+#     serial_id: NonNegativeInt
+#     strip: Optional[ScanningStrip] = Field(default=None)
+#     was_processed: bool = Field(default=False)
+#     look_at: Optional[Union[np.ndarray, int]] = Field(default=None)  # Only for TLS!! Might transfer to utils
+#     position: Optional[np.ndarray] = Field(default=None)
+#     horizontal_fov: Optional[float] = Field(default=None)
+#     vertical_fov: Optional[float] = Field(default=None)
+#     horizontal_resolution: Optional[float] = Field(default=None)
+#     vertical_resolution: Optional[float] = Field(default=None)
+#     is_active: bool = Field(default=True)
+
+#     @property
+#     def belongs_to_strip(self) -> bool:
+#         return self.strip is not None
diff --git a/python/helios/platform.py b/python/helios/platform.py
new file mode 100755
index 000000000..baade5e62
--- /dev/null
+++ b/python/helios/platform.py
@@ -0,0 +1,169 @@
+
+# from typing import Optional
+# from pydantic import BaseModel
+# import numpy as np
+# import math
+# from helios.scene import Scene
+# from helios.platformsettings import PlatformSettings
+
+# class Platform(BaseModel):
+#     device_relative_position: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     device_relative_attitude: Rotation = Rotation()
+#     scene: Optional[Scene] = None
+
+#     position_x_noise_source: Optional[NoiseSource] = None
+#     position_y_noise_source: Optional[NoiseSource] = None
+#     position_z_noise_source: Optional[NoiseSource] = None
+#     attitude_x_noise_source: Optional[NoiseSource] = None
+#     attitude_y_noise_source: Optional[NoiseSource] = None
+#     attitude_z_noise_source: Optional[NoiseSource] = None
+
+#     settings_speed_m_s: float = 0.0
+#     _origin_waypoint: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     _target_waypoint: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     _next_waypoint: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     is_on_ground: bool = False
+#     is_stop_and_turn: bool = True
+#     is_smooth_turn: bool = False
+#     is_slowdown_enabled: bool = True
+
+#     _position: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     _attitude: Rotation = Rotation()
+#     #caches
+#     cached_absolute_mount_position: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     cached_absolute_mount_attitude: Rotation = Rotation()
+#     cached_dir_current: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     cached_dir_current_xy: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     cached_array_to_target: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     cached_array_to_target_xy: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     cached_distance_to_target_xy: float = 0.0
+#     cached_origin_to_target_dir_xy: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     cached_target_to_next_dir_xy: np.ndarray = np.array([0.0, 0.0, 0.0])
+#     cached_end_target_angle_xy: float = 0.0
+#     cached_current_angle_xy: float = 0.0
+#     cached_origin_to_target_angle_xy: float = 0.0
+#     cached_target_to_next_angle_xy: float = 0.0
+
+
+#     #Проверить нужны ли эти декораторы во всех файлах!!!!!!
+#     @property
+#     def absolute_mount_attitude(self) -> Rotation:
+#         return self.cached_absolute_mount_attitude
+
+#     @property
+#     def absolute_mount_position(self) -> np.ndarray:
+#         return self.cached_absolute_mount_position
+    
+#     @property
+#     def attitude(self) -> Rotation:
+#         return self._attitude
+
+#     @attitude.setter
+#     def attitude(self, value: Rotation):
+#         self._attitude = value
+#         self.cached_absolute_mount_attitude = self._attitude.Rotation.apply_to(self.device_relative_attitude)
+
+#     @property
+#     def position(self) -> np.ndarray:
+#         return self._position
+    
+#     @position.setter
+#     def position(self, value: np.ndarray):
+#         self._position = value
+#         self.cached_absolute_mount_position = self._position + self.device_relative_position
+#         self.update_dynamic_cache()
+
+#     @property
+#     def origin_waypoint(self) -> np.ndarray:
+#         return self._origin_waypoint
+    
+#     @origin_waypoint.setter
+#     def origin_waypoint(self, value: np.ndarray):
+#         self._origin_waypoint = value
+#         self.update_static_cache()
+    
+#     @property
+#     def target_waypoint(self) -> np.ndarray:
+#         return self._target_waypoint
+    
+#     @target_waypoint.setter
+#     def target_waypoint(self, value: np.ndarray):
+#         self._target_waypoint = value
+#         self.update_static_cache()
+
+#     @property
+#     def next_waypoint(self) -> np.ndarray:
+#         return self._next_waypoint
+    
+#     @next_waypoint.setter
+#     def next_waypoint(self, value: np.ndarray):
+#         self._next_waypoint = value
+#         self.update_static_cache()
+
+#     @property
+#     def current_settings(self) -> PlatformSettings:
+#         current_settings = PlatformSettings()
+#         current_settings.speed_m_s = self.settings_speed_m_s
+#         current_settings.is_on_ground = self.is_on_ground
+#         current_settings.position(self.position)
+#         return self.current_settings
+    
+#     def apply_settings(self, settings: PlatformSettings) -> None:
+#         self.settings_speed_m_s = settings.speed_m_s
+#         self.is_on_ground = settings.is_on_ground
+#         self.position = settings.position
+    
+#     @property
+#     def current_direction(self) -> np.ndarray:
+#         return self.cached_current_direction
+    
+#     @property
+#     def is_interpolated(self) -> bool:
+#         return self.cached_is_interpolating
+
+        
+#     def update_static_cache(self) -> None:
+#         self.cached_origin_to_target_dir_xy = np.array([
+#             self.target_waypoint[0] - self.origin_waypoint[0],
+#             self.target_waypoint[1] - self.origin_waypoint[1],
+#             0.0
+#         ])
+#         self.cached_target_to_next_dir_xy = np.array([
+#             self.next_waypoint[0] - self.target_waypoint[0],
+#             self.next_waypoint[1] - self.target_waypoint[1],
+#             0.0
+#         ])
+#         self.cached_end_target_angle_xy = np.arccos(
+#             np.dot(self.cached_origin_to_target_dir_xy, self.cached_target_to_next_dir_xy) /
+#             (np.linalg.norm(self.cached_origin_to_target_dir_xy) * np.linalg.norm(self.cached_target_to_next_dir_xy))
+#         )
+#         if np.isnan(self.cached_end_target_angle_xy):
+#             self.cached_end_target_angle_xy = 0.0
+#         self.cached_origin_to_target_angle_xy = self.direction_to_angle_xy(self.cached_origin_to_target_dir_xy, True) # this function should be moved to a separate class
+#         self.cached_target_to_next_angle_xy = self.direction_to_angle_xy(self.cached_target_to_next_dir_xy, True) # this function should be moved to a separate class
+#         self.update_dynamic_cache()
+
+#     def update_dynamic_cache(self) -> None:
+#         self.cached_array_to_target = self.target_waypoint - self.position
+#         self.cached_array_to_target_xy = np.array([self.cached_array_to_target[0], self.cached_array_to_target[1], 0.0])
+#         self.cached_distance_to_target_xy = np.linalg.norm(self.cached_array_to_target_xy)
+#         self.cached_dir_current = self.current_direction()
+#         self.cached_dir_current_xy = np.array([self.cached_dir_current[0], self.cached_dir_current[1], 0.0])
+#         self.cached_current_angle_xy = np.arccos(
+#             np.dot(self.cached_dir_current_xy, self.cached_target_to_next_dir_xy) /
+#             (np.linalg.norm(self.cached_dir_current_xy) * np.linalg.norm(self.cached_target_to_next_dir_xy))
+#         )
+#         if np.isnan(self.cached_current_angle_xy):
+#             self.cached_current_angle_xy = 0.0
+
+
+#     def direction_to_angle_xy(self, direction: np.ndarray, is_normalized: bool) -> float: # this function should be moved to a separate class
+#         angle = np.arctan2(direction[0], direction[1])
+#         if is_normalized and angle < 0.0:
+#             angle += np.pi * 2
+#         return angle
+    
+#     def get_by_name(self, name: str) -> Optional['Platform']:
+#         if self.name == name:
+#             return self
+#         return None
\ No newline at end of file
diff --git a/python/helios/platformsettings.py b/python/helios/platformsettings.py
new file mode 100755
index 000000000..6c17e0d86
--- /dev/null
+++ b/python/helios/platformsettings.py
@@ -0,0 +1,38 @@
+# from pydantic import BaseModel
+# from typing import Optional, Set
+
+
+# class PlatformSettings(BaseModel):
+#     name: str = "#nullid#"
+#     basic_template: Optional["PlatformSettings"] = None
+#     x: float = 0.0
+#     y: float = 0.0
+#     z: float = 0.0 # combine 3 coordinates into a tuple?
+#     is_yaw_angle_specified: bool = False
+#     yaw_angle: float = 0.0
+#     is_on_ground: bool = False
+#     is_stop_and_turn: bool = True
+#     is_smooth_turn: bool = False
+#     is_slowdown_enabled: bool = True
+#     speed_m_s: float = 70.0
+#     altitude: float = 0.0 
+
+
+#     def cherry_pick(self, cherries: "PlatformSettings", fields: Set[str], template_fields: Optional[Set[str]] = None) -> "PlatformSettings":
+#         settings = self.model_copy(deep=True)
+#         for field in fields:
+#             if hasattr(cherries, field):
+#                 setattr(settings, field, getattr(cherries, field))
+#         if "basic_template" in fields and cherries.basic_template:
+#             if template_fields:
+#                 settings.basic_template = cherries.basic_template.cherry_pick(cherries.basic_template, template_fields)
+#             else:
+#                 settings.basic_template = cherries.basic_template.model_copy(deep=True)
+#         return settings
+    
+#     @property
+#     def has_template(self) -> bool:
+#         return self.basic_template is not None
+
+
+
diff --git a/python/helios/scanner.py b/python/helios/scanner.py
new file mode 100755
index 000000000..2b6886ab6
--- /dev/null
+++ b/python/helios/scanner.py
@@ -0,0 +1,79 @@
+# from typing import Optional, List
+# from pydantic import BaseModel, Field
+# import numpy as np
+# import threading
+# import json
+# from xml.etree.ElementTree import Element, SubElement, tostring, ElementTree
+
+# from helios.platform import Platform
+# from helios.platformsettings import PlatformSettings
+# from helios.scannersettings import ScannerSettings
+
+
+# class Scanner(BaseModel):
+#     name: str = Field(default="SCANNER-ID")
+#     write_waveform: bool = Field(default=False)
+#     write_pulse: bool = Field(default=False)
+#     calc_echowidth: bool = Field(default=False)
+#     full_wave_noise: bool = Field(default=False)
+#     platform_noise_disabled: bool = Field(default=False)
+#     fixed_incidence_angle: bool = Field(default=False)
+#     pulse_frequency: int = Field(default=0)
+#     is_state_active: bool = Field(default=True)
+#     trajectory_time_interval: float = Field(default=0.0)
+#     last_trajectory_time: float = Field(default=0.0)
+
+#     platform: Optional[Platform] = None
+#     scanning_pulse_process: Optional[ScanningPulseProcess] = None
+#     fms: Optional[FMSFacade] = None 
+#     output_paths: Optional[List[str]] = None
+#     all_measurements: Optional[List[Measurement]] = None
+#     all_trajectories: Optional[List[Trajectory]] = None
+#     all_measurements_mutex: Optional[threading.Lock] = None
+#     cycle_measurements: Optional[List[Measurement]] = None
+#     cycle_trajectories: Optional[List[Trajectory]] = None
+#     cycle_measurements_mutex: Optional[threading.Lock] = None
+#     rand_gen1: Optional[RandomnessGenerator] = None
+#     rand_gen2: Optional[RandomnessGenerator] = None
+#     intersection_handling_noise_source: Optional[UniformNoiseSource] = None
+
+
+#     @property
+#     def current_settings(self) -> ScannerSettings:
+#         current_settings = ScannerSettings(
+#             name=f"{self.name}_settings",
+#             pulse_frequency=self.pulse_frequency,
+#             is_active=self.is_state_active,
+#             beam_divergence_angle=self.beam_divergence_angle(0),
+#             trajectory_time_interval=self.trajectory_time_interval / 1e9,
+#             head_rotation=self.get_scanner_head(0).get_rotate_start(),
+#             rotation_start_angle=self.get_scanner_head(0).get_rotate_current(),
+#             rotation_stop_angle=self.get_scanner_head(0).get_rotate_stop(),
+#             scan_angle=self.get_beam_deflector(0).cfg_setting_scanAngle_rad,
+#             scan_frequency=self.get_beam_deflector(0).cfg_setting_scanFreq_Hz,
+#             min_vertical_angle=self.get_beam_deflector(0).cfg_setting_minVerticalAngle_rad,
+#             max_vertical_angle=self.get_beam_deflector(0).cfg_setting_maxVerticalAngle_rad
+#         )
+#         return current_settings
+
+#     def get_scanner_by_name(self, name: str) -> Optional['Scanner']:
+#         if self.name == name:
+#             return self
+#         return None
+
+#     def to_file(self, filename: str, format: str = 'json') -> None:
+#         if format == 'json':
+#             with open(filename, 'w') as file:
+#                 json.dump(self.dict(), file)
+#         elif format == 'xml':
+#             with open(filename, 'w') as file:
+#                 file.write(self.to_xml())
+#         else:
+#             raise ValueError(f"Unsupported format: {format}")
+
+#     def to_xml(self) -> str:
+#         root = Element('Scanner')
+#         for field, value in self.dict().items():
+#             child = SubElement(root, field)
+#             child.text = str(value)
+#         return tostring(root, encoding='unicode')
diff --git a/python/helios/scannersettings.py b/python/helios/scannersettings.py
new file mode 100755
index 000000000..e2ce65321
--- /dev/null
+++ b/python/helios/scannersettings.py
@@ -0,0 +1,120 @@
+# from pydantic import BaseModel, Field
+# from typing import Optional, Set
+# import numpy as np
+# import json
+
+
+# class ScannerSettings(BaseModel):
+#     name: str = Field("#nullid#", description="The name of the scanner settings.")
+#     _basic_template: Optional["ScannerSettings"] = Field(None, description="A template to base settings off of.")
+#     is_active: Optional[bool] = Field(True, description="Whether the scanner is active.")
+#     head_rotation: Optional[float] = Field(0.0, description="The rotation angle of the scanner head.")
+#     rotation_start_angle: Optional[float] = Field(0.0, description="The starting angle for rotation.")
+#     rotation_stop_angle: Optional[float] = Field(0.0, description="The stopping angle for rotation.")
+#     pulse_frequency: Optional[int] = Field(0, description="The frequency of pulses emitted by the scanner.")
+#     scan_angle: Optional[float] = Field(0.0, description="The scanning angle of the scanner.")
+#     min_vertical_angle: Optional[float] = Field(None, description="Minimum vertical scanning angle.")
+#     max_vertical_angle: Optional[float] = Field(None, description="Maximum vertical scanning angle.")
+#     scan_frequency: Optional[float] = Field(0.0, description="The frequency at which the scanner operates.")
+#     beam_divergence_angle: Optional[float] = Field(0.003, description="The divergence angle of the scanner beam.")
+#     trajectory_time_interval: Optional[float] = Field(0.0, description="Time interval for the trajectory.")
+#     vertical_resolution: Optional[float] = Field(0.0, description="Vertical resolution of the scanner.")
+#     horizontal_resolution: Optional[float] = Field(0.0, description="Horizontal resolution of the scanner.")
+#     vertical_fov: Optional[int] = Field(0, description="Vertical field of view.")
+#     horizontal_fov: Optional[int] = Field(0, description="Horizontal field of view.")
+#     optics: Optional[str] = Field(None, description="Type of optics used.")
+#     accuracy: Optional[float] = Field(None, description="Accuracy of the scanner.")
+#     beam_divergence_radius: Optional[float] = Field(None, description="Beam divergence radius.")
+#     max_nor: Optional[float] = Field(None, description="Maximum number of returns.")
+#     max_scan_angle: Optional[float] = Field(None, description="Maximum scan angle.")
+#     max_effective_scan_angle: Optional[float] = Field(None, description="Maximum effective scan angle.")
+#     min_scanner_frequency: Optional[float] = Field(None, description="Minimum scanner frequency.")
+#     max_scanner_frequency: Optional[float] = Field(None, description="Maximum scanner frequency.")
+#     beam_sample_quality: Optional[float] = Field(None, description="Quality of beam sampling.")
+#     beam_origin: Optional[np.ndarray] = Field(None, description="Origin of the scanner beam.")
+#     head_rotation_axis: Optional[np.ndarray] = Field(None, description="Axis of head rotation.")
+
+
+#     def cherry_pick(self, cherries: "ScannerSettings", fields: Set[str], template_fields: Optional[Set[str]] = None) -> "ScannerSettings":
+#         settings = self.model_copy(deep=True)
+#         for field in fields:
+#             if hasattr(cherries, field):
+#                 setattr(settings, field, getattr(cherries, field))
+
+#         if "basic_template" in fields and cherries._basic_template:
+#             if template_fields:
+#                 settings._basic_template = cherries._basic_template.cherry_pick(cherries._basic_template, template_fields)
+#             else:
+#                 settings._basic_template = cherries._basic_template.copy(deep=True)
+        
+#         return settings
+
+#     @property
+#     def has_template(self) -> bool:
+#         """
+#         Checks if the ScannerSettings object has a basic template.
+
+#         Returns:
+#             bool: True if the _basic_template is set, False othyour_moduleerwise.
+#         """
+#         return self._basic_template is not None
+
+#     @property
+#     def basic_template(self) -> 'ScannerSettings':
+#         """
+#         Returns the basic template associated with the ScannerSettings object.
+
+#         Returns:
+#             ScannerSettings: The basic template.
+
+#         Raises:
+#             ValueError: If no template is associated.
+#         """
+#         if self._basic_template is None:
+#             raise ValueError("No template associated with this ScannerSettings.")
+#         return self._basic_template
+
+#     @property
+#     def has_default_resolution(self) -> bool:
+#         """
+#         Checks if the ScannerSettings object has default resolution values.
+
+#         Returns:
+#             bool: True if both vertical and horizontal resolutions are 0.0, False otherwise.
+#         """
+#         return self.vertical_resolution == 0.0 and self.horizontal_resolution == 0.0
+    
+#     def fit_to_resolution(self, scan_angle_max_rad: float) -> None:
+#         """
+#         Adjusts the scan frequency and head rotation per second based on the resolution and maximum scan angle.
+
+#         Args:
+#             scan_angle_max_rad (float): The maximum scan angle in radians.
+#         """
+#         self.scan_frequency = (self.pulse_frequency * self.vertical_resolution) / (2.0 * scan_angle_max_rad)
+#         self.head_rotation = self.horizontal_resolution * self.scan_frequency
+
+#     @classmethod
+#     def create_preset(cls, name: str, pulse_frequency: int, horizontal_resolution: float, vertical_resolution: float, 
+#                       horizontal_fov: int, min_vertical_angle: float, max_vertical_angle: float, 
+#                       save_as: Optional[str] = None) -> 'ScannerSettings':
+        
+#         preset = ScannerSettings(name=name, pulse_frequency=pulse_frequency,
+#                                  horizontal_resolution=horizontal_resolution,
+#                                  vertical_resolution=vertical_resolution,
+#                                  horizontal_fov=horizontal_fov,
+#                                  min_vertical_angle=min_vertical_angle,
+#                                  max_vertical_angle=max_vertical_angle)
+#         if save_as:
+#             preset.to_file(save_as)
+#         return preset
+
+#     def to_file(self, file_path: str) -> None:
+#         with open(file_path, 'w') as file:
+#             json.dump(self.dict(), file)
+        
+#     @staticmethod
+#     def load_preset(file_path: str) -> 'ScannerSettings':
+#         with open(file_path, 'r') as file:
+#             preset_data = json.load(file)
+#         return ScannerSettings(**preset_data)
\ No newline at end of file
diff --git a/python/helios/scenepart.py b/python/helios/scenepart.py
new file mode 100755
index 000000000..cc06ce9d5
--- /dev/null
+++ b/python/helios/scenepart.py
@@ -0,0 +1,140 @@
+# from typing import Optional, List
+# from pydantic import BaseModel, Field
+# import numpy as np
+# import os
+# from pathlib import Path
+# import open3d as o3d
+# from enum import Enum
+
+# class PrimitiveType(str, Enum):
+#     NONE = "NONE"
+#     TRIANGLE = "TRIANGLE"
+#     VOXEL = "VOXEL"
+
+# class ObjectType(str, Enum):
+#     STATIC_OBJECT = "STATIC_OBJECT"
+#     DYN_OBJECT = "DYN_OBJECT"
+#     DYN_MOVING_OBJECT = "DYN_MOVING_OBJECT"
+
+# class ScenePart(BaseModel):
+#     name: str = Field(default="")
+#     primitive_type: PrimitiveType = Field(default=PrimitiveType.NONE)
+#     object_type: ObjectType = Field(default=ObjectType.STATIC_OBJECT)
+
+#     subpart_borders: List[int] = Field(default_factory=list)
+#     ray_intersection_mode: str = Field(default="")
+#     ray_intersection_argument: bool = Field(default=False)
+#     random_shift: bool = Field(default=False)
+#     origin: np.ndarray = Field(default_factory=lambda: np.array([0.0, 0.0, 0.0]))
+#     rotation: np.ndarray = Field(default_factory=lambda: np.eye(3))  # Assuming rotation is a 3x3 matrix
+#     scale: float = Field(default=1.0)
+#     centroid: np.ndarray = Field(default_factory=lambda: np.array([0.0, 0.0, 0.0]))
+
+#     motions: List[dict] = Field(default_factory=list)
+#     is_on_ground: bool = Field(default=True)
+#     time_step_duration: float = Field(default=0.0)
+
+#     @classmethod
+#     def from_file(cls, filename: str, file_format: Optional[str] = None) -> 'ScenePart':
+#         if not os.path.exists(filename):
+#             raise FileNotFoundError(f"File {filename} not found.")
+        
+#         if file_format is None:
+#             file_format = Path(filename).suffix[1:].lower()
+        
+#         # Logic to handle different file formats
+#         method_name = f"from_{file_format}"
+#         if hasattr(cls, method_name):
+#             method = getattr(cls, method_name)
+#             return method(filename)
+#         else:
+#             raise ValueError(f"Unsupported file format: {file_format}")
+
+#     @staticmethod
+#     def from_obj(filename: str) -> 'ScenePart':
+#         # Implement OBJ file processing logic
+#         pass
+
+#     @staticmethod
+#     def from_tiff(filename: str) -> 'ScenePart':
+#         # Implement TIFF file processing logic
+#         pass
+
+#     @staticmethod
+#     def from_xml(filename: str) -> 'ScenePart':
+#         # Implement XML file processing logic
+#         pass
+
+#     @staticmethod
+#     def from_json(filename: str) -> 'ScenePart':
+#         # Implement JSON file processing logic
+#         pass
+
+#     @staticmethod
+#     def from_csv(filename: str) -> 'ScenePart':
+#         # Implement CSV file processing logic
+#         pass
+
+#     @staticmethod
+#     def from_xyz(filename: str) -> 'ScenePart':
+#         # Implement XYZ file processing logic
+#         pass
+
+#     @staticmethod
+#     def from_las(filename: str) -> 'ScenePart':
+#         # Implement LAS file processing logic
+#         pass
+
+#     def from_o3d(self, o3d_mesh: o3d.geometry.TriangleMesh):
+#         # Implement processing logic for Open3D mesh
+#         pass
+
+#     def transform(
+#         self, 
+#         translation: Optional[np.ndarray] = None, 
+#         scale: Optional[float] = None, 
+#         is_on_ground: Optional[bool] = True, 
+#         apply_to_axis: Optional[int] = None
+#     ) -> 'ScenePart':
+#         # Implement transformation logic
+#         pass
+    
+#     def rotate(
+#         self, 
+#         axis: Optional[np.ndarray] = None, 
+#         angle: Optional[float] = None, 
+#         origin: Optional[np.ndarray] = None, 
+#         rotation: Optional[np.ndarray] = None, 
+#         matrix: Optional[np.ndarray] = None, 
+#         euler_angles: Optional[np.ndarray] = None
+#     ):
+#         # Implement rotation logic
+#         pass
+    
+#     def make_motion(
+#         self, 
+#         translation: Optional[np.ndarray] = None, 
+#         rotation_axis: Optional[np.ndarray] = None, 
+#         rotation_angle: Optional[float] = None, 
+#         radians: Optional[bool] = True,
+#         rotation_center: Optional[np.ndarray] = None, 
+#         loop: Optional[int] = 1, 
+#         rotate_around_self: Optional[bool] = False, 
+#         auto_crs: Optional[bool] = False
+#     ):
+#         # Implement motion logic
+#         pass
+
+#     def make_motion_sequence(
+#         self, 
+#         translations: Optional[List[np.ndarray]] = None, 
+#         rotation_axes: Optional[List[np.ndarray]] = None, 
+#         rotation_angles: Optional[List[float]] = None, 
+#         radians: Optional[bool] = True,
+#         rotation_centers: Optional[List[np.ndarray]] = None, 
+#         loop: Optional[int] = 1, 
+#         rotate_around_self: Optional[bool] = False, 
+#         auto_crs: Optional[bool] = False
+#     ):
+#         # Implement motion sequence logic
+#         pass
diff --git a/python/helios/survey.py b/python/helios/survey.py
new file mode 100755
index 000000000..1987f541a
--- /dev/null
+++ b/python/helios/survey.py
@@ -0,0 +1,137 @@
+# from pydantic import BaseModel
+# from typing import Optional, Union, List
+# from helios.scanner import Scanner
+# from helios.leg import Leg 
+# import math
+# from helios.scene import Scene
+# from helios.scannersettings import ScannerSettings
+# from helios.platform import Platform
+# from helios.platformsettings import PlatformSettings
+
+# import xml.etree.ElementTree as ET
+# import numpy as np
+
+# class Survey(BaseModel):
+#     name: str = "Unnamed Survey Playback"
+#     num_runs: int = -1
+#     scanner: Optional[Scanner] = None
+#     sim_speed_factor: float = 1.0
+#     legs: List[Leg] = []
+#     length: float = 0.0
+
+#     scene: Optional[Scene] = None
+#     scanner_settings: Optional[ScannerSettings] = None
+#     platform: Optional[Platform] = None
+#     platform_settings: Optional[PlatformSettings] = None
+#     trajectory_time_interval: float = 0.0
+#     trajectory: Optional[Trajectory] = None
+
+#     fullwave_settings: Optional[dict] = None
+#     run_threads: int = 0
+#     save_config: bool = False
+#     output_format: Optional[str] = None
+#     output_path: Optional[str] = None
+#     write_waveform: bool = False
+#     calc_echo_width: bool = False
+#     gps_start_time: Optional[str] = None
+#     on_finished_callback: Optional[callable] = None
+#     on_progress_callback: Optional[callable] = None
+#     is_running_flag: bool = False
+    
+#     #instead of propose functionality we first would create a Leg object, and then add it to survey legs 
+#     def add_leg(self, leg: Leg):
+#         if self._trajectory is not None:
+#             raise ValueError("Adding legs to a survey with an existing trajectory is not supported. "
+#                              "Set the trajectory to None first explicitly.")
+#         else:
+#             if leg not in self.legs:
+#                 self.legs.append(leg)
+
+#     def add_legs(self, horizontal_fov: float, scan_pattern: Union[ScannerSettings, List[ScannerSettings]], pos: List[List[float]]):
+#         legs = create_legs(horizontal_fov, scan_pattern, pos)
+#         self.legs.extend(legs)
+
+#     def remove_leg(self, leg_index: int):
+#         try:
+#             del self.legs[leg_index]
+#         except IndexError:
+#              raise ValueError(f"Leg index {leg_index} is out of range!")
+
+#     def calculate_length(self): 
+#         self._length = 0
+#         for i in range(len(self.legs) - 1):
+#             leg_distance = math.dist(self.legs[i].position, self.legs[i + 1].position)
+#             self.legs[i].set_length(leg_distance)
+#             self._length += self.legs[i].get_length()
+
+    
+#     def fullwave(self, **kwargs):
+#         self._fullwave_settings = kwargs
+
+#     def output(self):
+#         pass
+
+    
+#     def preview(self):
+#         ''' # some kind of visualization? e.g., 2D map preview, 3D preview with scene and markers for SPs/waypoints, etc.
+#             # survey.preview("2D")
+#             # survey.preview("3D")  # similar to scene.show(), but with marker (e.g. diamonds) for leg positions;
+#             # for static platforms also show movement direction and orientation of platform
+#         '''
+#         pass
+
+#     def save_report(self, filename: str):
+#         '''
+#         Alberto:
+#         Also as this is a research software, I think writing some tables
+#         and/or CSV files with the characteristics of the survey would be nice.
+#         I mean things such as the number of primitives, vertices, the simulation
+#         time (not the execution time), the volume of the bounding box, the
+#         depth for each KDTree in the KDGrove, etc.
+#         Hannah: Yes, so something like a "report" or "summary", see below
+#         '''
+#         pass
+
+#     def set_trajectory(self, trajectory: Union[Trajectory, str]) -> None:
+#         if self.trajectory is not None:
+#             raise ValueError("Overwriting a trajectory in a survey is not supported. Set it to None first explicitly.")
+#         if isinstance(trajectory, str):
+#             self.trajectory = Trajectory.from_file(trajectory)
+#         else:
+#             self.trajectory = trajectory
+
+
+
+#     def run(self,filename: str = None):
+#         #if filename is none, then run the survey without saving the output):
+#         self.is_running = True
+#         callback_counter = 0
+#         mpoints = []
+#         tpoints = []
+
+#         while self.is_running:
+#             if len(mpoints) > 0:
+#                 # update points in visualization
+#                 scene_vis.add_sim_points(mpoints)
+#                 scene_vis.add_traj_points(tpoints)
+
+#                 # + apply colour, refresh gui, etc.
+#             time.sleep(0.1)
+
+#     def stop(self):
+#         self.is_running = False
+    
+    
+#     def is_running(self):
+#         return self.is_running
+
+
+# def create_legs(horizontal_fov: float, scan_pattern: Union[ScannerSettings, List[ScannerSettings]], pos: List[List[float]]) -> List[Leg]:
+#     legs = []
+#     if isinstance(scan_pattern, list):
+#         for p, s in zip(pos, scan_pattern):
+#             legs.append(Leg(horizontal_fov=horizontal_fov, scan_pattern=s, position=p))
+#     else:
+#         for p in pos:
+#             legs.append(Leg(horizontal_fov=horizontal_fov, scan_pattern=scan_pattern, position=p))
+#     return legs
\ No newline at end of file
diff --git a/python/pyhelios/__init__.py b/python/pyhelios/__init__.py
index 1d1d20a0d..8d9c5805e 100644
--- a/python/pyhelios/__init__.py
+++ b/python/pyhelios/__init__.py
@@ -10,4 +10,4 @@
 
 # For now, we expose all the raw bindings code to the user
 # for backwards compatibility.
-from _pyhelios import *
+from _helios import *
diff --git a/python/pyhelios/__main__.py b/python/pyhelios/__main__.py
index ecb32e5c9..fb4263555 100644
--- a/python/pyhelios/__main__.py
+++ b/python/pyhelios/__main__.py
@@ -6,7 +6,7 @@
 
 def _get_executable():
     """Locate the compiled Helios executable."""
-    return resources.files("_pyhelios") / "pyhelios" / "bin" / "helios++"
+    return resources.files("_helios") / "pyhelios" / "bin" / "helios++"
 
 
 def helios_exec(args):
diff --git a/python/pyhelios/leg.py b/python/pyhelios/leg.py
new file mode 100644
index 000000000..bdb39c9e4
--- /dev/null
+++ b/python/pyhelios/leg.py
@@ -0,0 +1,74 @@
+from pyhelios.utils import Validatable, ValidatedCppManagedProperty
+from pyhelios.platforms import PlatformSettings
+from pyhelios.scanner import ScannerSettings
+from pyhelios.primitives import TrajectorySettings
+from typing import Optional, Type, Dict, Any
+
+import xml.etree.ElementTree as ET
+import _helios
+
+class ScanningStrip(Validatable):
+    def __init__(self, strip_id: Optional[str] = "", legs: Optional[dict[int, 'Leg']] = None) -> None:
+        
+        self._cpp_object = _helios.ScanningStrip(strip_id)
+        self.strip_id = strip_id
+        self.legs = legs or {}
+
+    strip_id: Optional[str] = ValidatedCppManagedProperty("strip_id")
+
+
+class Leg(Validatable):
+    def __init__(self, platform_settings: Optional[PlatformSettings] = None, scanner_settings: Optional[ScannerSettings] = None, 
+                 strip: Optional[ScanningStrip] = None, trajectory_settings: Optional[TrajectorySettings] = None,
+                 length: Optional[float] = 0.0, serial_id: Optional[int] = 0) -> None:
+        self._cpp_object = _helios.Leg()
+        self.platform_settings = platform_settings or PlatformSettings()
+        self.scanner_settings = scanner_settings or ScannerSettings()
+        self.strip = strip or ScanningStrip()
+        self.trajectory_settings = trajectory_settings
+        self.length = length
+        self.serial_id = serial_id
+ 
+    platform_settings: Optional[PlatformSettings] = ValidatedCppManagedProperty("platform_settings")
+    scanner_settings: Optional[ScannerSettings] = ValidatedCppManagedProperty("scanner_settings")
+    strip: Optional[ScanningStrip] = ValidatedCppManagedProperty("strip")
+    trajectory_settings: Optional[TrajectorySettings] = ValidatedCppManagedProperty("trajectory_settings")
+    length: Optional[float] = ValidatedCppManagedProperty("length")
+    serial_id: Optional[int] = ValidatedCppManagedProperty("serial_id")
+    
+    @classmethod
+    def _set_settings(cls, settings_node: ET.Element, settings_templates: Optional[Dict[str, Any]], settings_class: Type[Any]) -> Any:
+        template_id = settings_node.get('template')
+        if template_id and template_id in settings_templates: # TODO add logic for case when we face unknown template
+            
+            return settings_class.from_xml_node(settings_node, settings_templates[template_id])
+        else:
+            return settings_class.from_xml_node(settings_node)
+
+    @classmethod
+    def from_xml(cls, leg_origin_node: ET.Element, id: int, strips: Optional[Dict[str, ScanningStrip]] = None, 
+                 platform_settings_templates: Optional[Dict[str, PlatformSettings]] = None, scanner_settings_templates: Optional[Dict[str, ScannerSettings]] = None) -> 'Leg':
+        leg = cls()
+        #TODO: add "Obtain trajectory interpolator"
+        leg.serial_id = id
+        strip_id = leg_origin_node.get('stripId')
+        
+        if strip_id:
+            strip = strips.get(strip_id, ScanningStrip(strip_id))
+            strips[strip_id] = strip
+            leg.strip = strip
+            strip.legs[id] = leg
+        
+        platform_settings_node = leg_origin_node.find("platformSettings")
+        if platform_settings_node is not None:
+            leg.platform_settings = cls._set_settings(platform_settings_node, platform_settings_templates, PlatformSettings)
+        
+        scanner_settings_node = leg_origin_node.find("scannerSettings")
+        if scanner_settings_node is not None:
+            leg.scanner_settings = cls._set_settings(scanner_settings_node, scanner_settings_templates, ScannerSettings)
+
+        trajectory_settings_node = leg_origin_node.find("TrajectorySettings")
+        if trajectory_settings_node is not None:
+            leg.trajectory_settings = TrajectorySettings.from_xml_node(trajectory_settings_node)
+
+        return cls._validate(leg)
\ No newline at end of file
diff --git a/python/pyhelios/live.py b/python/pyhelios/live.py
index 9b66aad5b..848120d7a 100644
--- a/python/pyhelios/live.py
+++ b/python/pyhelios/live.py
@@ -25,27 +25,27 @@ def callback(output=None):
     if callback_counter >= n:
 
         # Extract trajectory points.
-        trajectories = output.trajectories
+        trajectories = output[1]
 
         if len(trajectories) != 0:
-            tpoints.append([trajectories[len(trajectories) - 1].getPosition().x,
-                        trajectories[len(trajectories) - 1].getPosition().y,
-                        trajectories[len(trajectories) - 1].getPosition().z])
+            tpoints.append([trajectories[len(trajectories) - 1].position[0],
+                        trajectories[len(trajectories) - 1].position[1],
+                        trajectories[len(trajectories) - 1].position[2]])
 
             callback_counter = 0
 
     # Extract measurement points.
-    measurements = output.measurements
+    measurements = output[0]
 
     if len(measurements) == 0:
         return
 
     # Add current values to list.
     try:
-        mpoints.append([measurements[len(measurements) - 1].getPosition().x,
-                        measurements[len(measurements) - 1].getPosition().y,
-                        measurements[len(measurements) - 1].getPosition().z,
-                        int(measurements[len(measurements) - 1].hitObjectId)])
+        mpoints.append([measurements[len(measurements) - 1].position[0],
+                        measurements[len(measurements) - 1].position[1],
+                        measurements[len(measurements) - 1].position[2],
+                        int(measurements[len(measurements) - 1].hit_object_id)])
 
     except Exception as err:
         print(err)
@@ -59,24 +59,24 @@ def helios_live():
     args = pyhelios_argparser.args
 
     # Set logging style.
-    if args.loggingv:
-        pyhelios.loggingVerbose()
+    if args.logging_verbose:
+        pyhelios.logging_verbose()
 
-    elif args.loggingv2:
-        pyhelios.loggingVerbose2()
+    elif args.logging_verbose2:
+        pyhelios.logging_verbose2()
 
-    elif args.loggingquiet:
-        pyhelios.loggingQuiet()
+    elif args.logging_quiet:
+        pyhelios.logging_quiet()
 
-    elif args.loggingsilent:
-        pyhelios.loggingSilent()
+    elif args.logging_silent:
+        pyhelios.logging_silent()
 
     else:
-        pyhelios.loggingDefault()
+        pyhelios.logging_default()
 
     # Set random generator seed if value has been supplied.
     if args.randomness_seed:
-        pyhelios.setDefaultRandomnessGeneratorSeed(args.randomness_seed)
+        pyhelios.default_rand_generator_seed(args.randomness_seed)
 
     # Build a simulation
     simBuilder = pyhelios.SimulationBuilder(
@@ -116,10 +116,10 @@ def helios_live():
         import time
 
         # Create instance of Scene class, generate scene, print scene (if logging v2), and visualize.
-        scene = Scene(args.survey_file, args.loggingv2)
+        scene = Scene(args.survey_file, args.logging_verbose2)
         scene.gen_from_xml()
 
-        if args.loggingv2:
+        if args.logging_verbose2:
             scene.print_scene()
 
         scene.visualize()
diff --git a/python/pyhelios/output_handling.py b/python/pyhelios/output_handling.py
index be3fa5c7b..a0ab5d379 100644
--- a/python/pyhelios/output_handling.py
+++ b/python/pyhelios/output_handling.py
@@ -3,7 +3,7 @@
 
 def outputToList(output=None):
     """Obtain the output as two different lists, the first one containing
-    measurements and the seconds one containing trajectories.
+    measurements and the second one containing trajectories.
 
     Arguments:
         output --- The output returned by a simulation
@@ -12,38 +12,35 @@ def outputToList(output=None):
         list of measurements, list of trajectories
     """
     # Prepare
-    measurements = output.measurements
-    nMeasurements = measurements.length()
-    lMeasurements = []
-    trajectories = output.trajectories
-    nTrajectories = trajectories.length()
-    lTrajectories = []
+    measurements, trajectories, _, _, _ = output
+    lMeasurements = []  # Initialize as empty list
+    lTrajectories = []  # Initialize as empty list
 
-    # Fill
-    for i in range(nMeasurements):
-        meas = measurements[i]
-        pos = meas.getPosition()
-        ori = meas.getBeamOrigin()
-        dir = meas.getBeamDirection()
+    # Fill measurements
+    for meas in measurements:
+        pos = meas.position
+        ori = meas.beam_origin
+        dir = meas.beam_direction
         lMeasurements.append([
-            pos.x, pos.y, pos.z,
-            ori.x, ori.y, ori.z,
-            dir.x, dir.y, dir.z,
+            pos[0], pos[1], pos[2],
+            ori[0], ori[1], ori[2],
+            dir[0], dir[1], dir[2],
             meas.intensity,  # 9
-            meas.echoWidth,  # 10
-            meas.returnNumber,  # 11
-            meas.pulseReturnNumber,  # 12
-            meas.fullwaveIndex,  # 13
-            int(meas.hitObjectId),  # 14
+            meas.echo_width,  # 10
+            meas.return_number,  # 11
+            meas.pulse_return_number,  # 12
+            meas.fullwave_index,  # 13
+            int(meas.hit_object_id),  # 14
             meas.classification,  # 15
-            meas.gpsTime  # 16
+            meas.gps_time  # 16
         ])
-    for i in range(nTrajectories):
-        traj = trajectories[i]
-        pos = traj.getPosition()
+
+    # Fill trajectories
+    for traj in trajectories:
+        pos = traj.position
         lTrajectories.append([
-            pos.x, pos.y, pos.z,
-            traj.gpsTime,
+            pos[0], pos[1], pos[2],
+            traj.gps_time,
             traj.roll,
             traj.pitch,
             traj.yaw
@@ -66,5 +63,5 @@ def outputToNumpy(output=None):
     # Obtain lists
     lMeasurements, lTrajectories = outputToList(output)
 
-    # Return
-    return np.array(lMeasurements), np.array(lTrajectories)
+    # Convert lists to numpy arrays
+    return np.array(lMeasurements, dtype=np.float64), np.array(lTrajectories, dtype=np.float64)
\ No newline at end of file
diff --git a/python/pyhelios/platforms.py b/python/pyhelios/platforms.py
new file mode 100644
index 000000000..d0fe2804e
--- /dev/null
+++ b/python/pyhelios/platforms.py
@@ -0,0 +1,429 @@
+from pyhelios.utils import Validatable, ValidatedCppManagedProperty, AssetManager
+from pyhelios.primitives import Rotation
+from pyhelios.scene import Scene
+import math
+import xml.etree.ElementTree as ET
+from typing import Optional, List, Tuple
+import _helios
+
+class PlatformSettings(Validatable):
+    def __init__(self, id: Optional[str] = "DEFAULT_TEMPLATE1_HELIOSCPP", x: Optional[float] = 0.0, y: Optional[float] = 0.0, z: Optional[float] = 0.0, is_on_ground: Optional[bool] = False,
+                 position: Optional[List[float]] = None, is_yaw_angle_specified: Optional[bool] = False, yaw_angle: Optional[float] = 0.0,
+                 is_stop_and_turn: Optional[bool] = True, is_smooth_turn: Optional[bool] = False, is_slowdown_enabled: Optional[bool] = True, speed_m_s: Optional[float] = 70.0) -> None:
+        
+        self._cpp_object = _helios.PlatformSettings()
+        self.id = id
+        self.x = x
+        self.y = y
+        self.z = z
+        self.is_on_ground = is_on_ground
+        self.position = position or [0, 0, 0]
+        self.is_yaw_angle_specified = is_yaw_angle_specified
+        self.yaw_angle = yaw_angle
+        self.is_stop_and_turn = is_stop_and_turn
+        self.is_smooth_turn = is_smooth_turn
+        self.is_slowdown_enabled = is_slowdown_enabled
+        self.speed_m_s = speed_m_s
+    
+    id: Optional[str] = ValidatedCppManagedProperty("id")
+    x: Optional[float] = ValidatedCppManagedProperty("x")
+    y: Optional[float] = ValidatedCppManagedProperty("y")
+    z: Optional[float] = ValidatedCppManagedProperty("z")
+    is_on_ground: Optional[bool] = ValidatedCppManagedProperty("is_on_ground")
+    position: Optional[List[float]] = ValidatedCppManagedProperty("position")
+    is_yaw_angle_specified: Optional[bool] = ValidatedCppManagedProperty("is_yaw_angle_specified")
+    yaw_angle: Optional[float] = ValidatedCppManagedProperty("yaw_angle")
+    is_stop_and_turn: Optional[bool] = ValidatedCppManagedProperty("is_stop_and_turn")
+    is_smooth_turn: Optional[bool] = ValidatedCppManagedProperty("is_smooth_turn")
+    is_slowdown_enabled: Optional[bool] = ValidatedCppManagedProperty("is_slowdown_enabled")
+    speed_m_s: Optional[float] = ValidatedCppManagedProperty("speed_m_s")
+    
+    @classmethod
+    def from_xml_node(cls, node: ET.Element, template: Optional['PlatformSettings'] = None) -> 'PlatformSettings':   
+        settings = cls.copy_template(template) if template else cls()
+  
+        settings.id = node.get('id', settings.id)
+        settings.x = float(node.get('x', settings.x))
+        settings.y = float(node.get('y', settings.y))
+        settings.z = float(node.get('z', settings.z))
+        settings.is_on_ground = bool(node.get('onGround', settings.is_on_ground))
+        settings.is_stop_and_turn = bool(node.get('stopAndTurn', settings.is_stop_and_turn))
+        settings.is_smooth_turn = bool(node.get('smoothTurn', settings.is_smooth_turn))
+        settings.is_slowdown_enabled = bool(node.get('slowdownEnabled', settings.is_slowdown_enabled))
+        settings.speed_m_s = float(node.get('movePerSec_m', settings.speed_m_s))
+        yaw_at_departure_deg = node.get("yawAtDeparture_deg")
+        if yaw_at_departure_deg is not None:
+            settings.is_yaw_angle_specified = True
+            settings.yaw_angle = math.radians(float(yaw_at_departure_deg))
+        if settings.is_stop_and_turn and settings.is_smooth_turn:
+            raise ValueError("Platform cannot be both stop-and-turn and smooth-turn")
+        settings.position = [settings.x, settings.y, settings.z]
+        return cls._validate(settings)
+
+    @classmethod
+    def copy_template(cls, template: 'PlatformSettings') -> 'PlatformSettings':
+        """Create a copy of the template to be used"""
+
+        return PlatformSettings(
+            id=template.id,
+            x=template.x,
+            y=template.y,
+            z=template.z,
+            is_on_ground=template.is_on_ground,
+            position=template.position,
+            is_yaw_angle_specified=template.is_yaw_angle_specified,
+            yaw_angle=template.yaw_angle,
+            is_stop_and_turn=template.is_stop_and_turn,
+            is_smooth_turn=template.is_smooth_turn,
+            is_slowdown_enabled=template.is_slowdown_enabled,
+            speed_m_s=template.speed_m_s
+        )
+    
+
+class Platform(Validatable):
+    def __init__(self, id: Optional[str] = '', platform_settings: Optional[PlatformSettings] = None, last_check_z: Optional[float] = 0.0, dmax: Optional[float] = 0.0, is_orientation_on_leg_init: Optional[bool] = False,
+                 is_on_ground: Optional[bool] = False, is_stop_and_turn: Optional[bool] = True, settings_speed_m_s: Optional[float] = 70.0,
+                 is_slowdown_enabled: Optional[bool] = False, is_smooth_turn: Optional[bool] = False, position: Optional[List[float]] = None, scene: Optional[Scene] = None) -> None:
+        
+        self._cpp_object = _helios.Platform()
+
+        self.id = id
+        self.last_check_z = last_check_z
+        self.dmax = dmax
+        self.is_orientation_on_leg_init = is_orientation_on_leg_init
+        self.is_on_ground = is_on_ground
+        self.is_stop_and_turn = is_stop_and_turn
+        self.settings_speed_m_s = settings_speed_m_s
+        self.is_slowdown_enabled = is_slowdown_enabled
+        self.is_smooth_turn = is_smooth_turn
+        self.position = position or [0, 0, 0]
+        self.device_relative_position = [0.0, 0.0, 0.0]
+        self.device_relative_attitude = Rotation(0.0, 0.0, 1.0, 0.0)
+        self.attitude = Rotation(0.0, 0.0, 1.0, 0.0)
+        self.scene = scene
+        self.target_waypoint = [0.0, 0.0, 0.0]
+        self.next_waypoint = [0.0, 0.0, 0.0]
+        self.origin_waypoint = [0.0, 0.0, 0.0]
+        
+        self.absolute_mount_position = [0.0, 0.0, 0.0]
+        self.absolute_mount_attitude = Rotation(0.0, 0.0, 1.0, 0.0)
+        self.cached_dir_current = [0.0, 0.0, 0.0]
+        self.cached_dir_current_xy = [0.0, 0.0, 0.0]
+
+        self.cached_vector_to_target = [0.0, 0.0, 0.0]
+        self.cached_vector_to_target_xy = [0.0, 0.0, 0.0]
+        self.cached_origin_to_target_dir_xy = [0.0, 0.0, 0.0]
+        self.cached_target_to_next_dir_xy = [0.0, 0.0, 0.0]
+        self.cached_distance_to_target_xy = 0.0
+
+        self.cached_current_angle_xy
+        self.cached_end_target_angle_xy 
+        self.cached_origin_to_target_angle_xy 
+        self.cached_target_to_next_angle_xy 
+    
+
+    last_check_z: Optional[float] = ValidatedCppManagedProperty("last_check_z")
+    dmax: Optional[float] = ValidatedCppManagedProperty("dmax")
+    is_orientation_on_leg_init: Optional[bool] = ValidatedCppManagedProperty("is_orientation_on_leg_init")
+    is_on_ground: Optional[bool] = ValidatedCppManagedProperty("is_on_ground")
+    is_stop_and_turn: Optional[bool] = ValidatedCppManagedProperty("is_stop_and_turn")
+    settings_speed_m_s: Optional[float] = ValidatedCppManagedProperty("settings_speed_m_s")
+    is_slowdown_enabled: Optional[bool] = ValidatedCppManagedProperty("is_slowdown_enabled")
+    is_smooth_turn: Optional[bool] = ValidatedCppManagedProperty("is_smooth_turn")
+    position: Optional[List[float]] = ValidatedCppManagedProperty("position")
+    scene: Optional[Scene] = ValidatedCppManagedProperty("scene")
+    device_relative_position: Optional[List[float]] = ValidatedCppManagedProperty("device_relative_position")
+    device_relative_attitude: Rotation = ValidatedCppManagedProperty("device_relative_attitude")
+    absolute_mount_position: List[float] = ValidatedCppManagedProperty("absolute_mount_position")
+    absolute_mount_attitude: Rotation = ValidatedCppManagedProperty("absolute_mount_attitude")
+    cached_dir_current: List[float] = ValidatedCppManagedProperty("cached_dir_current")
+    cached_dir_current_xy: List[float] = ValidatedCppManagedProperty("cached_dir_current_xy")
+    cached_vector_to_target: List[float] = ValidatedCppManagedProperty("cached_vector_to_target")
+    cached_vector_to_target_xy: List[float] = ValidatedCppManagedProperty("cached_vector_to_target_xy")
+    cached_origin_to_target_dir_xy: List[float] = ValidatedCppManagedProperty("cached_origin_to_target_dir_xy")
+    cached_target_to_next_dir_xy: List[float] = ValidatedCppManagedProperty("cached_target_to_next_dir_xy")
+    cached_distance_to_target_xy: float = ValidatedCppManagedProperty("cached_distance_to_target_xy")
+    cached_current_angle_xy: float = ValidatedCppManagedProperty("cached_current_angle_xy")
+    cached_end_target_angle_xy: float = ValidatedCppManagedProperty("cached_end_target_angle_xy")
+    cached_origin_to_target_angle_xy: float = ValidatedCppManagedProperty("cached_origin_to_target_angle_xy")
+    cached_target_to_next_angle_xy: float = ValidatedCppManagedProperty("cached_target_to_next_angle_xy")
+
+    @classmethod
+    def from_xml(cls, filename: str, id: Optional[str] = None) -> 'Platform':
+        file_path = AssetManager().find_file_by_name(filename, auto_add=True)
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+        
+        platform_element = root.find(f".//platform[@id='{id}']")
+        if platform_element is None:
+            raise ValueError(f"No platform found with id: {id}")
+        
+        platform = cls(id=id)
+        platform = cls._initialize_platform_from_xml(platform, platform_element)
+        
+        return cls._validate(platform)
+
+    @classmethod
+    def _initialize_platform_from_xml(cls, platform: 'Platform', platform_element: ET.Element) -> 'Platform':
+        platform_type = platform_element.get('type').lower()
+        
+        # Select platform subclass based on type
+        if platform_type == "groundvehicle":
+            platform = GroundVehiclePlatform(id=platform.id)
+        elif platform_type == "linearpath":
+            platform = LinearPathPlatform(id=platform.id)
+        elif platform_type == "multicopter":
+            platform = HelicopterPlatform(id=platform.id)
+        
+        # Apply type-specific settings
+        cls._apply_platform_specific_settings(platform, platform_element)
+        
+        # Parse scanner mount and other general settings
+        platform.device_relative_position, platform.device_relative_attitude = cls._parse_scanner_mount(platform_element)
+        
+        return platform
+
+    @classmethod
+    def _apply_platform_specific_settings(cls, platform: 'Platform', platform_element: ET.Element):
+        if isinstance(platform, SimplePhysicsPlatform):
+            platform.drag_magnitude = float(platform_element.get('drag', 1.0))
+        if isinstance(platform, HelicopterPlatform):
+            platform._apply_helicopter_specific_settings(platform_element)
+        
+    def _apply_helicopter_specific_settings(platform: 'HelicopterPlatform', platform_element: ET.Element):
+        platform.speedup_magnitude = float(platform_element.get('speedup_magnitude', 2.0))
+        platform.slowdown_magnitude = float(platform_element.get('slowdown_magnitude', 2.0))
+        platform.max_engine_force_xy = float(platform_element.get('engine_max_force', 0.1))
+        platform.base_pitch_angle = math.radians(float(platform_element.get('base_pitch_deg', -5.0)))
+        platform.pitch_speed = math.radians(float(platform_element.get('pitch_speed_deg', 85.94)))
+        platform.roll_speed = math.radians(float(platform_element.get('roll_speed_deg', 28.65)))
+        platform.yaw_speed = math.radians(float(platform_element.get('yaw_speed_deg', 85.94)))
+        platform.max_pitch_offset = math.radians(float(platform_element.get('max_pitch_offset_deg', 35.0)))
+        platform.max_roll_offset = math.radians(float(platform_element.get('max_roll_offset_deg', 25.0)))
+        platform.max_pitch = platform.base_pitch_angle + platform.max_pitch_offset
+        platform.min_pitch = platform.base_pitch_angle - platform.max_pitch_offset
+        platform.slowdown_distance_xy = float(platform_element.get('slowdown_distance_xy', 5.0))
+    
+    def _parse_scanner_mount(platform_element) -> Tuple[List[float], Rotation]:
+        scanner_mount = platform_element.find('scannerMount')
+        device_relative_position = [0.0, 0.0, 0.0]
+
+        if scanner_mount is not None:
+            x = float(scanner_mount.get('x', '0.0'))
+            y = float(scanner_mount.get('y', '0.0'))
+            z = float(scanner_mount.get('z', '0.0'))
+            device_relative_position = [x, y, z]
+
+        # Parse the rotation
+        device_relative_attitude = Rotation.from_xml_node(scanner_mount)
+       
+        return device_relative_position, device_relative_attitude
+    
+    def retrieve_current_settings(self) -> PlatformSettings:
+        current_settings = PlatformSettings()
+        current_settings.speed_m_s = self.settings_speed_m_s
+        current_settings.is_on_ground = self.is_on_ground
+        current_settings.position = self.position
+        return current_settings
+    
+    def update_static_cache(self):
+        self.cached_origin_to_target_dir_xy = self._normalize([
+            self.target_waypoint[0] - self.origin_waypoint[0],
+            self.target_waypoint[1] - self.origin_waypoint[1],
+            0
+        ])
+        
+        self.cached_target_to_next_dir_xy = self._normalize([
+            self.next_waypoint[0] - self.target_waypoint[0],
+            self.next_waypoint[1] - self.target_waypoint[1],
+            0
+        ])
+
+        self.cached_end_target_angle_xy = self._angle_between_vectors(
+            self.cached_origin_to_target_dir_xy, 
+            self.cached_target_to_next_dir_xy
+        )
+
+        # Convert directions to angles
+        self.cached_origin_to_target_angle_xy = self._direction_to_angle_xy(
+            self.cached_origin_to_target_dir_xy
+        )
+
+        self.cached_target_to_next_angle_xy = self._direction_to_angle_xy(
+            self.cached_target_to_next_dir_xy
+        )
+
+        # Update dynamic cache
+        self.update_dynamic_cache()
+
+    def update_dynamic_cache(self):
+        self.cached_vector_to_target = [
+            self.target_waypoint[i] - self.position[i] for i in range(3)
+        ]
+        self.cached_dir_current = self.attitude.apply_vector_rotation([0,1,0])
+        # Projected Vector in XY-plane
+        self.cached_vector_to_target_xy = [
+            self.cached_vector_to_target[0],
+            self.cached_vector_to_target[1],
+            0
+        ]
+
+        # Distance to Target in XY-plane
+        self.cached_distance_to_target_xy = self._l2_norm(
+            self.cached_vector_to_target_xy
+        )
+
+        # Current Direction (normalized)
+        self.cached_dir_current_xy = self._normalize([
+            self.cached_dir_current[0],
+            self.cached_dir_current[1],
+            0
+        ])
+
+        # Angle between current direction and Target-to-Next
+        self.cached_current_angle_xy = self._angle_between_vectors(
+            self.cached_dir_current_xy,
+            self.cached_target_to_next_dir_xy
+        )
+
+    def _normalize(self, vector):
+        length = math.sqrt(sum(comp ** 2 for comp in vector))
+        if length == 0:
+            return [0, 0, 0]
+        return [comp / length for comp in vector]
+    
+    def _angle_between_vectors(self, v1, v2):
+        # Compute dot product
+        dot_product = sum(v1[i] * v2[i] for i in range(3))
+        # Clamp to avoid precision errors
+        dot_product = max(-1.0, min(1.0, dot_product))
+        # Compute angle (in radians)
+        return math.acos(dot_product)
+
+    def _direction_to_angle_xy(self, vector):
+        # Angle in radians from X-axis
+        return math.atan2(vector[1], vector[0])
+
+    def _l2_norm(self, vector):
+        # Compute Euclidean norm (L2 norm)
+        return math.sqrt(sum(comp ** 2 for comp in vector))
+
+    def prepare_simulation(self, pulse_frequency: int):
+        self.cached_absolute_attitude = self.attitude.apply_rotation(self.device_relative_attitude)
+        self.update_static_cache()
+
+        
+class MovingPlatform(Platform):
+    def __init__(self, id: str | None = '', platform_settings: PlatformSettings | None = None, velocity: Optional[List[float]] = [0, 0, 0],  last_check_z: float | None = 0, dmax: float | None = 0, is_orientation_on_leg_init: bool | None = False, is_on_ground: bool | None = False, is_stop_and_turn: bool | None = True, settings_speed_m_s: float | None = 70, is_slowdown_enabled: bool | None = False, is_smooth_turn: bool | None = False) -> None:
+        super().__init__()
+        self._cpp_object = _helios.MovingPlatform()
+        self.velocity = velocity
+        self.id = id
+
+    velocity: List[float] = ValidatedCppManagedProperty("velocity")
+
+class SimplePhysicsPlatform(MovingPlatform):
+    def __init__(self, id: str | None = '', platform_settings: PlatformSettings | None = None, drag_magnitude: Optional[float] = 1.0, last_check_z: float | None = 0, dmax: float | None = 0, is_orientation_on_leg_init: bool | None = False, is_on_ground: bool | None = False, is_stop_and_turn: bool | None = True, settings_speed_m_s: float | None = 70, is_slowdown_enabled: bool | None = False, is_smooth_turn: bool | None = False) -> None:
+        super().__init__()
+        self._cpp_object = _helios.SimplePhysicsPlatform()
+        self.drag_magnitude = drag_magnitude
+        self.id = id
+        self.speed_step_magnitude = 0.0
+
+    drag_magnitude: float = ValidatedCppManagedProperty("drag_magnitude")
+
+    def prepare_simulation(self, pulse_frequency: int):
+        self.speed_step_magnitude = self.drag_magnitude / float(pulse_frequency)
+
+class GroundVehiclePlatform(SimplePhysicsPlatform):
+    def __init__(self, id: str | None = '', platform_settings: PlatformSettings | None = None, last_check_z: float | None = 0, dmax: float | None = 0, is_orientation_on_leg_init: bool | None = False, is_on_ground: bool | None = False, is_stop_and_turn: bool | None = True, settings_speed_m_s: float | None = 70, is_slowdown_enabled: bool | None = False, is_smooth_turn: bool | None = False) -> None:
+        super().__init__()
+        self._cpp_object = _helios.GroundVehiclePlatform()
+        self.id = id
+
+    def prepare_simulation(self, pulse_frequency: int):
+        SimplePhysicsPlatform.prepare_simulation(self, pulse_frequency)
+    
+
+class LinearPathPlatform(MovingPlatform):
+    def __init__(self, id: str | None = '', platform_settings: PlatformSettings | None = None, last_check_z: float | None = 0, dmax: float | None = 0, is_orientation_on_leg_init: bool | None = False, is_on_ground: bool | None = False, is_stop_and_turn: bool | None = True, settings_speed_m_s: float | None = 70, is_slowdown_enabled: bool | None = False, is_smooth_turn: bool | None = False) -> None:
+        super().__init__()
+        self._cpp_object = _helios.LinearPathPlatform()
+        self.id = id
+
+class HelicopterPlatform(SimplePhysicsPlatform):
+    def __init__(self, id: str | None = '', platform_settings: PlatformSettings | None = None, drag_magnitude: float | None = 1.0, last_check_z: float | None = 0, dmax: float | None = 0, is_orientation_on_leg_init: bool | None = False, is_on_ground: bool | None = False, is_stop_and_turn: bool | None = True, settings_speed_m_s: float | None = 70, is_slowdown_enabled: bool | None = False, is_smooth_turn: bool | None = False) -> None:
+                
+        super().__init__()
+        self._cpp_object = _helios.HelicopterPlatform()
+        self.id = id
+        self.slowdown_distance_xy = 5.0
+        self.slowdown_magnitude = 2.0
+        self.speedup_magnitude = 2.0
+        self.max_engine_force_xy = 0.1
+        self.heading_rad = 0.0
+        self.roll = 0.0
+        self.pitch = 0.0
+        self.last_sign = 1.0
+        self.base_pitch_angle = -0.087
+        self.pitch_speed = 1.5
+        self.roll_speed = 0.5
+        self.yaw_speed = 1.5
+        self.max_pitch_offset = 0.61
+        self.max_roll_offset = 0.45
+        self.max_pitch = self.base_pitch_angle + self.max_pitch_offset
+        self.min_pitch = self.base_pitch_angle - self.max_pitch_offset
+        self.pitch_step_magnitude = 0.0
+        self.roll_step_magnitude = 0.0
+        self.yaw_step_magnitude = 0.0
+        self.slowdown_factor = 0.0
+        self.speedup_factor = 0.0
+    
+    slowdown_distance_xy: float = ValidatedCppManagedProperty("slowdown_distance_xy")
+    slowdown_magnitude: float = ValidatedCppManagedProperty("slowdown_magnitude")
+    speedup_magnitude: float = ValidatedCppManagedProperty("speedup_magnitude")
+    max_engine_force_xy: float = ValidatedCppManagedProperty("max_engine_force_xy")
+    heading_rad: float = ValidatedCppManagedProperty("heading_rad")
+    roll: float = ValidatedCppManagedProperty("roll")
+    pitch: float = ValidatedCppManagedProperty("pitch")
+    last_sign: float = ValidatedCppManagedProperty("last_sign")
+    base_pitch_angle: float = ValidatedCppManagedProperty("base_pitch_angle")
+    pitch_speed: float = ValidatedCppManagedProperty("pitch_speed")
+    roll_speed: float = ValidatedCppManagedProperty("roll_speed")
+    yaw_speed: float = ValidatedCppManagedProperty("yaw_speed")
+    max_pitch_offset: float = ValidatedCppManagedProperty("max_pitch_offset")
+    max_roll_offset: float = ValidatedCppManagedProperty("max_roll_offset")
+    max_pitch: float = ValidatedCppManagedProperty("max_pitch")
+    min_pitch: float = ValidatedCppManagedProperty("min_pitch")
+
+    def prepare_simulation(self, pulse_frequency: int):
+        self.pitch_step_magnitude = self.pitch_speed / pulse_frequency
+        self.roll_step_magnitude = self.roll_speed / pulse_frequency
+        self.yaw_step_magnitude = self.yaw_speed / pulse_frequency
+        self.slowdown_factor = 1.0 - self.slowdown_magnitude /pulse_frequency
+        self.speedup_factor = 1.0 + self.speedup_magnitude / pulse_frequency
+        SimplePhysicsPlatform.prepare_simulation(pulse_frequency)
+        Platform.prepare_simulation(self, pulse_frequency)
+        
+
+SR22 = Platform.from_xml("data/platforms.xml", id="sr22")
+
+QUADCOPTER = Platform.from_xml("data/platforms.xml", id="quadcopter")
+
+COPTER_LIN_PATH = Platform.from_xml("data/platforms.xml", id="copter_linearpath")
+
+TRACTOR = Platform.from_xml("data/platforms.xml", id="tractor")
+
+TRACTOR_LEFT_SIDE = Platform.from_xml("data/platforms.xml", id="tractor_leftside")
+
+VEHILE_LIN_PATH = Platform.from_xml("data/platforms.xml", id="vehicle_linearpath")
+
+VMX_450_CAR_LEFT = Platform.from_xml("data/platforms.xml", id="vmx-450-car-left")
+
+VMX_450_CAR_RIGHT = Platform.from_xml("data/platforms.xml", id="vmx-450-car-right")
+
+VMQ_1HA_CAR_0 = Platform.from_xml("data/platforms.xml", id="vmq-1ha-car-0")
+
+SIMPLE_LIN_PATH = Platform.from_xml("data/platforms.xml", id="simple_linearpath")
+
+TRIPOD = Platform.from_xml("data/platforms.xml", id="tripod")
diff --git a/python/pyhelios/primitives.py b/python/pyhelios/primitives.py
new file mode 100644
index 000000000..513e6b4fa
--- /dev/null
+++ b/python/pyhelios/primitives.py
@@ -0,0 +1,845 @@
+from pyhelios.utils import Validatable, ValidatedCppManagedProperty, RandomnessGenerator, AssetManager
+
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict
+from enum import Enum
+import threading
+import re
+import numpy as np
+import xml.etree.ElementTree as ET
+from collections import deque
+import math
+from abc import ABC, abstractmethod
+import _helios
+
+class PrimitiveType(Enum):
+    NONE = _helios.PrimitiveType.NONE
+    TRIANGLE = _helios.PrimitiveType.TRIANGLE
+    VOXEL = _helios.PrimitiveType.VOXEL
+
+
+class Rotation(Validatable):
+    """
+        q0: float - The scalar part of the quaternion
+        q1: float - The x component of the vector part of the quaternion
+        q2: float - The y component of the vector part of the quaternion
+        q3: float - The z component of the vector part of the quaternion
+    """
+
+    def __init__(self, q0: Optional[float] = .0, q1: Optional[float] = .0, q2: Optional[float] = .0, q3: Optional[float] = .0, needs_normalization: Optional[bool] = False):
+        
+        self._cpp_object = _helios.Rotation(q0, q1, q2, q3, needs_normalization)
+        self.q0 = q0
+        self.q1 = q1
+        self.q2 = q2
+        self.q3 = q3
+        #TODO: add normalization procedure
+    
+    q0: Optional[float] = ValidatedCppManagedProperty("q0")
+    q1: Optional[float] = ValidatedCppManagedProperty("q1")
+    q2: Optional[float] = ValidatedCppManagedProperty("q2")
+    q3: Optional[float] = ValidatedCppManagedProperty("q3")
+
+    @classmethod
+    def from_xml_node(cls, beam_origin_node: ET.Element) -> 'Rotation':
+        if beam_origin_node is None:
+            return cls._validate(cls(q0=1., q1=1., q2=0., q3=0.))
+        global_rotation = True
+        if beam_origin_node.attrib.get("rotations") == "local":
+            global_rotation = False
+
+        rotation_node = beam_origin_node.findall('rot')
+        result_rotation = cls(q0=1.0, q1=0.0, q2=0.0, q3=0.0)  # Identity rotation
+        
+        for node in rotation_node:
+            axis = node.get('axis')
+            angle_deg = float(node.get('angle_deg', 0.0))
+            angle_rad = math.radians(angle_deg)  # Convert to radians
+            if angle_rad != 0:
+                rotation = cls._create_rotation_from_axis_angle(axis, angle_rad)
+                if global_rotation:
+                    result_rotation = rotation.apply_rotation(result_rotation)        
+                else:
+                    result_rotation = result_rotation.apply_rotation(rotation)  # Combine rotations
+                
+        return result_rotation._validate(result_rotation)
+
+    @staticmethod
+    def _create_rotation_from_axis_angle(axis: str, angle: float) -> 'Rotation':
+        if axis.lower() == 'x':
+            return Rotation(
+                math.cos(angle / 2),
+                -math.sin(angle / 2),
+                0.0,
+                0.0
+            )
+        elif axis.lower() == 'y':
+            return Rotation(
+                math.cos(angle / 2),
+                0.0,
+                math.sin(angle / 2),
+                0.0
+            )
+        elif axis.lower() == 'z':
+            return Rotation(
+                math.cos(angle / 2),
+                0.0,
+                0.0,
+                -math.sin(angle / 2)
+            )
+    
+    def scale(self, factor: float) -> None:
+        """Scale the positions of all vertices by a given factor."""
+        for vertex in self.vertices:
+            vertex.position[0] *= factor
+            vertex.position[1] *= factor
+            vertex.position[2] *= factor
+
+    def translate(self, shift: List[float]) -> None:
+        """Translate the positions of all vertices by a given shift."""
+        for vertex in self.vertices:
+            vertex.position[0] += shift[0]
+            vertex.position[1] += shift[1]
+            vertex.position[2] += shift[2]
+
+    def apply_rotation(self, r: 'Rotation') -> 'Rotation':
+        return  Rotation(r.q0 * self.q0 - (r.q1 * self.q1 + r.q2 * self.q2 + r.q3 * self.q3),
+                         r.q1 * self.q0 + r.q0 * self.q1 + (r.q2 * self.q3 - r.q3 * self.q2),
+                         r.q2 * self.q0 + r.q0 * self.q2 + (r.q3 * self.q1 - r.q1 * self.q3),
+                         r.q3 * self.q0 + r.q0 * self.q3 + (r.q1 * self.q2 - r.q2 * self.q1))
+    
+    def apply_vector_rotation(self, vec: List[float]) -> List[float]:
+        x = vec[0]
+        y = vec[1]
+        z = vec[2]
+        s = self.q1 * x + self.q2 * y + self.q3 * z
+        return [2*(self.q0*(self.q0 * x - (self.q2 * z - self.q3 * y)) + s * self.q1) - x,
+                2*(self.q0*(self.q0 * y - (self.q3 * x - self.q1 * z)) + s * self.q2) - y,
+                2*(self.q0*(self.q0 * z - (self.q1 * y - self.q2 * x)) + s * self.q3) - z]
+
+    def clone(self):
+        return Rotation(self.q0, self.q1, self.q2, self.q3)
+
+
+class Vertex(Validatable):
+    def __init__(self, position: Optional[List[float]]=None, tex_coords: Optional[List[float]] = None, normal: Optional[List[float]]=None) -> None:
+        self._cpp_object = _helios.Vertex()
+        self.position = position or [0., 0., 0.]
+        self.normal = normal or [0., 0., 0.]
+        self.tex_coords = tex_coords or [0., 0.]
+
+    position: Optional[List[float]] = ValidatedCppManagedProperty("position")
+    normal: Optional[List[float]] = ValidatedCppManagedProperty("normal")
+    tex_coords: Optional[List[float]] = ValidatedCppManagedProperty("tex_coords")
+  
+    def clone(self):
+        new_vertex = Vertex(self.position[:], self.tex_coords[:])
+        new_vertex._cpp_object = self._cpp_object.clone()
+        return new_vertex
+    
+    
+class DetailedVoxel(Validatable):
+    def __init__(self, center: Optional[List[float]], voxel_size: Optional[float], int_values: Optional[List[int]] = None, float_values: Optional[List[float]] = None) -> None:   #def __init__(self, nb_echos: Optional[int] = 0, nb_sampling: Optional[int] = 0, max_pad: Optional[float] = .0): #:
+        
+        self._cpp_object = _helios.DetailedVoxel((center, voxel_size, int_values, float_values) if int_values is not None and float_values is not None else ())
+        self.center = center
+        self.voxel_size = voxel_size
+        self.int_values = int_values
+        self.float_values = float_values    
+        self.nb_echos = self.int_values[0] if self.int_values is not None else 0
+    
+        self.nb_sampling = self.int_values[1] if self.int_values is not None else 0
+        self.max_pad = 0.0 
+    
+    nb_echos: Optional[int] = ValidatedCppManagedProperty("nb_echos")
+    nb_sampling: Optional[int] = ValidatedCppManagedProperty("nb_sampling")
+    max_pad: Optional[float] = ValidatedCppManagedProperty("max_pad")
+
+    def clone(self):
+        new_voxel = DetailedVoxel(self.center, self.voxel_size, self.int_values, self.float_values)
+        new_voxel._cpp_object = self._cpp_object.clone()
+        return new_voxel
+
+
+class EnergyModel(Validatable):
+    def __init__(self, scanning_device: 'ScanningDevice') -> None:
+        self._cpp_object = _helios.EnergyModel(scanning_device._cpp_object)
+        from pyhelios.scanner import ScanningDevice
+        self.scanning_device = scanning_device
+
+
+class BaseEnergyModel(EnergyModel):
+    def __init__(self, scanning_device: 'ScanningDevice') -> None:
+        super().__init__(scanning_device)
+        self._cpp_object = _helios.BaseEnergyModel(scanning_device._cpp_object)
+
+
+class Material(Validatable):
+    def __init__(self, mat_file_path: Optional[str] = "", name: Optional[str] = "default", is_ground: Optional[bool] = False, 
+                 use_vertex_colors: Optional[bool] = False, reflectance: Optional[float] = -1., specularity: Optional[float] = .0,
+                 ambient_components: Optional[List[float]] = None, diffuse_components: Optional[List[float]] = None,
+                 specular_components: Optional[List[float]] = None, map_kd: Optional[str] = "", spectra: Optional[str] = "") -> None:
+        self._cpp_object = _helios.Material()
+        self.name = name
+        self.mat_file_path = mat_file_path
+        self.is_ground = is_ground
+        self.use_vertex_colors = use_vertex_colors
+        self.reflectance = reflectance
+        self.specularity = specularity
+        self.ambient_components = ambient_components or [0.0, 0.0, 0.0, 0.0]
+        self.diffuse_components = diffuse_components or [0.0, 0.0, 0.0, 0.0]
+        self.specular_components = specular_components or [0.0, 0.0, 0.0, 0.0]
+        self.classification = 0
+        self.specular_exponent = 10
+        self.map_kd = map_kd
+        self.spectra = spectra
+    
+    name: Optional[str] = ValidatedCppManagedProperty("name")
+    mat_file_path: Optional[str] = ValidatedCppManagedProperty("mat_file_path")
+    is_ground: Optional[bool] = ValidatedCppManagedProperty("is_ground")
+    use_vertex_colors: Optional[bool] = ValidatedCppManagedProperty("use_vertex_colors")
+    reflectance: Optional[float] = ValidatedCppManagedProperty("reflectance")
+    specularity: Optional[float] = ValidatedCppManagedProperty("specularity")
+    ambient_components: Optional[List[float]] = ValidatedCppManagedProperty("ambient_components")
+    diffuse_components: Optional[List[float]] = ValidatedCppManagedProperty("diffuse_components")
+    specular_components: Optional[List[float]] = ValidatedCppManagedProperty("specular_components")
+    classification: Optional[int] = ValidatedCppManagedProperty("classification")
+    specular_exponent: Optional[float] = ValidatedCppManagedProperty("specular_exponent")
+    map_kd: Optional[str] = ValidatedCppManagedProperty("map_kd")
+    spectra: Optional[str] = ValidatedCppManagedProperty("spectra")
+
+    def calculate_specularity(self):
+        ds_sum = sum(self.diffuse_components) + sum(self.specular_components)
+        if ds_sum > 0:
+            self.specularity = sum(self.specular_components) / ds_sum
+    
+    @classmethod
+    def load_materials(cls, filePathString: str) -> Dict[str, 'Material']:
+        newMats = {}
+        is_first_material = True
+       
+        with open(filePathString, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if not line or line in ["\r", "\r\n", "\n"]:
+                    continue
+
+                lineParts = re.split(r'\s+', line)
+
+                # Wavefront .mtl standard attributes
+                if lineParts[0] == "newmtl" and len(lineParts) >= 2:
+                    if not is_first_material:
+                        newMats[newMat.name] = newMat
+                    newMat = Material()
+                    newMat.mat_file_path = filePathString
+                    newMat.name = lineParts[1]
+                    is_first_material = False
+                elif lineParts[0] == "Ka" and len(lineParts) >= 4:
+                    newMat.ambient_components = [float(x) for x in lineParts[1:4]] + [0.0]
+                elif lineParts[0] == "Kd" and len(lineParts) >= 4:
+                    newMat.diffuse_components = [float(x) for x in lineParts[1:4]] + [0.0]
+                elif lineParts[0] == "Ks" and len(lineParts) >= 4:
+                    newMat.specular_components = [float(x) for x in lineParts[1:4]] + [0.0]
+                elif lineParts[0] == "Ns" and len(lineParts) >= 2:
+                    newMat.specular_exponent = float(lineParts[1])
+                elif lineParts[0] == "map_Kd" and len(lineParts) >= 2:
+                    newMat.map_kd = lineParts[1]
+
+                # HELIOS-specific additions
+                elif lineParts[0] == "helios_reflectance" and len(lineParts) >= 2:
+                    newMat.reflectance = float(lineParts[1])
+
+                elif lineParts[0] == "helios_isGround" and len(lineParts) >= 2:
+                    newMat.is_ground = lineParts[1].lower() in ["true", "1"]
+                elif lineParts[0] == "helios_useVertexColors" and len(lineParts) >= 2:
+                    newMat.use_vertex_colors = bool(int(lineParts[1]))
+                elif lineParts[0] == "helios_classification" and len(lineParts) >= 2:
+                    newMat.classification = int(lineParts[1])
+                elif lineParts[0] == "helios_spectra" and len(lineParts) >= 2:
+                    newMat.spectra = lineParts[1]
+
+        newMat.calculate_specularity()
+        newMat = cls._validate(newMat)
+        newMats[newMat.name] = newMat
+ 
+        return newMats
+
+    @classmethod
+    def parse_materials(cls, params: Dict[str, any]) -> List[Optional['Material']]:
+        materials = []
+        matfile = params.get("matfile")
+        if not matfile:
+            return
+
+        mats = cls.load_materials(matfile)
+        matname = params.get("matname")
+        if matname and matname in mats:
+            materials.append(mats[matname])
+        elif mats:
+            materials.append(next(iter(mats.values())))  # Pick the first material
+
+        random_materials_count = params.get("randomMaterials")
+        if random_materials_count:
+            random_range = params.get("randomRange", 1.0)
+            uns = UniformNoiseSource(0, random_range)
+
+            base_material = materials[0] if materials else Material()  # Default base material
+            for _ in range(random_materials_count):
+                randomized_material = Material(name=base_material.name, **base_material.__dict__)
+                # Apply random adjustments to reflectance and other properties
+                randomized_material.reflectance += uns.next()
+                randomized_material.reflectance = max(0.0, min(randomized_material.reflectance, 1.0))  # Clamp between 0 and 1
+                randomized_material.calculate_specularity()
+                materials.append(randomized_material)
+
+        return materials
+        
+
+class Primitive(Validatable, ABC):
+    def __init__(self,  material: Optional[Material] = None, aabb: Optional['AABB'] = None,
+                 detailed_voxel: Optional[DetailedVoxel] = None, triangles: Optional[List['Triangle']] = None,
+                 scene_part: Optional['ScenePart'] = None) -> None:
+        self._cpp_object = _helios.Primitive()
+        self.material = material
+        if scene_part is not None:
+            from pyhelios.scene import ScenePart
+            self.scene_part = scene_part
+        else:
+            self.scene_part = None
+    
+    @property
+    @abstractmethod
+    def vertices(self) -> List[Vertex]:
+        pass
+    
+    def rotate(self, r: Rotation) -> None:
+        for vertex in self.vertices:
+            vertex.position = r.apply_vector_rotation(vertex.position)
+            vertex.normal = r.apply_vector_rotation(vertex.normal)
+    
+    def scale(self, factor: float) -> None:
+        for vertex in self.vertices:
+            vertex.position[0] *= factor
+            vertex.position[1] *= factor
+            vertex.position[2] *= factor
+    
+    def translate(self, shift: List[float]) -> None:
+        for vertex in self.vertices:
+            vertex.position[0] += shift[0]
+            vertex.position[1] += shift[1]
+            vertex.position[2] += shift[2]
+            
+
+class AABB(Primitive):
+    def __init__(self) -> None:
+        super().__init__()
+        self._cpp_object = _helios.AABB()
+        self._vertices: Optional[List[Vertex]] = None
+        self.bounds: Optional[List[List[float]]] = None   
+
+    @property
+    def vertices(self) -> List[Vertex]:
+        """Return the vertices for this AABB."""
+        return self._vertices    
+    
+
+class Triangle(Primitive):
+    def __init__(self, v0: Optional[Vertex], v1: Optional[Vertex], v2: Optional[Vertex]) -> None:
+        super().__init__()
+        self._cpp_object = _helios.Triangle(v0._cpp_object, v1._cpp_object, v2._cpp_object)
+        self._vertices: List[Vertex] = [v0, v1, v2]
+        self.face_normal_set = False
+        self.face_normal: List[float] = [0,0,0]
+
+    @property
+    def vertices(self) -> List[Vertex]:
+        """Return the vertices for this Triangle."""
+        return self._vertices
+
+    def get_face_normal(self):
+        if not self.face_normal_set:
+            self.update_face_normal()
+            self.face_normal_set = True
+        return self.face_normal
+
+    def update_face_normal(self):
+        # Compute the normal using the cross product of two edges of the triangle
+        v0, v1, v2 = [np.array(v.position) for v in self.vertices]
+        edge1 = v1 - v0
+        edge2 = v2 - v0
+        cross_prod = np.cross(edge1, edge2)
+        if np.linalg.norm(cross_prod) > 1e-8:
+            self.face_normal = cross_prod / np.linalg.norm(cross_prod)
+        else:
+            self.face_normal = [0, 0, 0]  # Normalize the normal
+
+    def clone(self):
+        new_triangle = Triangle(self.v0, self.v1, self.v2)
+        new_triangle._cpp_object = self._cpp_object.clone()
+        return new_triangle
+
+class Trajectory(Validatable):
+    def __init__(self, gps_time: Optional[float] = .0, position: Optional[List[float]] = None, roll: Optional[float] = .0, pitch: Optional[float] = .0, yaw: Optional[float] = .0) -> None:
+        self._cpp_object = _helios.Trajectory()
+        self.position = position or [0., 0., 0.]
+        self.roll = roll
+        self.pitch = pitch
+        self.yaw = yaw
+    
+    gps_time: Optional[float] = ValidatedCppManagedProperty("gps_time")
+    position: Optional[List[float]] = ValidatedCppManagedProperty("position")
+    roll: Optional[float] = ValidatedCppManagedProperty("roll")
+    pitch: Optional[float] = ValidatedCppManagedProperty("pitch")
+    yaw: Optional[float] = ValidatedCppManagedProperty("yaw")
+
+    def clone(self):
+        return Trajectory(self.gps_time, self.position, self.roll, self.pitch, self.yaw) 
+
+class TrajectorySettings(Validatable):
+    def __init__(self, start_time: Optional[float] = np.finfo(float).min, end_time: Optional[float] = np.finfo(float).max, teleport_to_start: Optional[bool] = False) -> None:
+        self._cpp_object = _helios.TrajectorySettings()
+        self.start_time = start_time
+        self.end_time = end_time
+        self.teleport_to_start = teleport_to_start
+
+    start_time: Optional[float] = ValidatedCppManagedProperty("start_time")
+    end_time: Optional[float] = ValidatedCppManagedProperty("end_time")
+    teleport_to_start: Optional[bool] = ValidatedCppManagedProperty("teleport_to_start")
+
+    @classmethod
+    def from_xml_node(cls, trajectory_settings_node: ET.Element) -> 'TrajectorySettings':
+        if trajectory_settings_node is None:
+            return cls._validate(cls())
+        start_time = float(trajectory_settings_node.get('startTime', np.finfo(float).min))
+        end_time = float(trajectory_settings_node.get('endTime', np.finfo(float).max))
+        teleport_to_start = bool(trajectory_settings_node.get('teleportToStart', False))
+        return cls._validate(cls(start_time=start_time, end_time=end_time, teleport_to_start=teleport_to_start))
+
+
+class Measurement(Validatable):
+    def __init__(self, hit_object_id: Optional[str] = "", position: Optional[List[float]] = None, beam_direction: Optional[List[float]] = None, 
+                beam_origin: Optional[List[float]] = None, distance: Optional[float] = .0, intensity: Optional[float] = .0, 
+                echo_width: Optional[float] = .0, return_number: Optional[int] = 0, pulse_return_number: Optional[int] = 0, 
+                fullwave_index: Optional[int] = 0, classification: Optional[int] = 0, gps_time: Optional[float] = .0):
+        
+        self._cpp_object = _helios.Measurement()
+        self.hit_object_id = hit_object_id
+        self.position = position or [0., 0., 0.]
+        self.beam_direction = beam_direction or [0., 0., 0.]
+        self.beam_origin = beam_origin or [0., 0., 0.]
+        self.distance = distance
+        self.intensity = intensity
+        self.echo_width = echo_width
+        self.return_number = return_number
+        self.pulse_return_number = pulse_return_number
+        self.fullwave_index = fullwave_index
+        self.classification = classification
+        self.gps_time = gps_time
+        
+    hit_object_id: Optional[str] = ValidatedCppManagedProperty("hit_object_id")
+    position: Optional[List[float]] = ValidatedCppManagedProperty("position")
+    beam_direction: Optional[List[float]] = ValidatedCppManagedProperty("beam_direction")
+    beam_origin: Optional[List[float]] = ValidatedCppManagedProperty("beam_origin")
+    distance: Optional[float] = ValidatedCppManagedProperty("distance")
+    intensity: Optional[float] = ValidatedCppManagedProperty("intensity")
+    echo_width: Optional[float] = ValidatedCppManagedProperty("echo_width")
+    return_number: Optional[int] = ValidatedCppManagedProperty("return_number")
+    pulse_return_number: Optional[int] = ValidatedCppManagedProperty("pulse_return_number")
+    fullwave_index: Optional[int] = ValidatedCppManagedProperty("fullwave_index")
+    classification: Optional[int] = ValidatedCppManagedProperty("classification")
+    gps_time: Optional[float] = ValidatedCppManagedProperty("gps_time")
+
+    def clone(self):
+        return Measurement(self.hit_object_id, self.position, self.beam_direction, self.beam_origin, self.distance, self.intensity, self.echo_width, self.return_number, self.pulse_return_number, self.fullwave_index, self.classification, self.gps_time)
+
+
+class FWFSettings(Validatable):
+    def __init__(self, bin_size: Optional[float] = .25, beam_sample_quality: Optional[int] = 3,
+                 pulse_length: Optional[float] = 4.0, max_fullwave_range: Optional[float] = 0.0,
+                 aperture_diameter: Optional[float] = 0.15, win_size: Optional[float] = None) -> None:
+        self._cpp_object = _helios.FWFSettings()
+        self.bin_size = bin_size
+        self.beam_sample_quality = beam_sample_quality
+        self.pulse_length  = pulse_length 
+        self.win_size = win_size if win_size is not None else pulse_length / 4
+        self.max_fullwave_range = max_fullwave_range
+        self.aperture_diameter = aperture_diameter
+    
+    bin_size: Optional[float] = ValidatedCppManagedProperty("bin_size")
+    beam_sample_quality: Optional[int] = ValidatedCppManagedProperty("beam_sample_quality")
+    pulse_length: Optional[float] = ValidatedCppManagedProperty("pulse_length")
+    win_size: Optional[float] = ValidatedCppManagedProperty("win_size")
+    max_fullwave_range: Optional[float] = ValidatedCppManagedProperty("max_fullwave_range")
+    aperture_diameter: Optional[float] = ValidatedCppManagedProperty("aperture_diameter")
+
+    @classmethod
+    def from_xml_node(cls, node: ET.Element) -> 'FWFSettings':
+        if node is None:
+            return cls._validate(cls())
+        bin_size = float(node.get('binSize_ns', 0.25))
+        beam_sample_quality = int(node.get('beamSampleQuality', 3))
+        max_fullwave_range = float(node.get('maxFullwaveRange_ns', 0.0))
+        aperture_diameter = float(node.get('apertureDiameter_m', 0.15))
+        win_size = float(node.get('winSize_ns', str(cls().pulse_length / 4)))
+        return cls._validate(cls(bin_size=bin_size, beam_sample_quality=beam_sample_quality, max_fullwave_range=max_fullwave_range, aperture_diameter=aperture_diameter, win_size=win_size))
+    
+    def clone(self):
+        return FWFSettings(self.bin_size, self.beam_sample_quality, self.pulse_length, self.max_fullwave_range, self.aperture_diameter, self.win_size)
+
+
+class AbstractBeamDeflector(Validatable):
+    def __init__(self, scan_angle_max: Optional[float] = .0, scan_freq_max: Optional[float] = .0, scan_freq_min: Optional[float] = .0, scan_freq: Optional[float] = .0, scan_angle: Optional[float] = .0,
+                 vertical_angle_min: Optional[float] = .0, vertical_angle_max: Optional[float] = .0, current_beam_angle: Optional[float] = .0, angle_diff_rad: Optional[float] = .0) -> None:
+        self._cpp_object = _helios.AbstractBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min)
+        self.scan_angle_max = scan_angle_max
+        self.scan_freq_max = scan_freq_max
+        self.scan_freq_min = scan_freq_min
+        self.scan_freq = scan_freq
+        self.scan_angle = scan_angle
+        self.vertical_angle_min = vertical_angle_min
+        self.vertical_angle_max = vertical_angle_max
+        self.current_beam_angle = current_beam_angle
+        self.angle_diff_rad = angle_diff_rad
+
+    scan_angle_max: Optional[float] = ValidatedCppManagedProperty("scan_angle_max")
+    scan_freq_max: Optional[float] = ValidatedCppManagedProperty("scan_freq_max")
+    scan_freq_min: Optional[float] = ValidatedCppManagedProperty("scan_freq_min")
+    scan_freq: Optional[float] = ValidatedCppManagedProperty("scan_freq")
+    scan_angle: Optional[float] = ValidatedCppManagedProperty("scan_angle")
+    vertical_angle_min: Optional[float] = ValidatedCppManagedProperty("vertical_angle_min")
+    vertical_angle_max: Optional[float] = ValidatedCppManagedProperty("vertical_angle_max")
+    current_beam_angle: Optional[float] = ValidatedCppManagedProperty("current_beam_angle")
+    angle_diff_rad: Optional[float] = ValidatedCppManagedProperty("angle_diff_rad")
+
+    @classmethod
+    def from_xml_node(cls, deflector_origin_node: ET.Element) -> 'AbstractBeamDeflector':
+       
+        optics_type = deflector_origin_node.get('optics')
+        scan_freq_max = float(deflector_origin_node.get('scanFreqMax_Hz', 0.0))
+        scan_freq_min = float(deflector_origin_node.get('scanFreqMin_Hz', 0.0))
+        scan_angle_max = float(deflector_origin_node.get('scanAngleMax_deg', 0.0))
+        
+        if optics_type == "oscillating":
+            scan_product = int(deflector_origin_node.get("scanProduct", 1000000))
+            return OscillatingMirrorBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min, scan_product) 
+
+        elif optics_type == "conic":
+            return ConicBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min)
+
+        elif optics_type == "line":
+            num_fibers = int(deflector_origin_node.get("numFibers", 1))
+            return FiberArrayBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min, num_fibers) 
+
+        elif optics_type == "rotating":
+            scan_angle_effective_max_deg = float(deflector_origin_node.get("scanAngleEffectiveMax_deg", 0.0))
+            scan_angle_effective_max_rad = math.radians(scan_angle_effective_max_deg)
+            return PolygonMirrorBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min, scan_angle_effective_max_rad) 
+
+        elif optics_type == "risley":
+            rotor_freq_1_hz = int(deflector_origin_node.get("rotorFreq1_Hz", 7294))
+            rotor_freq_2_hz = int(deflector_origin_node.get("rotorFreq2_Hz", -4664))
+            return RisleyBeamDeflector(scan_angle_max, rotor_freq_1_hz, rotor_freq_2_hz)
+    
+    def clone(self):
+        new_deflector = AbstractBeamDeflector(self.scan_angle_max, self.scan_freq_max, self.scan_freq_min, self.scan_freq, self.scan_angle, self.vertical_angle_min, self.vertical_angle_max, self.current_beam_angle, self.angle_diff_rad)
+        new_deflector._cpp_object = self._cpp_object.clone()
+        return new_deflector
+        
+
+class OscillatingMirrorBeamDeflector(AbstractBeamDeflector):
+    def __init__(self, scan_angle_max: float, scan_freq_max: float, scan_freq_min: float, scan_product: int) -> None:
+        super().__init__()
+        self._cpp_object = _helios.OscillatingMirrorBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min, scan_product)
+        self.scan_product = scan_product
+    
+    def clone(self):
+        new_deflector = OscillatingMirrorBeamDeflector(self.scan_angle_max, self.scan_freq_max, self.scan_freq_min, self.scan_product)
+        new_deflector._cpp_object = self._cpp_object.clone()
+        return new_deflector
+    
+    scan_product: Optional[int] = ValidatedCppManagedProperty("scan_product")
+
+
+class ConicBeamDeflector(AbstractBeamDeflector):
+    def __init__(self, scan_angle_max:float, scan_freq_max: float, scan_freq_min:float) -> None:
+        super().__init__()
+        self._cpp_object = _helios.ConicBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min)
+        self.scan_angle_max = scan_angle_max
+        self.scan_freq_max = scan_freq_max
+        self.scan_freq_min = scan_freq_min
+
+    def clone(self):
+        new_deflector = ConicBeamDeflector(self.scan_angle_max, self.scan_freq_max, self.scan_freq_min)
+        new_deflector._cpp_object = self._cpp_object.clone()
+        return new_deflector
+
+
+class FiberArrayBeamDeflector(AbstractBeamDeflector):
+    def __init__(self, scan_angle_max: float, scan_freq_max: float, scan_freq_min: float, num_fibers: int) -> None:
+        super().__init__()
+        self._cpp_object = _helios.FiberArrayBeamDeflector(scan_angle_max, scan_freq_max, scan_freq_min, num_fibers)
+        self.scan_angle_max = scan_angle_max
+        self.scan_freq_max = scan_freq_max
+        self.scan_freq_min = scan_freq_min
+        self.num_fibers = num_fibers
+    
+    num_fibers: Optional[int] = ValidatedCppManagedProperty("num_fibers")
+
+    def clone(self):
+        new_deflector = FiberArrayBeamDeflector(self.scan_angle_max, self.scan_freq_max, self.scan_freq_min, self.num_fibers)
+        new_deflector._cpp_object = self._cpp_object.clone()
+        return new_deflector
+
+ 
+class PolygonMirrorBeamDeflector(AbstractBeamDeflector):
+    def __init__(self, scan_freq_max: float, scan_freq_min: float, scan_angle_max: float, scan_angle_effective_max: float) -> None:
+        super().__init__()
+        self._cpp_object = _helios.PolygonMirrorBeamDeflector(scan_freq_max, scan_freq_min, scan_angle_max, scan_angle_effective_max)
+        self.scan_angle_max = scan_angle_max
+        self.scan_freq_max = scan_freq_max
+        self.scan_freq_min = scan_freq_min
+        self.scan_angle_effective_max = scan_angle_effective_max
+    
+    def clone(self):
+        new_deflector = PolygonMirrorBeamDeflector(self.scan_angle_max, self.scan_freq_max, self.scan_freq_min, self.scan_angle_effective_max)
+        new_deflector._cpp_object = self._cpp_object.clone()
+        return new_deflector
+
+
+class RisleyBeamDeflector(AbstractBeamDeflector):
+    def __init__(self, scan_angle_max: float, rotor_speed_rad_1: float, rotor_speed_rad_2: float) -> None:
+        super().__init__()
+        self._cpp_object = _helios.RisleyBeamDeflector(scan_angle_max, rotor_speed_rad_1, rotor_speed_rad_2)
+        self.rotor_speed_rad_1 = rotor_speed_rad_1
+        self.rotor_speed_rad_2 = rotor_speed_rad_2
+
+    rotor_freq_1: Optional[float] = ValidatedCppManagedProperty("rotor_speed_rad_1")
+    rotor_freq_2: Optional[float] = ValidatedCppManagedProperty("rotor_speed_rad_2")
+
+    def clone(self):
+        new_deflector = RisleyBeamDeflector(self.scan_angle_max, self.rotor_speed_rad_1, self.rotor_speed_rad_2)
+        new_deflector._cpp_object = self._cpp_object.clone()
+        return new_deflector
+
+
+class NoiseSource(Validatable):
+    def __init__(self, 
+                 clip_min: Optional[float] = 0.0, 
+                 clip_max: Optional[float] = 1.0, 
+                 clip_enabled: Optional[bool] = False, 
+                 fixed_lifespan: Optional[float] = None, 
+                 fixed_value_remaining_uses: Optional[int] = None):
+     
+        self._cpp_object = _helios.NoiseSource()
+        self.clip_min = clip_min
+        self.clip_max = clip_max
+        self.clip_enabled = clip_enabled
+        self.fixed_lifespan = fixed_lifespan
+        self.fixed_value_remaining_uses = fixed_value_remaining_uses
+
+    clip_min: Optional[float] = ValidatedCppManagedProperty("clip_min")
+    clip_max: Optional[float] = ValidatedCppManagedProperty("clip_max")
+    clip_enabled: Optional[bool] = ValidatedCppManagedProperty("clip_enabled")
+    fixed_lifespan: Optional[float] = ValidatedCppManagedProperty("fixed_lifespan")
+    fixed_value_remaining_uses: Optional[int] = ValidatedCppManagedProperty("fixed_value_remaining_uses")
+
+    @property
+    def fixed_value_enabled(self) -> bool:
+        """
+        Read-only property that checks if fixed value is enabled.
+        This binds to the C++ isFixedValueEnabled method.
+        """
+        return self._cpp_object.fixed_value_enabled
+
+    def next(self) -> float:
+        """
+        Implement the logic for generating the next noise value.
+        Mirrors the logic from the C++ `NoiseSource::next()`.
+        """
+        if self.fixed_lifespan == 0:
+            return self.fixed_value  # Return fixed value immediately if lifespan is 0
+
+        if self.fixed_lifespan > 0 and self.fixed_value_remaining_uses > 0:
+            self.fixed_value_remaining_uses -= 1
+            return self.fixed_value  # Decrement remaining uses and return fixed value
+
+        # Otherwise, generate a new noise value
+        self.fixed_value = self.clip(self.noise_function())
+        
+        # If fixed lifespan is greater than 1, update remaining uses
+        if self.fixed_lifespan and self.fixed_lifespan > 1:
+            self.fixed_value_remaining_uses = self.fixed_lifespan - 1
+        
+        return self.fixed_value
+    
+    def clip(self, value: float) -> float:
+        """
+        Clips the noise value to be within the min and max bounds (clip_min and clip_max) if clipping is enabled.
+        This mirrors the C++ `NoiseSource::clip()` function.
+        """
+        if self.clip_enabled:
+            value = max(self.clip_min, min(value, self.clip_max))
+        
+        return value
+    
+
+class RandomNoiseSource(NoiseSource):
+    """Python class representing RandomNoiseSource, inheriting from NoiseSource."""
+
+    # Constructor for initializing the Python class and the corresponding C++ object
+    def __init__(self, seed: Optional[str] = None):
+        # Initialize the C++ RandomNoiseSource object, either with a seed or the default constructor
+        if seed is not None:
+            self._cpp_object = _helios.RandomNoiseSourceDouble(seed)
+        else:
+            self._cpp_object = _helios.RandomNoiseSourceDouble()
+
+        # Initialize properties for validation
+        self.clip_min = self._cpp_object.clip_min
+        self.clip_max = self._cpp_object.clip_max
+        self.clip_enabled = self._cpp_object.clip_enabled
+        self.fixed_lifespan = self._cpp_object.fixed_lifespan
+        self.fixed_value_remaining_uses = self._cpp_object.fixed_value_remaining_uses
+
+    # Properties with validation that link to C++ object
+    clip_min: Optional[float] = ValidatedCppManagedProperty("clip_min")
+    clip_max: Optional[float] = ValidatedCppManagedProperty("clip_max")
+    clip_enabled: Optional[bool] = ValidatedCppManagedProperty("clip_enabled")
+    fixed_lifespan: Optional[int] = ValidatedCppManagedProperty("fixed_lifespan")
+    fixed_value_remaining_uses: Optional[int] = ValidatedCppManagedProperty("fixed_value_remaining_uses")
+
+
+class UniformNoiseSource(RandomNoiseSource):
+    """Python class representing UniformNoiseSource, inheriting from RandomNoiseSource."""
+
+    def __init__(self, seed: Optional[str] = None, min: Optional[float] = 0.0, max: Optional[float] = 1.0):
+        """Initialize the Python object, calling the appropriate C++ constructor."""
+        if seed is not None:
+            self._cpp_object = _helios.UniformNoiseSource(seed, min, max)
+        else:
+            self._cpp_object = _helios.UniformNoiseSource(min, max)
+
+        # Initialize properties for validation
+        self.min = self._cpp_object.min
+        self.max = self._cpp_object.max
+
+        # Initialize randomness generator (in Python)
+        self.randomness_generator = RandomnessGenerator(seed=seed) 
+        self.randomness_generator.compute_uniform_real_distribution(min, max)
+
+    # Properties with validation that link to the C++ object
+    min: Optional[float] = ValidatedCppManagedProperty("min")
+    max: Optional[float] = ValidatedCppManagedProperty("max")
+
+    def noise_function(self) -> float:
+        """Generate the next value in the uniform distribution."""
+        return self.randomness_generator.uniform_real_distribution_next()
+    
+    def configure_uniform_noise(self, min_value: float, max_value: float):
+        """Configure the uniform noise range in the C++ object."""
+        if min_value >= max_value:
+            raise ValueError("min_value must be less than max_value.")
+        
+        self._cpp_object.configure_uniform_noise(min_value, max_value)
+        self.randomness_generator.compute_uniform_real_distribution(min_value, max_value)
+
+
+class SwapOnRepeatHandler(Validatable):
+        def __init__(self, baseline: Optional['ScenePart'] = None, keep_crs: Optional[bool] = False, discard_on_replay: Optional[bool] = False) -> None:
+            self._cpp_object = _helios.SwapOnRepeatHandler()
+            self.baseline = baseline
+            self.keep_crs = keep_crs
+            self.times_to_live: deque[int] = deque()
+            self.discard_on_replay = discard_on_replay
+            self.num_target_swaps: int = 0
+            self.num_current_swaps: int = 0
+        
+        baseline: Optional['ScenePart'] = ValidatedCppManagedProperty("baseline")
+        keep_crs: Optional[bool] = ValidatedCppManagedProperty("keep_crs")
+        discard_on_replay: Optional[bool] = ValidatedCppManagedProperty("discard_on_replay")
+
+        def push_time_to_live(self, time_to_live: int):
+            self.times_to_live.append(time_to_live)
+            self._cpp_object.push_time_to_live(time_to_live)
+
+        def prepare(self, sp: 'ScenePart', swap_filters: deque):
+            # Calculate num_target_swaps based on the length of swap_filters
+            self.num_target_swaps = len(self._cpp_object.swap_filters)
+            
+            # Calculate num_target_replays by summing up all time-to-live values
+            self.num_target_replays = sum(self.times_to_live)
+            
+            # Set num_current_swaps to zero
+            self.num_current_swaps = 0
+
+            # Clone ScenePart object for baseline and set its primitives' parts to None
+            self.baseline = sp.clone()
+            for primitive in self.baseline.primitives:
+                primitive.part = None
+
+
+class KDTreeFactoryMaker(BaseModel):
+    loss_nodes_default: int = Field(21, description="Default loss nodes for SAH KDTree factories")
+
+    @staticmethod
+    def make_simple_kd_tree():
+        return _helios.SimpleKDTreeFactory()
+
+    @staticmethod
+    def make_multithreaded_simple_kd_tree(node_jobs: int, geom_jobs: int):
+        kdtree_factory = _helios.SimpleKDTreeFactory()
+        geom_strategy = _helios.SimpleKDTreeGeometricStrategy()
+        return _helios.MultiThreadKDTreeFactory(kdtree_factory, geom_strategy, node_jobs, geom_jobs)
+
+    @staticmethod
+    def make_sah_kd_tree_factory(loss_nodes: Optional[int] = None):
+        loss_nodes = loss_nodes or KDTreeFactoryMaker().loss_nodes_default
+        return _helios.SAHKDTreeFactory(loss_nodes)
+
+    @staticmethod
+    def make_multithreaded_sah_kd_tree_factory(node_jobs: int, geom_jobs: int, loss_nodes: Optional[int] = None):
+        loss_nodes = loss_nodes or KDTreeFactoryMaker().loss_nodes_default
+        kdtree_factory = _helios.SAHKDTreeFactory(loss_nodes)
+        geom_strategy = _helios.SAHKDTreeGeometricStrategy(kdtree_factory)
+        return _helios.MultiThreadKDTreeFactory(kdtree_factory, geom_strategy, node_jobs, geom_jobs)
+
+    @staticmethod
+    def make_axis_sah_kd_tree_factory(loss_nodes: Optional[int] = None):
+        loss_nodes = loss_nodes or KDTreeFactoryMaker().loss_nodes_default
+        return _helios.AxisSAHKDTreeFactory(loss_nodes)
+
+    @staticmethod
+    def make_multithreaded_axis_sah_kd_tree_factory(node_jobs: int, geom_jobs: int, loss_nodes: Optional[int] = None):
+        loss_nodes = loss_nodes or KDTreeFactoryMaker().loss_nodes_default
+        kdtree_factory = _helios.AxisSAHKDTreeFactory(loss_nodes)
+        geom_strategy = _helios.AxisSAHKDTreeGeometricStrategy(kdtree_factory)
+        return _helios.MultiThreadKDTreeFactory(kdtree_factory, geom_strategy, node_jobs, geom_jobs)
+
+    @staticmethod
+    def make_fast_sah_kd_tree_factory(loss_nodes: Optional[int] = 32):
+        return _helios.FastSAHKDTreeFactory(loss_nodes)
+
+    @staticmethod
+    def make_multithreaded_fast_sah_kd_tree_factory(node_jobs: int, geom_jobs: int, loss_nodes: Optional[int] = 32):
+        kdtree_factory = _helios.FastSAHKDTreeFactory(loss_nodes)
+        geom_strategy = _helios.FastSAHKDTreeGeometricStrategy(kdtree_factory)
+        return _helios.MultiThreadSAHKDTreeFactory(kdtree_factory, geom_strategy, node_jobs, geom_jobs)
+    
+
+class SimulationCycleCallback:
+    def __init__(self) -> None:
+        self._cpp_object = _helios.SimulationCycleCallback()
+        self.is_callback_in_progress = False  # Flag to prevent recursion
+        self._lock = threading.Lock()
+
+    def __call__(self, measurements: List[Measurement], trajectories: List[Trajectory], outpath: str):
+        with self._lock:
+            if self.is_callback_in_progress:
+                return
+            self.is_callback_in_progress = True  # Set flag to prevent recursion
+            try:
+                self.measurements = measurements
+                self.trajectories = trajectories
+                self.output_path = outpath
+            finally:
+                self.is_callback_in_progress = False 
\ No newline at end of file
diff --git a/python/pyhelios/scanner.py b/python/pyhelios/scanner.py
new file mode 100644
index 000000000..00d812f26
--- /dev/null
+++ b/python/pyhelios/scanner.py
@@ -0,0 +1,859 @@
+from pyhelios.utils import Validatable, ValidatedCppManagedProperty, AssetManager, calc_propagation_time_legacy, create_property
+from pyhelios.primitives import FWFSettings, AbstractBeamDeflector, FWFSettings, Rotation, RisleyBeamDeflector, PolygonMirrorBeamDeflector, FiberArrayBeamDeflector, ConicBeamDeflector, OscillatingMirrorBeamDeflector, EnergyModel, Measurement, Trajectory
+from pyhelios.platforms import Platform
+import sys
+import threading
+import math
+import numpy as np
+from typing import Optional, List, Tuple, Annotated, Type, Any
+from types import SimpleNamespace
+from pydantic import Field, field_validator, model_validator, ConfigDict
+import xml.etree.ElementTree as ET
+import _helios
+
+class ScannerSettings(Validatable):
+    def __init__(self, id: Optional[str] = "DEFAULT_TEMPLATE1_HELIOSCPP", is_active: Optional[bool] = True, head_rotation: Optional[float] = .0, 
+                 rotation_start_angle: Optional[float] = .0, rotation_stop_angle: Optional[float] = .0, pulse_frequency: Optional[int] = 0,
+                 scan_angle: Optional[float] = .0, min_vertical_angle: Optional[float] = -1, max_vertical_angle: Optional[float] = -1,
+                 scan_frequency: Optional[float] = .0, beam_divergence_angle: Optional[float] = 0.0003,
+                   trajectory_time_interval: Optional[float] = .0,
+                 vertical_resolution: Optional[float] = .0, horizontal_resolution: Optional[float] = .0) -> None:
+
+        self._cpp_object = _helios.ScannerSettings()
+        self.id = id
+        self.is_active = is_active
+        self.head_rotation = head_rotation
+        self.rotation_start_angle = rotation_start_angle
+        self.rotation_stop_angle = rotation_stop_angle
+        self.pulse_frequency = pulse_frequency
+        self.scan_angle = scan_angle
+        self.min_vertical_angle = min_vertical_angle
+        self.max_vertical_angle = max_vertical_angle
+        self.scan_frequency = scan_frequency
+        self.beam_divergence_angle = beam_divergence_angle
+        self.trajectory_time_interval = trajectory_time_interval
+        self.vertical_resolution = vertical_resolution
+        self.horizontal_resolution = horizontal_resolution
+
+    id: Optional[str] = ValidatedCppManagedProperty("id")
+    is_active: Optional[bool] = ValidatedCppManagedProperty("is_active")
+    head_rotation: Optional[float] = ValidatedCppManagedProperty("head_rotation")
+    rotation_start_angle: Optional[float] = ValidatedCppManagedProperty("rotation_start_angle")
+    rotation_stop_angle: Optional[float] = ValidatedCppManagedProperty("rotation_stop_angle")
+    pulse_frequency: Optional[int] = ValidatedCppManagedProperty("pulse_frequency")
+    scan_angle: Optional[float] = ValidatedCppManagedProperty("scan_angle")
+    min_vertical_angle: Optional[float] = ValidatedCppManagedProperty("min_vertical_angle")
+    max_vertical_angle: Optional[float] = ValidatedCppManagedProperty("max_vertical_angle")
+    scan_frequency: Optional[float] = ValidatedCppManagedProperty("scan_frequency")
+    beam_divergence_angle: Optional[float] = ValidatedCppManagedProperty("beam_divergence_angle")
+    trajectory_time_interval: Optional[float] = ValidatedCppManagedProperty("trajectory_time_interval")
+    vertical_resolution: Optional[float] = ValidatedCppManagedProperty("vertical_resolution")
+    horizontal_resolution: Optional[float] = ValidatedCppManagedProperty("horizontal_resolution")
+
+    @classmethod
+    def from_xml_node(cls, node: ET.Element, template: Optional['ScannerSettings'] = None) -> 'ScannerSettings':
+    
+        settings = cls.copy_template(template) if template else cls()
+        
+        settings.id = node.get('id', settings.id)
+        settings.is_active = node.get('active', str(settings.is_active)).lower() == 'true'
+        settings.head_rotation = float(node.get('headRotate_deg', settings.head_rotation))
+        settings.rotation_start_angle = float(node.get('headRotateStart_deg', settings.rotation_start_angle))
+        settings.rotation_stop_angle = float(node.get('headRotateStop_deg', settings.rotation_stop_angle))
+        settings.pulse_frequency = int(node.get('pulseFreq_hz', settings.pulse_frequency))
+        settings.scan_angle = math.radians(float(node.get('scanAngle_deg'))) if node.get('scanAngle_deg') is not None else settings.scan_angle
+        settings.min_vertical_angle = float(node.get('verticalAngleMin_deg', settings.min_vertical_angle))
+        settings.max_vertical_angle = float(node.get('verticalAngleMax_deg', settings.max_vertical_angle))
+        settings.scan_frequency = float(node.get('scanFreq_hz', settings.scan_frequency))
+        settings.beam_divergence_angle = float(node.get('beamDivergence_rad', settings.beam_divergence_angle))
+        settings.vertical_resolution = float(node.get('verticalResolution_deg', settings.vertical_resolution))
+        settings.horizontal_resolution = float(node.get('horizontalResolution_deg', settings.horizontal_resolution))
+        settings.trajectory_time_interval = float(node.get('trajectoryTimeInterval_s', settings.trajectory_time_interval))
+
+        if settings.rotation_stop_angle < settings.rotation_start_angle and settings.head_rotation > 0:
+            raise ValueError("Rotation stop angle must be greater than rotation start angle if head rotation is positive")
+        
+        if settings.rotation_start_angle < settings.rotation_stop_angle and settings.head_rotation < 0:
+            raise ValueError("Rotation start angle must be greater than rotation stop angle if head rotation is negative")
+     
+        return cls._validate(settings)
+
+    @classmethod
+    def copy_template(cls, template: 'ScannerSettings') -> 'ScannerSettings':
+        """Create a copy of the template to be used"""
+   
+        return ScannerSettings(
+            id=template.id,
+            is_active=template.is_active,
+            head_rotation=template.head_rotation,
+            rotation_start_angle=template.rotation_start_angle,
+            rotation_stop_angle=template.rotation_stop_angle,
+            pulse_frequency=template.pulse_frequency,
+            scan_angle=template.scan_angle,
+            min_vertical_angle=template.min_vertical_angle,
+            max_vertical_angle=template.max_vertical_angle,
+            scan_frequency=template.scan_frequency,
+            beam_divergence_angle=template.beam_divergence_angle,
+            trajectory_time_interval=template.trajectory_time_interval,
+            vertical_resolution=template.vertical_resolution,
+            horizontal_resolution=template.horizontal_resolution
+        )      
+
+
+class ScannerHead(Validatable):
+    def __init__(self, rotate_per_sec_max: Optional[float] = float('inf'), rotation_axis: Optional[List[float]] = None, rotate_per_sec: Optional[float] = .0, rotate_stop: Optional[float] = .0, rotate_start: Optional[float] = .0,
+                 rotate_range: Optional[float] = .0, current_rotate_angle: Optional[float] = .0) -> None:
+        if rotation_axis is None:
+            rotation_axis = [1., 0., 0.]
+
+        self._cpp_object = _helios.ScannerHead(rotation_axis, rotate_per_sec_max)
+        self.rotation_axis = rotation_axis
+        self.rotate_per_sec_max = rotate_per_sec_max
+        self.rotate_per_sec = rotate_per_sec
+        self.rotate_stop = rotate_stop
+        self.rotate_start = rotate_start
+        self.rotate_range = rotate_range
+        self.current_rotate_angle = current_rotate_angle
+
+    rotation_axis: Optional[List[float]] = ValidatedCppManagedProperty("rotation_axis")
+    rotate_per_sec_max: Optional[float] = ValidatedCppManagedProperty("rotate_per_sec_max")
+    rotate_per_sec: Optional[float] = ValidatedCppManagedProperty("rotate_per_sec")
+    rotate_stop: Optional[float] = ValidatedCppManagedProperty("rotate_stop")
+    rotate_start: Optional[float] = ValidatedCppManagedProperty("rotate_start")
+    rotate_range: Optional[float] = ValidatedCppManagedProperty("rotate_range")
+    current_rotate_angle: Optional[float] = ValidatedCppManagedProperty("current_rotate_angle")
+
+    @classmethod
+    def from_xml_node(cls, head_node: ET.Element) -> 'ScannerHead':
+        if head_node is None:
+            raise ValueError("No head node found")
+
+        head_rotate_axis = [0, 0, 1]
+        axis_node = head_node.find("headRotateAxis")
+     
+        if axis_node is not None:
+            x = float(axis_node.get('x', 0.0))
+            y = float(axis_node.get('y', 0.0))
+            z = float(axis_node.get('z', 1.0))
+            head_rotate_axis = [x, y, z]
+            if math.sqrt(sum([coord**2 for coord in head_rotate_axis])) <= 0.1:
+                head_rotate_axis = [0, 0, 1]  
+        
+        rotate_per_sec_max = float(head_node.get('headRotatePerSecMax_deg', 0.0))
+        return cls._validate(cls(rotation_axis=head_rotate_axis, rotate_per_sec_max=rotate_per_sec_max))
+    
+    def clone(self):
+        return ScannerHead(self.rotate_per_sec_max, self.rotation_axis, self.rotate_per_sec, self.rotate_stop, self.rotate_start, self.rotate_range, self.current_rotate_angle)
+
+
+class EvalScannerHead(ScannerHead):
+    def __init__(self, rotation_axis: Optional[List[float]] = None, rotate_per_sec_max: Optional[float] = float('inf')):
+        if rotation_axis is None:
+            rotation_axis = [1., 0., 0.] 
+        super().__init__(rotation_axis, rotate_per_sec_max)
+        self._cpp_object = _helios.EvalScannerHead(rotation_axis, rotate_per_sec_max)
+        
+
+class ScanningDevice(Validatable):
+    def __init__(self, 
+                 dev_idx: int,
+                 id: str,
+                 beam_div_rad: float,
+                 emitter_position: List[float],
+                 emitter_attitude: Rotation,
+                 pulse_freqs: List[int],
+                 pulse_length: float,
+                 avg_power: float,
+                 beam_quality: float,
+                 optical_efficiency: float,
+                 receiver_diameter: float,
+                 atmospheric_visibility: float,
+                 wavelength: float,
+                 last_pulse_was_hit: Optional[bool] = False,
+                 fwf_settings: Optional[FWFSettings] = None
+                 ) -> None:
+        
+        self._cpp_object = _helios.ScanningDevice(
+            dev_idx, id, beam_div_rad, emitter_position, emitter_attitude._cpp_object, pulse_freqs, 
+            pulse_length, avg_power, beam_quality, optical_efficiency, 
+            receiver_diameter, atmospheric_visibility, wavelength
+        )
+
+        self.dev_idx = dev_idx
+        self.id = id
+        self.beam_div_rad = beam_div_rad
+        self.emitter_position = emitter_position
+        self.emitter_attitude = emitter_attitude
+        self.pulse_freqs = pulse_freqs
+        self.pulse_length = pulse_length
+        self.avg_power = avg_power
+        self.beam_quality = beam_quality
+        self.optical_efficiency = optical_efficiency
+        self.receiver_diameter = receiver_diameter
+        self.atmospheric_visibility = atmospheric_visibility
+        self.wavelength = wavelength
+        self.last_pulse_was_hit = last_pulse_was_hit or False
+        self.fwf_settings = fwf_settings or FWFSettings()
+
+        self.max_nor = 0
+        self.beam_deflector = AbstractBeamDeflector()
+        self.detector = AbstractDetector(Scanner("0"))
+        self.scanner_head = ScannerHead()
+
+        self.num_rays: int = 0
+        self.num_time_bins: int = -1
+        self.timevawe: List[float] = []
+        self.peak_intensity_index: int = -1
+
+        self.received_energy_min: float = 0.0001
+        self.cached_dr2: float = 0.0
+        self.cached_bt2: float = 0.0
+        self.cached_subray_rotation: List[Rotation] = [Rotation()]
+        self.cached_div_angles: List[float] = []
+        self.cached_radius_steps: List[int] = []
+        self.energy_model: Optional[EnergyModel] = None
+    
+    fwf_settings: FWFSettings = ValidatedCppManagedProperty("fwf_settings")
+    received_energy_min: float = ValidatedCppManagedProperty("received_energy_min")
+    last_pulse_was_hit: bool = ValidatedCppManagedProperty("last_pulse_was_hit")
+    cached_dr2: float = ValidatedCppManagedProperty("cached_dr2")
+    cached_bt2: float = ValidatedCppManagedProperty("cached_bt2")
+    cached_subray_rotation: List[Rotation] = ValidatedCppManagedProperty("cached_subray_rotation")
+
+    def calc_rays_number(self) -> None:
+        count = 1 
+        for radius_step in range(self.fwf_settings.beam_sample_quality):
+            circle_steps = int(2 * math.pi * radius_step)
+            count += circle_steps
+
+        self.num_rays = count
+
+    def prepare_simulation(self, legacy_energy_model: Optional[bool] = False) -> None:
+        beam_sample_quality = self.fwf_settings.beam_sample_quality
+        radius_step = self.beam_div_rad / beam_sample_quality
+        axis = np.array([1, 0, 0])
+        axis2 = np.array([0, 1, 0])
+        norm_axis = np.linalg.norm(np.array(axis))
+        norm_axis2 = np.linalg.norm(np.array(axis2))
+        
+        for i in range(beam_sample_quality):
+            div_angle_rad = i * radius_step
+            self.cached_div_angles.append(div_angle_rad)
+            half_div_angle_rad = -0.5 * div_angle_rad
+            coeff_dif_angle = math.sin(half_div_angle_rad) / norm_axis
+
+            r1 = Rotation(math.cos(half_div_angle_rad),
+                          coeff_dif_angle * axis[0],
+                          coeff_dif_angle * axis[1],
+                          coeff_dif_angle * axis[2])
+
+            circle_steps = int(2 * math.pi) * i
+            if circle_steps > 0:
+                circle_step = 2 * math.pi / circle_steps
+                for j in range(circle_steps):
+                    div_angle_rad2 = j * circle_step
+                    half_div_angle_rad2 = -0.5 * div_angle_rad2
+                    coeff_dif_angle2 = math.sin(half_div_angle_rad2) / norm_axis2
+                    r2 = Rotation(math.cos(half_div_angle_rad2),
+                                    coeff_dif_angle2 * axis2[0],
+                                    coeff_dif_angle2 * axis2[1],
+                                    coeff_dif_angle2 * axis2[2])
+                    
+                    r2= r2.apply_to(r1)
+                    self.cached_subray_rotation.append(r2)
+                    self.cached_radius_steps.append(i)
+        
+        if legacy_energy_model:
+            #TODO call the improved energy model for the more advanced functionality
+            pass
+        
+        else:
+            self.energy_model = EnergyModel(self) 
+        
+    def clone(self):
+        return ScanningDevice(self.dev_idx, self.id, self.beam_div_rad, self.emitter_position, self.emitter_attitude, self.pulse_freqs, self.pulse_length, self.avg_power, self.beam_quality, self.optical_efficiency, self.receiver_diameter, self.atmospheric_visibility, self.wavelength, self.last_pulse_was_hit, self.fwf_settings)
+
+
+class Scanner(Validatable):
+    def __init__(self, id: Optional[str], supported_pulse_freqs_hz: Optional[List[int]] = None, platform: Optional[Platform] = None, pulse_freq_hz: Optional[int] = 0) -> None:
+        if supported_pulse_freqs_hz is None:
+            supported_pulse_freqs_hz = [0]
+        self._cpp_object = _helios.Scanner(id, supported_pulse_freqs_hz)
+        self.id = id
+        self.platform = platform
+        self.supported_pulse_freqs_hz = supported_pulse_freqs_hz
+        self.trajectory_time_interval: float = 0.0
+        self.is_state_active: bool = True
+        self.pulse_freq_hz = pulse_freq_hz
+
+        self.all_measurements: List[Measurement] = []
+        self.all_trajectories: List[Trajectory] = []
+        self.all_output_paths: List[str] = []
+
+        self.write_waveform: Optional[bool] = False
+        self.calc_echowidth: Optional[bool] = False
+        self.fullwavenoise: Optional[bool] = False
+        self.is_platform_noise_disabled: Optional[bool] = False
+
+        self.cycle_measurements: Optional[List[Measurement]] = []
+        self.cycle_trajectories: Optional[List[Trajectory]] = []
+        self.cycle_measurements_mutex = None
+        self.all_measurements_mutex = None 
+          
+    id: Optional[str] = ValidatedCppManagedProperty("id")
+    trajectory_time_interval: float = ValidatedCppManagedProperty("trajectory_time_interval")
+    is_state_active: bool = ValidatedCppManagedProperty("is_state_active")
+    all_output_paths: List[str] = ValidatedCppManagedProperty("all_output_paths")
+    all_measurements: List[Measurement] = ValidatedCppManagedProperty("all_measurements")
+    all_trajectories: List[Trajectory] = ValidatedCppManagedProperty("all_trajectories")
+    cycle_measurements: Optional[List[Measurement]] = ValidatedCppManagedProperty("cycle_measurements")
+    cycle_trajectories: Optional[List[Trajectory]] = ValidatedCppManagedProperty("cycle_trajectories")
+    platform: Optional[Platform] = ValidatedCppManagedProperty("platform")
+
+    @classmethod
+    def from_xml(cls, filename: str, id: Optional[str] = None) -> 'Scanner':
+        file_path = AssetManager().find_file_by_name(filename, auto_add=True)
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+        
+        scanner_element = root.find(f".//scanner[@id='{id}']")
+        if scanner_element is None:
+            raise ValueError(f"No scanner found with id: {id}")
+        
+        emitter_position, emitter_attitude = cls._parse_emitter(scanner_element)
+        pulse_freqs = cls._parse_pulse_frequencies(scanner_element)
+
+        setting_characteristics = cls._combine_scanner_characteristics(scanner_element)
+        multi_scanner_element = scanner_element.find('channels')
+        if multi_scanner_element is None:
+            scanner = cls._create_single_scanner(scanner_element, pulse_freqs, setting_characteristics, emitter_position, emitter_attitude)
+        else:
+            scanner = cls._create_multi_scanner(scanner_element, pulse_freqs, setting_characteristics, emitter_position, emitter_attitude)
+       
+        return scanner
+
+    @classmethod
+    def _parse_emitter(cls, scanner_element) -> Tuple[List[float], Rotation]:
+        beam_origin = scanner_element.find('beamOrigin')
+        
+        emitter_position = [0.0, 0.0, 0.0]
+
+        if beam_origin is not None:
+            x = float(beam_origin.get('x', '0.0'))
+            y = float(beam_origin.get('y', '0.0'))
+            z = float(beam_origin.get('z', '0.0'))
+            emitter_position = [x, y, z]
+
+        # Parse the rotation
+        emitter_attitude = Rotation.from_xml_node(beam_origin)
+        
+        return emitter_position, emitter_attitude
+
+    @classmethod
+    def _parse_pulse_frequencies(cls, root) -> List[int]:
+        pulse_freqs_string = root.get('pulseFreqs_Hz', "0")
+        return [int(freq) for freq in pulse_freqs_string.split(',')]
+
+    @classmethod
+    def _combine_scanner_characteristics(cls, root) -> SimpleNamespace:
+
+        settings_characteristics = SimpleNamespace(
+            beam_div_rad=float(root.get('beamDivergence_rad', '0.0003')),
+            pulse_length=float(root.get('pulseLength_ns', '4.0')),
+            average_power=float(root.get('averagePower_w', '4.0')),
+            beam_quality=float(root.get('beamQualityFactor', '1.0')),
+            efficiency=float(root.get('opticalEfficiency', '0.99')),
+            receiver_diameter=float(root.get('receiverDiameter_m', '0.15')),
+            atmospheric_visibility=float(root.get('atmosphericVisibility_km', '23.0')),
+            wavelength=int(root.get('wavelength_nm', '1064'))
+        )
+        return settings_characteristics
+    
+    def retrieve_current_settings(self, idx: Optional[int] = 0) -> ScannerSettings:
+        current_settings = ScannerSettings()
+        current_settings.id = self.id + "_settings"
+        current_settings.trajectory_time_interval = self.trajectory_time_interval/1000000000
+        if isinstance(self, SingleScanner):
+            # For SingleScanner, use the single scanning device
+            current_settings.pulse_frequency = self.pulse_freq_hz
+            current_settings.is_active = self.is_state_active
+            current_settings.beam_divergence_angle = self.scanning_device.beam_div_rad
+            current_settings.head_rotation = self.scanning_device.scanner_head.rotate_start
+            current_settings.rotation_start_angle = self.scanning_device.scanner_head.current_rotate_angle
+            current_settings.rotation_stop_angle = self.scanning_device.scanner_head.rotate_stop
+            current_settings.scan_angle = self.scanning_device.beam_deflector.scan_angle
+            current_settings.scan_frequency = self.scanning_device.beam_deflector.scan_freq_max
+            current_settings.min_vertical_angle = self.scanning_device.beam_deflector.vertical_angle_min
+            current_settings.max_vertical_angle = self.scanning_device.beam_deflector.vertical_angle_max
+
+        elif isinstance(self, MultiScanner):
+            # For MultiScanner, use the scanning device at index idx
+            current_settings.pulse_frequency = self.scanning_devices[idx].pulse_freqs
+            current_settings.is_active = self.is_state_active
+            current_settings.beam_divergence_angle = self.scanning_devices[idx].beam_div_rad
+            current_settings.head_rotation = self.scanning_devices[idx].scanner_head.rotate_start
+            current_settings.rotation_start_angle = self.scanning_devices[idx].scanner_head.current_rotate_angle
+            current_settings.rotation_stop_angle = self.scanning_devices[idx].scanner_head.rotate_stop
+            current_settings.scan_angle = self.scanning_devices[idx].beam_deflector.scan_angle
+            current_settings.scan_frequency = self.scanning_devices[idx].beam_deflector.scan_freq_max
+            current_settings.min_vertical_angle = self.scanning_devices[idx].beam_deflector.vertical_angle_min
+            current_settings.max_vertical_angle = self.scanning_devices[idx].beam_deflector.vertical_angle_max
+        
+        return current_settings
+    
+    @classmethod
+    def _create_single_scanner(cls, scanner_element, pulse_freqs, setting_characteristics, emitter_position, emitter_attitude) -> 'SingleScanner':
+        # Create the single scanner instance
+        scanner = SingleScanner(
+            id=scanner_element.get('id', 'default'),
+            average_power=setting_characteristics.average_power,
+            pulse_freqs=pulse_freqs,
+            beam_quality=setting_characteristics.beam_quality,
+            efficiency=setting_characteristics.efficiency,
+            receiver_diameter=setting_characteristics.receiver_diameter,
+            atmospheric_visibility=setting_characteristics.atmospheric_visibility,
+            wavelength=setting_characteristics.wavelength,
+            beam_div_rad=setting_characteristics.beam_div_rad,
+            beam_origin=emitter_position,
+            beam_orientation=emitter_attitude,
+            pulse_length=setting_characteristics.pulse_length
+        )
+
+        # Optionally set additional properties (detector, deflector, head, etc.)
+        scanner.max_NOR = int(scanner_element.get('maxNOR', 0))
+        scanner.beam_deflector = AbstractBeamDeflector.from_xml_node(scanner_element)
+        scanner.detector = AbstractDetector.from_xml_node(scanner_element, scanner)
+        scanner.scanner_head = ScannerHead.from_xml_node(scanner_element)
+      
+        # Apply waveform settings if present
+        fwf_node = scanner_element.find('FWFSettings')
+        fwf_settings = FWFSettings()
+        fwf_settings.pulse_length = setting_characteristics.pulse_length
+
+        scanner.apply_settings_FWF(fwf_settings.from_xml_node(fwf_node))
+        return scanner
+
+
+    @classmethod
+    def _create_multi_scanner(cls, scanner_element, pulse_freqs, settings, emitter_position, emitter_attitude) -> 'MultiScanner':
+        # Handle multi-scanner setup similar to the C++ code
+        channels = scanner_element.find('channels')
+        n_channels = sum(1 for _ in channels.findall('channel'))
+
+        scan_devs = []
+        for idx in range(n_channels):
+            scan_dev = ScanningDevice(
+                idx, 
+                scanner_element.get('id', 'default'),
+                settings.beam_div_rad,
+                emitter_position,
+                emitter_attitude,
+                pulse_freqs,
+                settings.pulse_length,
+                settings.average_power,
+                settings.beam_quality,
+                settings.efficiency,
+                settings.receiver_diameter,
+                settings.atmospheric_visibility,
+                settings.wavelength * 1e-9,  # Placeholder for range error expression
+            )
+            scan_dev.received_energy_min = float(scanner_element.get('receivedEnergyMin', '0.0001'))
+            scan_devs.append(scan_dev)
+
+        scanner = MultiScanner(scan_devs, str(scanner_element.get('id', 'default')), pulse_freqs)
+
+        # Set properties like beam deflector, detector, scanner head, etc.
+        fwf_settings = FWFSettings.from_xml_node(scanner_element.find('FWFSettings'))
+        abs_beam_def = AbstractBeamDeflector.from_xml_node(scanner_element)
+        abs_detector = AbstractDetector.from_xml_node(scanner_element, scanner)
+        scanner_head = ScannerHead.from_xml_node(scanner_element) 
+
+        cls._fill_scan_devs_from_channels(scanner, scanner_element, channels, abs_beam_def, abs_detector,
+                                          scanner_head, fwf_settings)
+        return scanner
+
+    @classmethod
+    def _fill_scan_devs_from_channels(cls, scanner, scanner_element, channels, abs_deflector, abs_detector, scanner_head, fwf_settings) -> None:
+        # Iterate over the channels and fill the scan devices, also it should have a counter for the index from 0
+        for idx, channel in enumerate(channels.findall('channel')):
+            scanner.active_scanner_index = idx
+            scanner._cpp_object.set_device_index(idx, idx)
+
+            scanner.device_id = channel.get('id', 'DeviceID')
+
+            emitter_position, emitter_attitude = cls._parse_emitter(channel)
+            scanner.head_relative_emitter_position = emitter_position
+            scanner.head_relative_emitter_attitude = emitter_attitude
+            scanner.apply_settings_FWF(fwf_settings.from_xml_node(channel.find('FWFSettings')))
+
+            update_deflector = True
+          
+            optics_type = channel.get('optics')
+            if optics_type is not None: 
+                deflectors_match = (optics_type == "oscillating" and isinstance(abs_deflector, OscillatingMirrorBeamDeflector)
+                ) or (
+                    optics_type == "conic" and isinstance(abs_deflector, ConicBeamDeflector)
+                ) or (
+                    optics_type == "line" and isinstance(abs_deflector, FiberArrayBeamDeflector)
+                ) or (
+                    optics_type == "rotating" and isinstance(abs_deflector, PolygonMirrorBeamDeflector)
+                ) or (
+                    optics_type == "risley" and isinstance(abs_deflector, RisleyBeamDeflector))
+
+                if not deflectors_match:
+                    new_deflector = AbstractBeamDeflector.from_xml_node(channel)
+                    scanner.beam_deflector = new_deflector
+                    update_deflector = False  # Don't update if we just replaced the deflector
+                
+                if update_deflector:
+                    scanner.beam_deflector = abs_deflector.clone()
+                    current_deflector = scanner.beam_deflector
+                    current_deflector.scan_freq_min = float(channel.get('scanFreqMin_Hz', current_deflector.scan_freq_min))
+                    current_deflector.scan_freq_max = float(channel.get('scanFreqMax_Hz', current_deflector.scan_freq_max))
+
+                    if 'scanAngleMax_deg' in channel.attrib:
+                        current_deflector.scan_angle_max = math.radians(float(channel.get('scanAngleMax_deg', 0.0)))
+
+                    # Handle specific updates for Oscillating Mirror Beam Deflector
+                    if isinstance(current_deflector, OscillatingMirrorBeamDeflector):
+                        current_deflector.scan_product = int(channel.get('scanProduct', current_deflector.scan_product))
+
+                    # Handle specific updates for Fiber Array Beam Deflector
+                    elif isinstance(current_deflector, FiberArrayBeamDeflector):
+                        current_deflector.num_fibers = int(channel.get('numFibers', current_deflector.num_fibers))
+
+                    # Handle specific updates for Polygon Mirror Beam Deflector
+                    elif isinstance(current_deflector, PolygonMirrorBeamDeflector):
+                        current_deflector.scan_angle_max = math.radians(float(channel.get('scanAngleEffectiveMax_deg', math.degrees(current_deflector.scan_angle_max))))
+
+                    # Handle specific updates for Risley Beam Deflector
+                    elif isinstance(current_deflector, RisleyBeamDeflector):
+                        current_deflector.rotor_freq_1 = float(channel.get('rotorFreq1_Hz', 7294)) / (2 * math.pi)
+                        current_deflector.rotor_freq_2 = float(channel.get('rotorFreq2_Hz', -4664)) / (2 * math.pi)
+
+            current_detector = abs_detector.clone()
+            current_detector.range_max = float(channel.get('rangeMax_m', current_detector.range_max))
+            current_detector.accuracy = float(channel.get('accuracy_m', current_detector.accuracy))
+            current_detector.range_min = float(channel.get('rangeMin_m', current_detector.range_min))
+            scanner.detector = current_detector
+
+            current_head = scanner_head.clone()
+            current_head.rotate_per_sec_max = math.radians(float(channel.get('headRotatePerSecMax_deg', math.degrees(current_head.rotate_per_sec_max))))
+            axis_node = channel.find("headRotateAxis")
+            if axis_node is not None:
+                    axis_str = axis_node.text.split()
+                    axis = [float(coord) for coord in axis_str]
+                    current_head.rotation_axis = axis
+            scanner.scanner_head = current_head
+            
+            scanner.beam_div_rad = float(channel.get('beamDivergence_rad', scanner.beam_div_rad))
+            scanner.pulse_length = float(channel.get('pulseLength_ns', scanner.pulse_length))
+            if channel.get("wavelength_nm") is not None:
+                scanner.wavelength = int(channel.get('wavelength_nm', 1064))
+            scanner.max_nor = int(channel.get('maxNOR', 0))
+            scanner.received_energy_min = float(channel.get('receivedEnergyMin', scanner.received_energy_min))
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class SingleScanner(Scanner):
+    def __init__(self, id: str, average_power: float, pulse_freqs: List[int],
+                 beam_quality: float, efficiency: float, receiver_diameter: float, 
+                 atmospheric_visibility: float, wavelength: int, beam_div_rad: Optional[float] = 0, 
+                 beam_origin: Optional[List[float]] = None, beam_orientation: Optional[Rotation] = None,  
+                 pulse_length: Optional[float] = 0, scanner_settings: Optional[ScannerSettings] = None, write_waveform=False, 
+                 write_pulse=False, calc_echowidth=False, full_wave_noise=False, 
+                 platform_noise_disabled=False) -> None:
+        
+        
+        beam_origin = beam_origin or [0.0, 0.0, 0.0]
+        
+        beam_orientation = beam_orientation or Rotation()
+            
+        super().__init__(id, supported_pulse_freqs_hz=pulse_freqs)
+        self._cpp_object = _helios.SingleScanner(
+            beam_div_rad, beam_origin, beam_orientation._cpp_object, pulse_freqs, pulse_length, id, average_power, 
+            beam_quality, efficiency, receiver_diameter, atmospheric_visibility, wavelength, 
+            write_waveform, write_pulse, calc_echowidth, full_wave_noise, platform_noise_disabled)
+        
+        self.id = id
+        self.scanner_settings = scanner_settings
+        self.scanning_device = ScanningDevice(0, id, beam_div_rad, beam_origin, beam_orientation, pulse_freqs, pulse_length, average_power, beam_quality, efficiency, receiver_diameter, atmospheric_visibility, wavelength)
+        self.write_waveform = write_waveform
+        self.write_pulse = write_pulse
+        self.calc_echowidth = calc_echowidth
+        self.full_wave_noise = full_wave_noise
+        self.platform_noise_disabled = platform_noise_disabled
+        self.pulse_freqs = pulse_freqs
+        self.supported_pulse_freqs_hz = pulse_freqs
+    
+    @classmethod
+    def from_xml(cls, filename: str, id: str = None) -> 'SingleScanner':
+        file_path = AssetManager().find_file_by_name(filename, auto_add=True)
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+
+        id = root.get('id', id)
+        beam_div_rad = float(root.get('beamDivergence_rad'))
+        beam_origin = [float(x) for x in root.get('beam_origin').split(',')]
+        beam_orientation = root.get('beam_orientation')
+        pulse_freqs = [int(x) for x in root.get('pulseFreqs_Hz').split(',')]
+        pulse_length = float(root.get('pulseLength_ns'))
+        average_power = float(root.get('average_power'))
+        beam_quality = float(root.get('beam_quality'))
+        efficiency = float(root.get('efficiency'))
+        receiver_diameter = float(root.get('receiver_diameter'))
+        atmospheric_visibility = float(root.get('atmospheric_visibility'))
+        wavelength = int(root.get('wavelength'))
+       
+        scanner_instance = cls(
+            id=id,
+            beam_div_rad=beam_div_rad,
+            beam_origin=beam_origin,
+            beam_orientation=beam_orientation,
+            pulse_freqs=pulse_freqs,
+            pulse_length=pulse_length,
+            average_power=average_power,
+            beam_quality=beam_quality,
+            efficiency=efficiency,
+            receiver_diameter=receiver_diameter,
+            atmospheric_visibility=atmospheric_visibility,
+            wavelength=wavelength,
+            range_err_expr=None
+        )
+        return cls._validate(scanner_instance)
+    
+    device_id = create_property('id', 'set_device_id')
+    average_power = create_property('avg_power', 'set_average_power')
+    beam_div_rad = create_property('beam_div_rad', 'set_beam_divergence')
+    
+    beam_quality = create_property('beam_quality', 'set_beam_quality')
+    efficiency = create_property('optical_efficiency', 'set_optical_efficiency')
+    receiver_diameter = create_property('receiver_diameter', 'set_receiver_diameter')
+    atmospheric_visibility = create_property('atmospheric_visibility', 'set_atmospheric_visibility')
+    wavelength = create_property('wavelength', 'set_wavelength')
+    beam_origin = create_property('emitter_position', 'set_head_relative_emitter_position')
+    beam_orientation = create_property('emitter_attitude', 'set_head_relative_emitter_attitude')
+    max_NOR = create_property('max_nor', 'set_max_nor')
+    beam_deflector = create_property('beam_deflector', 'set_beam_deflector')
+    detector = create_property('detector', 'set_detector')
+    scanner_head = create_property('scanner_head', 'set_scanner_head')
+    fwf_settings = create_property('fwf_settings', 'set_fwf_settings')
+    num_time_bins = create_property('num_time_bins', 'set_num_time_bins')
+    pulse_length = create_property('pulse_length', 'set_pulse_length')
+    timewave = create_property('timewave', 'set_time_wave')
+    peak_intensity_index = create_property('peak_intensity_index', 'set_peak_intensity_index')
+    
+    def prepare_discretization(self):
+        self.num_time_bins = int(self.pulse_length / self.fwf_settings.bin_size)
+        self.timewave = [0.0] * self.num_time_bins
+
+        self.peak_intensity_index = calc_propagation_time_legacy(self.timewave, self.num_time_bins, self.fwf_settings.bin_size, self.pulse_length, 7.0)
+
+    def apply_settings_FWF(self, settings: FWFSettings):
+        self._cpp_object.apply_settings_FWF(settings._cpp_object, 0)
+        self.fwf_settings = settings
+        self.scanning_device.calc_rays_number()
+        self.prepare_discretization()
+    
+    def prepare_simulation(self, is_legacy_energy_model: bool = False):
+        self.scanning_device.prepare_simulation(is_legacy_energy_model)
+    
+    def clone(self):
+        new_scanner = SingleScanner(self.id, self.average_power, self.pulse_freqs, self.beam_quality, self.efficiency, self.receiver_diameter, self.atmospheric_visibility, self.wavelength, self.beam_div_rad, self.beam_origin, self.beam_orientation, self.pulse_length, self.scanner_settings, self.write_waveform, self.write_pulse, self.calc_echowidth, self.full_wave_noise, self.platform_noise_disabled)
+        new_scanner.max_NOR = self.max_NOR
+        new_scanner.beam_deflector = self.beam_deflector
+        new_scanner.detector = self.detector
+        new_scanner.scanner_head = self.scanner_head
+        new_scanner.fwf_settings = self.fwf_settings
+        new_scanner.num_time_bins = self.num_time_bins
+        new_scanner.timewave = self.timewave
+        new_scanner.peak_intensity_index = self.peak_intensity_index
+        new_scanner._cpp_object = self._cpp_object.clone()
+
+
+class MultiScanner(Scanner):
+    def __init__(self, 
+                 scanning_devices: List[ScanningDevice],
+                 id: str,
+                 pulse_freqs: Optional[List[int]] = None,
+                 device_rotation: Optional[Rotation] = None,
+                 global_position: Optional[List[float]] = None,
+                 active_scanner_index: Optional[int] = -1,
+                 write_waveform: Optional[bool] = False,
+                 calc_echowidth: Optional[bool] = False,
+                 full_wave_noise: Optional[bool] = False,
+                 platform_noise_disabled: Optional[bool] = False) -> None:
+      
+        pulse_freqs = pulse_freqs or [0]
+
+        super().__init__(id)
+        self._cpp_object = _helios.MultiScanner([sd._cpp_object for sd in scanning_devices], id, pulse_freqs)
+  
+        self.id = id
+        self.scanning_devices = scanning_devices
+        self.device_rotation = device_rotation or Rotation()
+        self.global_position = global_position or [0.0, 0.0, 0.0]
+        self.active_scanner_index = active_scanner_index
+        self.write_waveform = write_waveform
+        self.calc_echowidth = calc_echowidth
+        self.full_wave_noise = full_wave_noise
+        self.platform_noise_disabled = platform_noise_disabled
+
+    def _get_active_device(self):
+        return self.scanning_devices[self.active_scanner_index]
+    
+    device_id = create_property('id', 'set_device_id', index_function=lambda self: self.active_scanner_index)
+    head_relative_emitter_position = create_property('emitter_position', 'set_head_relative_emitter_position', index_function=lambda self: self.active_scanner_index)
+    head_relative_emitter_attitude = create_property('emitter_attitude', 'set_head_relative_emitter_attitude', index_function=lambda self: self.active_scanner_index)
+    num_time_bins = create_property('num_time_bins', 'set_num_time_bins', index_function=lambda self: self.active_scanner_index)
+    timewave = create_property('timewave', 'set_time_wave', index_function=lambda self: self.active_scanner_index)
+    pulse_length = create_property('pulse_length', 'set_pulse_length', index_function=lambda self: self.active_scanner_index)
+    fwf_settings = create_property('fwf_settings', 'set_fwf_settings', index_function=lambda self: self.active_scanner_index)
+    peak_intensity_index = create_property('peak_intensity_index', 'set_peak_intensity_index', index_function=lambda self: self.active_scanner_index)
+    beam_deflector = create_property('beam_deflector', 'set_beam_deflector', index_function=lambda self: self.active_scanner_index)
+    detector = create_property('detector', 'set_detector', index_function=lambda self: self.active_scanner_index)
+    scanner_head = create_property('scanner_head', 'set_scanner_head', index_function=lambda self: self.active_scanner_index)
+    beam_div_rad = create_property('beam_div_rad', 'set_beam_divergence', index_function=lambda self: self.active_scanner_index)
+    wavelength = create_property('wavelength', 'set_wavelength', index_function=lambda self: self.active_scanner_index)
+    max_nor = create_property('max_nor', 'set_max_nor', index_function=lambda self: self.active_scanner_index)
+    received_energy_min = create_property('received_energy_min', 'set_received_energy_min', index_function=lambda self: self.active_scanner_index)
+    average_power = create_property('average_power', 'set_average_power', index_function=lambda self: self.active_scanner_index)
+    pulse_freqs = create_property('pulse_freqs', 'set_pulse_freqs', index_function=lambda self: self.active_scanner_index)
+    beam_quality = create_property('beam_quality', 'set_beam_quality', index_function=lambda self: self.active_scanner_index)
+    efficiency = create_property('efficiency', 'set_optical_efficiency', index_function=lambda self: self.active_scanner_index)
+    receiver_diameter = create_property('receiver_diameter', 'set_receiver_diameter', index_function=lambda self: self.active_scanner_index)
+    
+    def prepare_discretization(self):
+        self.num_time_bins = int(self.pulse_length / self.fwf_settings.bin_size)
+        self.timewave = [0.0] * self.num_time_bins
+
+        self.peak_intensity_index = calc_propagation_time_legacy(self.timewave, self.num_time_bins, self.fwf_settings.bin_size, self.pulse_length, 7.0)
+
+    def apply_settings_FWF(self, settings: FWFSettings):
+        active_device = self._get_active_device()
+        self._cpp_object.apply_settings_FWF(settings._cpp_object, self.active_scanner_index)
+        self.fwf_settings = settings
+        active_device.calc_rays_number()
+        self.prepare_discretization()
+
+    def prepare_simulation(self, is_legacy_energy_model: bool = False):
+        num_devices = len(self.scanning_devices)
+        for i in range(num_devices):
+            self.scanning_devices[i].prepare_simulation(is_legacy_energy_model)
+    
+    def clone(self):
+        new_scanner = MultiScanner(self.scanning_devices, self.id, self.pulse_freqs, self.device_rotation, self.global_position, self.active_scanner_index, self.write_waveform, self.calc_echowidth, self.full_wave_noise, self.platform_noise_disabled)
+        new_scanner._cpp_object = self._cpp_object.clone()
+        new_scanner.scanning_devices = [sd.clone() for sd in self.scanning_devices]
+        new_scanner.device_rotation = self.device_rotation
+        new_scanner.global_position = self.global_position
+        new_scanner.active_scanner_index = self.active_scanner_index
+        new_scanner.pulse_freqs = self.pulse_freqs
+        new_scanner.write_waveform = self.write_waveform
+        new_scanner.calc_echowidth = self.calc_echowidth
+        new_scanner.full_wave_noise = self.full_wave_noise
+        new_scanner.platform_noise_disabled = self.platform_noise_disabled
+        return new_scanner
+
+
+class AbstractDetector(Validatable):
+    def __init__(self, scanner: Optional[Scanner], range_max: Optional[float] =  sys.float_info.max,
+                  accuracy: Optional[float] = .0, range_min: Optional[float] = .0) -> None:
+        scanner = scanner or Scanner()
+        self._cpp_object = _helios.AbstractDetector(scanner._cpp_object, accuracy, range_min, range_max)
+        self.scanner = scanner
+        self.accuracy = accuracy
+        self.range_min = range_min
+        self.range_max = range_max
+    
+    accuracy: Optional[float] = ValidatedCppManagedProperty("accuracy")
+    range_min: Optional[float] = ValidatedCppManagedProperty("range_min")
+    range_max: Optional[float] = ValidatedCppManagedProperty("range_max")
+
+    @classmethod
+    def from_xml_node(cls, detector_node: ET.Element, scanner: Scanner) -> 'AbstractDetector':
+    
+        range_max = float(detector_node.get('rangeMax_m', 1e20))
+        accuracy = float(detector_node.get('accuracy_m', '0.0'))
+        range_min = float(detector_node.get('rangeMin_m', '0.0'))
+    
+        return FullWaveformPulseDetector._validate(FullWaveformPulseDetector(scanner=scanner, range_max=range_max, accuracy=accuracy, range_min=range_min))
+
+    def clone(self):
+        new_detector = AbstractDetector(self.scanner, self.range_max, self.accuracy, self.range_min)
+        new_detector._cpp_object = self._cpp_object.clone()
+        return new_detector
+
+
+class FullWaveformPulseDetector(AbstractDetector):
+    def __init__(self, scanner: Optional[Scanner], range_max: Optional[float], accuracy: Optional[float] = .0, range_min: Optional[float] = .0, pulse_length: Optional[float] = .0) -> None:
+        scanner = scanner or Scanner()
+        self._cpp_object = _helios.FullWaveformPulseDetector(scanner._cpp_object, accuracy, range_min, range_max)
+        self.scanner = scanner
+        self.accuracy = accuracy
+        self.range_min = range_min
+        self.range_max = range_max
+        self.pulse_length = pulse_length
+    
+    def clone(self):
+        new_detector = FullWaveformPulseDetector(self.scanner, self.range_max, self.accuracy, self.range_min, self.pulse_length)
+        new_detector._cpp_object = self._cpp_object.clone()
+        return new_detector
+
+
+LEICAALS50 = Scanner.from_xml("data/scanners_als.xml", id="leica_als50")
+
+LEICAALS50_II = Scanner.from_xml("data/scanners_als.xml", id="leica_als50-ii")
+
+OPTECH_2033 = Scanner.from_xml("data/scanners_als.xml", id="optech_2033")
+
+OPTECH_3100 = Scanner.from_xml("data/scanners_als.xml", id="optech_3100")
+
+OPTECH_GALAXY = Scanner.from_xml("data/scanners_als.xml", id="optech_galaxy")
+
+RIEGL_LMS_Q560 = Scanner.from_xml("data/scanners_als.xml", id="riegl_lms-q560")
+
+RIEGL_LMS_Q780 = Scanner.from_xml("data/scanners_als.xml", id="riegl_lms-q780")
+
+RIEGL_VQ_780i = Scanner.from_xml("data/scanners_als.xml", id="riegl_vq_780i")
+
+RIEGL_VUX_1UAV = Scanner.from_xml("data/scanners_als.xml", id="riegl_vux-1uav")
+
+RIEGL_VUX_1UAV22 = Scanner.from_xml("data/scanners_als.xml", id="riegl_vux-1uav22")
+
+RIEGL_VUX_1HA22 = Scanner.from_xml("data/scanners_als.xml", id="riegl_vux-1ha22")
+
+RIEGL_VQ_880g = Scanner.from_xml("data/scanners_als.xml", id="riegl_vq-880g")
+
+RIEGL_VQ_1560i = Scanner.from_xml("data/scanners_als.xml", id="riegl_vq-1560i")
+
+LIVOX_MID70 = Scanner.from_xml("data/scanners_als.xml", id="livox_mid-70")
+
+LIVOX_MID100 = Scanner.from_xml("data/scanners_als.xml", id="livox-mid-100")
+
+LIVOX_MID100a = Scanner.from_xml("data/scanners_als.xml", id="livox-mid-100a")
+
+LIVOX_MID100b = Scanner.from_xml("data/scanners_als.xml", id="livox-mid-100b")
+
+LIVOX_MID100c = Scanner.from_xml("data/scanners_als.xml", id="livox-mid-100c")
+
+
+#TLS 
+
+RIEGL_VZ_400 = Scanner.from_xml("data/scanners_tls.xml", id="riegl_vz400")
+
+RIEGL_VZ_1000 = Scanner.from_xml("data/scanners_tls.xml", id="riegl_vz1000")
+
+RIEGL_VQ_450 = Scanner.from_xml("data/scanners_tls.xml", id="riegl_vq-450")
+
+LIVOX_MID70_TLS = Scanner.from_xml("data/scanners_tls.xml", id="livox_mid-70")
+
+VLP16 = Scanner.from_xml("data/scanners_tls.xml", id="vlp16")
+
+VELODYNE_HDL_64E = Scanner.from_xml("data/scanners_tls.xml", id="velodyne_hdl-64e")
+
+TRACTOR_SCANNER = Scanner.from_xml("data/scanners_tls.xml", id="tractorscanner")
+
+PANO_SCANNER = Scanner.from_xml("data/scanners_tls.xml", id="panoscanner")
\ No newline at end of file
diff --git a/python/pyhelios/scene.py b/python/pyhelios/scene.py
new file mode 100644
index 000000000..feea75d52
--- /dev/null
+++ b/python/pyhelios/scene.py
@@ -0,0 +1,814 @@
+from pyhelios.utils import Validatable, ValidatedCppManagedProperty, AssetManager
+from pyhelios.primitives import Rotation, Primitive, AABB, Vertex, Triangle, Material, SwapOnRepeatHandler, PrimitiveType, KDTreeFactoryMaker
+
+from pydantic import Field, ConfigDict
+from osgeo import gdal
+from osgeo import osr
+from osgeo import ogr
+import os
+import re
+import threading
+import numpy as np
+from typing import Optional, List, Tuple, Annotated, Type, Any, Dict
+import xml.etree.ElementTree as ET
+import sys
+from collections import defaultdict, deque
+from numpy import array, zeros
+from numpy.linalg import norm
+
+import _helios
+
+gdal.DontUseExceptions()
+
+class ScenePart(Validatable):
+    def __init__(self, 
+                 id: Optional[str] = "", 
+                 origin: Optional[List[float]] = None, 
+                 rotation: Optional[Rotation] = None, 
+                 scale: Optional[float] = 1.0, 
+                 bound: Optional[List[float]] = None,
+                 primitives: Optional[List[Primitive]] = None,
+                 translation: Optional[List[float]] = None,
+                 rotation_method: Optional[str] = 'global') -> None:  
+              
+        self._cpp_object = _helios.ScenePart()
+        self.id = id
+        self.origin = origin or [0.0, 0.0, 0.0]
+        self.rotation = rotation or Rotation(1,0,0,0)
+        self.scale = scale
+        self.bound = bound
+        self.primitives = primitives or []
+        self.translation = translation or [0.0, 0.0, 0.0]
+        self.rotation_method = rotation_method
+        self.env = None
+        self.sorh = None
+        self.is_force_on_ground = 0
+        self.primitive_type: PrimitiveType = Field(default=PrimitiveType.NONE)
+
+    id: Optional[str] = ValidatedCppManagedProperty("id")
+    origin: Optional[Tuple[float, float, float]] = ValidatedCppManagedProperty("origin")
+    rotation: Optional[Rotation] = ValidatedCppManagedProperty("rotation")
+    scale: Optional[float] = ValidatedCppManagedProperty("scale")
+    bound: Optional[Tuple[float, float, float]] = ValidatedCppManagedProperty("bound")
+    primitives: Optional[List[Primitive]] = ValidatedCppManagedProperty("primitives")
+    is_force_on_ground: Optional[int] = ValidatedCppManagedProperty("is_force_on_ground")
+
+    @classmethod
+    def read_from_xml(cls: Type['ScenePart'], xml: str) -> 'ScenePart':
+        root = ET.fromstring(xml)
+        scene_part = cls()
+
+        part_element = root.find("part")
+        if part_element is not None:
+            filter_element = part_element.find("filter")
+            if filter_element is not None:
+                filter_type = filter_element.attrib.get("type")
+                if filter_type == 'scale':
+                    scene_part.scale = float(filter_element.attrib.get("value"))
+                elif filter_type == 'translate':
+                    scene_part.translation = [float(v) for v in filter_element.attrib.get("value").split(";")]
+                elif filter_type == 'rotate':
+                    scene_part._parse_rotation(filter_element)
+                elif filter_type == 'geotiffloader':
+                    scene_part._load_tiff(xml)
+        scene_part = cls._validate(scene_part)
+
+        return scene_part
+    
+    def _create_params(self, filter_type: ET.Element) -> dict:
+        params = {}
+        for param_elem in filter_type.findall('param'):
+            param_type = param_elem.get("type", "string")
+            key = param_elem.get("key")
+            value_str = param_elem.get("value")
+
+            if param_type == "string":
+                params[key] = value_str
+            elif param_type in ["boolean", "bool"]:
+                params[key] = value_str.lower() == "true"
+            elif param_type == "double":
+                try:
+                    params[key] = float(value_str)
+                except ValueError:
+                    raise ValueError(f"Invalid double value for key '{key}': {value_str}")
+            elif param_type in ["integer", "int"]:
+                try:
+                    params[key] = int(value_str)
+                except ValueError:
+                    raise ValueError(f"Invalid integer value for key '{key}': {value_str}")
+            elif param_type == "vec3":
+                try:
+                    vec = value_str.split(";")
+                    if len(vec) != 3:
+                        raise ValueError(f"Invalid vec3 value for key '{key}': {value_str}")
+                    params[key] = [float(vec[0]), float(vec[1]), float(vec[2])]
+                except (ValueError, IndexError):
+                    raise ValueError(f"Invalid vec3 format for key '{key}': {value_str}")
+            elif param_type == "rotation":
+                params[key] = Rotation.from_xml_node(param_elem)
+            else:
+                raise ValueError(f"Unknown parameter type '{param_type}' for key '{key}'")
+      
+        return params
+    
+    def _apply_filter(self, filter_type: str, params: dict) -> None:
+        if filter_type == "scale":
+            self.scale_loader(params)
+        elif filter_type == "translate":
+            self.translate_loader(params)
+        elif filter_type == "rotate":
+            self.rotate_loader(params)
+        if filter_type == "geotiffloader":
+            self._geotiff_loader(params)
+        elif filter_type == "objloader":
+            self._obj_loader(params)
+        #TODO: implement xyzloader and detailed_voxels_loader
+    
+    def load_scene_filter(self, filter_element: ET.Element) -> None:
+        for filter_elem in filter_element.findall('filter'):
+            filter_type = filter_elem.attrib.get('type')
+            params = self._create_params(filter_elem)
+            
+            self._apply_filter(filter_type, params)
+            if filter_type in ["geotiffloader", "detailed_voxels_loader", "xyzloader", "objloader"] and filter_element.find('swap') is not None:
+                if self.sorh is not None:
+                    raise ValueError("Multiple swap filters are not supported.")
+                    
+                self.sorh = self.load_scene_part_swaps(filter_elem, params)
+
+    def load_scene_part_swaps(self, filter_elem: ET.Element, params: dict) -> Optional[SwapOnRepeatHandler]:
+        swap_nodes = filter_elem.findall("swap")
+        if not swap_nodes:
+            return None
+        
+        sorh = SwapOnRepeatHandler()
+
+        for swap_node in swap_nodes:
+            # Get swapStep and keepCRS attributes
+            swap_step = int(swap_node.get("swapStep", 1))
+            keep_crs = bool(swap_node.get("keepCRS", sorh.keep_crs))
+            
+            sorh.push_time_to_live(swap_step)
+            sorh.keep_crs = keep_crs
+            
+            # Prepare to collect filters for the swap
+            swap_filters = deque()
+            
+            # Check for null geometry filter
+            if swap_node.get("force_null", "false") == "true":
+                swap_filters.append("null")
+            else:
+                # Load filters if they exist
+                for filter_node in swap_node.findall("filter"):
+                    filter_type = filter_node.attrib.get('type')
+                    params = self._create_params(filter_elem)
+    
+                    self._apply_filter(filter_type, params)
+                    swap_filters.append(params)
+            
+            # Add the swap filters to the handler
+            sorh.swap_filters.append(swap_filters)
+        
+        # Prepare the SwapOnRepeatHandler with the scene part
+        sorh.prepare(self, swap_filters)
+        return sorh
+    
+    def validate_scene_part(self, part_elem: ET.Element) -> bool:
+        # Check if the scene part is valid
+        if self.primitive_type == "NONE" and not self.primitives:
+            path = "#NULL#"
+            path_type = "path"
+            found_path = False
+            for filter_elem in part_elem.findall('filter'):
+                for param_elem in filter_elem.findall('param'):
+                    if 'key' in param_elem.attrib:
+                        key = param_elem.attrib['key']
+                        if key in ["filepath", "efilepath"]:
+                            path = param_elem.attrib.get('value', '#NULL#')
+                            path_type = "extended path expression" if key == "efilepath" else "path"
+                            found_path = True
+                            break
+                if found_path:
+                    break
+
+            # Log a warning or error for invalid scene parts
+            print(f"XmlSceneLoader::validate_scene_part detected an invalid scene part with id \"{self.id}\".\n"
+                  f"The {path_type} \"{path}\" was given.\n"
+                  "It leads to the loading of an invalid scene part, which is automatically ignored.")
+            return False
+        return True
+
+    def load_scene_part_id(self, part_elem: ET.Element, idx: int) -> bool:
+        """
+        This method loads the `id` attribute of a scene part from an XML element.
+        If no ID is present, it generates an ID from the index.
+        
+        Parameters:
+            part_elem (ET.Element): The XML element representing the scene part.
+            idx (int): The index of the part in the scene.
+
+        Returns:
+            bool: Returns True if the part should be split, False otherwise.
+        """
+        part_id = ""
+        split_part = True
+
+        # Try to find the 'id' attribute
+        part_id_attr = part_elem.attrib.get("id")
+
+        if part_id_attr is not None:
+            part_id = part_id_attr
+            try:
+                # Try to convert the ID to an integer (to simulate checking if it's numerical)
+                int(part_id)
+            except ValueError:
+                # If it's not numerical, log a warning and proceed
+                print(f'Warning: Scene part id "{part_id}" is non-numerical. '
+                      'This is not compatible with LAS format specification.')
+        
+        # If no id was found, assign the partIndex as the id
+        if not part_id:
+            self.id = str(idx)
+        else:
+            self.id = part_id
+            split_part = False
+
+        return split_part
+
+    def scale_loader(self, params: dict) -> None:
+        for key, value in params.items():
+            if key == "scale":
+                self.scale = float(value)
+
+    def translate_loader(self, params: dict) -> None:
+        for key, value in params.items():
+            if key == "offset":
+                self.origin = value
+            if key == "onGround":
+                self.is_force_on_ground = int(value)
+
+    def rotate_loader(self, params: dict) -> None:
+        for key, value in params.items():
+            if key == "rotation":
+                rotation = value
+                self.rotation = rotation.apply_rotation(self.rotation)
+               
+    def _parse_rotation(self, filter_element: ET.Element) -> None:
+        """Helper method to parse rotation data from XML."""
+        self.rotation_method = filter_element.attrib.get('rotations', 'global')
+        rotation_param = filter_element.find('param')
+        if rotation_param is not None and rotation_param.attrib.get('type') == 'rotation':
+            self.rotation = [
+                (rot.attrib.get('axis', ''), rot.attrib.get('angle_deg', ''))
+                for rot in rotation_param.findall('rot')
+            ]
+    
+    def _obj_loader(self, params: dict) -> None:
+        y_is_up = self._determine_up_axis(params)
+        for key, value in params.items():
+            
+            if 'filepath' in key:
+                file_path = AssetManager().find_file_by_name(value, auto_add=False)
+                self._load_obj(file_path, y_is_up)       
+    
+    def _load_obj(self, file_path: str, y_is_up: bool) -> None:
+        with open(file_path, 'r') as file:
+            primitives = []
+            vertices = []
+            normals = []
+            tex_coords = []
+            materials = {}
+            current_mat_type = "default"
+            mat = Material()
+            mat.use_vertex_colors = True
+            mat.mat_file_path = str(file_path)
+            if current_mat_type not in materials:
+                materials[current_mat_type] = [] 
+            materials[current_mat_type].append(mat)
+
+            for line in file:
+                    line = line.strip()
+                    if not line or line.startswith("#"):
+                        continue
+                    line_parts = re.split(r"\s+", line)
+                    if line_parts[0] == "v":
+                        vertices.append(self._read_obj_vertex(line_parts, y_is_up))
+                        
+                    elif line_parts[0] == "vn":
+                        normals.append(self._read_obj_normal_vector(line_parts, y_is_up))
+                    elif line_parts[0] == "vt":
+                        tex_coords.append([float(line_parts[1]), float(line_parts[2])])
+                    elif line_parts[0] == "f":
+
+                        # We need to check if the name that is in currentmat is in the materials dict, the we need to save to variable the value from the dict. If not we create Material instance set name to currentMat and insert this pair to dict
+                        if current_mat in materials.keys():
+                            mat = materials[current_mat]
+                        else:
+                            mat = Material()
+                            mat.name = current_mat
+                            materials.update({current_mat_type: [mat]})
+                        self._read_obj_primitive(primitives, line_parts, vertices, tex_coords, normals, mat, file_path)
+                    elif line_parts[0] == "usemtl":
+                        current_mat = line_parts[1]
+                       
+                    elif line_parts[0] == "mtllib":
+                        file_path_string = os.path.join(os.path.dirname(file_path), line_parts[1])
+                        new_materials = Material.load_materials(file_path_string)
+                        materials.update(new_materials)
+            self.primitives.extend(primitives)
+                  
+    def _determine_up_axis(self, params: dict) -> bool:
+        up_axis = params.get("up", "z")
+        if up_axis == "y":
+            return True
+        elif up_axis != "z":
+            raise RuntimeWarning(f"Invalid up axis value: {up_axis}. Defaulting to z-axis.")
+        return False
+
+    def _read_obj_vertex(self, line_parts: List[str], y_is_up: bool) -> Vertex:
+        if y_is_up:
+            position = [float(line_parts[1]), -float(line_parts[3]), float(line_parts[2])]
+        else:
+            position = [float(line_parts[1]), float(line_parts[2]), float(line_parts[3])]
+        
+        return Vertex(position=position)
+                    
+    def _read_obj_normal_vector(self, line_parts: List[str], y_is_up: bool):
+        if y_is_up:
+            return [float(line_parts[1]), -float(line_parts[3]), float(line_parts[2])]
+        else:
+            return [float(line_parts[1]), float(line_parts[2]), float(line_parts[3])]
+
+    def _read_obj_primitive(self, primitives: List[Primitive], line_parts: List[str], vertices: List[Vertex],
+                      texcoords: List[List[float]], normals: List[List[float]], current_mat: Material, mat_file_path: str) -> None:
+        verts = []
+
+        for part in line_parts[1:]:
+            fields = part.split('/')
+            vi = int(fields[0]) - 1
+            ti = int(fields[1]) - 1 if len(fields) > 1 and fields[1] else -1
+            ni = int(fields[2]) - 1 if len(fields) > 2 and fields[2] else -1
+            vert = self._build_primitive_vertex(vertices[vi], vertices[vi], ti, ni, texcoords, normals)
+            verts.append(vert)
+
+        if len(verts) == 3:
+            tri = Triangle(v0=verts[0], v1=verts[1], v2=verts[2])
+            tri.material = current_mat
+            primitives.append(tri)
+          
+        elif len(verts) == 4:
+            tri1 = Triangle(v0=verts[0], v1=verts[1], v2=verts[2])
+            tri2 = Triangle(v0=verts[0], v1=verts[2], v2=verts[3])
+            tri1.material = current_mat
+            tri2.material = current_mat
+            primitives.append(tri1)
+            primitives.append(tri2)
+        
+    def _build_primitive_vertex(self, dst_vert: Vertex, src_vert: Vertex, tex_idx: int, normal_idx: int,
+                         texcoords: List[List[float]], normals: List[List[float]]):
+        dst_vert = src_vert.clone() 
+        if tex_idx >= 0:
+            dst_vert.tex_coords = texcoords[tex_idx]
+        if normal_idx >= 0:
+            dst_vert.normal = normals[normal_idx]
+        return dst_vert
+
+    def _geotiff_loader(self, params: dict) -> None:
+        """Load TIFF file and generate a 3D mesh using GDAL and Open3D."""
+
+        file_path = AssetManager().find_file_by_name(params["filepath"], auto_add=False)
+        if file_path is None:
+            raise FileNotFoundError(f"No filepath was provided for the GeoTIFF file.")
+        
+        tiff_dataset = gdal.Open(file_path, gdal.GA_ReadOnly)
+        if tiff_dataset is None:
+            raise RuntimeError(f"Failed to open GeoTIFF file at {file_path}")
+        
+        coord_ref_sys = tiff_dataset.GetSpatialRef()
+        if coord_ref_sys is not None:
+            source_crs = coord_ref_sys.Clone()
+        else:
+            source_crs = osr.SpatialReference()
+        
+        raster_band = tiff_dataset.GetRasterBand(1)  # Get the first raster band (band 1)
+        if raster_band is None:
+            raise RuntimeError("Failed to obtain raster band from TIFF file.")
+        
+        # Get the raster dimensions (width and height)
+        raster_width = raster_band.XSize
+        raster_height = raster_band.YSize
+
+        # envelope data
+        self.env = {"MinX": 0, "MaxX": 0, "MinY": 0, "MaxY": 0}
+        layer = tiff_dataset.GetLayer(0)  # Assuming only one layer
+        geom = None
+        if layer is not None:
+            # Get spatial filter if available
+            geom = layer.GetSpatialFilter()
+
+        if geom is not None:
+            # Envelope from geometry
+            env = geom.GetEnvelope()
+            self.env["MinX"], self.env["MaxX"], self.env["MinY"], self.env["MaxY"] = env
+        elif layer is not None:
+            # Envelope from layer extent
+            env = ogr.Envelope()
+            if layer.GetExtent(env, True) == ogr.OGRERR_NONE:
+                self.env["MinX"], self.env["MaxX"], self.env["MinY"], self.env["MaxY"] = env.MinX, env.MaxX, env.MinY, env.MaxY
+            else:
+                raise RuntimeError("Failed to retrieve envelope from layer.")
+        else:
+            # Envelope from GeoTransform (fallback)
+            transform = tiff_dataset.GetGeoTransform()
+            if transform:
+                if transform[1] > 0:
+                    self.env["MinX"] = transform[0]
+                    self.env["MaxX"] = self.env["MinX"] + transform[1] * raster_width
+                else:
+                    self.env["MaxX"] = transform[0]
+                    self.env["MinX"] = self.env["MaxX"] + transform[1] * raster_width
+                
+                if transform[5] < 0:  # Negative value for pixel height
+                    self.env["MaxY"] = transform[3]
+                    self.env["MinY"] = self.env["MaxY"] + transform[5] * raster_height
+                else:
+                    self.env["MinY"] = transform[3]
+                    self.env["MaxY"] = self.env["MinY"] + transform[5] * raster_height
+
+            else:
+                raise RuntimeError("No valid GeoTransform found.")
+
+        width = self.env["MaxX"] - self.env["MinX"]
+        height = self.env["MaxY"] - self.env["MinY"]
+
+        # Calculate pixel size
+        pixel_width = width / raster_width
+        pixel_height = height / raster_height
+
+        #fill Vertices
+        # Get no-data value from the raster
+        nodata = raster_band.GetNoDataValue()
+        if nodata is None:
+            nodata = float('nan')
+        
+        half_pixel_width = pixel_width / 2.0
+        half_pixel_height = pixel_height / 2.0
+        eps = 1e-6
+        vertices = [[None for _ in range(raster_height)] for _ in range(raster_width)]
+        for x in range(raster_width):
+            for y in range(raster_height):
+                z = np.array([0.0], dtype=np.float32)  # Buffer to store the pixel value
+                err = raster_band.ReadRaster(
+                    xoff=x,
+                    yoff=y,
+                    xsize=1,
+                    ysize=1,
+                    buf_xsize=1,
+                    buf_ysize=1,
+                    buf_type=gdal.GDT_Float32,
+                    buf_obj=z
+                )
+
+                if err is None:
+                    continue
+
+                z_val = z[0]
+                if np.abs(z_val - nodata) < eps:
+                    v = None  # No data, so no vertex
+                else:
+                    # Create the vertex with 3D position and texture coordinates
+                    v = Vertex()
+                    v.position = [
+                        self.env["MinX"]+ x * pixel_width + half_pixel_width,
+                        self.env["MinY"] - y * pixel_height - half_pixel_height + height,
+                        z_val
+                    ]
+                    v.tex_coords = [
+                        x / raster_width,
+                        (raster_height - y) / raster_height
+                    ]
+                # Store the vertex in the grid
+                vertices[x][y] = v
+
+        # Build triangles from the vertices
+        for x in range(raster_width - 1):
+            for y in range(raster_height - 1):
+                # Get the four vertices that form the two triangles in this square
+                vert0 = vertices[x][y]
+                vert1 = vertices[x][y + 1]
+                vert2 = vertices[x + 1][y + 1]
+                vert3 = vertices[x + 1][y]
+
+                # Create the first triangle (vert0, vert1, vert3) if all vertices are valid
+                if vert0 is not None and vert1 is not None and vert3 is not None:
+                    tri1 = Triangle(vert0, vert1, vert3)
+                    self.primitives.append(tri1)
+
+                # Create the second triangle (vert1, vert2, vert3) if all vertices are valid
+                if vert1 is not None and vert2 is not None and vert3 is not None:
+                    tri2 = Triangle(vert1, vert2, vert3)
+                    self.primitives.append(tri2)
+
+        # parse Material
+        materials = []
+        materials = Material.parse_materials(params)
+       
+        mat_file_path = params.get("matfile", "")
+        mat = Material(mat_file_path=mat_file_path, name="default") if not materials else materials[0]
+        for prim in self.primitives:
+            prim.material = mat
+        self.smooth_vertex_normals()
+
+    def compute_transform(self, holistic: Optional[bool] = False) -> None:
+        for primitive in self.primitives:
+            primitive.scene_part = self
+            primitive.rotate(self.rotation)
+    
+            # If holistic is True, scale the vertices of the primitive
+            if holistic:
+                for vertex in primitive.vertices:
+                    vertex.position[0] *= self.scale
+                    vertex.position[1] *= self.scale
+                    vertex.position[2] *= self.scale
+            
+            # Scale the primitive
+            primitive.scale(self.scale)
+            # Translate the primitive
+            primitive.translate(self.origin)
+              
+    def smooth_vertex_normals(self):
+        # Dictionary to store the list of triangles for each vertex
+        vt_map = defaultdict(list)
+
+        for primitive in self.primitives:
+            if isinstance(primitive, Triangle):  # Check if primitive is a Triangle
+                for vert in primitive.vertices:  # Use the vertices property
+                    vt_map[vert].append(primitive)
+
+        for vertex, triangles in vt_map.items():
+            vertex.normal = np.zeros(3)  # Initialize vertex normal as a zero vector
+            for triangle in triangles:
+                vertex.normal += triangle.get_face_normal()  # Accumulate face normals
+            if len(triangles) > 0:
+                vertex.normal /= np.linalg.norm(vertex.normal) 
+
+
+class Scene(Validatable):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    def __init__(self, 
+            scene_parts: Optional[List[ScenePart]], bbox: Optional[AABB] = None, bbox_crs: Optional[AABB] = None) -> None:
+        
+        self._cpp_object = _helios.Scene()
+        self._scene_parts = scene_parts
+        self.bbox = bbox
+        self.bbox_crs = bbox_crs
+
+        self._kd_grove_factory: _helios.KDGroveFactory
+        self.kd_grove: Optional[_helios.KDGrove]
+        self.kd_factory_type: int = 1
+        self.kdt_num_jobs: int = 1
+        self.kdt_geom_jobs: int = 1
+        self.kdt_sah_loss_nodes: int = 21
+        self.primitives: Optional[List[Primitive]] = []
+        self.default_reflectance: float = 50.0
+
+    @property
+    def scene_parts(self) -> Optional[List[ScenePart]]:
+        return self._scene_parts
+
+    @property
+    def kd_grove_factory(self) -> Optional[_helios.KDGroveFactory]:
+        return self._kd_grove_factory
+
+    @kd_grove_factory.setter
+    def kd_grove_factory(self, value: Optional[_helios.KDGroveFactory]) -> None:
+        self._kd_grove_factory = value
+        self._cpp_object.kd_grove_factory = value
+
+    def add_scene_part(self, scene_part: ScenePart) -> None:
+        if scene_part is not None:
+            self._scene_parts.append(scene_part)
+
+    scene_parts: Optional[List[ScenePart]] = ValidatedCppManagedProperty("scene_parts")
+    kd_grove_factory: Optional[_helios.KDGroveFactory] = ValidatedCppManagedProperty("kd_grove_factory")
+    bbox: Optional[AABB] = ValidatedCppManagedProperty("bbox")
+    bbox_crs: Optional[AABB] = ValidatedCppManagedProperty("bbox_crs")
+    primitives: Optional[List[Primitive]] = ValidatedCppManagedProperty("primitives")
+    default_reflectance: Optional[float] = ValidatedCppManagedProperty("default_reflectance")
+    
+    def get_scene_parts_size(self) -> int:
+        return len(self._scene_parts)
+    
+    @classmethod
+    def read_from_xml(cls: Type['Scene'], filename: str, id: Optional[str] = '', kd_factory_type: Optional[int] = 1, kdt_num_jobs: Optional[int] = 1, kdt_geom_jobs: Optional[int] = 1,  kdt_sah_loss_nodes: Optional[int] = 21) -> 'Scene':
+
+        file_path = AssetManager.find_file_by_name(filename, auto_add=True)
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+        
+        scene_element = root.find(f".//scene[@id='{id}']")
+        
+        if scene_element is None:
+            raise ValueError(f"No scanner found with id: {id}")
+        
+        is_dyn_scene = False
+        holistic = False #TODO Implement holistis for xyzloader
+        scene_parts = []
+        scene = StaticScene._validate(StaticScene())
+        for idx, part_elem in enumerate(scene_element.findall('part')):
+            scene_part = ScenePart()
+            scene_part.load_scene_filter(part_elem)
+            is_split_part = scene_part.load_scene_part_id(part_elem, idx)
+            if not scene_part.validate_scene_part(part_elem):
+                # If invalid, skip to the next element
+                continue
+            
+            #TODO Implement reading of dynamic scene parts
+            #TODO: scene loading specification
+            scene._digest_scene_part(scene_part, idx, holistic, is_split_part, is_dyn_scene)
+         
+            scene_parts.append(scene_part)
+
+        scene.scene_parts = scene_parts
+
+        #Trying to validate directly
+        scene._cpp_object.scene_parts = [scene_part._cpp_object for scene_part in scene_parts]
+        scene._cpp_object.primitives = [primitive._cpp_object for primitive in scene.primitives]
+
+        for part in scene.scene_parts:
+            part._cpp_object.primitives = [primitive._cpp_object for primitive in part.primitives]
+            for primitive in part.primitives:
+                if primitive.material is not None:
+                    primitive._cpp_object.material = primitive.material._cpp_object
+      
+                if primitive.vertices is not None:
+                    abd = [vertex._cpp_object for vertex in primitive.vertices]       
+                    primitive._cpp_object.vertices = abd
+
+            part._cpp_object.compute_transform(False)
+        
+        scene._cpp_object.finalize_loading()
+        scene.kd_factory_type = kd_factory_type
+        scene.kdt_num_jobs = kdt_num_jobs
+        scene.kdt_geom_jobs = kdt_geom_jobs
+        scene.kdt_sah_loss_nodes = kdt_sah_loss_nodes
+        kd_tree_type = scene.define_kd_type()
+        scene._cpp_object.kd_grove_factory = _helios.KDGroveFactory(kd_tree_type)
+
+        return cls._validate(scene)
+
+    def _digest_scene_part(self, scene_part: ScenePart, part_index: int, holistic: Optional[bool] = False, split_part: Optional[bool] = False, dyn_object: Optional[bool] = False) -> None:
+        scene_part.compute_transform(holistic)
+
+        if not dyn_object:
+            self.static_objects.append(scene_part)
+            self._cpp_object.append_static_object_part(scene_part._cpp_object)
+
+        self.primitives.extend(scene_part.primitives)
+        #TODO: implement splitting of scene parts
+        '''
+        if (split_part):
+            part_index_offset = len(scene_part.subpart_limit) - 1
+            if scene_part.split_subparts():
+                part_index += part_index_offset
+        '''
+       
+        num_vertices = len(scene_part.primitives[0].vertices)
+
+        if num_vertices == 3:
+            scene_part.primitive_type = PrimitiveType.TRIANGLE
+        elif num_vertices == 2:
+            scene_part.primitive_type = PrimitiveType.VOXEL
+
+    def define_kd_type(self):
+        """Define the KD tree factory based on the factory type and number of jobs."""
+        self.kdt_num_jobs = self.kdt_num_jobs or (os.cpu_count() or 1)
+        self.kdt_geom_jobs = self.kdt_geom_jobs or self.kdt_num_jobs
+        
+        # Define a mapping of factory types to corresponding maker functions
+        factory_makers = {
+            1: {
+                'single': KDTreeFactoryMaker.make_simple_kd_tree,
+                'multi': KDTreeFactoryMaker.make_multithreaded_simple_kd_tree,
+            },
+            2: {
+                'single': KDTreeFactoryMaker.make_sah_kd_tree_factory,
+                'multi': KDTreeFactoryMaker.make_multithreaded_sah_kd_tree_factory,
+            },
+            3: {
+                'single': KDTreeFactoryMaker.make_axis_sah_kd_tree_factory,
+                'multi': KDTreeFactoryMaker.make_multithreaded_axis_sah_kd_tree_factory,
+            },
+            4: {
+                'single': KDTreeFactoryMaker.make_fast_sah_kd_tree_factory,
+                'multi': KDTreeFactoryMaker.make_multithreaded_fast_sah_kd_tree_factory,
+            }
+        }
+
+        # Determine whether to use a multi-threaded or single-threaded factory
+        factory_type = 'multi' if self.kdt_num_jobs > 1 else 'single'
+        
+        # Get the appropriate factory maker function based on the type
+        if self.kd_factory_type in factory_makers:
+            factory_func = factory_makers[self.kd_factory_type][factory_type]
+
+            # Pass the required parameters to the factory function
+            if factory_type == 'multi':
+                # For multithreaded factories, pass node_jobs, geom_jobs, and optionally loss_nodes
+                if self.kd_factory_type == 1:  # SimpleKDTreeFactory doesn't use loss_nodes
+                    return factory_func(self.kdt_num_jobs, self.kdt_geom_jobs)
+                else:
+                    return factory_func(self.kdt_num_jobs, self.kdt_geom_jobs, self.kdt_sah_loss_nodes)
+            else:
+                # For single-threaded factories
+                if self.kd_factory_type == 1:  # SimpleKDTreeFactory doesn't use any arguments
+                    return factory_func()
+                else:
+                    return factory_func(self.kdt_sah_loss_nodes)
+    
+    # Function to interpolate reflectance
+    def interpolate_reflectance(self, wavelength: float, w0: float, w1: float, r0: float, r1: float) -> float:
+        w_range = w1 - w0
+        w_shift = wavelength - w0
+        factor = w_shift / w_range
+        r_range = r1 - r0
+        return r0 + (factor * r_range)
+
+    # Function to read reflectances from files in the given directory
+    def read_extra_reflectances(self, wavelength: float) -> Dict[str, float]:
+        reflectance_map = {}
+        wavelength_um = wavelength * 1000000 
+
+        for path in AssetManager._assets:
+            spectra_path = os.path.join(path, "spectra")
+            if not os.path.isdir(spectra_path):
+                continue
+
+            
+            for file in os.listdir(spectra_path):
+                file_path = os.path.join(spectra_path, file)
+                try:
+                    with open(file_path, 'rb') as f:
+                        # Skip the header (first 26 lines)
+                        for _ in range(26):
+                            next(f)
+
+                        prev_wavelength = prev_reflectance = None
+                        for line in f:
+                            values = line.decode('utf-8').strip().split("\t")
+                            new_wavelength = float(values[0])
+                            reflectance = float(values[1])
+
+                            # Skip wavelengths smaller than the desired wavelength
+                            if new_wavelength < wavelength_um:
+                                prev_wavelength = new_wavelength
+                                prev_reflectance = reflectance
+                                continue
+
+                            if new_wavelength > wavelength_um:
+                                # Interpolate reflectance for the desired wavelength
+                                reflectance = self.interpolate_reflectance(wavelength_um, prev_wavelength, new_wavelength, prev_reflectance, reflectance)
+                            break
+
+                        # Store the reflectance value in the map with the file name as the key
+                        file_name = os.path.splitext(os.path.basename(file))[0]
+                        reflectance_map[file_name] = reflectance
+                except Exception as e:
+                    raise Exception(f"Error reading file {file_path}: {e}")
+
+        return reflectance_map
+
+    # Function to set reflectances for materials in the scene
+    def specify_extra_reflectances(self, reflectance_map: Dict[str, float], default_reflectance: Optional[float] = 50.0) -> None:
+        mats_missing = set()  
+
+        for prim in self.primitives:
+            if prim.material.reflectance >= 0:
+                continue  # If reflectance is already set, skip
+
+            prim.material.reflectance = default_reflectance  # Set the default reflectance
+
+            if not prim.material.spectra:
+                if prim.material.spectra not in mats_missing:
+                    mats_missing.add(prim.material.spectra)
+                continue
+
+            if prim.material.spectra not in reflectance_map:
+                if prim.material.spectra not in mats_missing:
+                    mats_missing.add(prim.material.spectra)
+                continue
+
+            prim.material.reflectance = reflectance_map[prim.material.spectra]
+            prim.material.calculate_specularity()        
+
+    class Config:
+        arbitrary_types_allowed = True              
+
+class StaticScene(Scene):
+    def __init__(self, 
+                 static_objects: Optional[List[ScenePart]] = [], 
+                 bbox: Optional[AABB] = None, 
+                 bbox_crs: Optional[AABB] = None) -> None:
+        super().__init__(static_objects, bbox, bbox_crs)
+        self._cpp_object = _helios.StaticScene()
+        self.static_objects: Optional[List[ScenePart]] = static_objects
\ No newline at end of file
diff --git a/python/pyhelios/simulation.py b/python/pyhelios/simulation.py
new file mode 100644
index 000000000..dcafd92d1
--- /dev/null
+++ b/python/pyhelios/simulation.py
@@ -0,0 +1,151 @@
+
+from pyhelios.utils import Validatable, ValidatedCppManagedProperty
+from pyhelios.primitives import Rotation, Measurement, Trajectory
+from pyhelios.survey import Survey
+from typing import Optional, List, Callable
+import _helios
+
+class SimulationCycleCallback:
+    def __init__(self, callback: Optional[Callable] = None):
+        # Create an instance of the C++ SimulationCycleCallback and pass the callback object
+        self._cpp_object = _helios.SimulationCycleCallback(callback)
+        self._callback = callback  # Store the Python callable
+
+    @property
+    def callback(self) -> Optional[Callable]:
+        return self._callback
+
+    @callback.setter
+    def callback(self, value: Optional[Callable]):
+        if not callable(value) and value is not None:
+            raise ValueError("The callback must be callable.")
+        self._callback = value
+    
+
+    def __call__(self, measurements: List['Measurement'], trajectories: List['Trajectory'], outpath: str):
+        """
+        Invokes the callback function with the measurements, trajectories, and outpath.
+        """
+        if self._callback:
+            self._callback(measurements, trajectories, outpath)
+        else:
+            raise ValueError("No callback function set.")
+
+    def set_callback(self, callback: Callable):
+        """
+        Set a new callback function for the C++ object.
+        """
+        self.callback = callback
+
+class PyheliosSimulation(Validatable):
+    def __init__(self, final_output: Optional[bool] = True, legacy_energy_model: Optional[bool] = False, export_to_file: Optional[bool] = True,
+                 num_threads: Optional[int] = 0, num_runs: Optional[int] = 1, callback_frequency: Optional[int] = 0, 
+                 simulation_frequency: Optional[SimulationCycleCallback] = None, fixed_gps_time: Optional[str] = "", 
+                 las_output: Optional[bool] = False, las10_output: Optional[bool] = False,
+                 zip_output: Optional[bool] = False , split_by_channel: Optional[bool] = False, las_scale: Optional[float] = 0.0001, 
+                 kdt_factory_type: Optional[int] = 4,
+                 kdt_jobs: Optional[int] = 0, kdt_SAH_loss_nodes: Optional[int] = 32, parallelization_strategy: Optional[int] = 1, chunk_size: Optional[int] = 32,
+                 warehouse_factor: Optional[int] = 1, survey: Optional[Survey] = None, survey_path: Optional[str] = "",
+                 assets_path: Optional[str] = "", output_path: Optional[str] = ""
+                 ) -> None:
+        self._cpp_object = _helios.PyheliosSimulation()
+        self.survey_path = survey_path
+        self.assets_path = assets_path
+        self.output_path = output_path
+        self.survey = survey
+        self.final_output = final_output
+        self.legacy_energy_model = legacy_energy_model
+        self.export_to_file = export_to_file
+        self.num_threads = num_threads
+        self.num_runs = num_runs
+        self.callback_frequency = callback_frequency
+        self.simulation_frequency = simulation_frequency
+        self.fixed_gps_time = fixed_gps_time
+        self.las_output = las_output
+
+        self.las10_output = las10_output
+        self.zip_output = zip_output
+        self.split_by_channel = split_by_channel
+        self.las_scale = las_scale
+        self.kdt_factory_type = kdt_factory_type
+        self.kdt_jobs = kdt_jobs
+        self.kdt_SAH_loss_nodes = kdt_SAH_loss_nodes
+        self.parallelization_strategy = parallelization_strategy
+        self.chunk_size = chunk_size
+        self.warehouse_factor = warehouse_factor
+
+        
+        self.is_started = False
+        self.is_paused = False
+        self.is_stopped = False
+
+
+    final_output: Optional[bool] = ValidatedCppManagedProperty("final_output")
+    legacy_energy_model: Optional[bool] = ValidatedCppManagedProperty("legacy_energy_model")
+    export_to_file: Optional[bool] = ValidatedCppManagedProperty("export_to_file")
+    num_threads: Optional[int] = ValidatedCppManagedProperty("num_threads")
+    num_runs: Optional[int] = ValidatedCppManagedProperty("num_runs")
+    callback_frequency: Optional[int] = ValidatedCppManagedProperty("callback_frequency")
+    simulation_frequency: Optional[SimulationCycleCallback] = ValidatedCppManagedProperty("simulation_frequency")
+    fixed_gps_time: Optional[str] = ValidatedCppManagedProperty("fixed_gps_time")
+    las_output: Optional[bool] = ValidatedCppManagedProperty("las_output")
+    las10_output: Optional[bool] = ValidatedCppManagedProperty("las10_output")
+    zip_output: Optional[bool] = ValidatedCppManagedProperty("zip_output")
+    split_by_channel: Optional[bool] = ValidatedCppManagedProperty("split_by_channel")
+    las_scale: Optional[float] = ValidatedCppManagedProperty("las_scale")
+    kdt_factory_type: Optional[int] = ValidatedCppManagedProperty("kdt_factory")
+    kdt_jobs: Optional[int] = ValidatedCppManagedProperty("kdt_jobs")
+    kdt_SAH_loss_nodes: Optional[int] = ValidatedCppManagedProperty("kdt_SAH_loss_nodes")
+    parallelization_strategy: Optional[int] = ValidatedCppManagedProperty("parallelization_strategy")
+    chunk_size: Optional[int] = ValidatedCppManagedProperty("chunk_size")
+    warehouse_factor: Optional[int] = ValidatedCppManagedProperty("warehouse_factor")
+    survey: Optional[Survey] = ValidatedCppManagedProperty("survey")
+
+
+
+    def start(self):
+        if self.is_started:
+            raise ValueError("Simulation is already started")
+        
+        if self.survey is None:
+            self.load_survey(self.survey_path)
+        self.is_started = True
+        
+        # Add output here later
+
+        self.build_pulse_thread_pool()
+
+    def pause(self):
+        pass
+
+    def stop(self):
+        pass
+
+    def resume(self):
+        pass
+
+    def join(self):
+        pass
+
+    def load_survey(self, survey_path: str):
+        self.survey = Survey.from_xml(survey_path)
+
+    def add_rotation(self, rotation: Rotation):
+        pass
+
+    def add_scale_filter(self, scale_filter: float):
+        pass
+
+    def add_translate_filter(self, translate_filter: float):
+        pass
+
+    def build_pulse_thread_pool(self):
+        
+        #FOR NOW JUST CALL IT FROM THE C++ SIDE
+        self._cpp_object.build_pulse_thread_pool()
+
+    
+
+
+    
+
diff --git a/python/pyhelios/simulation_build.py b/python/pyhelios/simulation_build.py
index a5db4ca4f..a77d2f12a 100644
--- a/python/pyhelios/simulation_build.py
+++ b/python/pyhelios/simulation_build.py
@@ -1,4 +1,4 @@
-import pyhelios
+import _helios
 from threading import Condition as CondVar
 
 PYHELIOS_SIMULATION_BUILD_CONDITION_VARIABLE = CondVar()
@@ -36,7 +36,7 @@ def __init__(
         if copy:
             return
 
-        self.sim = pyhelios.Simulation(
+        self.sim = _helios.PyheliosSimulation(
             surveyPath,
             assetsDir,
             outputDir,
@@ -52,7 +52,7 @@ def __init__(
             chunkSize,
             warehouseFactor
         )
-        self.sim.fixedGpsTimeStart = fixedGpsTimeStart
+        self.sim.fixed_gps_time_start = fixedGpsTimeStart
 
     # ---  CONTROL METHODS  --- #
     # ------------------------- #
@@ -71,11 +71,11 @@ def resume(self):
     def join(self):
         # Conditional variable necessary for callback mode
         with PYHELIOS_SIMULATION_BUILD_CONDITION_VARIABLE:
-            output = self.sim.join()
-            while not output.finished:
+            measurements, trajectories, outpath, outpaths, finished = self.sim.join()
+            while not finished:
                 PYHELIOS_SIMULATION_BUILD_CONDITION_VARIABLE.wait()
-                output = self.sim.join()
-        return output
+                measurements, trajectories, outpath, outpaths, finished = self.sim.join()
+        return (measurements, trajectories, outpath, outpaths, finished)
 
     # ---  C O P Y  --- #
     # ----------------- #
@@ -92,19 +92,19 @@ def copy(self):
     # ---  GETTERS and SETTERS  --- #
     # ----------------------------- #
     def isStarted(self):
-        return self.sim.isStarted()
+        return self.sim.is_started
 
     def isPaused(self):
-        return self.sim.isPaused()
+        return self.sim.is_paused
 
     def isStopped(self):
-        return self.sim.isStopped()
+        return self.sim.is_stopped
 
     def isFinished(self):
-        return self.sim.isFinished()
+        return self.sim.is_finished
 
     def isRunning(self):
-        return self.sim.isRunning()
+        return self.sim.is_running
 
     def getScanner(self):
-        return self.sim.getScanner()
+        return self.sim.scanner
diff --git a/python/pyhelios/simulation_builder.py b/python/pyhelios/simulation_builder.py
index b4c456d14..a0d446279 100644
--- a/python/pyhelios/simulation_builder.py
+++ b/python/pyhelios/simulation_builder.py
@@ -2,6 +2,7 @@
 from .simulation_build import SimulationBuild
 from collections import namedtuple
 from collections.abc import Iterable
+from collections.abc import Iterable
 from math import isnan
 import os
 import time
@@ -67,6 +68,8 @@ class SimulationBuilder:
     # ---  CONSTRUCTOR  --- #
     # --------------------- #
     def __init__(self, surveyPath, assetsDir, outputDir):
+        if not isinstance(assetsDir, Iterable) or isinstance(assetsDir, str):
+            assetsDir = [assetsDir]
         if not isinstance(assetsDir, Iterable) or isinstance(assetsDir, str):
             assetsDir = [assetsDir]
         # Add default values for asset directories
@@ -126,12 +129,12 @@ def build(self):
             self.splitByChannel,
             fixedGpsTimeStart=self.fixedGpsTimeStart
         )
-        build.sim.callbackFrequency = self.callbackFrequency
-        build.sim.finalOutput = self.finalOutput
-        build.sim.legacyEnergyModel = self.legacyEnergyModel
-        build.sim.exportToFile = self.exportToFile
+        build.sim.callback_frequency = self.callbackFrequency
+        build.sim.final_output = self.finalOutput
+        build.sim.legacy_energy_model = self.legacyEnergyModel
+        build.sim.export_to_file = self.exportToFile
         for rotateFilter in self.rotateFilters:
-            build.sim.addRotateFilter(
+            build.sim.add_rotate_filter(
                 rotateFilter.q0,
                 rotateFilter.q1,
                 rotateFilter.q2,
@@ -139,18 +142,18 @@ def build(self):
                 rotateFilter.id
             )
         for scaleFilter in self.scaleFilters:
-            build.sim.addScaleFilter(
+            build.sim.add_scale_filter(
                 scaleFilter.factor,
                 scaleFilter.id
             )
         for translateFilter in self.translateFilters:
-            build.sim.addTranslateFilter(
+            build.sim.add_translate_filter(
                 translateFilter.x,
                 translateFilter.y,
                 translateFilter.z,
                 translateFilter.id
             )
-        build.sim.loadSurvey(
+        build.sim.load_survey(
             self.legNoiseDisabled,
             self.rebuildScene,
             self.writeWaveform,
@@ -159,7 +162,7 @@ def build(self):
             self.platformNoiseDisabled
         )
         if self.callback is not None:
-            build.sim.setCallback(self.callback)
+            build.sim.callback(self.callback)
 
         end = time.perf_counter()
         print(
diff --git a/python/pyhelios/survey.py b/python/pyhelios/survey.py
new file mode 100644
index 000000000..0ecc379fd
--- /dev/null
+++ b/python/pyhelios/survey.py
@@ -0,0 +1,307 @@
+from pyhelios.scene import Scene
+from pyhelios.utils import Validatable, ValidatedCppManagedProperty, AssetManager, PyHeliosException
+from pyhelios.scanner import Scanner, AbstractDetector, ScannerSettings, SingleScanner, MultiScanner
+from pyhelios.platforms import PlatformSettings, Platform
+from pyhelios.primitives import Rotation, FWFSettings, SimulationCycleCallback, Measurement, Trajectory
+import threading
+from pyhelios.leg import Leg
+
+import os 
+from threading import Thread
+from typing import Optional, List, Dict
+import xml.etree.ElementTree as ET
+import _helios
+
+from datetime import datetime, timezone
+import time
+
+class Survey(Validatable):
+    def __init__(self, name: Optional[str] = "", num_runs: Optional[int] = -1, 
+                 sim_speed_factor: Optional[float] = 1., scanner: Optional[Scanner] = None, 
+                 legs: Optional[List[Leg]] = None) -> None:
+        
+        self._cpp_object = _helios.Survey()
+        self.name = name
+        self.num_runs = num_runs
+        self.sim_speed_factor = sim_speed_factor
+        self.scanner = scanner
+        self.legs = legs or []
+
+        self.is_legacy_energy_model: Optional[bool] = False # this is used in c++ Simulation class
+        self.fixed_gps_time_start: Optional[str] = ""
+
+        self.is_started: Optional[bool] = False
+        self.is_paused: Optional[bool] = False
+        self.is_stopped: Optional[bool] = False 
+        self.is_finished: Optional[bool] = False 
+        self.output_path: Optional[str] = ""
+        self.las_scale: Optional[float] = 0.0001
+        self.las_output: Optional[bool] = False
+        self.las_10: Optional[bool] = False
+        self.zip_output: Optional[bool] = False
+        self.split_by_channel: Optional[bool] = False
+        self.playback: Optional[_helios.SurveyPlayback] = None
+        self.callback: Optional[_helios.SimulationCycleCallback] = None
+
+        self.kd_factory_type: Optional[int] = 4
+        self.kdt_num_jobs: Optional[int] = 0
+        self.kdt_geom_jobs: Optional[int] = 0
+        self.kdt_sah_loss_nodes: Optional[int] = 32
+        self.parallelization_strategy: Optional[int] = 1
+
+        self.export_to_file: Optional[bool] = False
+        self.write_waveform: Optional[bool] = False
+        self.calc_echowidth: Optional[bool] = False
+        self.fullwavenoise: Optional[bool] = False
+        self.is_platform_noise_disabled: Optional[bool] = False
+        self.final_output: Optional[bool] = False
+        self.scanner_settings_templates: Dict[str, ScannerSettings] = {}
+        self.platform_settings_templates: Dict[str, PlatformSettings] = {}
+        self.callback_frequency: Optional[int] = 0
+       
+    name: Optional[str] = ValidatedCppManagedProperty("name")
+    num_runs: Optional[int] = ValidatedCppManagedProperty("num_runs")
+    sim_speed_factor: Optional[float] = ValidatedCppManagedProperty("sim_speed_factor")
+    scanner: Optional[Scanner] = ValidatedCppManagedProperty("scanner")
+    legs: Optional[List[Leg]] = ValidatedCppManagedProperty("legs")
+     
+    @classmethod
+    def from_xml(cls, filename: str) -> 'Survey':
+        # Locate the XML file using the AssetManager
+        file_path = AssetManager().find_file_by_name(filename, auto_add=True)
+
+        # Parse the XML file
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+        
+        # Extract main survey attributes
+        survey_node = root.find('survey')
+        if survey_node is None:
+            raise ValueError("Invalid XML file, missing 'survey' tag")
+        name = survey_node.get('name', "")
+        # Optional scanner parsing if specified in XML
+        scanner_path, scanner_id = survey_node.get('scanner').split('#') if survey_node.get('scanner') else (None, None)
+        scanner = Scanner.from_xml(scanner_path, scanner_id) if scanner_path else None
+        
+        platform_path, platform_id = survey_node.get('platform').split('#') if survey_node.get('scanner') else (None, None)
+        scanner.platform = Platform.from_xml(platform_path, platform_id) if platform_path else None
+
+        if survey_node.find("FWFSettings") is not None:
+            scanner.apply_settings_FWF(FWFSettings.from_xml_node(survey_node.find("FWFSettings")))
+        
+        num_runs = int(survey_node.get('numRuns', 1))
+
+        speed = float(survey_node.get('simSpeedFactor', 1.0))
+
+        sim_speed_factor = 1 / speed if speed > 0 else 1.0
+
+        #TODO: add detector overloading -  XmlSurveyLoader::handleCoreOverloading
+        # TODO: add interpolated legs + platform
+
+        platform_settings_templates = {}
+        for template_node in root.findall('platformSettings'):
+            template_id = template_node.get('id')
+            
+            if template_id:
+                template = PlatformSettings.from_xml_node(template_node)
+                platform_settings_templates[template_id] = template
+
+        scanner_settings_templates = {}
+        for template_node in root.findall('scannerSettings'):
+            template_id = template_node.get('id')
+            
+            if template_id:
+                template = ScannerSettings.from_xml_node(template_node)
+                scanner_settings_templates[template_id] = template     
+
+        legs = []
+        for idx, leg_node in enumerate(survey_node.findall('leg')):
+          
+            leg = Leg.from_xml(leg_node, idx, platform_settings_templates=platform_settings_templates, scanner_settings_templates = scanner_settings_templates)
+            legs.append(leg)
+            # TODO:  waypoints for interpolated legs
+
+        if(scanner.beam_deflector is not None):
+            for leg in legs:
+                if not (leg.scanner_settings.vertical_resolution == 0 and leg.scanner_settings.horizontal_resolution == 0):
+                    leg.scanner_settings.scan_frequency = (leg.scanner_settings.pulse_frequency * leg.scanner_settings.vertical_resolution) / (2 * scanner.beam_deflector.scan_angle_max) 
+                    leg.scanner_settings.head_rotation =  leg.scanner_settings.horizontal_resolution * leg.scanner_settings.scan_frequency
+
+        for leg in legs:
+            scan_settings = leg.scanner_settings
+            beam_deflector = scanner.beam_deflector
+            if scan_settings.scan_frequency < beam_deflector.scan_freq_min:
+                raise ValueError(f"Leg {leg.serial_id} scan frequency is below the minimum frequency of the beam deflector.\n The requested scanning frequency cannot be achieved by this scanner. \n")
+            if scan_settings.scan_frequency > beam_deflector.scan_freq_max and beam_deflector.scan_freq_max != 0:
+                raise ValueError(f"Leg {leg.serial_id} scan frequency is above the maximum frequency of the beam deflector.\n The requested scanning frequency cannot be achieved by this scanner.\n")
+            #TODO: add cherry picking of the scan settings 
+        scene_path, scene_id = survey_node.get('scene').split('#') if survey_node.get('scene') else (None, None)
+
+        kd_factory_type = 4
+        kdt_num_jobs = os.cpu_count()
+        kdt_sah_loss_nodes = 32
+        scanner.platform.scene = Scene.read_from_xml(scene_path, scene_id, kd_factory_type=kd_factory_type, kdt_num_jobs=kdt_num_jobs, kdt_sah_loss_nodes=kdt_sah_loss_nodes)
+        #TODO: add spec lib if required
+        reflectance_map = scanner.platform.scene.read_extra_reflectances(float(scanner.wavelength))
+        scanner.platform.scene.specify_extra_reflectances(reflectance_map)
+        
+        for scene_part in scanner.platform.scene.scene_parts:
+            if scene_part.sorh is None:
+                continue
+            
+            num_primitives = len(scene_part.primitives)
+            baseline_primitives = scene_part.sorh.baseline.primitives
+            for i in range(num_primitives):
+                baseline_primitives.primitives[i].material = scene_part.primitives[i].material
+
+        #TODO: add shifting of interpolated objects and a random offset
+        pos1 = scanner.platform.scene._cpp_object.bbox_crs.vertices[0].position
+        pos2 = scanner.platform.scene._cpp_object.bbox_crs.vertices[1].position
+
+        # Check that the positions are valid tuples with the same length (x, y, z)
+        if len(pos1) != len(pos2):
+            raise ValueError("Positions of the vertices must have the same length (x, y, z).")
+
+        # Calculate the bounding box size (assuming 3D coordinates: x, y, z)
+        bbox_size = tuple(pos2[i] - pos1[i] for i in range(len(pos1)))
+
+        # Halve the bbox size (center the bounding box)
+        bbox_size = tuple(coord / 2 for coord in bbox_size)
+
+        # Calculate the center of the bounding box for shifting purposes
+        shift = tuple(pos1[i] + bbox_size[i] for i in range(len(pos1)))
+        
+        for leg in legs:
+            if leg.platform_settings is not None:
+                leg.platform_settings.position = (leg.platform_settings.position[0] - shift[0], leg.platform_settings.position[1] - shift[1], leg.platform_settings.position[2] - shift[2])
+        
+        scanner._cpp_object.initialize_sequential_generators()
+        scanner.platform.scene._cpp_object.build_kd_grove()
+
+        # Create the validated Survey instance
+        survey_instance = cls(
+            name=name,
+            scanner=scanner,
+            num_runs=num_runs,
+            sim_speed_factor=sim_speed_factor,
+            legs=legs
+        )
+
+        survey_instance.scanner.write_waveform = survey_instance.write_waveform
+        survey_instance.scanner.calc_echowidth = survey_instance.calc_echowidth
+        survey_instance.scanner.fullwavenoise = survey_instance.fullwavenoise
+        survey_instance.scanner.is_platform_noise_disabled = survey_instance.is_platform_noise_disabled 
+        survey_instance.scanner_settings_templates = scanner_settings_templates
+        survey_instance.platform_settings_templates = platform_settings_templates
+        # Validate the created instance using _validate method
+        survey_instance = cls._validate(survey_instance)
+        return survey_instance
+   
+    def run(self, num_threads: Optional[int] = 0, chunk_size: Optional[int] = 32, warehouse_factor: Optional[int] = 1,
+            callback_frequency: Optional[int] = 0, blocking: Optional[bool] = True, export_to_file: Optional[bool] = True):
+            
+            if num_threads == 0:
+                num_threads = os.cpu_count()
+            
+            fms = None
+            
+            if export_to_file: #TODO: finish with export to file
+                fms = _helios.FMSFacadeFactory().build_facade(self.output_path, self.las_scale, self.las_output, self.las_10, self.zip_output, self.split_by_channel, self._cpp_object)
+           
+            det = self.scanner.scanning_device.detector if isinstance(self.scanner, SingleScanner) else self.scanner.scanning_devices[0].detector
+
+            ptpf = _helios.PulseThreadPoolFactory(self.parallelization_strategy, num_threads-1, det.accuracy, chunk_size, warehouse_factor)  
+            pulse_thread_pool = ptpf.make_pulse_thread_pool()
+
+            current_time = datetime.now(timezone.utc).isoformat(timespec='seconds') 
+            self.playback = _helios.SurveyPlayback(self._cpp_object, _helios.FMSFacade(), self.parallelization_strategy, pulse_thread_pool, chunk_size, current_time, self.is_legacy_energy_model, export_to_file)
+            self.playback.callback = self.callback._cpp_object
+            self.playback.callback_frequency = callback_frequency
+            self.scanner._cpp_object.cycle_measurements_mutex  = None 
+
+            self.scanner._cpp_object.cycle_measurements = []
+            self.scanner._cpp_object.cycle_trajectories = []
+            self.scanner._cpp_object.all_measurements = []
+            self.scanner._cpp_object.all_trajectories = []
+            self.scanner._cpp_object.all_output_paths = []
+            self.scanner._cpp_object.set_time_wave(self.scanner.timewave, 0)
+
+            self.thread = threading.Thread(target=self.playback.start)
+            self.thread.start()
+            
+            self.is_started = True
+
+    def pause(self):
+        if not self.is_started:
+            raise PyHeliosException("PyHeliosSimulation was not started so it cannot be paused")
+        
+        if self.is_stopped:
+            raise PyHeliosException("PyHeliosSimulation was stopped so it cannot be paused")
+
+            
+        if self.is_finished:
+            raise PyHeliosException("PyHeliosSimulation was finished so it cannot be paused")
+
+        self.playback.pause(True)
+        self.is_paused = True
+    
+    def stop(self):
+        if not self.is_started:
+            raise PyHeliosException("PyHeliosSimulation was not started so it cannot be stopped")
+        
+        if self.is_stopped:
+            raise PyHeliosException("PyHeliosSimulation was already stopped")
+        
+        if self.is_finished:
+            raise PyHeliosException("PyHeliosSimulation was finished so it cannot be stopped")
+        
+        self.playback.stop()
+        self.is_stopped = True
+    
+    def resume(self):
+        if not self.is_started:
+            raise PyHeliosException("PyHeliosSimulation was not started so it cannot be resumed")
+        
+        if self.is_stopped:
+            raise PyHeliosException("PyHeliosSimulation was stopped so it cannot be resumed")
+        
+        if self.playback.is_finished:
+            raise PyHeliosException("PyHeliosSimulation was finished so it cannot be resumed")
+        if not self.is_paused:
+            raise PyHeliosException("PyHeliosSimulation was not paused so it cannot be resumed")
+        
+        self.playback.resume()
+        self.is_paused = False
+
+    def join_output(self):
+        if not self.is_started or self.is_paused:
+            raise PyHeliosException("PyHeliosSimulation is not running so it cannot be joined")
+        
+        outpath = ""
+        if self.export_to_file:
+            outpath = str(self.scanner.fms.write.getMeasurementWriterOutputPath())
+        if self.callback_frequency > 0 and self.callback is not None:
+            if not self.playback.is_finished:
+                # Return empty vectors if the simulation is not finished yet
+                return ([], [], outpath, [outpath], False)
+            else:
+                # Return collected data if the simulation is finished
+                self.is_finished = True
+                return (self.scanner._cpp_object.all_measurements, 
+                        self.scanner._cpp_object.all_trajectories, 
+                        outpath, 
+                        self.scanner._cpp_object.all_output_paths, 
+                        True)
+
+        if self.thread and self.thread.is_alive():
+            self.thread.join()
+        
+        self.finished = True
+        if not self.final_output:
+            return ([], [], outpath, [], False)
+        
+        return (self.scanner._cpp_object.all_measurements, 
+                self.scanner._cpp_object.all_trajectories, 
+                outpath, 
+                self.scanner._cpp_object.all_output_paths, 
+                True)
\ No newline at end of file
diff --git a/python/pyhelios/utils.py b/python/pyhelios/utils.py
new file mode 100644
index 000000000..3b27f94fb
--- /dev/null
+++ b/python/pyhelios/utils.py
@@ -0,0 +1,205 @@
+import os
+import importlib_resources as resources
+from pydantic import validate_call, GetCoreSchemaHandler 
+from pydantic_core import core_schema
+from typing import Optional, Type, Any, Callable
+import random
+import math
+import numpy as np
+
+class Validatable:
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source: Type[Any], handler: GetCoreSchemaHandler):
+        return core_schema.no_info_after_validator_function(cls._validate, core_schema.any_schema())
+
+    @classmethod
+    def _validate(cls, value):
+        if not isinstance(value, cls):
+            raise ValueError(f"Expected {cls.__name__}, got {type(value).__name__}")
+        return value
+    
+
+class ValidatedCppManagedProperty:
+    def __init__(self, name):
+        self.name = name
+        self._values = {}
+
+    def __get__(self, obj, objtype=None):
+        return self._values.get(obj, None)
+
+    def __set__(self, obj, value):
+        @validate_call
+        def _validated_setter(value: self._get_annotation(obj)):
+            if isinstance(value, list):
+                cpp_value = [getattr(item, "_cpp_object") if hasattr(item, "_cpp_object") else item for item in value]
+            else:
+                cpp_value = getattr(value, "_cpp_object") if hasattr(value, "_cpp_object") else value
+            setattr(obj._cpp_object, self.name, cpp_value)
+            self._values[obj] = value
+
+        _validated_setter(value)  
+    def _get_annotation(self, obj):
+        for cls in obj.__class__.__mro__:
+            if self.name in getattr(cls, '__annotations__', {}):
+                return cls.__annotations__[self.name]
+        raise AttributeError(f"'{obj.__class__.__name__}' object has no annotation for '{self.name}'")
+
+class AssetManager:
+    _instance = None
+    _assets = set()  
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(AssetManager, cls).__new__(cls)
+            cls._initialize_default_assets()
+        return cls._instance
+
+    @classmethod
+    def _initialize_default_assets(cls):
+        # Attempt to initialize default paths and verify they are valid
+        current_dir = os.getcwd()
+        pyhelios_dir = str(resources.files("pyhelios"))
+        pyhelios_data_dir = str(resources.files("pyhelios") / "data")
+
+        cls._assets.add(current_dir)
+        if os.path.exists(pyhelios_dir):
+            cls._assets.add(pyhelios_dir)
+        else:
+            print(f"Pyhelios directory does not exist: {pyhelios_dir}")
+
+        if os.path.exists(pyhelios_data_dir):
+            cls._assets.add(pyhelios_data_dir)
+        else:
+            print(f"Pyhelios data directory does not exist: {pyhelios_data_dir}")
+
+    @classmethod
+    def add_asset(cls, path: str):
+        cls._assets.add(path)
+
+    @classmethod
+    def locate_asset(cls, filename: str) -> Optional[str]:
+        # Look for the file in all registered assets
+        for path in cls._assets:
+            potential_path = os.path.join(path, filename)
+            if os.path.exists(potential_path):
+                return potential_path
+        return None
+
+    @classmethod
+    def find_file_by_name(cls, filename: str, auto_add: bool = False) -> str:
+        if os.path.isabs(filename):
+            if os.path.exists(filename):
+                if auto_add:
+                    cls.add_asset(os.path.dirname(filename))
+                return filename
+            else:
+                raise FileNotFoundError(f"File not found: {filename}")
+        
+        located_path = cls.locate_asset(filename)
+        if located_path:
+            return located_path
+        
+        raise FileNotFoundError(f"File not found in registered assets: {filename} \n existed assets: {cls._assets}")
+
+
+
+def calc_propagation_time_legacy(time_wave, num_bins, bin_size, pulse_length, pulse_length_divisor):
+    # Prepare variables
+
+    tau = pulse_length / pulse_length_divisor
+    peak_value = 0
+    peak_index = 0
+
+    # Do forward iterative process to compute nodes and pick max
+    for i in range(num_bins):
+        t = i * bin_size
+        t_tau = t / tau
+        pt = (t_tau ** 2) * math.exp(-t_tau)
+        time_wave[i] = pt
+        
+        if pt > peak_value:
+            peak_value = pt
+            peak_index = i
+
+    return peak_index
+
+class RandomnessGenerator:
+    """Randomness generator that mimics the behavior of the C++ version."""
+
+    def __init__(self, mode="AUTO_SEED", seed=None):
+        self.mode = mode
+        self.urd_gen = None  # The random generator
+        self.urd = None      # The uniform distribution
+
+        if self.mode == "AUTO_SEED":
+            self.seed = random.SystemRandom().randint(0, 2**32 - 1)  # Auto seed
+        elif self.mode == "FIXED_SEED_DOUBLE" or self.mode == "FIXED_SEED_LONG":
+            if seed is None:
+                raise ValueError("Fixed seed mode requires a seed")
+            self.seed = seed
+        else:
+            raise ValueError(f"Unknown mode: {self.mode}")
+
+        random.seed(self.seed)
+
+    def compute_uniform_real_distribution(self, lower_bound=0.0, upper_bound=1.0):
+        """Compute the uniform real distribution with given bounds."""
+        # For Python's random, no need to store the distribution explicitly
+        self.urd_gen = random.uniform  # Directly use random.uniform
+
+    def uniform_real_distribution_next(self):
+        """Return the next value in the uniform distribution."""
+        if self.urd_gen is None:
+            self.compute_uniform_real_distribution(0.0, 1.0)  
+        
+        return self.urd_gen(0.0, 1.0) 
+    
+
+class PyHeliosException(Exception):
+    """PyHelios exception class"""
+
+    def __init__(self, msg):
+        """PyHeliosException constructor: Build a new exception.
+
+        Arguments:
+            msg -- message for the exception
+        """
+        super().__init__(msg)
+
+
+def create_property(property_name, cpp_function_setter, cpp_function_getter=None, index_function=None):
+    """
+    Factory function to create a property getter and setter for python instance and _cpp_object.
+    
+    Args:
+        property_name (str): The name of the property.
+        cpp_function_setter (str): The C++ method to call to set the property on _cpp_object.
+        cpp_function_getter (str, optional): The C++ method to call to get the property from _cpp_object.
+        index_function (function, optional): Function to get the index of the active scanning device (if multi-device).
+    
+    Returns:
+        property: A property object with getter and setter methods.
+    """
+    
+    def getter(self):
+        if index_function:
+            # If index_function is provided, use it to get the active device's property
+            active_device = self.scanning_devices[index_function(self)]
+            return getattr(active_device, property_name)
+        return getattr(self.scanning_device, property_name)
+    
+    def setter(self, value):
+        if index_function:
+            # If index_function is provided, set the value for the active device
+            active_device = self.scanning_devices[index_function(self)]
+            setattr(active_device, property_name, value)
+            if cpp_function_setter:
+                cpp_value = value._cpp_object if hasattr(value, '_cpp_object') else value
+                getattr(self._cpp_object, cpp_function_setter)(cpp_value, index_function(self))
+        else:
+            setattr(self.scanning_device, property_name, value)
+            if cpp_function_setter:
+                cpp_value = value._cpp_object if hasattr(value, '_cpp_object') else value
+                getattr(self._cpp_object, cpp_function_setter)(cpp_value, 0)
+
+    return property(getter, setter)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
old mode 100644
new mode 100755
index 4f3e92d74..cd670ebf5
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,7 +9,7 @@ add_subdirectory(main)
 add_subdirectory(maths)
 add_subdirectory(noise)
 add_subdirectory(platform)
-add_subdirectory(pybinds)
+add_subdirectory(python)
 add_subdirectory(scanner)
 add_subdirectory(scene)
 add_subdirectory(sim)
@@ -18,4 +18,4 @@ add_subdirectory(test)
 add_subdirectory(util)
 add_subdirectory(visualhelios)
 
-target_include_directories(helios PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
\ No newline at end of file
+target_include_directories(helios PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/src/assetloading/XmlAssetsLoader.cpp b/src/assetloading/XmlAssetsLoader.cpp
index 9ac5bc363..08a747ac5 100644
--- a/src/assetloading/XmlAssetsLoader.cpp
+++ b/src/assetloading/XmlAssetsLoader.cpp
@@ -931,7 +931,8 @@ XmlAssetsLoader::createScannerFromXml(tinyxml2::XMLElement *scannerNode) {
       scanner = std::make_shared<SingleScanner>(
           beamDiv_rad, emitterPosition, emitterAttitude, pulseFreqs,
           pulseLength_ns, id, avgPower, beamQuality, efficiency,
-          receiverDiameter, visibility, wavelength, rangeErrExpr
+          receiverDiameter, visibility, wavelength, false, 
+          false, false, false, false, rangeErrExpr
       );
       // Parse max number of returns per pulse
       scanner->setMaxNOR(boost::get<int>(XmlUtils::getAttribute(
diff --git a/src/pybinds/CMakeLists.txt b/src/pybinds/CMakeLists.txt
deleted file mode 100644
index 41c6d9559..000000000
--- a/src/pybinds/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-if(BUILD_PYTHON)
-  target_include_directories(
-    _pyhelios
-    PUBLIC
-    "."
-  )
-
-  target_sources(
-    _pyhelios
-    PRIVATE
-    "PySceneWrapper.cpp"
-    "PyHeliosSimulation.cpp"
-    "PyHelios.cpp"
-    "PyScenePartWrapper.cpp"
-    "PyScannerWrapper.cpp"
-  )
-endif()
diff --git a/src/pybinds/PyAABBWrapper.h b/src/pybinds/PyAABBWrapper.h
deleted file mode 100644
index dac379d5e..000000000
--- a/src/pybinds/PyAABBWrapper.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include <PyVertexWrapper.h>
-#include <AABB.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for AABB class
- *
- * @see AABB
- */
-class PyAABBWrapper{
-public:
-    // ***  ATTRIBUTE  *** //
-    // ******************* //
-    AABB *aabb;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyAABBWrapper(AABB *aabb) : aabb(aabb) {}
-    virtual ~PyAABBWrapper() = default;
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    inline PyVertexWrapper * getMinVertex()
-        {return new PyVertexWrapper(aabb->vertices);}
-    inline PyVertexWrapper * getMaxVertex()
-        {return new PyVertexWrapper(aabb->vertices + 1);}
-
-    // ***  TO STRING  *** //
-    // ******************* //
-    inline std::string toString(){return aabb->toString();}
-};
-
-}
\ No newline at end of file
diff --git a/src/pybinds/PyBeamDeflectorWrapper.h b/src/pybinds/PyBeamDeflectorWrapper.h
deleted file mode 100644
index 832cd0be9..000000000
--- a/src/pybinds/PyBeamDeflectorWrapper.h
+++ /dev/null
@@ -1,83 +0,0 @@
-#pragma once
-
-#include <AbstractBeamDeflector.h>
-#include <scanner/beamDeflector/ConicBeamDeflector.h>
-#include <scanner/beamDeflector/FiberArrayBeamDeflector.h>
-#include <scanner/beamDeflector/OscillatingMirrorBeamDeflector.h>
-#include <scanner/beamDeflector/PolygonMirrorBeamDeflector.h>
-#include <scanner/beamDeflector/RisleyBeamDeflector.h>
-
-#include <memory>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for AbstractBeamDeflector class
- *
- * @see AbstractBeamDeflector
- */
-class PyBeamDeflectorWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    AbstractBeamDeflector &beamDeflector;
-
-    // ***  CONSTRUCTION  *** //
-    // ********************** //
-    PyBeamDeflectorWrapper(
-        std::shared_ptr<AbstractBeamDeflector> beamDeflector
-    ) : beamDeflector(*beamDeflector) {}
-    virtual ~PyBeamDeflectorWrapper(){}
-
-	// ***  GETTERS and SETTERS  *** //
-	// ***************************** //
-	inline double getScanFreqMax()
-	    {return beamDeflector.cfg_device_scanFreqMax_Hz;}
-	inline void setScanFreqMax(double scanFreqMax_Hz)
-        {beamDeflector.cfg_device_scanFreqMax_Hz = scanFreqMax_Hz;}
-	inline double getScanFreqMin()
-        {return beamDeflector.cfg_device_scanFreqMin_Hz;}
-    inline void setScanFreqMin(double scanFreqMin_Hz)
-        {beamDeflector.cfg_device_scanFreqMin_Hz = scanFreqMin_Hz;}
-    inline double getScanAngleMax()
-        {return beamDeflector.cfg_device_scanAngleMax_rad;}
-    inline void setScanAngleMax(double scanAngleMax)
-        {beamDeflector.cfg_device_scanAngleMax_rad = scanAngleMax;}
-    inline double getScanFreq()
-        {return beamDeflector.cfg_device_scanFreqMin_Hz;}
-    inline void setScanFreq(double scanFreq)
-        {beamDeflector.cfg_device_scanFreqMin_Hz = scanFreq;}
-    inline double getScanAngle()
-        {return beamDeflector.cfg_setting_scanAngle_rad;}
-    inline void setScanAngle(double scanAngle)
-        {beamDeflector.cfg_setting_scanAngle_rad = scanAngle;}
-    inline double getVerticalAngleMin()
-        {return beamDeflector.cfg_setting_verticalAngleMin_rad;}
-    inline void setVerticalAngleMin(double verticalAngleMin)
-        {beamDeflector.cfg_setting_verticalAngleMin_rad = verticalAngleMin;}
-    inline double getVerticalAngleMax()
-        {return beamDeflector.cfg_setting_verticalAngleMax_rad;}
-    inline void setVerticalAngleMax(double verticalAngleMax)
-        {beamDeflector.cfg_setting_verticalAngleMax_rad = verticalAngleMax;}
-    inline double getCurrentBeamAngle()
-        {return beamDeflector.state_currentBeamAngle_rad;}
-    inline void setCurrentBeamAngle(double currentBeamAngle)
-        {beamDeflector.state_currentBeamAngle_rad = currentBeamAngle;}
-    inline double getAngleDiff()
-        {return beamDeflector.state_angleDiff_rad;}
-    inline void setAngleDiff(double angleDiff)
-        {beamDeflector.state_angleDiff_rad = angleDiff;}
-    inline double getCachedAngleBetweenPulses()
-        {return beamDeflector.cached_angleBetweenPulses_rad;}
-    inline void setCachedAngleBetweenPulses(double angleBetweenPulses)
-        {beamDeflector.cached_angleBetweenPulses_rad = angleBetweenPulses;}
-    inline Rotation& getEmitterRelativeAttitude()
-        {return beamDeflector.getEmitterRelativeAttitudeByReference();}
-    inline std::string getOpticsType() const {
-    return beamDeflector.getOpticsType();}
-
-};
-
-}
diff --git a/src/pybinds/PyDetailedVoxelWrapper.h b/src/pybinds/PyDetailedVoxelWrapper.h
deleted file mode 100644
index 3ae8132a0..000000000
--- a/src/pybinds/PyDetailedVoxelWrapper.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <PyPrimitiveWrapper.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for DetailedVoxel class
- *
- * @see DetailedVoxel
- */
-class PyDetailedVoxelWrapper : public PyPrimitiveWrapper{
-public:
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyDetailedVoxelWrapper(DetailedVoxel *dv) : PyPrimitiveWrapper(dv) {}
-    ~PyDetailedVoxelWrapper() override = default;
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    int getNbEchos() {return ((DetailedVoxel *)prim)->getNbEchos(); }
-    void setNbEchos(int nbEchos)
-    {((DetailedVoxel *)prim)->setNbEchos(nbEchos); }
-    int getNbSampling() {return ((DetailedVoxel *)prim)->getNbSampling(); }
-    void setNbSampling(int nbSampling)
-    {((DetailedVoxel *)prim)->setNbSampling(nbSampling); }
-    size_t getNumberOfDoubleValues()
-    {return ((DetailedVoxel *)prim)->getNumberOfDoubleValues();}
-    double getDoubleValue(size_t index)
-    {return ((DetailedVoxel *)prim)->getDoubleValue(index);}
-    void setDoubleValue(size_t index, double value)
-    {((DetailedVoxel *)prim)->setDoubleValue(index, value);}
-    double getMaxPad() {return ((DetailedVoxel *)prim)->getMaxPad();}
-    void setMaxPad(double maxPad) {((DetailedVoxel *)prim)->setMaxPad(maxPad);}
-};
-
-}
diff --git a/src/pybinds/PyDetectorWrapper.h b/src/pybinds/PyDetectorWrapper.h
deleted file mode 100644
index 2436de4e9..000000000
--- a/src/pybinds/PyDetectorWrapper.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-#include <PyDetectorWrapper.h>
-#include <filems/facade/FMSFacade.h>
-using helios::filems::FMSFacade;
-#include <AbstractDetector.h>
-
-#include <memory>
-
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for AbstractDetector class
- *
- * @see AbstractDetector
- */
-class PyDetectorWrapper {
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    AbstractDetector &detector;
-
-    // ***  CONSTRUCTION  *** //
-    // ********************** //
-    PyDetectorWrapper(
-        std::shared_ptr<AbstractDetector> detector
-    ) :
-        detector(*detector) {}
-
-    virtual ~PyDetectorWrapper() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    inline double getAccuracy()
-        {return detector.cfg_device_accuracy_m;}
-    inline void setAccuracy(double const accuracy)
-        {detector.cfg_device_accuracy_m = accuracy;}
-    inline double getRangeMin()
-        {return detector.cfg_device_rangeMin_m;}
-    inline void setRangeMin(double const rangeMin)
-        {detector.cfg_device_rangeMin_m = rangeMin;}
-    inline double getRangeMax()
-        {return detector.cfg_device_rangeMax_m;}
-    inline void setRangeMax(double const rangeMax)
-        {detector.cfg_device_rangeMax_m = rangeMax;}
-    inline double getLasScale()
-        {return detector.getFMS()->write.getMeasurementWriterLasScale();}
-    inline void setLasScale(double const lasScale)
-        {detector.getFMS()->write.setMeasurementWriterLasScale(lasScale);}
-};
-
-}
diff --git a/src/pybinds/PyDoubleVector.h b/src/pybinds/PyDoubleVector.h
deleted file mode 100644
index 55a0957e5..000000000
--- a/src/pybinds/PyDoubleVector.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include <PyHeliosUtils.h>
-#include <vector>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for std::vector<double> class
- *
- * @see std::vector
- */
-class PyDoubleVector{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    std::vector<double> *vec = nullptr;
-    bool release = true;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyDoubleVector(std::vector<double> *vec) : vec(vec), release(false) {}
-    PyDoubleVector(std::vector<double> const vec){
-        this->vec = new std::vector<double>(vec);
-        release = true;
-    }
-    virtual ~PyDoubleVector(){if(release && vec != nullptr) free(vec);}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    double get(long _index){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, vec->size());
-        return (*vec)[index];
-    }
-    void set(long _index, double value){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, vec->size());
-        (*vec)[index] = value;
-    }
-    void insert(double value){vec->push_back(value);}
-    void erase(long _index){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, vec->size());
-        vec->erase(vec->begin() + index);
-    }
-    size_t length() {return vec->size();}
-};
-
-}
diff --git a/src/pybinds/PyHelios.cpp b/src/pybinds/PyHelios.cpp
deleted file mode 100644
index 5d1ecebfb..000000000
--- a/src/pybinds/PyHelios.cpp
+++ /dev/null
@@ -1,2165 +0,0 @@
-#include <boost/python.hpp>
-#include <PyHeliosSimulation.h>
-#include <PythonDVec3.h>
-#include <PyBeamDeflectorWrapper.h>
-#include <PyDetectorWrapper.h>
-#include <PyIntegerList.h>
-#include <PyDoubleVector.h>
-#include <PyPlatformWrapper.h>
-#include <PyScannerWrapper.h>
-#include <PyPrimitiveWrapper.h>
-#include <PySimulationCycleCallback.h>
-#include <PyScanningStripWrapper.h>
-#include <Material.h>
-#include <gdal_priv.h>
-#include <logging.hpp>
-
-// LOGGING FLAGS (DO NOT MODIFY HERE BUT IN logging.hpp makeDefault())
-bool    logging::LOGGING_SHOW_TRACE,    logging::LOGGING_SHOW_DEBUG,
-        logging::LOGGING_SHOW_INFO,     logging::LOGGING_SHOW_TIME,
-        logging::LOGGING_SHOW_WARN,     logging::LOGGING_SHOW_ERR;
-
-// ***  PYHELIOS PYTHON MODULE  *** //
-// ******************************** //
-BOOST_PYTHON_MODULE(_pyhelios){
-    // Namespace must be used locally to prevent conflicts
-    using namespace boost::python;
-    using namespace pyhelios;
-
-
-    // Configure logging system
-    logging::makeQuiet();
-    logging::configure({
-        {"type", "std_out"}
-    });
-
-    // Enable GDAL (Load its drivers)
-    GDALAllRegister();
-
-    // Definitions
-    def(
-        "loggingQuiet",
-        logging::makeQuiet,
-        "Set the logging verbosity level to quiet"
-    );
-    def(
-        "loggingSilent",
-        logging::makeSilent,
-        "Set the logging verbosity level to silent"
-    );
-    def(
-        "loggingDefault",
-        logging::makeDefault,
-        "Set the logging verbosity level to default"
-    );
-    def(
-        "loggingVerbose",
-        logging::makeVerbose,
-        "Set the logging verbosity level to verbose"
-    );
-    def(
-        "loggingVerbose2",
-        logging::makeVerbose2,
-        "Set the logging verbosity level to verbose 2"
-    );
-    def(
-        "loggingTime",
-        logging::makeTime,
-        "Set the logging verbosity level to time"
-    );
-
-    // Register PyHeliosSimulation
-    def(
-        "setDefaultRandomnessGeneratorSeed",
-        setDefaultRandomnessGeneratorSeed,
-        "Set the seed for the default randomness generator"
-    );
-    class_<PyHeliosSimulation>("Simulation", init<>())
-        .def(init<
-            std::string,
-            list,
-            std::string,
-            size_t,
-            bool,
-            bool,
-            bool,
-            bool
-        >())
-        .def(init<
-            std::string,
-            list,
-            std::string,
-            size_t,
-            bool,
-            bool,
-            bool,
-            bool,
-            int,
-            size_t,
-            size_t,
-            int,
-            int,
-            int
-        >())
-        .def(
-            "loadSurvey",
-            &PyHeliosSimulation::loadSurvey
-        )
-        .def(
-            "copy",
-            &PyHeliosSimulation::copy,
-            return_value_policy<manage_new_object>()
-        )
-        .def("isStarted", &PyHeliosSimulation::isStarted)
-        .def("isPaused", &PyHeliosSimulation::isPaused)
-        .def("isStopped", &PyHeliosSimulation::isStopped)
-        .def("isFinished", &PyHeliosSimulation::isFinished)
-        .def("isRunning", &PyHeliosSimulation::isRunning)
-        .def("getSurveyPath", &PyHeliosSimulation::getSurveyPath)
-        .def("getAssetsPath", &PyHeliosSimulation::getAssetsPath)
-        .def(
-            "getSurvey",
-            &PyHeliosSimulation::getSurvey,
-            return_internal_reference<>()
-        )
-        .def(
-            "getScanner",
-            &PyHeliosSimulation::getScanner,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getPlatform",
-            &PyHeliosSimulation::getPlatform,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getScene",
-            &PyHeliosSimulation::getScene,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getNumLegs",
-            &PyHeliosSimulation::getNumLegs
-        )
-        .def(
-            "getLeg",
-            &PyHeliosSimulation::getLeg,
-            return_internal_reference<>()
-        )
-        .def(
-            "removeLeg",
-            &PyHeliosSimulation::removeLeg
-        )
-        .def(
-            "newLeg",
-            &PyHeliosSimulation::newLeg,
-            return_internal_reference<>()
-        )
-        .def(
-            "newScanningStrip",
-            &PyHeliosSimulation::newScanningStrip,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "assocLegWithScanningStrip",
-            &PyHeliosSimulation::assocLegWithScanningStrip
-        )
-        .add_property(
-            "simulationFrequency",
-            &PyHeliosSimulation::getSimFrequency,
-            &PyHeliosSimulation::setSimFrequency
-        )
-        .add_property(
-            "dynSceneStep",
-            &PyHeliosSimulation::getDynSceneStep,
-            &PyHeliosSimulation::setDynSceneStep
-        )
-        .add_property(
-            "callbackFrequency",
-            &PyHeliosSimulation::getCallbackFrequency,
-            &PyHeliosSimulation::setCallbackFrequency
-        )
-        .add_property(
-            "finalOutput",
-            &PyHeliosSimulation::finalOutput,
-            &PyHeliosSimulation::finalOutput
-        )
-        .add_property(
-            "legacyEnergyModel",
-            &PyHeliosSimulation::legacyEnergyModel,
-            &PyHeliosSimulation::legacyEnergyModel
-        )
-        .add_property(
-            "exportToFile",
-            &PyHeliosSimulation::exportToFile,
-            &PyHeliosSimulation::exportToFile
-        )
-        .def("start", &PyHeliosSimulation::start)
-        .def("pause", &PyHeliosSimulation::pause)
-        .def("stop", &PyHeliosSimulation::stop)
-        .def("resume", &PyHeliosSimulation::resume)
-        .def(
-            "join",
-            &PyHeliosSimulation::join,
-            return_value_policy<manage_new_object>()
-        )
-        .def("setCallback", &PyHeliosSimulation::setCallback)
-        .def("clearCallback", &PyHeliosSimulation::clearCallback)
-        .add_property(
-            "fixedGpsTimeStart",
-            &PyHeliosSimulation::getFixedGpsTimeStart,
-            &PyHeliosSimulation::setFixedGpsTimeStart
-        )
-        .add_property(
-            "lasOutput",
-            &PyHeliosSimulation::getLasOutput,
-            &PyHeliosSimulation::setLasOutput
-        )
-        .add_property(
-            "las10",
-            &PyHeliosSimulation::getLas10,
-            &PyHeliosSimulation::setLas10
-        )
-        .add_property(
-            "zipOutput",
-            &PyHeliosSimulation::getZipOutput,
-            &PyHeliosSimulation::setZipOutput
-        )
-        .add_property(
-            "splitByChannel",
-            &PyHeliosSimulation::getSplitByChannel,
-            &PyHeliosSimulation::setSplitByChannel
-        )
-        .add_property(
-            "lasScale",
-            &PyHeliosSimulation::getLasScale,
-            &PyHeliosSimulation::setLasScale
-        )
-        .add_property(
-            "numThreads",
-            &PyHeliosSimulation::getNumThreads,
-            &PyHeliosSimulation::setNumThreads
-        )
-        .add_property(
-            "kdtFactory",
-            &PyHeliosSimulation::getKDTFactory,
-            &PyHeliosSimulation::setKDTFactory
-        )
-        .add_property(
-            "kdtJobs",
-            &PyHeliosSimulation::getKDTJobs,
-            &PyHeliosSimulation::setKDTJobs
-        )
-        .add_property(
-            "kdtSAHLossNodes",
-            &PyHeliosSimulation::getKDTSAHLossNodes,
-            &PyHeliosSimulation::setKDTSAHLossNodes
-        )
-        .add_property(
-            "parallelizationStrategy",
-            &PyHeliosSimulation::getParallelizationStrategy,
-            &PyHeliosSimulation::setParallelizationStrategy
-        )
-        .add_property(
-            "chunkSize",
-            &PyHeliosSimulation::getChunkSize,
-            &PyHeliosSimulation::setChunkSize
-        )
-        .add_property(
-            "warehouseFactor",
-            &PyHeliosSimulation::getWarehouseFactor,
-            &PyHeliosSimulation::setWarehouseFactor
-        )
-        .def(
-            "addRotateFilter",
-            &PyHeliosSimulation::addRotateFilter
-        )
-        .def(
-            "addScaleFilter",
-            &PyHeliosSimulation::addScaleFilter
-        )
-        .def(
-            "addTranslateFilter",
-            &PyHeliosSimulation::addTranslateFilter
-        )
-        ;
-
-    // Register Survey
-    class_<Survey, boost::noncopyable>("Survey", no_init)
-        .def("calculateLength", &Survey::calculateLength)
-        .def("getLength", &Survey::getLength)
-        .add_property("name", &Survey::name, &Survey::name)
-        .add_property("numRuns", &Survey::numRuns, &Survey::numRuns)
-        .add_property(
-            "simSpeedFactor",
-            &Survey::simSpeedFactor,
-            &Survey::simSpeedFactor
-        )
-    ;
-
-    // Register ScannerSettings
-    class_<ScannerSettings>("ScannerSettings", no_init)
-        .add_property(
-            "active",
-            &ScannerSettings::active,
-            &ScannerSettings::active
-        )
-        .add_property(
-            "headRotatePerSec",
-            &ScannerSettings::headRotatePerSec_rad,
-            &ScannerSettings::headRotatePerSec_rad
-        )
-        .add_property(
-            "headRotateStart",
-            &ScannerSettings::headRotateStart_rad,
-            &ScannerSettings::headRotateStart_rad
-        )
-        .add_property(
-            "headRotateStop",
-            &ScannerSettings::headRotateStop_rad,
-            &ScannerSettings::headRotateStop_rad
-        )
-        .add_property(
-            "pulseFreq",
-            &ScannerSettings::pulseFreq_Hz,
-            &ScannerSettings::pulseFreq_Hz
-        )
-        .add_property(
-            "scanAngle",
-            &ScannerSettings::scanAngle_rad,
-            &ScannerSettings::scanAngle_rad
-        )
-        .add_property(
-            "verticalAngleMin",
-            &ScannerSettings::verticalAngleMin_rad,
-            &ScannerSettings::verticalAngleMin_rad
-        )
-        .add_property(
-            "verticalAngleMax",
-            &ScannerSettings::verticalAngleMax_rad,
-            &ScannerSettings::verticalAngleMax_rad
-        )
-        .add_property(
-            "scanFreq",
-            &ScannerSettings::scanFreq_Hz,
-            &ScannerSettings::scanFreq_Hz
-        )
-        .add_property(
-            "beamDivAngle",
-            &ScannerSettings::beamDivAngle,
-            &ScannerSettings::beamDivAngle
-        )
-        .add_property(
-            "trajectoryTimeInterval",
-            &ScannerSettings::trajectoryTimeInterval,
-            &ScannerSettings::trajectoryTimeInterval
-        )
-        .add_property(
-            "id",
-            &ScannerSettings::id,
-            &ScannerSettings::id
-        )
-        .def(
-            "hasTemplate",
-            &ScannerSettings::hasTemplate
-        )
-        .def(
-            "getTemplate",
-            &ScannerSettings::getTemplate,
-            return_internal_reference<>()
-        )
-        .def(
-            "toString",
-            &ScannerSettings::toString
-        )
-    ;
-
-    // Register PlatformSettings
-    class_<PlatformSettings>("PlatformSettings", no_init)
-        .add_property("id", &PlatformSettings::id, &PlatformSettings::id)
-        .add_property("x", &PlatformSettings::x, &PlatformSettings::x)
-        .add_property("y", &PlatformSettings::y, &PlatformSettings::y)
-        .add_property("z", &PlatformSettings::z, &PlatformSettings::z)
-        .add_property(
-            "onGround",
-            &PlatformSettings::onGround,
-            &PlatformSettings::onGround
-        )
-        .add_property(
-            "stopAndTurn",
-            &PlatformSettings::stopAndTurn,
-            &PlatformSettings::stopAndTurn
-        )
-        .add_property(
-            "movePerSec",
-            &PlatformSettings::movePerSec_m,
-            &PlatformSettings::movePerSec_m
-        )
-        .add_property(
-            "slowdownEnabled",
-            &PlatformSettings::slowdownEnabled,
-            &PlatformSettings::slowdownEnabled
-        )
-        .add_property(
-            "yawAtDepartureSpecified",
-            &PlatformSettings::yawAtDepartureSpecified,
-            &PlatformSettings::yawAtDeparture
-        )
-        .add_property(
-            "yawAtDeparture",
-            &PlatformSettings::yawAtDeparture,
-            &PlatformSettings::yawAtDeparture
-        )
-        .add_property(
-            "smoothTurn",
-            &PlatformSettings::smoothTurn,
-            &PlatformSettings::smoothTurn
-        )
-        .def(
-            "hasTemplate",
-            &PlatformSettings::hasTemplate
-        )
-        .def(
-            "getTemplate",
-            &PlatformSettings::getTemplate,
-            return_internal_reference<>()
-        )
-        .def(
-            "toString",
-            &PlatformSettings::toString
-        )
-    ;
-
-    // Register Leg
-    class_<Leg, boost::noncopyable>("Leg", no_init)
-        .add_property("length", &Leg::getLength, &Leg::setLength)
-        .add_property("serialId", &Leg::getSerialId, &Leg::setSerialId)
-        .add_property(
-            "strip",
-            make_function(
-                +[](const Leg &leg) {
-                    return new PyScanningStripWrapper(leg.getStrip());
-                },
-                return_value_policy<manage_new_object>()
-            ),
-            +[](Leg& leg, PyScanningStripWrapper *pssw) {
-                leg.setStrip(pssw->ss);
-            }
-        )
-        .def(
-            "getScannerSettings",
-            &Leg::getScannerSettings,
-            return_internal_reference<>()
-        )
-        .def(
-            "getPlatformSettings",
-            &Leg::getPlatformSettings,
-            return_internal_reference<>()
-        )
-        .def("isContainedInAStrip", &Leg::isContainedInAStrip)
-    ;
-
-    // Register ScanningStrip
-    class_<PyScanningStripWrapper>("ScanningStrip", no_init)
-        .add_property(
-            "stripId",
-            &PyScanningStripWrapper::getStripId,
-            &PyScanningStripWrapper::setStripId
-        )
-        .def(
-            "getLeg",
-            &PyScanningStripWrapper::getLegRef,
-            return_internal_reference<>()
-        )
-        .def(
-            "isLastLegInStrip",
-            &PyScanningStripWrapper::isLastLegInStrip
-        )
-        .def<bool (PyScanningStripWrapper::*)(int const)>(
-            "has", &PyScanningStripWrapper::has
-        )
-        .def<bool (PyScanningStripWrapper::*)(Leg &)>(
-            "has", &PyScanningStripWrapper::has
-        )
-    ;
-
-
-    // Register Scanner
-    class_<PyScannerWrapper, boost::noncopyable>("Scanner", no_init)
-        .add_property(
-            "fwfSettings",
-            &PyScannerWrapper::getFWFSettings,
-            &PyScannerWrapper::setFWFSettings
-        )
-        .add_property(
-            "numTimeBins",
-            &PyScannerWrapper::getNumTimeBins,
-            &PyScannerWrapper::setNumTimeBins
-        )
-        .add_property(
-            "peakIntensityIndex",
-            &PyScannerWrapper::getPeakIntensityIndex,
-            &PyScannerWrapper::setPeakIntensityIndex
-        )
-        .def(
-            "getTimeWave",
-            &PyScannerWrapper::getTimeWave,
-            return_value_policy<manage_new_object>()
-        )
-        .add_property(
-            "pulseFreq_Hz",
-            &PyScannerWrapper::getPulseFreq_Hz,
-            &PyScannerWrapper::setPulseFreq_Hz
-        )
-        .add_property(
-            "lastPulseWasHit",
-            &PyScannerWrapper::lastPulseWasHit,
-            static_cast<void(PyScannerWrapper::*)(bool const)>(
-                &PyScannerWrapper::setLastPulseWasHit
-            )
-        )
-        .def("toString", &PyScannerWrapper::toString)
-        .def(
-            "getCurrentPulseNumber",
-            static_cast<int(PyScannerWrapper::*)(size_t const) const>(
-                &PyScannerWrapper::getCurrentPulseNumber
-            )
-        )
-        .add_property(
-            "numRays",
-            static_cast<int(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getNumRays
-            ),
-            static_cast<void(PyScannerWrapper::*)(int const)>(
-                &PyScannerWrapper::setNumRays
-            )
-        )
-        .def(
-            "getNumRays",
-            static_cast<int(PyScannerWrapper::*)(size_t const) const>(
-                &PyScannerWrapper::getNumRays
-            )
-        )
-        .def(
-            "setNumRays",
-            static_cast<void(PyScannerWrapper::*)(int const, size_t const)>(
-                &PyScannerWrapper::setNumRays
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "pulseLength_ns",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getPulseLength_ns
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setPulseLength_ns
-            )
-        )
-        .def(
-            "getPulseLength_ns",
-            static_cast<double(PyScannerWrapper::*)(size_t const)>(
-                &PyScannerWrapper::getPulseLength_ns
-            )
-        )
-        .def(
-            "setPulseLength_ns",
-            static_cast<
-                void(PyScannerWrapper::*)(double const, size_t const)
-            >(
-                &PyScannerWrapper::setPulseLength_ns
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "beamDivergence",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getBeamDivergence
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setBeamDivergence
-            )
-        )
-        .def(
-            "getBeamDivergence",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getBeamDivergence
-            )
-        )
-        .def(
-            "setBeamDivergence",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setBeamDivergence
-            )
-        )
-        .def(
-            "getLastPulseWasHit",
-            static_cast<bool(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getLastPulseWasHit
-            )
-        )
-        .def(
-            "setLastPulseWasHit",
-            static_cast<void(PyScannerWrapper::*)(bool const, size_t const)>(
-                &PyScannerWrapper::setLastPulseWasHit
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "averagePower",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getAveragePower
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setAveragePower
-            )
-        )
-        .def(
-            "getAveragePower",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getAveragePower
-            )
-        )
-        .def(
-            "setAveragePower",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setAveragePower
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "beamQuality",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getBeamQuality
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setBeamQuality
-            )
-        )
-        .def(
-            "getBeamQuality",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getBeamQuality
-            )
-        )
-        .def(
-            "setBeamQuality",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setBeamQuality
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "efficiency",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getEfficiency
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setEfficiency
-            )
-        )
-        .def(
-            "getEfficiency",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getEfficiency
-            )
-        )
-        .def(
-            "setEfficiency",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setEfficiency
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "receiverDiameter",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getReceiverDiameter
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setReceiverDiameter
-            )
-        )
-        .def(
-            "getReceiverDiameter",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getReceiverDiameter
-            )
-        )
-        .def(
-            "setReceiverDiameter",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setReceiverDiameter
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "visibility",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getVisibility
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setVisibility
-            )
-        )
-        .def(
-            "getVisibility",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getVisibility
-            )
-        )
-        .def(
-            "setVisibility",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setVisibility
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "wavelength",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getWavelength
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setWavelength
-            )
-        )
-        .def(
-            "getWavelength",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getWavelength
-            )
-        )
-        .def(
-            "setWavelength",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setWavelength
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "atmosphericExtinction",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getAtmosphericExtinction
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setAtmosphericExtinction
-            )
-        )
-        .def(
-            "getAtmosphericExtinction",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getAtmosphericExtinction
-            )
-        )
-        .def(
-            "setAtmosphericExtinction",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setAtmosphericExtinction
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "beamWaistRadius",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getBeamWaistRadius
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setBeamWaistRadius
-            )
-        )
-        .def(
-            "getBeamWaistRadius",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getBeamWaistRadius
-            )
-        )
-        .def(
-            "setBeamWaistRadius",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setBeamWaistRadius
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "maxNOR",
-            static_cast<int(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getMaxNOR
-            ),
-            static_cast<void(PyScannerWrapper::*)(int const)>(
-                &PyScannerWrapper::setMaxNOR
-            )
-        )
-        .def(
-            "getMaxNOR",
-            static_cast<int(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getMaxNOR
-            )
-        )
-        .def(
-            "setMaxNOR",
-            static_cast<void(PyScannerWrapper::*)(int const, size_t const)>(
-                &PyScannerWrapper::setMaxNOR
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "bt2",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getBt2
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setBt2
-            )
-        )
-        .def(
-            "getBt2",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getBt2
-            )
-        )
-        .def(
-            "setBt2",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setBt2
-            )
-        )
-        .add_property( // Only access first device. Use get/set for n device
-            "dr2",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getDr2
-            ),
-            static_cast<void(PyScannerWrapper::*)(double const)>(
-                &PyScannerWrapper::setDr2
-            )
-        )
-        .def(
-            "getDr2",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getDr2
-            )
-        )
-        .def(
-            "setDr2",
-            static_cast<void(PyScannerWrapper::*)(double const, size_t const)>(
-                &PyScannerWrapper::setDr2
-            )
-        )
-        .add_property(
-            "active",
-            &PyScannerWrapper::isActive,
-            &PyScannerWrapper::setActive
-        )
-        .add_property(
-            "writeWaveform",
-            &PyScannerWrapper::isWriteWaveform,
-            &PyScannerWrapper::setWriteWaveform
-        )
-        .add_property(
-            "calcEchowidth",
-            &PyScannerWrapper::isCalcEchowidth,
-            &PyScannerWrapper::setCalcEchowidth
-        )
-        .add_property(
-            "fullWaveNoise",
-            &PyScannerWrapper::isFullWaveNoise,
-            &PyScannerWrapper::setFullWaveNoise
-        )
-        .add_property(
-            "platformNoiseDisabled",
-            &PyScannerWrapper::isPlatformNoiseDisabled,
-            &PyScannerWrapper::setPlatformNoiseDisabled
-        )
-        .def(
-            "getSupportedPulseFrequencies",
-            static_cast<PyIntegerList*(PyScannerWrapper::*)()>(
-                &PyScannerWrapper::getSupportedPulseFrequencies
-            ),
-            return_internal_reference<>()
-        )
-        .def(
-            "getSupportedPulseFrequencies",
-            static_cast<PyIntegerList*(PyScannerWrapper::*)(size_t const)>(
-                &PyScannerWrapper::getSupportedPulseFrequencies
-            ),
-            return_internal_reference<>()
-        )
-        .def(
-            "getRelativeAttitude",
-            static_cast<Rotation &(PyScannerWrapper::*)()>(
-                &PyScannerWrapper::getRelativeAttitudeByReference
-            ),
-            return_internal_reference<>()
-        )
-        .def(
-            "getRelativeAttitude",
-            static_cast<Rotation &(PyScannerWrapper::*)(size_t const)>(
-                &PyScannerWrapper::getRelativeAttitudeByReference
-            ),
-            return_internal_reference<>()
-        )
-        .def(
-            "getRelativePosition",
-            static_cast<PythonDVec3 *(PyScannerWrapper::*)()>(
-                &PyScannerWrapper::getRelativePosition
-            ),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getRelativePosition",
-            static_cast<PythonDVec3 *(PyScannerWrapper::*)(size_t const)>(
-                &PyScannerWrapper::getRelativePosition
-            ),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getIntersectionHandlingNoiseSource",
-            &PyScannerWrapper::getIntersectionHandlingNoiseSource,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getRandGen1",
-            &PyScannerWrapper::getRandGen1,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getRandGen2",
-            &PyScannerWrapper::getRandGen2,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getScannerHead",
-            static_cast<ScannerHead&(PyScannerWrapper::*)()>(
-                &PyScannerWrapper::getScannerHead
-            ),
-            return_internal_reference<>()
-        )
-        .def(
-            "getScannerHead",
-            static_cast<ScannerHead&(PyScannerWrapper::*)(size_t const)>(
-                &PyScannerWrapper::getScannerHead
-            ),
-            return_internal_reference<>()
-        )
-        .def(
-            "getBeamDeflector",
-            static_cast<
-                PyBeamDeflectorWrapper*(PyScannerWrapper::*)()
-            >(&PyScannerWrapper::getPyBeamDeflector),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getBeamDeflector",
-            static_cast<
-                PyBeamDeflectorWrapper*(PyScannerWrapper::*)(size_t const)
-                >(&PyScannerWrapper::getPyBeamDeflector),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getDetector",
-            static_cast<
-                PyDetectorWrapper*(PyScannerWrapper::*)()
-            >(&PyScannerWrapper::getPyDetectorWrapper),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getDetector",
-            static_cast<
-                PyDetectorWrapper*(PyScannerWrapper::*)(size_t const)
-            >(&PyScannerWrapper::getPyDetectorWrapper),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "calcRaysNumber",
-            static_cast<void(PyScannerWrapper::*)()>(
-                &PyScannerWrapper::calcRaysNumber
-            ),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "calcRaysNumber",
-            static_cast<void(PyScannerWrapper::*)(size_t const)>(
-                &PyScannerWrapper::calcRaysNumber
-            ),
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "calcAtmosphericAttenuation",
-            static_cast<double(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::calcAtmosphericAttenuation
-            )
-        )
-        .def(
-            "calcAtmosphericAttenuation",
-            static_cast<double(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::calcAtmosphericAttenuation
-            )
-        )
-        .add_property(
-            "fixedIncidenceAngle",
-            &PyScannerWrapper::isFixedIncidenceAngle,
-            &PyScannerWrapper::setFixedIncidenceAngle
-        )
-        .add_property( // It was not in ns before, but in seconds
-            "trajectoryTimeInterval",
-            &PyScannerWrapper::getTrajectoryTimeInterval,
-            &PyScannerWrapper::setTrajectoryTimeInterval
-        )
-        .add_property(
-            "trajectoryTimeInterval_ns",
-            &PyScannerWrapper::getTrajectoryTimeInterval,
-            &PyScannerWrapper::setTrajectoryTimeInterval
-        )
-        .add_property(  // Only access first device. Use get/set for n device.
-            "deviceId",
-            static_cast<std::string(PyScannerWrapper::*)()const>(
-                &PyScannerWrapper::getDeviceId
-            ),
-            static_cast<void(PyScannerWrapper::*)(std::string const)>(
-                &PyScannerWrapper::setDeviceId
-            )
-        )
-        .def(
-            "getDeviceId",
-            static_cast<std::string(PyScannerWrapper::*)(size_t const)const>(
-                &PyScannerWrapper::getDeviceId
-            )
-        )
-        .def(
-            "setDeviceId",
-            static_cast<
-                void(PyScannerWrapper::*)(std::string const, size_t const)
-            >(&PyScannerWrapper::setDeviceId)
-        )
-        .add_property(
-            "id",
-            &PyScannerWrapper::getScannerId,
-            &PyScannerWrapper::setScannerId
-        )
-        .def("getNumDevices", &PyScannerWrapper::getNumDevices)
-    ;
-
-    // Register FWFSettings
-    class_<FWFSettings>("FWFSettings", no_init)
-        .add_property(
-            "binSize_ns",
-            &FWFSettings::binSize_ns,
-            &FWFSettings::binSize_ns
-        )
-        .add_property(
-            "minEchoWidth",
-            &FWFSettings::minEchoWidth,
-            &FWFSettings::minEchoWidth
-        )
-        .add_property(
-            "peakEnergy",
-            &FWFSettings::peakEnergy,
-            &FWFSettings::peakEnergy
-        )
-        .add_property(
-            "apertureDiameter",
-            &FWFSettings::apertureDiameter,
-            &FWFSettings::apertureDiameter
-        )
-        .add_property(
-            "scannerEfficiency",
-            &FWFSettings::scannerEfficiency,
-            &FWFSettings::scannerEfficiency
-        )
-        .add_property(
-            "atmosphericVisiblity",
-            &FWFSettings::atmosphericVisibility,
-            &FWFSettings::atmosphericVisibility
-        )
-        .add_property(
-            "scannerWaveLength",
-            &FWFSettings::scannerWaveLength,
-            &FWFSettings::scannerWaveLength
-        )
-        .add_property(
-            "beamDivergence",
-            &FWFSettings::beamDivergence_rad,
-            &FWFSettings::beamDivergence_rad
-        )
-        .add_property(
-            "pulseLength_ns",
-            &FWFSettings::pulseLength_ns,
-            &FWFSettings::pulseLength_ns
-        )
-        .add_property(
-            "beamSampleQuality",
-            &FWFSettings::beamSampleQuality,
-            &FWFSettings::beamSampleQuality
-        )
-        .add_property(
-            "winSize_ns",
-            &FWFSettings::winSize_ns,
-            &FWFSettings::winSize_ns
-        )
-        .add_property(
-            "maxFullwaveRange_ns",
-            &FWFSettings::maxFullwaveRange_ns,
-            &FWFSettings::maxFullwaveRange_ns
-        )
-        .def("toString", &FWFSettings::toString)
-    ;
-
-    // Register DVec3 (glm::dvec3 wrapper)
-    class_<PythonDVec3>("DVec3", no_init)
-        .add_property("x", &PythonDVec3::getX, &PythonDVec3::setX)
-        .add_property("y", &PythonDVec3::getY, &PythonDVec3::setY)
-        .add_property("z", &PythonDVec3::getZ, &PythonDVec3::setZ)
-    ;
-
-    // Register Rotation
-    class_<Rotation>("Rotation", no_init)
-        .add_property("q0", &Rotation::getQ0, &Rotation::setQ0)
-        .add_property("q1", &Rotation::getQ1, &Rotation::setQ1)
-        .add_property("q2", &Rotation::getQ2, &Rotation::setQ2)
-        .add_property("q3", &Rotation::getQ3, &Rotation::setQ3)
-        .def(
-            "getAxis",
-            // The unary operator+ is a C++ trick to convert a capture-less
-            // lambda to a function pointer, so that we can do this inline.
-            +[](Rotation &r) {
-                return new PythonDVec3(r.getAxis());
-            },
-            //&Rotation::getAxisPython,
-            return_value_policy<manage_new_object>()
-        )
-        .def("getAngle", &Rotation::getAngle)
-    ;
-
-    // Register ScannerHead
-    class_<ScannerHead>("ScannerHead", no_init)
-        .add_property(
-            "rotatePerSecMax",
-            &ScannerHead::getRotatePerSecMax,
-            &ScannerHead::setRotatePerSecMax
-        )
-        .add_property(
-            "rotatePerSec",
-            &ScannerHead::getRotatePerSec_rad,
-            &ScannerHead::setRotatePerSec_rad
-        )
-        .add_property(
-            "rotateStop",
-            &ScannerHead::getRotateStop,
-            &ScannerHead::setRotateStop
-        )
-        .add_property(
-            "rotateStart",
-            &ScannerHead::getRotateStart,
-            &ScannerHead::setRotateStart
-        )
-        .add_property(
-            "rotateRange",
-            &ScannerHead::getRotateRange,
-            &ScannerHead::setRotateRange
-        )
-        .add_property(
-            "currentRotateAngle",
-            &ScannerHead::getRotateCurrent,
-            &ScannerHead::setCurrentRotateAngle_rad
-        )
-        .def(
-            "getMountRelativeAttitude",
-            &ScannerHead::getMountRelativeAttitudeByReference,
-            return_internal_reference<>()
-        )
-    ;
-
-    // Register AbstractBeamDeflector
-    class_<PyBeamDeflectorWrapper>("AbstractBeamDeflector", no_init)
-        .add_property(
-            "scanFreqMax",
-            &PyBeamDeflectorWrapper::getScanFreqMax,
-            &PyBeamDeflectorWrapper::setScanFreqMax
-        )
-        .add_property(
-            "scanFreqMin",
-            &PyBeamDeflectorWrapper::getScanFreqMin,
-            &PyBeamDeflectorWrapper::setScanFreqMin
-        )
-        .add_property(
-            "scanAngleMax",
-            &PyBeamDeflectorWrapper::getScanAngleMax,
-            &PyBeamDeflectorWrapper::setScanAngleMax
-        )
-        .add_property(
-            "scanFreq",
-            &PyBeamDeflectorWrapper::getScanFreq,
-            &PyBeamDeflectorWrapper::setScanFreq
-        )
-        .add_property(
-            "scanAngle",
-            &PyBeamDeflectorWrapper::getScanAngle,
-            &PyBeamDeflectorWrapper::setScanAngle
-        )
-        .add_property(
-            "verticalAngleMin",
-            &PyBeamDeflectorWrapper::getVerticalAngleMin,
-            &PyBeamDeflectorWrapper::setVerticalAngleMin
-        )
-        .add_property(
-            "verticalAngleMax",
-            &PyBeamDeflectorWrapper::getVerticalAngleMax,
-            &PyBeamDeflectorWrapper::setVerticalAngleMax
-        )
-        .add_property(
-            "currentBeamAngle",
-            &PyBeamDeflectorWrapper::getCurrentBeamAngle,
-            &PyBeamDeflectorWrapper::setCurrentBeamAngle
-        )
-        .add_property(
-            "angleDiff",
-            &PyBeamDeflectorWrapper::getAngleDiff,
-            &PyBeamDeflectorWrapper::setAngleDiff
-        )
-        .add_property(
-            "cachedAngleBetweenPulses",
-            &PyBeamDeflectorWrapper::getCachedAngleBetweenPulses,
-            &PyBeamDeflectorWrapper::setCachedAngleBetweenPulses
-        )
-        .def(
-            "getEmitterRelativeAttitude",
-            &PyBeamDeflectorWrapper::getEmitterRelativeAttitude,
-            return_internal_reference<>()
-        )
-        .def(
-            "getOpticsType",
-            &PyBeamDeflectorWrapper::getOpticsType
-        )
-    ;
-
-    // Register AbstractDetector
-    class_<PyDetectorWrapper>("AbstractDetector", no_init)
-        .add_property(
-            "accuracy",
-            &PyDetectorWrapper::getAccuracy,
-            &PyDetectorWrapper::setAccuracy
-        )
-        .add_property(
-            "rangeMin",
-            &PyDetectorWrapper::getRangeMin,
-            &PyDetectorWrapper::setRangeMin
-        )
-        .add_property(
-            "rangeMax",
-            &PyDetectorWrapper::getRangeMax,
-            &PyDetectorWrapper::setRangeMax
-        )
-        .add_property(
-            "lasScale",
-            &PyDetectorWrapper::getLasScale,
-            &PyDetectorWrapper::setLasScale
-        )
-    ;
-
-    // Register list<int>
-    class_<PyIntegerList>("IntegerList", no_init)
-        .def(
-            "__getitem__",
-            &PyIntegerList::get
-        )
-        .def(
-            "__setitem__",
-            &PyIntegerList::set
-        )
-        .def(
-            "__len__",
-            &PyIntegerList::length
-        )
-        .def(
-            "get",
-            &PyIntegerList::get
-        )
-        .def(
-            "set",
-            &PyIntegerList::set
-        )
-        .def(
-            "insert",
-            &PyIntegerList::insert
-        )
-        .def(
-            "erase",
-            &PyIntegerList::erase
-        )
-        .def(
-            "length",
-            &PyIntegerList::length
-        )
-    ;
-
-    // Register vector<double>
-    class_<PyDoubleVector>("DoubleVector", no_init)
-        .def(
-            "__getitem__",
-            &PyDoubleVector::get
-        )
-        .def(
-            "__setitem__",
-            &PyDoubleVector::set
-        )
-        .def(
-            "__len__",
-            &PyDoubleVector::length
-        )
-        .def(
-            "get",
-            &PyDoubleVector::get
-        )
-        .def(
-            "set",
-            &PyDoubleVector::set
-        )
-        .def(
-            "insert",
-            &PyDoubleVector::insert
-        )
-        .def(
-            "erase",
-            &PyDoubleVector::erase
-        )
-        .def(
-            "length",
-            &PyDoubleVector::length
-        )
-    ;
-
-    // Register vector<string>
-    class_<PyStringVector>("StringVector", no_init)
-        .def(
-            "__getitem__",
-            &PyStringVector::get
-        )
-        .def(
-            "__setitem__",
-            &PyStringVector::set
-        )
-        .def(
-            "__len__",
-            &PyStringVector::length
-        )
-        .def(
-            "get",
-            &PyStringVector::get
-        )
-        .def(
-            "set",
-            &PyStringVector::set
-        )
-        .def(
-            "insert",
-            &PyStringVector::insert
-        )
-        .def(
-            "erase",
-            &PyStringVector::erase
-        )
-        .def(
-            "length",
-            &PyStringVector::length
-        )
-    ;
-
-    // Register NoiseSource
-    class_<PyNoiseSourceWrapper>("NoiseSource", no_init)
-        .add_property(
-            "clipMin",
-            &PyNoiseSourceWrapper::getClipMin,
-            &PyNoiseSourceWrapper::setClipMin
-        )
-        .add_property(
-            "clipMax",
-            &PyNoiseSourceWrapper::getClipMax,
-            &PyNoiseSourceWrapper::setClipMax
-        )
-        .add_property(
-            "enabled",
-            &PyNoiseSourceWrapper::isEnabled,
-            &PyNoiseSourceWrapper::setEnabled
-        )
-        .def(
-            "isFixedValueEnabled",
-            &PyNoiseSourceWrapper::isFixedValueEnabled
-        )
-        .add_property(
-            "fixedLifespan",
-            &PyNoiseSourceWrapper::getFixedLifespan,
-            &PyNoiseSourceWrapper::setFixedLifespan
-        )
-        .add_property(
-            "fixedValueRemainingUses",
-            &PyNoiseSourceWrapper::getFixedValueRemainingUses,
-            &PyNoiseSourceWrapper::setFixedValueRemainingUses
-        )
-    ;
-
-    // Register RandomnessGenerator
-    class_<PyRandomnessGeneratorWrapper>("RandomnessGenerator", no_init)
-        .def(
-            "computeUniformRealDistribution",
-            &PyRandomnessGeneratorWrapper::computeUniformRealDistribution
-        )
-        .def(
-            "uniformRealDistributionNext",
-            &PyRandomnessGeneratorWrapper::uniformRealDistributionNext
-        )
-        .def(
-            "computeNormalDistribution",
-            &PyRandomnessGeneratorWrapper::computeNormalDistribution
-        )
-        .def(
-            "normalDistributionNext",
-            &PyRandomnessGeneratorWrapper::normalDistributionNext
-        )
-    ;
-
-    // Register Platform
-    class_<PyPlatformWrapper>("Platform", no_init)
-        .add_property(
-            "lastCheckZ",
-            &PyPlatformWrapper::getLastCheckZ,
-            &PyPlatformWrapper::setLastCheckZ
-        )
-        .add_property(
-            "dmax",
-            &PyPlatformWrapper::getDmax,
-            &PyPlatformWrapper::setDmax
-        )
-        .add_property(
-            "movePerSec",
-            &PyPlatformWrapper::getMovePerSec,
-            &PyPlatformWrapper::setMovePerSec
-        )
-        .add_property(
-            "onGround",
-            &PyPlatformWrapper::isOnGround,
-            &PyPlatformWrapper::setOnGround
-        )
-        .add_property(
-            "stopAndTurn",
-            &PyPlatformWrapper::isStopAndTurn,
-            &PyPlatformWrapper::setStopAndTurn
-        )
-        .add_property(
-            "slowdownEnabled",
-            &PyPlatformWrapper::isSlowdownEnabled,
-            &PyPlatformWrapper::setSlowdownEnabled
-        )
-        /*.add_property(
-            "yawAtDeparture",
-            &PyPlatformWrapper::getYawAtDeparture,
-            &PyPlatformWrapper::setYawAtDeparture
-        )*/
-        .add_property(
-            "smoothTurn",
-            &PyPlatformWrapper::isSmoothTurn,
-            &PyPlatformWrapper::setSmoothTurn
-        )
-        .add_property(
-            "mSetOrientationOnLegInit",
-            &PyPlatformWrapper::isOrientationOnLegInit,
-            &PyPlatformWrapper::setOrientationOnLegInit
-        )
-        .def(
-            "getPositionXNoiseSource",
-            &PyPlatformWrapper::getPositionXNoiseSource,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getPositionYNoiseSource",
-            &PyPlatformWrapper::getPositionYNoiseSource,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getPositionZNoiseSource",
-            &PyPlatformWrapper::getPositionZNoiseSource,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getAttitudeXNoiseSource",
-            &PyPlatformWrapper::getAttitudeXNoiseSource,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getAttitudeYNoiseSource",
-            &PyPlatformWrapper::getAttitudeYNoiseSource,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getAttitudeZNoiseSource",
-            &PyPlatformWrapper::getAttitudeZNoiseSource,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getRelativePosition",
-            &PyPlatformWrapper::getRelativePosition,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getRelativeAttitude",
-            &PyPlatformWrapper::getRelativeAttitude,
-            return_internal_reference<>()
-        )
-        .def(
-            "getLastGroundCheck",
-            &PyPlatformWrapper::getLastGroundCheck,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getNextWaypointPosition",
-            &PyPlatformWrapper::getNextWaypointPosition,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getPositionPython",
-            &PyPlatformWrapper::getPositionPython,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getPosition",
-            &PyPlatformWrapper::getPositionPython,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getAttitudePython",
-            &PyPlatformWrapper::getAttitudePython,
-            return_internal_reference<>()
-        )
-        .def(
-            "getAttitude",
-            &PyPlatformWrapper::getAttitudePython,
-            return_internal_reference<>()
-        )
-        .def(
-            "getCachedAbsolutePosition",
-            &PyPlatformWrapper::getCachedAbsolutePosition,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getCachedAbsoluteAttitude",
-            &PyPlatformWrapper::getCachedAbsoluteAttitude,
-            return_internal_reference<>()
-        )
-        .def(
-            "getCachedCurrentDir",
-            &PyPlatformWrapper::getCachedCurrentDir,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getCachedCurrentDirXY",
-            &PyPlatformWrapper::getCachedCurrentDirXY,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getCachedVectorToTarget",
-            &PyPlatformWrapper::getCachedVectorToTarget,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getCachedVectorToTargetXY",
-            &PyPlatformWrapper::getCachedVectorToTargetXY,
-            return_value_policy<manage_new_object>()
-        )
-    ;
-
-    // Register Primitive
-    class_<PyPrimitiveWrapper>("Primitive", no_init)
-        .def(
-            "getScenePart",
-            &PyPrimitiveWrapper::getScenePart,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getMaterial",
-            &PyPrimitiveWrapper::getMaterial,
-            return_internal_reference<>()
-        )
-        .def(
-            "getAABB",
-            &PyPrimitiveWrapper::getAABB,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getCentroid",
-            &PyPrimitiveWrapper::getCentroid,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getIncidenceAngle",
-            &PyPrimitiveWrapper::getIncidenceAngle
-        )
-        .def(
-            "getRayIntersection",
-            &PyPrimitiveWrapper::getRayIntersection,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getRayIntersectionDistance",
-            &PyPrimitiveWrapper::getRayIntersectionDistance
-        )
-        .def(
-            "getNumVertices",
-            &PyPrimitiveWrapper::getNumVertices
-        )
-        .def(
-            "getVertex",
-            &PyPrimitiveWrapper::getVertex,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "update",
-            &PyPrimitiveWrapper::update
-        )
-        .def(
-            "isTriangle",
-            &PyPrimitiveWrapper::isTriangle
-        )
-        .def(
-            "isAABB",
-            &PyPrimitiveWrapper::isAABB
-        )
-        .def(
-            "isVoxel",
-            &PyPrimitiveWrapper::isVoxel
-        )
-        .def(
-            "isDetailedVoxel",
-            &PyPrimitiveWrapper::isDetailedVoxel
-        )
-    ;
-
-    // Register Material
-    class_<Material>("Material", no_init)
-        .add_property(
-            "name",
-            &Material::name,
-            &Material::name
-        )
-        .add_property(
-            "isGround",
-            &Material::isGround,
-            &Material::isGround
-        )
-        .add_property(
-            "useVertexColors",
-            &Material::useVertexColors,
-            &Material::useVertexColors
-        )
-        .add_property(
-            "matFilePath",
-            &Material::matFilePath,
-            &Material::matFilePath
-        )
-        .add_property(
-            "map_Kd",
-            &Material::map_Kd,
-            &Material::map_Kd
-        )
-        .add_property(
-            "reflectance",
-            &Material::reflectance,
-            &Material::reflectance
-        )
-        .add_property(
-            "specularity",
-            &Material::specularity,
-            &Material::specularity
-        )
-        .add_property(
-            "specularExponent",
-            &Material::specularExponent,
-            &Material::specularExponent
-        )
-        .add_property(
-            "classification",
-            &Material::classification,
-            &Material::classification
-        )
-        .add_property(
-            "spectra",
-            &Material::spectra,
-            &Material::spectra
-        )
-        .add_property("ka0",
-            +[](Material &m){ return m.ka[0]; },
-            +[](Material &m, double v){ m.ka[0] = v; }
-        )
-        .add_property("ka1",
-            +[](Material &m){ return m.ka[1]; },
-            +[](Material &m, double v){ m.ka[1] = v; }
-        )
-        .add_property("ka2",
-            +[](Material &m){ return m.ka[2]; },
-            +[](Material &m, double v){ m.ka[2] = v; }
-        )
-        .add_property("ka3",
-            +[](Material &m){ return m.ka[3]; },
-            +[](Material &m, double v){ m.ka[3] = v; }
-        )
-        .add_property("kd0",
-            +[](Material &m){ return m.kd[0]; },
-            +[](Material &m, double v){ m.kd[0] = v; }
-        )
-        .add_property("kd1",
-            +[](Material &m){ return m.kd[1]; },
-            +[](Material &m, double v){ m.kd[1] = v; }
-        )
-        .add_property("kd2",
-            +[](Material &m){ return m.kd[2]; },
-            +[](Material &m, double v){ m.kd[2] = v; }
-        )
-        .add_property("kd3",
-            +[](Material &m){ return m.kd[3]; },
-            +[](Material &m, double v){ m.kd[3] = v; }
-        )
-        .add_property("ks0",
-            +[](Material &m){ return m.ks[0]; },
-            +[](Material &m, double v){ m.ks[0] = v; }
-        )
-        .add_property("ks1",
-            +[](Material &m){ return m.ks[1]; },
-            +[](Material &m, double v){ m.ks[1] = v; }
-        )
-        .add_property("ks2",
-            +[](Material &m){ return m.ks[2]; },
-            +[](Material &m, double v){ m.ks[2] = v; }
-        )
-        .add_property("ks3",
-            +[](Material &m){ return m.ks[3]; },
-            +[](Material &m, double v){ m.ks[3] = v; }
-        );
-
-    // Register ScenePart
-    class_<PyScenePartWrapper>("ScenePart", no_init)
-        .add_property(
-            "id",
-            &PyScenePartWrapper::getId,
-            &PyScenePartWrapper::setId
-        )
-        .def(
-            "getOrigin",
-            &PyScenePartWrapper::getOrigin,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "setOrigin",
-            &PyScenePartWrapper::setOrigin
-        )
-        .def(
-            "setRotation",
-            &PyScenePartWrapper::setRotation
-        )
-        .def(
-            "getRotation",
-            &PyScenePartWrapper::getRotation,
-            return_internal_reference<>()
-        )
-        .add_property(
-            "scale",
-            &PyScenePartWrapper::getScale,
-            &PyScenePartWrapper::setScale
-        )
-        .def(
-            "isDynamicMovingObject",
-            &PyScenePartWrapper::isDynamicMovingObject
-        )
-        .add_property(
-            "dynObjectStep",
-            &PyScenePartWrapper::getDynObjectStep,
-            &PyScenePartWrapper::setDynObjectStep
-        )
-        .add_property(
-            "observerStep",
-            &PyScenePartWrapper::getObserverStep,
-            &PyScenePartWrapper::setObserverStep
-        )
-        .def(
-            "getPrimitive",
-            &PyScenePartWrapper::getPrimitive,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getNumPrimitives",
-            &PyScenePartWrapper::getNumPrimitives
-        )
-        .def(
-            "computeCentroid",
-            &PyScenePartWrapper::computeCentroid
-        )
-        .def(
-            "computeBound",
-            &PyScenePartWrapper::computeBound
-        )
-        .def(
-            "getCentroid",
-            &PyScenePartWrapper::getCentroid,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getBound",
-            &PyScenePartWrapper::getBound,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "translate",
-            &PySceneWrapper::translate
-        )
-    ;
-
-    // Register Scene
-    class_<PySceneWrapper>("Scene", no_init)
-        .def(
-            "newTriangle",
-            &PySceneWrapper::newTriangle,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "newDetailedVoxel",
-            &PySceneWrapper::newDetailedVoxel,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getPrimitive",
-            &PySceneWrapper::getPrimitive,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getNumPrimitives",
-            &PySceneWrapper::getNumPrimitives
-        )
-        .def(
-            "getAABB",
-            &PySceneWrapper::getAABB,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getGroundPointAt",
-            &PySceneWrapper::getGroundPointAt,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getIntersection",
-            &PySceneWrapper::getIntersection,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getShift",
-            &PySceneWrapper::getShift,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "finalizeLoading",
-            &PySceneWrapper::finalizeLoading
-        )
-        .def(
-            "writeObject",
-            &PySceneWrapper::writeObject
-        )
-        .def(
-            "getNumSceneParts",
-            &PySceneWrapper::getNumSceneParts
-        )
-        .def(
-            "getScenePart",
-            &PySceneWrapper::getScenePart,
-            return_value_policy<manage_new_object>()
-        )
-        .add_property(
-            "dynSceneStep",
-            &PySceneWrapper::getDynSceneStep,
-            &PySceneWrapper::setDynSceneStep
-        )
-        .def(
-            "getBBox",
-            &PySceneWrapper::getBBox,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getBBoxCRS",
-            &PySceneWrapper::getBBoxCRS,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "translate",
-            &PySceneWrapper::translate
-        )
-    ;
-
-    // Register AABB
-    class_<PyAABBWrapper>("AABB", no_init)
-        .def(
-            "getMinVertex",
-            &PyAABBWrapper::getMinVertex,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getMaxVertex",
-            &PyAABBWrapper::getMaxVertex,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "toString",
-            &PyAABBWrapper::toString
-        )
-    ;
-
-    // Register Vertex
-    class_<PyVertexWrapper>("Vertex", no_init)
-        .def(
-            "getPosition",
-            &PyVertexWrapper::getPosition,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "getNormal",
-            &PyVertexWrapper::getNormal,
-            return_value_policy<manage_new_object>()
-        )
-    ;
-
-    // Register Triangle
-    class_<PyTriangleWrapper, bases<PyPrimitiveWrapper>>
-    ("Triangle", no_init)
-        .def(
-            "getFaceNormal",
-            &PyTriangleWrapper::getFaceNormal,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "toString",
-            &PyTriangleWrapper::toString
-        )
-    ;
-
-    // Register DetailedVoxel
-    class_<PyDetailedVoxelWrapper, bases<PyPrimitiveWrapper>>
-    ("DetailedVoxel", no_init)
-        .add_property(
-            "nbEchos",
-            &PyDetailedVoxelWrapper::getNbEchos,
-            &PyDetailedVoxelWrapper::setNbEchos
-        )
-        .add_property(
-            "nbSampling",
-            &PyDetailedVoxelWrapper::getNbSampling,
-            &PyDetailedVoxelWrapper::setNbSampling
-        )
-        .def(
-            "getNumberOfDoubleValues",
-            &PyDetailedVoxelWrapper::getNumberOfDoubleValues
-        )
-        .def(
-            "getDoubleValue",
-            &PyDetailedVoxelWrapper::getDoubleValue
-        )
-        .def(
-            "setDoubleValue",
-            &PyDetailedVoxelWrapper::setDoubleValue
-        )
-        .add_property(
-            "maxPad",
-            &PyDetailedVoxelWrapper::getMaxPad,
-            &PyDetailedVoxelWrapper::setMaxPad
-        )
-    ;
-
-    // Register MeasurementVector
-    class_<PyMeasurementVectorWrapper>("MeasurementVector", no_init)
-        .def(
-            "__getitem__",
-            &PyMeasurementVectorWrapper::get,
-            return_value_policy<manage_new_object>()
-        )
-        .def("__len__",
-            &PyMeasurementVectorWrapper::length
-        )
-        .def(
-            "get",
-            &PyMeasurementVectorWrapper::get,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "erase",
-            &PyMeasurementVectorWrapper::erase
-        )
-        .def(
-            "length",
-            &PyMeasurementVectorWrapper::length
-        )
-    ;
-
-    // Register Measurement
-    class_<PyMeasurementWrapper>("Measurement", no_init)
-        .add_property(
-            "hitObjectId",
-            &PyMeasurementWrapper::getHitObjectId,
-            &PyMeasurementWrapper::setHitObjectId
-        )
-        .def(
-            "getPosition",
-            &PyMeasurementWrapper::getPosition,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "setPosition",
-            &PyMeasurementWrapper::setPosition
-        )
-        .def(
-            "getBeamDirection",
-            &PyMeasurementWrapper::getBeamDirection,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "setBeamDirection",
-            &PyMeasurementWrapper::setBeamDirection
-        )
-        .def(
-            "getBeamOrigin",
-            &PyMeasurementWrapper::getBeamOrigin,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "setBeamOrigin",
-            &PyMeasurementWrapper::setBeamOrigin
-        )
-        .add_property(
-            "distance",
-            &PyMeasurementWrapper::getDistance,
-            &PyMeasurementWrapper::setDistance
-        )
-        .add_property(
-            "intensity",
-            &PyMeasurementWrapper::getIntensity,
-            &PyMeasurementWrapper::setIntensity
-        )
-        .add_property(
-            "echoWidth",
-            &PyMeasurementWrapper::getEchoWidth,
-            &PyMeasurementWrapper::setEchoWidth
-        )
-        .add_property(
-            "returnNumber",
-            &PyMeasurementWrapper::getReturnNumber,
-            &PyMeasurementWrapper::setReturnNumber
-        )
-        .add_property(
-            "pulseReturnNumber",
-            &PyMeasurementWrapper::getPulseReturnNumber,
-            &PyMeasurementWrapper::setPulseReturnNumber
-        )
-        .add_property(
-            "fullwaveIndex",
-            &PyMeasurementWrapper::getFullwaveIndex,
-            &PyMeasurementWrapper::setFullwaveIndex
-        )
-        .add_property(
-            "classification",
-            &PyMeasurementWrapper::getClassification,
-            &PyMeasurementWrapper::setClassification
-        )
-        .add_property(
-            "gpsTime",
-            &PyMeasurementWrapper::getGpsTime,
-            &PyMeasurementWrapper::setGpsTime
-        )
-    ;
-
-    // Register TrajectoryVector
-    class_<PyTrajectoryVectorWrapper>("TrajectoryVector", no_init)
-        .def(
-            "__getitem__",
-            &PyTrajectoryVectorWrapper::get,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "__len__",
-            &PyTrajectoryVectorWrapper::length
-        )
-        .def(
-            "get",
-            &PyTrajectoryVectorWrapper::get,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "erase",
-            &PyTrajectoryVectorWrapper::erase
-        )
-        .def(
-            "length",
-            &PyTrajectoryVectorWrapper::length
-        )
-    ;
-
-    // Register Trajectory
-    class_<PyTrajectoryWrapper>("Trajectory", no_init)
-        .add_property(
-            "gpsTime",
-            &PyTrajectoryWrapper::getGpsTime,
-            &PyTrajectoryWrapper::setGpsTime
-        )
-        .def(
-            "getPosition",
-            &PyTrajectoryWrapper::getPosition,
-            return_value_policy<manage_new_object>()
-        )
-        .def(
-            "setPosition",
-            &PyTrajectoryWrapper::setPosition,
-            return_value_policy<manage_new_object>()
-        )
-        .add_property(
-            "roll",
-            &PyTrajectoryWrapper::getRoll,
-            &PyTrajectoryWrapper::setRoll
-        )
-        .add_property(
-            "pitch",
-            &PyTrajectoryWrapper::getPitch,
-            &PyTrajectoryWrapper::setPitch
-        )
-        .add_property(
-            "yaw",
-            &PyTrajectoryWrapper::getYaw,
-            &PyTrajectoryWrapper::setYaw
-        )
-    ;
-
-    // Register PyHeliosOutputWrapper
-    class_<PyHeliosOutputWrapper>("HeliosOutput", no_init)
-        .add_property(
-            "measurements",
-            &PyHeliosOutputWrapper::measurements,
-            &PyHeliosOutputWrapper::measurements
-        )
-        .add_property(
-            "trajectories",
-            &PyHeliosOutputWrapper::trajectories,
-            &PyHeliosOutputWrapper::trajectories
-        )
-        .add_property(
-            "finished",
-            &PyHeliosOutputWrapper::finished,
-            &PyHeliosOutputWrapper::finished
-        )
-        .add_property(
-            "outpath",
-            &PyHeliosOutputWrapper::outpath,
-            &PyHeliosOutputWrapper::outpath
-        )
-        .add_property(
-            "filepath",
-            &PyHeliosOutputWrapper::outpath,
-            &PyHeliosOutputWrapper::outpath
-        )
-        .add_property(
-            "outpaths",
-            &PyHeliosOutputWrapper::outpaths,
-            &PyHeliosOutputWrapper::outpaths
-        )
-        .add_property(
-            "filepaths",
-            &PyHeliosOutputWrapper::outpaths,
-            &PyHeliosOutputWrapper::outpaths
-        )
-    ;
-
-    // Register PySimulationCycleCallback
-    class_<PySimulationCycleCallback>(
-        "SimulationCycleCallback",
-        init<PyObject *>()
-    )
-        .def("call", &PySimulationCycleCallback::operator())
-    ;
-}
diff --git a/src/pybinds/PyHeliosException.h b/src/pybinds/PyHeliosException.h
deleted file mode 100644
index fa1ecd583..000000000
--- a/src/pybinds/PyHeliosException.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <HeliosException.h>
-
-namespace pyhelios{
-
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- *
- * Simple wrapper for HeliosException
- */
-class PyHeliosException : public HeliosException{
-public:
-    PyHeliosException(std::string const msg = "") : HeliosException(msg) {}
-};
-
-}
diff --git a/src/pybinds/PyHeliosOutputWrapper.h b/src/pybinds/PyHeliosOutputWrapper.h
deleted file mode 100644
index b2adb01eb..000000000
--- a/src/pybinds/PyHeliosOutputWrapper.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#pragma once
-
-#include <PyMeasurementVectorWrapper.h>
-#include <PyTrajectoryVectorWrapper.h>
-#include <PyStringVector.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Python wrapper for helios output
- *
- * @see PyMeasurementVectorWrapper
- * @see PyTrajectoryVectorWrapper
- */
-class PyHeliosOutputWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    PyMeasurementVectorWrapper measurements;
-    PyTrajectoryVectorWrapper trajectories;
-    std::string outpath;
-    PyStringVector outpaths;
-    bool finished;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyHeliosOutputWrapper(
-        std::shared_ptr<std::vector<Measurement>> measurements,
-        std::shared_ptr<std::vector<Trajectory>> trajectories,
-        std::string const &outpath,
-        std::shared_ptr<std::vector<std::string>> outpaths,
-        bool finished
-    ) :
-        measurements(PyMeasurementVectorWrapper(*measurements)),
-        trajectories(PyTrajectoryVectorWrapper(*trajectories)),
-        outpath(outpath),
-        outpaths(PyStringVector(*outpaths)),
-        finished(finished)
-    {}
-    PyHeliosOutputWrapper(
-        std::vector<Measurement> &measurements,
-        std::vector<Trajectory> &trajectories,
-        std::string const &outpath,
-        std::vector<std::string> outpaths,
-        bool finished
-    ) :
-        measurements(PyMeasurementVectorWrapper(measurements)),
-        trajectories(PyTrajectoryVectorWrapper(trajectories)),
-        outpath(outpath),
-        outpaths(PyStringVector(outpaths)),
-        finished(finished)
-    {}
-    virtual ~PyHeliosOutputWrapper() {}
-};
-
-}
diff --git a/src/pybinds/PyHeliosUtils.h b/src/pybinds/PyHeliosUtils.h
deleted file mode 100644
index 92f33f3eb..000000000
--- a/src/pybinds/PyHeliosUtils.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include <boost/python/errors.hpp>
-
-namespace pyhelios{
-
-class PyHeliosUtils{
-public:
-    /**
-     * @brief Translate received index from python, where negative values have
-     *  a special meaning (i.e. index -1 means index n-1), to C++ index domain
-     * @param _index The index itself
-     * @param n The number of elements so n-1 would be the last valid index
-     */
-    static size_t handlePythonIndex(long _index, size_t n){
-        size_t index = (size_t) _index;
-        if(_index < 0){
-            index = (size_t) (n + _index);
-        }
-        if(index >= n){
-            std::stringstream ss;
-            ss << "Index " << _index << " out of range";
-            PyErr_SetString(PyExc_IndexError, ss.str().c_str());
-            boost::python::throw_error_already_set();
-        }
-        return index;
-    }
-};
-
-}
diff --git a/src/pybinds/PyIntegerList.h b/src/pybinds/PyIntegerList.h
deleted file mode 100644
index 6fc92f988..000000000
--- a/src/pybinds/PyIntegerList.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#pragma once
-
-#include <PyHeliosUtils.h>
-#include <list>
-
-namespace pyhelios{
-
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for std::list<int> class
- *
- * @see std::list
- */
-class PyIntegerList{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    std::list<int> &list;
-
-    // ***  CONSTRUCTION  *** //
-    // ********************** //
-    PyIntegerList(std::list<int> &list) : list(list) {}
-    virtual ~PyIntegerList() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    int get(long _index){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, list.size());
-        std::list<int>::iterator it = list.begin();
-        for(size_t i = 0 ; i < index ; i++)it++;
-        return *it;
-    }
-    void set(long _index, int value){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, list.size());
-        std::list<int>::iterator it = list.begin();
-        for(size_t i = 0 ; i < index ; i++)it++;
-        *it = value;
-    }
-    void insert(long _index, int value){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, list.size());
-        std::list<int>::iterator it = list.begin();
-        for(size_t i = 0 ; i < index ; i++)it++;
-        list.insert(it, value);
-    }
-    void erase(long _index){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, list.size());
-        std::list<int>::iterator it = list.begin();
-        for(size_t i = 0 ; i < index ; i++)it++;
-        list.erase(it);
-    }
-    size_t length() {return list.size();}
-};
-
-}
diff --git a/src/pybinds/PyMeasurementVectorWrapper.h b/src/pybinds/PyMeasurementVectorWrapper.h
deleted file mode 100644
index ee9bfe40a..000000000
--- a/src/pybinds/PyMeasurementVectorWrapper.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include <PyMeasurementWrapper.h>
-#include <PyHeliosUtils.h>
-#include <vector>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for std::vector<Measurement> class
- *
- * @see std::vector
- * @see PyWrapperMeasurement
- * @see Measurement
- */
-class PyMeasurementVectorWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    std::vector<Measurement> allMeasurements;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyMeasurementVectorWrapper(std::vector<Measurement> &allMeasurements) :
-        allMeasurements(allMeasurements) {}
-    virtual ~PyMeasurementVectorWrapper() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    PyMeasurementWrapper * get(long index){
-        return new PyMeasurementWrapper(allMeasurements[
-            PyHeliosUtils::handlePythonIndex(index, allMeasurements.size())
-        ]);
-    }
-    void erase(long index){
-        allMeasurements.erase(
-            allMeasurements.begin() +
-            PyHeliosUtils::handlePythonIndex(index, allMeasurements.size())
-        );
-    }
-    size_t length() {return allMeasurements.size();}
-
-};
-
-}
diff --git a/src/pybinds/PyMeasurementWrapper.h b/src/pybinds/PyMeasurementWrapper.h
deleted file mode 100644
index e58b87e84..000000000
--- a/src/pybinds/PyMeasurementWrapper.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include <string>
-#include <Measurement.h>
-#include <PythonDVec3.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Measurement class
- *
- * @see Measurement
- */
-class PyMeasurementWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    Measurement &m;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyMeasurementWrapper(Measurement &m) : m(m) {}
-    virtual ~PyMeasurementWrapper() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    std::string getHitObjectId() {return m.hitObjectId;}
-    void setHitObjectId(std::string const hitObjectId)
-        {m.hitObjectId = hitObjectId;}
-    PythonDVec3 *getPosition() {return new PythonDVec3(m.position);}
-    void setPosition(double x, double y, double z)
-        {m.position = glm::dvec3(x, y, z);}
-    PythonDVec3 *getBeamDirection() {return new PythonDVec3(m.beamDirection);}
-    void setBeamDirection(double x, double y, double z)
-        {m.beamDirection = glm::dvec3(x, y, z);}
-    PythonDVec3 *getBeamOrigin() {return new PythonDVec3(m.beamOrigin);}
-    void setBeamOrigin(double x, double y, double z)
-        {m.beamOrigin = glm::dvec3(x, y, z);}
-    double getDistance() {return m.distance;}
-    void setDistance(double distance) {m.distance = distance;}
-    double getIntensity() {return m.intensity;}
-    void setIntensity(double intensity) {m.intensity = intensity;}
-    double getEchoWidth() {return m.echo_width;}
-    void setEchoWidth(double echoWidth) {m.echo_width = echoWidth;}
-    int getReturnNumber() {return m.returnNumber;}
-    void setReturnNumber(int returnNumber) {m.returnNumber = returnNumber;}
-    int getPulseReturnNumber() {return m.pulseReturnNumber;}
-    void setPulseReturnNumber(double pulseReturnNumber)
-        {m.pulseReturnNumber = pulseReturnNumber;}
-    int getFullwaveIndex() {return m.fullwaveIndex;}
-    void setFullwaveIndex(int fullwaveIndex) {m.fullwaveIndex = fullwaveIndex;}
-    int getClassification() {return m.classification;}
-    void setClassification(int classification)
-        {m.classification = classification;}
-    long getGpsTime() {return m.gpsTime;}
-    void setGpsTime(long gpsTime) {m.gpsTime = gpsTime;}
-};
-
-}
diff --git a/src/pybinds/PyNoiseSourceWrapper.h b/src/pybinds/PyNoiseSourceWrapper.h
deleted file mode 100644
index 1e6fb7fae..000000000
--- a/src/pybinds/PyNoiseSourceWrapper.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <NoiseSource.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for NoiseSource abstract class
- *
- * @see NoiseSource
- */
-class PyNoiseSourceWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    NoiseSource<double> &ns;
-
-    // ***  CONSTRUCTION  *** //
-    // ********************** //
-    PyNoiseSourceWrapper(NoiseSource<double> &ns) : ns(ns) {}
-    virtual ~PyNoiseSourceWrapper(){}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    inline double getClipMin() {return ns.getClipMin();}
-    inline void setClipMin(double clipMin) {ns.setClipMin(clipMin);}
-    inline double getClipMax() {return ns.getClipMax();}
-    inline void setClipMax(double clipMax) {ns.setClipMax(clipMax);}
-    inline bool isEnabled() {return ns.isClipEnabled();}
-    inline void setEnabled(bool enabled) {ns.setClipEnabled(enabled);}
-    inline bool isFixedValueEnabled() {return ns.isFixedValueEnabled();}
-    inline unsigned long getFixedLifespan() {return ns.getFixedLifespan();}
-    inline void setFixedLifespan(unsigned long fixedLifespan)
-        {ns.setFixedLifespan(fixedLifespan);}
-    inline unsigned long getFixedValueRemainingUses()
-        {return ns.getFixedValueRemainingUses();}
-    inline void setFixedValueRemainingUses(unsigned long remainingUses)
-        {ns.setFixedValueRemainingUses(remainingUses);}
-    double next(){return ns.next();}
-};
-
-}
diff --git a/src/pybinds/PyPlatformWrapper.h b/src/pybinds/PyPlatformWrapper.h
deleted file mode 100644
index a7aab549b..000000000
--- a/src/pybinds/PyPlatformWrapper.h
+++ /dev/null
@@ -1,119 +0,0 @@
-#pragma once
-
-#include <PythonDVec3.h>
-#include <PyNoiseSourceWrapper.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Platform class
- */
-class PyPlatformWrapper {
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    Platform &platform;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyPlatformWrapper(Platform &platform) : platform(platform) {}
-
-    virtual ~PyPlatformWrapper() = default;
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    double getLastCheckZ() { return platform.lastCheckZ; }
-
-    void setLastCheckZ(double checkZ) { platform.lastCheckZ = checkZ; }
-
-    double getDmax() { return platform.dmax; }
-
-    void setDmax(double dmax) { platform.dmax = dmax; }
-
-    double getMovePerSec() { return platform.cfg_settings_movePerSec_m; }
-
-    void setMovePerSec(double movePerSec) { platform.cfg_settings_movePerSec_m = movePerSec; }
-
-    bool isOnGround() { return platform.onGround; }
-
-    void setOnGround(bool onGround) { platform.onGround = onGround; }
-
-    bool isStopAndTurn() { return platform.stopAndTurn; }
-
-    void setStopAndTurn(bool stopAndTurn) { platform.stopAndTurn = stopAndTurn; }
-
-    bool isSlowdownEnabled() { return platform.slowdownEnabled; }
-
-    void setSlowdownEnabled(bool slowdownEnabled) { platform.slowdownEnabled = slowdownEnabled; }
-
-    //double getYawAtDeparture() { return platform.yawAtDeparture; }
-
-    //void setYawAtDeparture(double yawAtDeparture) { platform.yawAtDeparture = yawAtDeparture; }
-
-    bool isSmoothTurn() { return platform.smoothTurn; }
-
-    void setSmoothTurn(bool smoothTurn) { platform.smoothTurn = smoothTurn; }
-
-    bool isOrientationOnLegInit() { return platform.mSetOrientationOnLegInit; }
-
-    void setOrientationOnLegInit(bool setOrientationOnLegInit) { platform.mSetOrientationOnLegInit = setOrientationOnLegInit; }
-
-    PyNoiseSourceWrapper *getPositionXNoiseSource() {
-        if (platform.positionXNoiseSource == nullptr) return nullptr;
-        return new PyNoiseSourceWrapper(*platform.positionXNoiseSource);
-    }
-
-    PyNoiseSourceWrapper *getPositionYNoiseSource() {
-        if (platform.positionYNoiseSource == nullptr) return nullptr;
-        return new PyNoiseSourceWrapper(*platform.positionYNoiseSource);
-    }
-
-    PyNoiseSourceWrapper *getPositionZNoiseSource() {
-        if (platform.positionZNoiseSource == nullptr) return nullptr;
-        return new PyNoiseSourceWrapper(*platform.positionZNoiseSource);
-    }
-
-    PyNoiseSourceWrapper *getAttitudeXNoiseSource(){
-        if(platform.attitudeXNoiseSource == nullptr) return nullptr;
-        return new PyNoiseSourceWrapper(*platform.attitudeXNoiseSource);
-    }
-
-    PyNoiseSourceWrapper *getAttitudeYNoiseSource(){
-        if(platform.attitudeYNoiseSource == nullptr) return nullptr;
-        return new PyNoiseSourceWrapper(*platform.attitudeYNoiseSource);
-    }
-
-    PyNoiseSourceWrapper *getAttitudeZNoiseSource(){
-        if(platform.attitudeZNoiseSource == nullptr) return nullptr;
-        return new PyNoiseSourceWrapper(*platform.attitudeZNoiseSource);
-    }
-
-    PythonDVec3 * getRelativePosition()
-        {return new PythonDVec3(&platform.cfg_device_relativeMountPosition);}
-    Rotation & getRelativeAttitude()
-        {return platform.cfg_device_relativeMountAttitude;}
-    PythonDVec3 * getLastGroundCheck()
-        {return new PythonDVec3(&platform.lastGroundCheck);}
-    PythonDVec3 * getNextWaypointPosition()
-        {return new PythonDVec3(&platform.targetWaypoint);}
-    PythonDVec3 * getPositionPython()
-        {return new PythonDVec3(&platform.position);}
-    Rotation & getAttitudePython()
-        {return platform.attitude;}
-    PythonDVec3 * getCachedAbsolutePosition()
-        {return new PythonDVec3(&platform.cached_absoluteMountPosition);}
-    Rotation & getCachedAbsoluteAttitude()
-        {return platform.cached_absoluteMountAttitude;}
-    PythonDVec3 * getCachedCurrentDir()
-        {return new PythonDVec3(&platform.cached_dir_current);}
-    PythonDVec3 * getCachedCurrentDirXY()
-        {return new PythonDVec3(&platform.cached_dir_current_xy);}
-    PythonDVec3 * getCachedVectorToTarget()
-        {return new PythonDVec3(&platform.cached_vectorToTarget);}
-    PythonDVec3 * getCachedVectorToTargetXY()
-        {return new PythonDVec3(&platform.cached_vectorToTarget_xy);}
-};
-
-}
diff --git a/src/pybinds/PyPrimitiveWrapper.h b/src/pybinds/PyPrimitiveWrapper.h
deleted file mode 100644
index 1ced586fb..000000000
--- a/src/pybinds/PyPrimitiveWrapper.h
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma once
-
-#include <PyScenePartWrapper.h>
-#include <PyAABBWrapper.h>
-#include <PythonDVec3.h>
-#include <PyDoubleVector.h>
-#include <PyVertexWrapper.h>
-#include <Triangle.h>
-#include <AABB.h>
-#include <Voxel.h>
-#include <DetailedVoxel.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Primitive class
- *
- * @see Primitive
- */
-class PyPrimitiveWrapper{
-public:
-    // ***  ATTRIBUTE  *** //
-    // ******************* //
-    Primitive *prim = nullptr;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyPrimitiveWrapper(Primitive *prim) : prim(prim) {}
-    virtual ~PyPrimitiveWrapper() = default;
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    PyScenePartWrapper * getScenePart()
-        {return new PyScenePartWrapper(*prim->part);}
-    Material & getMaterial()
-        {return *prim->material;}
-    PyAABBWrapper * getAABB() {return new PyAABBWrapper(prim->getAABB());}
-    PythonDVec3 * getCentroid() {return new PythonDVec3(prim->getCentroid());}
-    double getIncidenceAngle(
-        double ox, double oy, double oz,
-        double dx, double dy, double dz,
-        double px, double py, double pz
-    ){
-        glm::dvec3 origin(ox, oy, oz);
-        glm::dvec3 direction(dx, dy, dz);
-        glm::dvec3 intersectionPoint(px, py, pz);
-        return prim->getIncidenceAngle_rad(
-            origin,
-            direction,
-            intersectionPoint
-        );
-    }
-    PyDoubleVector * getRayIntersection(
-        double ox, double oy, double oz,
-        double dx, double dy, double dz
-    ){
-        glm::dvec3 origin(ox, oy, oz);
-        glm::dvec3 direction(dx, dy, dz);
-        return new PyDoubleVector(prim->getRayIntersection(origin, direction));
-    }
-    double getRayIntersectionDistance(
-        double ox, double oy, double oz,
-        double dx, double dy, double dz
-    ){
-        glm::dvec3 origin(ox, oy, oz);
-        glm::dvec3 direction(dx, dy, dz);
-        return prim->getRayIntersectionDistance(origin, direction);
-    }
-    size_t getNumVertices(){return prim->getNumVertices();}
-    PyVertexWrapper * getVertex(size_t index)
-        {return new PyVertexWrapper(prim->getVertices()+index);}
-    bool isTriangle () const
-        {return dynamic_cast<Triangle *>(prim) != nullptr;}
-    bool isAABB () const
-        {return dynamic_cast<AABB *>(prim) != nullptr;}
-    bool isVoxel () const
-        {return dynamic_cast<Voxel *>(prim) != nullptr;}
-    bool isDetailedVoxel () const
-        {return dynamic_cast<DetailedVoxel *>(prim) != nullptr;}
-    void update(){prim->update();}
-
-
-};
-
-}
diff --git a/src/pybinds/PyRandomnessGeneratorWrapper.h b/src/pybinds/PyRandomnessGeneratorWrapper.h
deleted file mode 100644
index 783c732d0..000000000
--- a/src/pybinds/PyRandomnessGeneratorWrapper.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for RandomnessGenerator class
- */
-class PyRandomnessGeneratorWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    RandomnessGenerator<double> &rg;
-
-    // ***  CONSTRUCTION  *** //
-    // ********************** //
-    PyRandomnessGeneratorWrapper(RandomnessGenerator<double> &rg) : rg(rg) {};
-    virtual ~PyRandomnessGeneratorWrapper(){}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    void computeUniformRealDistribution(double lowerBound, double upperBound)
-        {rg.computeUniformRealDistribution(lowerBound, upperBound);}
-    double uniformRealDistributionNext()
-        {return rg.uniformRealDistributionNext();}
-    void computeNormalDistribution(double mean, double stdev)
-        {return rg.computeNormalDistribution(mean, stdev);}
-    double normalDistributionNext()
-        {return rg.normalDistributionNext();}
-};
-
-}
diff --git a/src/pybinds/PyRaySceneIntersectionWrapper.h b/src/pybinds/PyRaySceneIntersectionWrapper.h
deleted file mode 100644
index 8e9d8cb8b..000000000
--- a/src/pybinds/PyRaySceneIntersectionWrapper.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include <PythonDVec3.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for RaySceneIntersection
- *
- * @see RaySceneIntersection
- */
-class PyRaySceneIntersectionWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    RaySceneIntersection * rsi;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyRaySceneIntersectionWrapper(RaySceneIntersection const rsi) :
-        rsi(new RaySceneIntersection(rsi)) {}
-    virtual ~PyRaySceneIntersectionWrapper() {delete rsi;}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    PyPrimitiveWrapper * getPrimitive()
-        {return new PyPrimitiveWrapper(rsi->prim);}
-    PythonDVec3 * getPoint()
-        {return new PythonDVec3(rsi->point);}
-    double getIncidenceAngle() {return rsi->incidenceAngle;}
-    void setIncidenceAngle(double incidenceAngle)
-        {rsi->incidenceAngle = incidenceAngle;}
-
-};
-
-}
diff --git a/src/pybinds/PyScannerWrapper.cpp b/src/pybinds/PyScannerWrapper.cpp
deleted file mode 100644
index c03943e76..000000000
--- a/src/pybinds/PyScannerWrapper.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <pybinds/PyDetectorWrapper.h>
-#include <pybinds/PyScannerWrapper.h>
-
-using namespace pyhelios;
-
-PyDetectorWrapper * PyScannerWrapper::getPyDetectorWrapper(){
-    return new PyDetectorWrapper(scanner.getDetector());
-}
-
-PyDetectorWrapper * PyScannerWrapper::getPyDetectorWrapper(size_t const idx){
-    return new PyDetectorWrapper(scanner.getDetector(idx));
-}
diff --git a/src/pybinds/PyScannerWrapper.h b/src/pybinds/PyScannerWrapper.h
deleted file mode 100644
index da492b3ac..000000000
--- a/src/pybinds/PyScannerWrapper.h
+++ /dev/null
@@ -1,455 +0,0 @@
-#pragma once
-
-#include <PythonDVec3.h>
-#include <PyBeamDeflectorWrapper.h>
-namespace pyhelios{ class PyDetectorWrapper;};
-#include <PyIntegerList.h>
-#include <PyNoiseSourceWrapper.h>
-#include <PyRandomnessGeneratorWrapper.h>
-#include <PyDoubleVector.h>
-using pyhelios::PyBeamDeflectorWrapper;
-using pyhelios::PyDetectorWrapper;
-using pyhelios::PyIntegerList;
-using pyhelios::PyNoiseSourceWrapper;
-using pyhelios::PyRandomnessGeneratorWrapper;
-using pyhelios::PyDoubleVector;
-
-#include <scanner/Scanner.h>
-#include <maths/WaveMaths.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Scanner class.
- */
-class PyScannerWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    Scanner &scanner;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyScannerWrapper(Scanner &scanner) : scanner(scanner) {}
-    virtual ~PyScannerWrapper() = default;
-
-    // ***  M E T H O D S  *** //
-    // *********************** //
-    void initializeSequentialGenerators(){
-        scanner.initializeSequentialGenerators();
-    }
-    void buildScanningPulseProcess(
-        int const parallelizationStrategy,
-        PulseTaskDropper &dropper,
-        std::shared_ptr<PulseThreadPoolInterface> pool
-    ){
-        scanner.buildScanningPulseProcess(
-            parallelizationStrategy,
-            dropper,
-            pool
-        );
-    }
-    void applySettings(std::shared_ptr<ScannerSettings> settings){
-        scanner.applySettings(settings);
-    }
-    std::shared_ptr<ScannerSettings> retrieveCurrentSettings(){
-        return scanner.retrieveCurrentSettings();
-    }
-    void applySettingsFWF(FWFSettings settings){
-        scanner.applySettingsFWF(settings);
-    }
-    void doSimStep(
-        unsigned int legIndex,
-        double currentGpsTime
-    ){
-        scanner.doSimStep(legIndex, currentGpsTime);
-    }
-    std::string toString(){
-        return scanner.toString();
-    }
-    inline void calcRaysNumber(){scanner.calcRaysNumber();}
-    inline void calcRaysNumber(size_t const idx){scanner.calcRaysNumber(idx);}
-    inline void prepareDiscretization(){scanner.prepareDiscretization();}
-    inline void prepareDiscretization(size_t const idx)
-    {scanner.prepareDiscretization(idx);}
-    int calcTimePropagation(
-        std::vector<double> & timeWave, int const numBins
-    ){
-        return WaveMaths::calcPropagationTimeLegacy(
-            timeWave,
-            numBins,
-            scanner.getFWFSettings(0).binSize_ns,
-            scanner.getPulseLength_ns(0),
-            7.0  // 3.5 too many ops., 7.0 just one op.
-        );
-    }
-    inline double calcAtmosphericAttenuation() const{
-        return scanner.calcAtmosphericAttenuation();
-    }
-    inline double calcAtmosphericAttenuation(size_t const idx) const{
-        return scanner.calcAtmosphericAttenuation(idx);
-    }
-    Rotation calcAbsoluteBeamAttitude() const{
-        return scanner.calcAbsoluteBeamAttitude();
-    }
-    inline bool checkMaxNOR(int nor) {return scanner.checkMaxNOR(nor);}
-
-
-    // ***  SIM STEP UTILS  *** //
-    // ************************ //
-    void handleSimStepNoise(
-        glm::dvec3 & absoluteBeamOrigin,
-        Rotation & absoluteBeamAttitude
-    ){
-        scanner.handleSimStepNoise(absoluteBeamOrigin, absoluteBeamAttitude);
-    }
-    inline void onLegComplete() {scanner.onLegComplete();}
-    void inline onSimulationFinished() {scanner.onSimulationFinished();}
-    void handleTrajectoryOutput(double const currentGpsTime){
-        scanner.handleTrajectoryOutput(currentGpsTime);
-    }
-    void trackOutputPath(std::string const &path){
-        scanner.trackOutputPath(path);
-    }
-
-    // *** GETTERs and SETTERs *** //
-    // *************************** //
-    inline int getCurrentPulseNumber() const {
-        return scanner.getCurrentPulseNumber();
-    }
-    inline int getCurrentPulseNumber(size_t const idx) const {
-        return scanner.getCurrentPulseNumber(idx);
-    }
-    inline int getNumRays() const {
-        return scanner.getNumRays();
-    }
-    inline int getNumRays(size_t const idx) const{
-        return scanner.getNumRays(idx);
-    }
-    inline void setNumRays(int const numRays) {
-        scanner.setNumRays(numRays);
-    }
-    inline void setNumRays(int const numRays, size_t const idx){
-        scanner.setNumRays(numRays, idx);
-    }
-    inline int getPulseFreq_Hz() const {
-        return scanner.getPulseFreq_Hz();
-    }
-    void setPulseFreq_Hz(int const pulseFreq_Hz){
-        scanner.setPulseFreq_Hz(pulseFreq_Hz);
-    }
-    double getPulseLength_ns(size_t const idx){
-        return scanner.getPulseLength_ns(idx);
-    }
-    inline double getPulseLength_ns() const {
-        return scanner.getPulseLength_ns(0);
-    }
-    void setPulseLength_ns(
-        double const pulseLength_ns, size_t const idx
-    ){
-        scanner.setPulseLength_ns(pulseLength_ns, idx);
-    }
-    inline void setPulseLength_ns(double const pulseLength_ns){
-        scanner.setPulseLength_ns(pulseLength_ns, 0);
-    }
-    inline bool lastPulseWasHit() const {
-        return scanner.lastPulseWasHit();
-    }
-    inline bool getLastPulseWasHit(size_t const idx) const {
-        return scanner.lastPulseWasHit(idx);
-    }
-    void setLastPulseWasHit(bool const lastPulseWasHit){
-        scanner.setLastPulseWasHit(lastPulseWasHit);
-    }
-    void setLastPulseWasHit(bool const lastPulseWasHit, size_t const idx){
-        scanner.setLastPulseWasHit(lastPulseWasHit, idx);
-    }
-    double getBeamDivergence(size_t const idx) const{
-        return scanner.getBeamDivergence(idx);
-    }
-    inline double getBeamDivergence() const {
-        return scanner.getBeamDivergence(0);
-    }
-    void setBeamDivergence(
-        double const beamDivergence, size_t const idx
-    ){
-        scanner.setBeamDivergence(beamDivergence, idx);
-    }
-    inline void setBeamDivergence(double const beamDivergence){
-        scanner.setBeamDivergence(beamDivergence, 0);
-    }
-    double getAveragePower(size_t const idx) const{
-        return scanner.getAveragePower(idx);
-    }
-    inline double getAveragePower() const {
-        return scanner.getAveragePower(0);
-    }
-    void setAveragePower(
-        double const averagePower, size_t const idx
-    ){
-        scanner.setAveragePower(averagePower, idx);
-    }
-    inline void setAveragePower(double const averagePower){
-        scanner.setAveragePower(averagePower, 0);
-    }
-    double getBeamQuality(size_t const idx) const{
-        return scanner.getBeamQuality(idx);
-    }
-    inline double getBeamQuality() const {
-        return scanner.getBeamQuality(0);
-    }
-    void setBeamQuality(
-        double const beamQuality, size_t const idx
-    ){
-        scanner.setBeamQuality(beamQuality, idx);
-    }
-    inline void setBeamQuality(double const beamQuality){
-        scanner.setBeamQuality(beamQuality, 0);
-    }
-    double getEfficiency(size_t const idx) const{
-        return scanner.getEfficiency(idx);
-    }
-    inline double getEfficiency() const {
-        return scanner.getEfficiency(0);
-    }
-    void setEfficiency(double const efficiency, size_t const idx=0){
-        scanner.setEfficiency(efficiency, idx);
-    }
-    inline void setEfficiency(double const efficiency){
-        scanner.setEfficiency(efficiency, 0);
-    }
-    double getReceiverDiameter(size_t const idx) const{
-        return scanner.getReceiverDiameter(idx);
-    }
-    inline double getReceiverDiameter() const {
-        return scanner.getReceiverDiameter(0);
-    }
-    void setReceiverDiameter(
-        double const receiverDiameter, size_t const idx
-    ){
-        scanner.setReceiverDiameter(receiverDiameter, idx);
-    }
-    inline void setReceiverDiameter(double const receiverDiameter)
-    {setReceiverDiameter(receiverDiameter, 0);}
-    double getVisibility(size_t const idx) const{
-        return scanner.getVisibility(idx);
-    }
-    inline double getVisibility() const{return scanner.getVisibility(0);}
-    void setVisibility(double const visibility, size_t const idx){
-        scanner.setVisibility(visibility, idx);
-    }
-    inline void setVisibility(double const visibility)
-    {setVisibility(visibility, 0);}
-    double getWavelength(size_t const idx) const{
-        return scanner.getWavelength();
-    }
-    inline double getWavelength() const {
-        return scanner.getWavelength(0);
-    }
-    void setWavelength(double const wavelength, size_t const idx){
-        scanner.setWavelength(wavelength, idx);
-    }
-    inline void setWavelength(double const wavelength){
-        scanner.setWavelength(wavelength, 0);
-    }
-    double getAtmosphericExtinction(size_t const idx) const{
-        return scanner.getAtmosphericExtinction(idx);
-    }
-    inline double getAtmosphericExtinction() const{
-        return scanner.getAtmosphericExtinction(0);
-    }
-    void setAtmosphericExtinction(
-        double const atmosphericExtinction,
-        size_t const idx
-    ){
-        scanner.setAtmosphericExtinction(atmosphericExtinction, idx);
-    }
-    inline void setAtmosphericExtinction(double const atmosphericExtinction){
-        scanner.setAtmosphericExtinction(atmosphericExtinction, 0);
-    }
-    double getBeamWaistRadius(size_t const idx) const{
-        return scanner.getBeamWaistRadius(idx);
-    }
-    inline double getBeamWaistRadius() const {
-        return scanner.getBeamWaistRadius(0);
-    }
-    void setBeamWaistRadius(
-        double const beamWaistRadius, size_t const idx
-    ){
-        return scanner.setBeamWaistRadius(beamWaistRadius, idx);
-    }
-    inline void setBeamWaistRadius(double const beamWaistRadius){
-        scanner.setBeamWaistRadius(beamWaistRadius, 0);
-    }
-    inline int getMaxNOR(size_t const idx) const
-        {return scanner.getMaxNOR(idx);}
-    inline int getMaxNOR() const {return scanner.getMaxNOR(0);}
-    inline void setMaxNOR(int const maxNOR, size_t const idx)
-        {scanner.setMaxNOR(maxNOR, idx);}
-    inline void setMaxNOR(int const maxNOR) {scanner.setMaxNOR(maxNOR);}
-    glm::dvec3 getHeadRelativeEmitterPosition(
-        size_t const idx
-    ) const{
-        return scanner.getHeadRelativeEmitterPosition(idx);
-    }
-    void setHeadRelativeEmitterPosition(
-        glm::dvec3 const &pos, size_t const idx
-    ){
-        scanner.setHeadRelativeEmitterPosition(pos, idx);
-    }
-    Rotation getHeadRelativeEmitterAttitude(size_t const idx) const{
-        return scanner.getHeadRelativeEmitterAttitude(idx);
-    }
-    void setHeadRelativeEmitterAttitude(
-        Rotation const &attitude, size_t const idx
-    ){
-        scanner.setHeadRelativeEmitterAttitude(attitude, idx);
-    }
-    double getBt2(size_t const idx) const{
-        return scanner.getBt2(idx);
-    }
-    inline double getBt2() const {
-        return scanner.getBt2(0);
-    }
-    void setBt2(double const bt2, size_t const idx){
-        scanner.setBt2(bt2, idx);
-    }
-    inline void setBt2(double const bt2) {
-        scanner.setBt2(bt2, 0);
-    }
-    double getDr2(size_t const idx) const{
-        return scanner.getDr2(idx);
-    }
-    inline double getDr2() const {
-        return scanner.getDr2(0);
-    }
-    void setDr2(double const dr2, size_t const idx){
-        scanner.setDr2(dr2, idx);
-    }
-    inline void setDr2(double const dr2) {
-        scanner.setDr2(dr2, 0);
-    }
-    inline bool isActive() const {
-        return scanner.isActive();
-    }
-    inline void setActive(bool const active) {
-        scanner.setActive(active);
-    }
-    inline bool isWriteWaveform() const {
-        return scanner.isWriteWaveform();
-    }
-    inline void setWriteWaveform(bool const writeWaveform){
-        scanner.setWriteWaveform(writeWaveform);
-    }
-    inline bool isCalcEchowidth() const {
-        return scanner.isCalcEchowidth();
-    }
-    inline void setCalcEchowidth(bool const calcEchowidth){
-        scanner.setCalcEchowidth(calcEchowidth);
-    }
-    inline bool isFullWaveNoise() const {
-        return scanner.isFullWaveNoise();
-    }
-    inline void setFullWaveNoise(bool const fullWaveNoise){
-        scanner.setFullWaveNoise(fullWaveNoise);
-    }
-    inline bool isPlatformNoiseDisabled() {
-        return scanner.isPlatformNoiseDisabled();
-    }
-    inline void setPlatformNoiseDisabled(bool const platformNoiseDisabled){
-        scanner.setPlatformNoiseDisabled(platformNoiseDisabled);
-    }
-    inline bool isFixedIncidenceAngle() const {
-        return scanner.isFixedIncidenceAngle();
-    }
-    inline void setFixedIncidenceAngle(bool const fixedIncidenceAngle){
-        scanner.setFixedIncidenceAngle(fixedIncidenceAngle);
-    }
-    inline std::string getScannerId() const {
-        return scanner.getScannerId();
-    }
-    inline void setScannerId(std::string const &id) {
-        scanner.setScannerId(id);
-    }
-    std::string getDeviceId(size_t const idx) const{
-        return scanner.getDeviceId(idx);
-    }
-    inline std::string getDeviceId() const {
-        return scanner.getDeviceId(0);
-    }
-    void setDeviceId(std::string const deviceId, size_t const idx){
-        scanner.setDeviceId(deviceId, idx);
-    }
-    inline void setDeviceId(std::string const deviceId){
-        scanner.setDeviceId(deviceId, 0);
-    }
-    size_t getNumDevices(){
-        return scanner.getNumDevices();
-    }
-
-    // ***  PyScannerWrapper ADHOC  *** //
-    // ******************************** //
-    ScannerHead & getScannerHead(){return *scanner.getScannerHead();}
-    ScannerHead & getScannerHead(size_t const idx)
-    {return *scanner.getScannerHead(idx);}
-    PyBeamDeflectorWrapper * getPyBeamDeflector()
-    {return new PyBeamDeflectorWrapper(scanner.getBeamDeflector());}
-    PyBeamDeflectorWrapper * getPyBeamDeflector(size_t const idx)
-    {return new PyBeamDeflectorWrapper(scanner.getBeamDeflector(idx));}
-    PyDetectorWrapper * getPyDetectorWrapper();
-    PyDetectorWrapper * getPyDetectorWrapper(size_t const idx);
-    PyIntegerList * getSupportedPulseFrequencies()
-    {return new PyIntegerList(scanner.getSupportedPulseFreqs_Hz());}
-    PyIntegerList * getSupportedPulseFrequencies(size_t const idx)
-    {return new PyIntegerList(scanner.getSupportedPulseFreqs_Hz(idx));}
-    Rotation & getRelativeAttitudeByReference(size_t const idx){
-        return scanner.getHeadRelativeEmitterAttitudeByRef(idx);
-    }
-    Rotation & getRelativeAttitudeByReference(){
-        return scanner.getHeadRelativeEmitterAttitudeByRef(0);
-    }
-    PythonDVec3 * getRelativePosition(size_t const idx){
-        return new PythonDVec3(
-            scanner.getHeadRelativeEmitterPositionByRef(idx)
-        );
-    }
-    PythonDVec3 * getRelativePosition(){
-        return new PythonDVec3(scanner.getHeadRelativeEmitterPositionByRef(0));
-    }
-    PyNoiseSourceWrapper * getIntersectionHandlingNoiseSource(){
-        if(scanner.intersectionHandlingNoiseSource == nullptr) return nullptr;
-        return new PyNoiseSourceWrapper(
-            *scanner.intersectionHandlingNoiseSource
-        );
-    }
-    PyRandomnessGeneratorWrapper * getRandGen1(){
-        if(scanner.randGen1 == nullptr) return nullptr;
-        return new PyRandomnessGeneratorWrapper(*scanner.randGen1);
-    }
-    PyRandomnessGeneratorWrapper * getRandGen2(){
-        if(scanner.randGen2 == nullptr) return nullptr;
-        return new PyRandomnessGeneratorWrapper(*scanner.randGen2);
-    }
-    PyDoubleVector * getTimeWave(){
-        return new PyDoubleVector(scanner.getTimeWave());
-    }
-    FWFSettings getFWFSettings() {return scanner.getFWFSettings();}
-    void setFWFSettings(FWFSettings const &fwfSettings)
-    {scanner.setFWFSettings(fwfSettings);}
-    int getNumTimeBins() {return scanner.getNumTimeBins();}
-    void setNumTimeBins(int const numTimeBins)
-    {scanner.setNumTimeBins(numTimeBins);}
-    int getPeakIntensityIndex() {return scanner.getPeakIntensityIndex();}
-    void setPeakIntensityIndex(int const peakIntensityIndex)
-    {scanner.setPeakIntensityIndex(peakIntensityIndex);}
-    double getTrajectoryTimeInterval()
-    {return scanner.trajectoryTimeInterval_ns;}
-    void setTrajectoryTimeInterval(double const trajectoryTimeInterval_ns){
-        scanner.trajectoryTimeInterval_ns = trajectoryTimeInterval_ns;
-    }
-
-};
-
-}
diff --git a/src/pybinds/PyScanningStripWrapper.h b/src/pybinds/PyScanningStripWrapper.h
deleted file mode 100644
index 494dc9a8b..000000000
--- a/src/pybinds/PyScanningStripWrapper.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include <ScanningStrip.h>
-
-#include <memory>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for ScanningStrip class
- * @see ScanningStrip
- */
-class PyScanningStripWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    std::shared_ptr<ScanningStrip> ss = nullptr;
-
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyScanningStripWrapper(std::shared_ptr<ScanningStrip> ss) : ss(ss) {}
-    virtual ~PyScanningStripWrapper() = default;
-
-
-    // ***  GETTERs and SETTERs  *** //
-    // ***************************** //
-    inline std::string getStripId() {return ss->getStripId();}
-    inline void setStripId(std::string const stripId){ss->setStripId(stripId);}
-    /**
-     * @brief Like the ScanningStrip::getLeg but obtaining the leg by reference
-     * @see ScanningStrip::getLeg
-     */
-    inline Leg & getLegRef(int const serialId) {return *ss->getLeg(serialId);}
-    inline bool isLastLegInStrip() {return ss->isLastLegInStrip();}
-    inline bool has(int const serialId) {return ss->has(serialId);}
-    inline bool has(Leg &leg){return ss->has(leg);}
-
-};
-
-}
diff --git a/src/pybinds/PyScenePartWrapper.cpp b/src/pybinds/PyScenePartWrapper.cpp
deleted file mode 100644
index be510c3a7..000000000
--- a/src/pybinds/PyScenePartWrapper.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <PyScenePartWrapper.h>
-#include <PyHeliosException.h>
-#include <PyPrimitiveWrapper.h>
-#include <Primitive.h>
-
-using pyhelios::PyScenePartWrapper;
-using pyhelios::PyPrimitiveWrapper;
-
-// ***   UTIL METHODS   *** //
-// ************************ //
-void PyScenePartWrapper::translate(double const x, double const y, double const z){
-    glm::dvec3 const v(x, y, z);
-    for(Primitive *p : sp.mPrimitives) p->translate(v);
-}
-
-// ***  GETTERs and SETTERs  *** //
-// ***************************** //
-PyPrimitiveWrapper * PyScenePartWrapper::getPrimitive(size_t const index){
-    return new PyPrimitiveWrapper(sp.mPrimitives[index]);
-}
-
-// ***  INTERNAL USE  *** //
-// ********************** //
-DynObject & PyScenePartWrapper::_asDynObject(){
-    try{
-        return dynamic_cast<DynObject&>(sp);
-    }
-    catch(std::exception &ex){
-        throw PyHeliosException(
-            "Failed to retrieve scene part as dynamic object"
-        );
-    }
-}
-DynMovingObject & PyScenePartWrapper::_asDynMovingObject(){
-    try{
-        return dynamic_cast<DynMovingObject&>(sp);
-    }
-    catch(std::exception &ex){
-        throw PyHeliosException(
-            "Failed to retrieve scene part as dynamic moving object"
-        );
-    }
-}
diff --git a/src/pybinds/PyScenePartWrapper.h b/src/pybinds/PyScenePartWrapper.h
deleted file mode 100644
index ef15bba02..000000000
--- a/src/pybinds/PyScenePartWrapper.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#pragma once
-
-#include <string>
-#include <PythonDVec3.h>
-#include <ScenePart.h>
-#include <DynMovingObject.h>
-#include <pybinds/PyAABBWrapper.h>
-
-
-namespace pyhelios{
-
-class PyPrimitiveWrapper;
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for ScenePart class
- *
- * @see ScenePart
- */
-class PyScenePartWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    ScenePart &sp;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyScenePartWrapper(ScenePart &sp) : sp(sp) {}
-    virtual ~PyScenePartWrapper() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    std::string getId() {return sp.mId;};
-    void setId(std::string id) {sp.mId = id;}
-    PythonDVec3 * getOrigin() {return new PythonDVec3(sp.mOrigin);}
-    void setOrigin(double x, double y, double z)
-    {sp.mOrigin = glm::dvec3(x, y, z);}
-    Rotation & getRotation() {return sp.mRotation;}
-    void setRotation(double x, double y, double z, double angle)
-    {sp.mRotation = Rotation(glm::dvec3(x, y, z), angle);}
-    double getScale() {return sp.mScale;}
-    void setScale(double scale) {sp.mScale = scale;}
-    bool isDynamicMovingObject()
-    {return sp.getType() == ScenePart::ObjectType::DYN_MOVING_OBJECT;}
-    size_t getDynObjectStep() {return _asDynObject().getStepInterval();}
-    void setDynObjectStep(size_t const stepInterval)
-    {return _asDynObject().setStepInterval(stepInterval);}
-    size_t getObserverStep()
-    {return _asDynMovingObject().getObserverStepInterval();}
-    void setObserverStep(size_t const stepInterval)
-    {_asDynMovingObject().setObserverStepInterval(stepInterval);}
-    PyPrimitiveWrapper * getPrimitive(size_t const index);
-    size_t getNumPrimitives() const {return sp.mPrimitives.size();}
-    PythonDVec3 * getCentroid() {return new PythonDVec3(sp.centroid);}
-    PyAABBWrapper * getBound() {return new PyAABBWrapper(sp.bound.get());}
-
-    // ***   UTIL METHODS   *** //
-    // ************************ //
-    void computeCentroid(bool const computeBound=false)
-    {sp.computeCentroid(computeBound);}
-    void computeBound() {sp.computeCentroid(true);}
-    void translate(double const x, double const y, double const z);
-
-
-
-
-    // ***  INTERNAL USE  *** //
-    // ********************** //
-    /**
-     * @brief Obtain the scene part as a dynamic object. Use with caution as
-     *  it might throw an exception
-     */
-    DynObject & _asDynObject();
-    /**
-     * @brief Obtain the scene part as a dynamic moving object. Use with
-     *  caution as it might throw an exception
-     */
-    DynMovingObject & _asDynMovingObject();
-};
-
-}
diff --git a/src/pybinds/PySceneWrapper.cpp b/src/pybinds/PySceneWrapper.cpp
deleted file mode 100644
index ae4dda37a..000000000
--- a/src/pybinds/PySceneWrapper.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <PySceneWrapper.h>
-#include <PyHeliosException.h>
-
-using pyhelios::PySceneWrapper;
-
-// ***   METHODS   *** //
-// ******************* //
-void PySceneWrapper::translate(double const x, double const y, double const z){
-    glm::dvec3 const v(x, y, z);
-    for(Primitive *p : scene.primitives) p->translate(v);
-}
-
-// ***  INTERNAL USE  *** //
-// ********************** //
-DynScene & PySceneWrapper::_asDynScene(){
-    try{
-        return dynamic_cast<DynScene &>(scene);
-    }
-    catch(std::exception &ex){
-        throw PyHeliosException(
-            "Failed to obtain scene as dynamic scene"
-        );
-    }
-}
diff --git a/src/pybinds/PySceneWrapper.h b/src/pybinds/PySceneWrapper.h
deleted file mode 100644
index 45450596d..000000000
--- a/src/pybinds/PySceneWrapper.h
+++ /dev/null
@@ -1,99 +0,0 @@
-#pragma once
-
-#include <string>
-#include <Triangle.h>
-#include <DetailedVoxel.h>
-#include <AABB.h>
-#include <Scene.h>
-#include <DynScene.h>
-#include <PyPrimitiveWrapper.h>
-#include <PyTriangleWrapper.h>
-#include <PyDetailedVoxelWrapper.h>
-#include <PyAABBWrapper.h>
-#include <PyRaySceneIntersectionWrapper.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Scene
- *
- * @see Scene
- */
-class PySceneWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    Scene &scene;
-
-    // ***  CONSTRUCTOR / DESTRUCTOR  *** //
-    // ********************************** //
-    PySceneWrapper(Scene &scene) : scene(scene) {}
-    virtual ~PySceneWrapper() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    PyTriangleWrapper * newTriangle(){
-        Vertex v;
-        v.pos[0] = 0.0;     v.pos[1] = 0.0;     v.pos[2] = 0.0;
-        Triangle * tri = new Triangle(v, v, v);
-        scene.primitives.push_back(tri);
-        return new PyTriangleWrapper(tri);
-    }
-    PyDetailedVoxelWrapper * newDetailedVoxel(){
-        std::vector<int> vi({0, 0});
-        std::vector<double> vd({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
-        DetailedVoxel *dv = new DetailedVoxel(0.0, 0.0, 0.0, 0.5, vi, vd);
-        scene.primitives.push_back(dv);
-        return new PyDetailedVoxelWrapper(dv);
-    }
-    PyPrimitiveWrapper * getPrimitive(size_t const index)
-        {return new PyPrimitiveWrapper(scene.primitives[index]);}
-    size_t getNumPrimitives() const {return scene.primitives.size();}
-    PyAABBWrapper * getAABB()
-        {return new PyAABBWrapper(scene.getAABB().get());}
-    PythonDVec3 * getGroundPointAt(double x, double y, double z){
-        glm::dvec3 gp = glm::dvec3(x, y, z);
-        return new PythonDVec3(gp);
-    }
-    PyRaySceneIntersectionWrapper * getIntersection(
-        double ox, double oy, double oz, // Origin
-        double dx, double dy, double dz, // Direction
-        bool groundOnly
-    ){
-        glm::dvec3 origin(ox, oy, oz);
-        glm::dvec3 direction(dx, dy, dz);
-        return new PyRaySceneIntersectionWrapper(
-            *scene.getIntersection(origin, direction, groundOnly)
-        );
-    }
-    PythonDVec3 * getShift(){return new PythonDVec3(scene.getShift());}
-    size_t getNumSceneParts(){return scene.parts.size();}
-    PyScenePartWrapper * getScenePart(size_t const i)
-    {return new PyScenePartWrapper(*scene.parts[i]);}
-    size_t getDynSceneStep(){return _asDynScene().getStepInterval();}
-    void setDynSceneStep(size_t const stepInterval)
-    {_asDynScene().setStepInterval(stepInterval);}
-    PyAABBWrapper * getBBox()
-    {return new PyAABBWrapper(scene.getBBox().get());}
-    PyAABBWrapper * getBBoxCRS()
-    {return new PyAABBWrapper(scene.getBBoxCRS().get());}
-
-
-    // ***  M E T H O D S  *** //
-    // *********************** //
-    bool finalizeLoading() {return scene.finalizeLoading();}
-    void writeObject(std::string path) {scene.writeObject(path);}
-    void translate(double const x, double const y, double const z);
-
-    // ***  INTERNAL USE  *** //
-    // ********************** //
-    /**
-     * @brief Obtain the scene as a dynamic scene if possible. Use with caution
-     *  because an exception can be thrown if the scene is not dynamic.
-     */
-    DynScene & _asDynScene();
-};
-
-}
diff --git a/src/pybinds/PySimulationCycleCallback.h b/src/pybinds/PySimulationCycleCallback.h
deleted file mode 100644
index f12b9ee1e..000000000
--- a/src/pybinds/PySimulationCycleCallback.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include <SimulationCycleCallback.h>
-#include <PyHeliosOutputWrapper.h>
-#include <boost/python.hpp>
-
-using boost::ref;
-using boost::python::call;
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Python callback for each simulation cycle that has been completed
- *
- * @see PyHeliosOutputWrapper
- */
-class PySimulationCycleCallback : public SimulationCycleCallback {
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    PyObject *pyCallback;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PySimulationCycleCallback(PyObject *pyCallback) : pyCallback(pyCallback) {}
-    ~PySimulationCycleCallback() override {}
-
-    // ***  F U N C T O R  *** //
-    // *********************** //
-    void operator() (
-        std::vector<Measurement> &measurements,
-        std::vector<Trajectory> &trajectories,
-        std::string const &outpath
-    ) override {
-        PyHeliosOutputWrapper phow(
-            measurements,
-            trajectories,
-            outpath,
-            std::vector<std::string>{outpath},
-            false
-        );
-        PyGILState_STATE gilState = PyGILState_Ensure();
-        call<void>(pyCallback, ref(phow));
-        PyGILState_Release(gilState);
-    }
-
-};
-
-}
diff --git a/src/pybinds/PyStringVector.h b/src/pybinds/PyStringVector.h
deleted file mode 100644
index b3ab51ecb..000000000
--- a/src/pybinds/PyStringVector.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <PyHeliosUtils.h>
-#include <vector>
-#include <string>
-
-namespace pyhelios{
-
-
-class PyStringVector{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    std::vector<std::string> *vec = nullptr;
-    bool release = true;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyStringVector(std::vector<std::string> *vec) : vec(vec), release(false) {}
-    PyStringVector(std::vector<std::string> const vec){
-        this->vec = new std::vector<std::string>(vec);
-        release = true;
-    }
-    virtual ~PyStringVector(){if(release && vec != nullptr) free(vec);}
-
-    // ***  GETTERs and SETTERs  *** //
-    // ***************************** //
-    std::string get(long _index){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, vec->size());
-        return (*vec)[index];
-    }
-    void set(long _index, std::string value){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, vec->size());
-        (*vec)[index] = value;
-    }
-    void insert(std::string value){vec->push_back(value);}
-    void erase(long _index){
-        size_t index = PyHeliosUtils::handlePythonIndex(_index, vec->size());
-        vec->erase(vec->begin() + index);
-    }
-    size_t length() {return vec->size();}
-};
-
-}
diff --git a/src/pybinds/PyTrajectoryVectorWrapper.h b/src/pybinds/PyTrajectoryVectorWrapper.h
deleted file mode 100644
index 6cb68f54b..000000000
--- a/src/pybinds/PyTrajectoryVectorWrapper.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include <PyTrajectoryWrapper.h>
-#include <PyHeliosUtils.h>
-#include <vector>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Python wrapper for helios trajectory
- *
- * @see PyTrajectoryWrapper
- * @see PyHeliosOutputWrapper
- */
-class PyTrajectoryVectorWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    std::vector<Trajectory> allTrajectories;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyTrajectoryVectorWrapper(std::vector<Trajectory> &allTrajectories) :
-        allTrajectories(allTrajectories) {}
-    virtual ~PyTrajectoryVectorWrapper() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    PyTrajectoryWrapper * get(size_t index){
-        return new PyTrajectoryWrapper(
-            allTrajectories[
-                PyHeliosUtils::handlePythonIndex(index, allTrajectories.size())
-            ]
-        );
-    }
-    void erase(size_t index){
-        allTrajectories.erase(
-            allTrajectories.begin() +
-            PyHeliosUtils::handlePythonIndex(index, allTrajectories.size())
-        );
-    }
-    size_t length() {return allTrajectories.size();}
-};
-
-}
diff --git a/src/pybinds/PyTrajectoryWrapper.h b/src/pybinds/PyTrajectoryWrapper.h
deleted file mode 100644
index 8429fc3d7..000000000
--- a/src/pybinds/PyTrajectoryWrapper.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include <Trajectory.h>
-#include <PythonDVec3.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Trajectory class
- *
- * @see Trajectory
- * @see PyTrajectoryVectorWrapper
- */
-
-class PyTrajectoryWrapper{
-public:
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-    Trajectory &t;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyTrajectoryWrapper(Trajectory &t) : t(t) {}
-    virtual ~PyTrajectoryWrapper() {}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    long getGpsTime() {return t.gpsTime;}
-    void setGpsTime(long gpsTime) {t.gpsTime = gpsTime;}
-    PythonDVec3 *getPosition() {return new PythonDVec3(t.position);}
-    void setPosition(double x, double y, double z)
-        {t.position = glm::dvec3(x, y, z);}
-    double getRoll() {return t.roll;}
-    void setRoll(double roll) {t.roll = roll;}
-    double getPitch() {return t.pitch;}
-    void setPitch(double pitch) {t.pitch = pitch;}
-    double getYaw() {return t.yaw;}
-    void setYaw(double yaw) {t.yaw = yaw;}
-};
-
-}
diff --git a/src/pybinds/PyTriangleWrapper.h b/src/pybinds/PyTriangleWrapper.h
deleted file mode 100644
index 424fac52a..000000000
--- a/src/pybinds/PyTriangleWrapper.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <PyPrimitiveWrapper.h>
-#include <Triangle.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Triangle class
- *
- * @see Triangle
- */
-class PyTriangleWrapper : public PyPrimitiveWrapper {
-public:
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyTriangleWrapper(Triangle * tri) : PyPrimitiveWrapper(tri) {}
-    ~PyTriangleWrapper() override = default;
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    inline PythonDVec3 * getFaceNormal()
-        {return new PythonDVec3( ((Triangle *) prim)->getFaceNormal() ); }
-    // ***  TO STRING  *** //
-    // ******************* //
-    inline std::string toString(){return ((Triangle *) prim)->toString();}
-};
-
-}
diff --git a/src/pybinds/PyVertexWrapper.h b/src/pybinds/PyVertexWrapper.h
deleted file mode 100644
index d27ffd335..000000000
--- a/src/pybinds/PyVertexWrapper.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma once
-
-#include <Vertex.h>
-#include <PythonDVec3.h>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- * @brief Wrapper for Vertex class
- *
- * @see Vertex
- */
-class PyVertexWrapper{
-public:
-    // ***  ATTRIBUTE  *** //
-    // ******************* //
-    Vertex *v;
-    bool release = true;
-
-    // ***  CONSTRUCTION / DESTRUCTION  *** //
-    // ************************************ //
-    PyVertexWrapper(Vertex *v){
-        this->v = v;
-        release = false;
-    }
-    PyVertexWrapper(Vertex const v){
-        this->v = new Vertex(v);
-        release = true;
-    }
-    virtual ~PyVertexWrapper(){}
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    PythonDVec3 * getPosition() {return new PythonDVec3(&v->pos);}
-    PythonDVec3 * getNormal() {return new PythonDVec3(&v->normal);}
-};
-
-}
diff --git a/src/pybinds/PythonDVec3.h b/src/pybinds/PythonDVec3.h
deleted file mode 100644
index b63da1f88..000000000
--- a/src/pybinds/PythonDVec3.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include <glm/glm.hpp>
-#include <memory>
-#include <armadillo>
-
-namespace pyhelios{
-
-/**
- * @author Alberto M. Esmoris Pena
- * @version 1.0
- *
- * @brief Wrapper to communicate glm::dvec3 with python
- */
-class PythonDVec3 {
-    // ***  ATTRIBUTES  *** //
-    // ******************** //
-private:
-    bool release = 1;
-
-public:
-    glm::dvec3 * v = nullptr;
-
-    // ***  CONSTRUCTION  *** //
-    // ********************** //
-    PythonDVec3(glm::dvec3 const v) {
-        this->v = new glm::dvec3(v);
-        release = true;
-    }
-    PythonDVec3(glm::dvec3 *v){
-        this->v = v;
-        release = false;
-    }
-    PythonDVec3(arma::colvec const v){
-        this->v = new glm::dvec3(v[0], v[1], v[2]);
-        release = true;
-    }
-    virtual ~PythonDVec3(){
-        if(release && v!=nullptr) delete v;
-    }
-
-    // ***  GETTERS and SETTERS  *** //
-    // ***************************** //
-    double getX() {return v->x;}
-    void setX(double x) {v->x = x;}
-    double getY() {return v->y;}
-    void setY(double y) {v->y = y;}
-    double getZ() {return v->z;}
-    void setZ(double z) {v->z = z;}
-
-};
-
-}
diff --git a/src/python/AbstractBeamDeflectorWrap.h b/src/python/AbstractBeamDeflectorWrap.h
new file mode 100644
index 000000000..61a299466
--- /dev/null
+++ b/src/python/AbstractBeamDeflectorWrap.h
@@ -0,0 +1,34 @@
+#include <pybind11/pybind11.h>
+
+#include <scanner/beamDeflector/AbstractBeamDeflector.h>
+
+class AbstractBeamDeflectorWrap : public AbstractBeamDeflector {
+public:
+    using AbstractBeamDeflector::AbstractBeamDeflector;
+
+    std::shared_ptr<AbstractBeamDeflector> clone() override {
+        PYBIND11_OVERRIDE_PURE(
+            std::shared_ptr<AbstractBeamDeflector>,  // Return type
+            AbstractBeamDeflector,                  // Parent class
+            clone                                  // Function name
+        );
+    }
+
+    void doSimStep() override {
+        PYBIND11_OVERRIDE_PURE(
+            void,                   // Return type
+            AbstractBeamDeflector,  // Parent class
+            doSimStep               // Function name
+        );
+    }
+
+    std::string getOpticsType() const override {
+        PYBIND11_OVERRIDE_PURE(
+            std::string,            // Return type
+            AbstractBeamDeflector,  // Parent class
+            getOpticsType           // Function name
+        );
+    }
+    
+
+};
\ No newline at end of file
diff --git a/src/python/AbstractDetectorWrap.h b/src/python/AbstractDetectorWrap.h
new file mode 100644
index 000000000..33f5b2cd5
--- /dev/null
+++ b/src/python/AbstractDetectorWrap.h
@@ -0,0 +1,29 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <memory>
+#include <scanner/detector/AbstractDetector.h>
+
+// Trampoline class
+class AbstractDetectorWrap : public AbstractDetector {
+public:
+    using AbstractDetector::AbstractDetector;  // Inherit constructors
+
+    // Override the pure virtual function clone()
+    std::shared_ptr<AbstractDetector> clone() override {
+        PYBIND11_OVERRIDE_PURE(
+            std::shared_ptr<AbstractDetector>,  // Return type
+            AbstractDetector,                   // Parent class
+            clone,                              // Function name
+        );
+    }
+
+    // Override any other virtual functions if necessary
+    void _clone(std::shared_ptr<AbstractDetector> ad) override {
+        PYBIND11_OVERRIDE(
+            void,                                // Return type
+            AbstractDetector,                    // Parent class
+            _clone,                              // Function name
+            ad                                   // Arguments
+        );
+    }
+};
diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt
new file mode 100755
index 000000000..711c9d06a
--- /dev/null
+++ b/src/python/CMakeLists.txt
@@ -0,0 +1,13 @@
+if(BUILD_PYTHON)
+  target_include_directories(
+    _helios
+    PUBLIC
+    ${CMAKE_SOURCE_DIR}/src
+  )
+
+  target_sources(
+    _helios
+    PRIVATE
+    "PyHeliosSimulation.cpp"
+  )  
+endif()
\ No newline at end of file
diff --git a/src/python/EnergyModelWrap.h b/src/python/EnergyModelWrap.h
new file mode 100644
index 000000000..ca396fe09
--- /dev/null
+++ b/src/python/EnergyModelWrap.h
@@ -0,0 +1,34 @@
+#include <pybind11/pybind11.h>
+#include <memory>
+#include <vector>
+#include "EnergyModel.h"  // Include your EnergyModel header
+#include "ScanningDevice.h"  // Include your ScanningDevice header
+
+namespace py = pybind11;
+
+class EnergyModelWrap : public EnergyModel {
+public:
+    // Constructor for wrapping
+    EnergyModelWrap(ScanningDevice const &sd) : EnergyModel(sd) {}
+
+    // Implement all pure virtual methods
+    double computeIntensity(double const incidenceAngle, double const targetRange, Material const &mat, int const subrayRadiusStep) override {
+        PYBIND11_OVERLOAD_PURE(double, EnergyModel, computeIntensity, incidenceAngle, targetRange, mat, subrayRadiusStep);
+    }
+
+    double computeReceivedPower(ModelArg const &args) override {
+        PYBIND11_OVERLOAD_PURE(double, EnergyModel, computeReceivedPower, args);
+    }
+
+    double computeEmittedPower(ModelArg const &args) override {
+        PYBIND11_OVERLOAD_PURE(double, EnergyModel, computeEmittedPower, args);
+    }
+
+    double computeTargetArea(ModelArg const &args) override {
+        PYBIND11_OVERLOAD_PURE(double, EnergyModel, computeTargetArea, args);
+    }
+
+    double computeCrossSection(ModelArg const &args) override {
+        PYBIND11_OVERLOAD_PURE(double, EnergyModel, computeCrossSection, args);
+    }
+};
\ No newline at end of file
diff --git a/src/python/GLMTypeCaster.h b/src/python/GLMTypeCaster.h
new file mode 100755
index 000000000..cae938ee6
--- /dev/null
+++ b/src/python/GLMTypeCaster.h
@@ -0,0 +1,62 @@
+#pragma once
+#ifndef GLM_TYPE_CASTER_H
+#define GLM_TYPE_CASTER_H
+#include <pybind11/pybind11.h>
+#include <glm/glm.hpp>
+
+namespace pybind11 { namespace detail {
+
+    template <> struct type_caster<glm::dvec3> {
+    public:
+        PYBIND11_TYPE_CASTER(glm::dvec3, _("dvec3"));
+
+        bool load(handle src, bool) {
+            if (!src) return false;
+            if (!pybind11::isinstance<pybind11::iterable>(src)) return false;
+
+            pybind11::tuple t = pybind11::cast<pybind11::tuple>(src);
+            if (t.size() != 3) return false;
+
+            value = glm::dvec3(
+                static_cast<double>(pybind11::cast<double>(t[0])),
+                static_cast<double>(pybind11::cast<double>(t[1])),
+                static_cast<double>(pybind11::cast<double>(t[2]))
+            );
+
+            return true;
+        }
+       
+        static handle cast(const glm::dvec3& src, return_value_policy, handle) {
+            return pybind11::make_tuple(src.x, src.y, src.z).release();
+        }
+    };
+
+    template <> struct type_caster<glm::dvec2> {
+    public:
+        PYBIND11_TYPE_CASTER(glm::dvec2, _("dvec2"));
+
+        // Load function to convert from Python tuple/list to glm::dvec2
+        bool load(handle src, bool) {
+            if (!src) return false;
+            if (!pybind11::isinstance<pybind11::iterable>(src)) return false;
+
+            pybind11::tuple t = pybind11::cast<pybind11::tuple>(src);
+            if (t.size() != 2) return false;  // glm::dvec2 needs two elements
+
+            value = glm::dvec2(
+                static_cast<double>(pybind11::cast<double>(t[0])),
+                static_cast<double>(pybind11::cast<double>(t[1]))
+            );
+
+            return true;
+        }
+
+        // Cast function to convert glm::dvec2 to Python tuple
+        static handle cast(const glm::dvec2& src, return_value_policy, handle) {
+            return pybind11::make_tuple(src.x, src.y).release();
+        }
+    };
+
+}
+} 
+#endif
diff --git a/src/python/KDTreeFactoryWrapper.h b/src/python/KDTreeFactoryWrapper.h
new file mode 100644
index 000000000..564991375
--- /dev/null
+++ b/src/python/KDTreeFactoryWrapper.h
@@ -0,0 +1,30 @@
+#include <adt/kdtree/KDTreeFactory.h>
+
+class KDTreeFactoryWrap : public KDTreeFactory {
+public:
+    using KDTreeFactory::KDTreeFactory; // Inherit constructors
+
+    // Override pure virtual clone method
+    KDTreeFactory* clone() const override {
+        PYBIND11_OVERLOAD_PURE(
+            KDTreeFactory*, // Return type
+            KDTreeFactory,  // Parent class
+            clone           // Function name
+        );
+    }
+
+    KDTreeNodeRoot* makeFromPrimitivesUnsafe(
+        std::vector<Primitive*>& primitives, 
+        bool const computeStats=false, 
+        bool const reportStats=false
+    ) override {
+        PYBIND11_OVERLOAD_PURE(
+            KDTreeNodeRoot*,  // Return type
+            KDTreeFactory,    // Parent class
+            makeFromPrimitivesUnsafe, // Method name
+            primitives,       // Arguments
+            computeStats,
+            reportStats
+        );
+    }
+};
\ No newline at end of file
diff --git a/src/python/NoiseSourceWrap.h b/src/python/NoiseSourceWrap.h
new file mode 100755
index 000000000..fcb9ca025
--- /dev/null
+++ b/src/python/NoiseSourceWrap.h
@@ -0,0 +1,34 @@
+
+template <typename RealType>
+class NoiseSourceWrap : public NoiseSource<RealType> {
+public:
+
+    using NoiseSource<RealType>::NoiseSource;
+
+    RealType noiseFunction() override {
+        throw std::runtime_error("Called pure virtual function noiseFunction()");
+    }
+};
+
+template <typename RealType>
+class RandomNoiseSourceWrap : public RandomNoiseSource<RealType> {
+public:
+    using RandomNoiseSource<RealType>::RandomNoiseSource;
+    
+
+    // Override the pure virtual method in Python
+    std::string getRandomNoiseType() override {
+        PYBIND11_OVERRIDE_PURE(
+            std::string,                 // Return type
+            RandomNoiseSource<RealType>, // Parent class
+            getRandomNoiseType           // Function name
+        );
+    }
+     RealType noiseFunction() override {
+        PYBIND11_OVERLOAD_PURE(
+            RealType,                  // Return type
+            RandomNoiseSource<RealType>, // Parent class
+            noiseFunction,              // Method name in C++
+        );
+    }
+};
\ No newline at end of file
diff --git a/src/python/PrimitiveWrap.h b/src/python/PrimitiveWrap.h
new file mode 100644
index 000000000..0d1074fd8
--- /dev/null
+++ b/src/python/PrimitiveWrap.h
@@ -0,0 +1,80 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+class PrimitiveWrap : public Primitive {
+public:
+    using Primitive::Primitive; // Inherit constructors
+
+     Primitive* clone() override {
+        PYBIND11_OVERRIDE_PURE(
+            Primitive*,   // Return type
+            Primitive,    // Parent class
+            clone,        // Name of the function in C++
+        );
+    }
+    // Override getAABB method
+    AABB* getAABB() override {
+        PYBIND11_OVERRIDE_PURE(
+            AABB*,         // Return type
+            Primitive,     // Parent class
+            getAABB,       // Name of the function in C++
+        );
+    }
+
+    // Override getCentroid method
+    glm::dvec3 getCentroid() override {
+        PYBIND11_OVERRIDE_PURE(
+            glm::dvec3,    // Return type
+            Primitive,     // Parent class
+            getCentroid,   // Name of the function in C++
+        );
+    }
+
+    // Override getIncidenceAngle_rad method
+    double getIncidenceAngle_rad(const glm::dvec3& p, const glm::dvec3& d, const glm::dvec3& n) override {
+        PYBIND11_OVERRIDE_PURE(
+            double,        // Return type
+            Primitive,     // Parent class
+            getIncidenceAngle_rad,   // Name of the function in C++
+            p, d, n        // Arguments
+        );
+    }
+
+    // Override getRayIntersection method
+    std::vector<double> getRayIntersection(const glm::dvec3& p, const glm::dvec3& d) override {
+        PYBIND11_OVERRIDE_PURE(
+            std::vector<double>,    // Return type
+            Primitive,              // Parent class
+            getRayIntersection,     // Name of the function in C++
+            p, d                    // Arguments
+        );
+    }
+
+    // Override getRayIntersectionDistance method
+    double getRayIntersectionDistance(const glm::dvec3& p, const glm::dvec3& d) override {
+        PYBIND11_OVERRIDE_PURE(
+            double,        // Return type
+            Primitive,     // Parent class
+            getRayIntersectionDistance,   // Name of the function in C++
+            p, d           // Arguments
+        );
+    }
+
+    // Override getVertices method
+    Vertex* getVertices() override {
+        PYBIND11_OVERRIDE_PURE(
+            Vertex*,       // Return type
+            Primitive,     // Parent class
+            getVertices    // Name of the function in C++
+        );
+    }
+
+    // Override update method
+    void update() override {
+        PYBIND11_OVERRIDE_PURE(
+            void,          // Return type
+            Primitive,     // Parent class
+            update         // Name of the function in C++
+        );
+    }
+};
diff --git a/src/python/PulseThreadPoolInterfaceWrap.h b/src/python/PulseThreadPoolInterfaceWrap.h
new file mode 100755
index 000000000..b7fd6f8e8
--- /dev/null
+++ b/src/python/PulseThreadPoolInterfaceWrap.h
@@ -0,0 +1,52 @@
+#include <scanner/detector/PulseThreadPoolInterface.h>
+
+class PulseThreadPoolInterfaceWrap : public PulseThreadPoolInterface {
+    public:
+        using PulseThreadPoolInterface::PulseThreadPoolInterface; // Inherit constructors
+
+        void run_pulse_task(TaskDropper<
+            PulseTask,
+            PulseThreadPoolInterface,
+            std::vector<std::vector<double>>&,
+            RandomnessGenerator<double>&,
+            RandomnessGenerator<double>&,
+            NoiseSource<double>&
+#if DATA_ANALYTICS >= 2
+        , std::shared_ptr<HDA_PulseRecorder>
+#endif
+        > &dropper) override {
+            PYBIND11_OVERLOAD_PURE(
+                void,                            // Return type
+                PulseThreadPoolInterface,        // Parent class
+                run_pulse_task,                  // Name of function in Python
+                dropper                           // Arguments
+            );
+        }
+
+        bool try_run_pulse_task(TaskDropper<
+            PulseTask,
+            PulseThreadPoolInterface,
+            std::vector<std::vector<double>>&,
+            RandomnessGenerator<double>&,
+            RandomnessGenerator<double>&,
+            NoiseSource<double>&
+#if DATA_ANALYTICS >= 2
+        , std::shared_ptr<HDA_PulseRecorder>
+#endif
+        > &dropper) override {
+            PYBIND11_OVERLOAD_PURE(
+                bool,                            // Return type
+                PulseThreadPoolInterface,        // Parent class
+                try_run_pulse_task,             // Name of function in Python
+                dropper                           // Arguments
+            );
+        }
+
+        void join() override {
+            PYBIND11_OVERLOAD_PURE(
+                void,                            // Return type
+                PulseThreadPoolInterface,        // Parent class
+                join,                             // Name of function in Python
+            );
+        }
+};
\ No newline at end of file
diff --git a/src/pybinds/PyHeliosSimulation.cpp b/src/python/PyHeliosSimulation.cpp
similarity index 76%
rename from src/pybinds/PyHeliosSimulation.cpp
rename to src/python/PyHeliosSimulation.cpp
index 7d420f1fd..c8cdd903d 100644
--- a/src/pybinds/PyHeliosSimulation.cpp
+++ b/src/python/PyHeliosSimulation.cpp
@@ -1,37 +1,26 @@
 #include <PyHeliosSimulation.h>
-#include <PyHeliosException.h>
+#include <HeliosException.h>
 #include <AbstractDetector.h>
 #include <Rotation.h>
 #include <RotateFilter.h>
-#include <PyHeliosOutputWrapper.h>
+
 #include <chrono>
 #include <PulseThreadPoolFactory.h>
 #include <filems/facade/FMSFacade.h>
 #include <filems/facade/FMSWriteFacade.h>
 #include <filems/factory/FMSFacadeFactory.h>
-#include <PyScanningStripWrapper.h>
+// #include <PyScanningStripWrapper.h>
 
 using helios::filems::FMSWriteFacade;
 
-using pyhelios::PyHeliosSimulation;
-using pyhelios::PyHeliosOutputWrapper;
-using pyhelios::PyScanningStripWrapper;
 
 namespace fms = helios::filems;
 
-template<typename T>
-std::vector<T> py_list_to_std_vector(const boost::python::object& iterable)
-{
-    return std::vector<T>(boost::python::stl_input_iterator< T >(iterable),
-                          boost::python::stl_input_iterator< T >());
-}
-
-
 // ***  CONSTRUCTION / DESTRUCTION  *** //
 // ************************************ //
 PyHeliosSimulation::PyHeliosSimulation(
     std::string surveyPath,
-    boost::python::list assetsPath,
+    const std::vector<std::string>& assetsPath,
     std::string outputPath,
     size_t numThreads,
     bool lasOutput,
@@ -51,7 +40,7 @@ PyHeliosSimulation::PyHeliosSimulation(
     this->zipOutput = zipOutput;
     this->splitByChannel = splitByChannel;
     this->surveyPath = surveyPath;
-    this->assetsPath = py_list_to_std_vector<std::string>(assetsPath);
+    this->assetsPath = assetsPath;
     this->outputPath = outputPath;
     if(numThreads == 0) this->numThreads = std::thread::hardware_concurrency();
     else this->numThreads = numThreads;
@@ -95,7 +84,12 @@ PyHeliosSimulation::~PyHeliosSimulation() {
             }
         }
     }
-    if(thread != nullptr) delete thread;
+   if (thread) {
+        if (thread->joinable()) {
+            thread->join();
+        }
+        delete thread;
+    }
 }
 
 // ***  GETTERs and SETTERs  *** //
@@ -112,17 +106,14 @@ Leg & PyHeliosSimulation::newLeg(int index){
     return *leg;
 }
 
-PyScanningStripWrapper * PyHeliosSimulation::newScanningStrip(
+std::shared_ptr<ScanningStrip> PyHeliosSimulation::newScanningStrip(
     std::string const &stripId
 ){
-    std::shared_ptr<ScanningStrip> ss = std::make_shared<ScanningStrip>(
-        stripId
-    );
-    return new PyScanningStripWrapper(ss);
+    return std::make_shared<ScanningStrip>(stripId);
 }
 bool PyHeliosSimulation::assocLegWithScanningStrip(
-    Leg &leg, PyScanningStripWrapper *strip
-){
+    Leg &leg, std::shared_ptr<ScanningStrip> strip)
+{
     // Check leg status
     bool previouslyAssoc = leg.isContainedInAStrip();
     // Find leg pointer by serial ID
@@ -135,8 +126,8 @@ bool PyHeliosSimulation::assocLegWithScanningStrip(
         }
     }
     // Associate
-    leg.setStrip(strip->ss);
-    strip->ss->emplace(legSerialId, _leg);
+    leg.setStrip(strip);
+    strip->emplace(legSerialId, _leg);
     // Return original leg association status
     return previouslyAssoc;
 }
@@ -144,7 +135,8 @@ bool PyHeliosSimulation::assocLegWithScanningStrip(
 // ***  CONTROL FUNCTIONS *** //
 // ************************** //
 void PyHeliosSimulation::start (){
-    if(started) throw PyHeliosException(
+    
+    if(started) throw HeliosException(
         "PyHeliosSimulation was already started so it cannot be started again"
     );
 
@@ -162,6 +154,7 @@ void PyHeliosSimulation::start (){
                 std::vector<Trajectory>(0)
             );
         survey->scanner->allMeasurementsMutex = std::make_shared<std::mutex>();
+  
     }
 
     std::shared_ptr<fms::FMSFacade> fms = exportToFile ?
@@ -191,20 +184,20 @@ void PyHeliosSimulation::start (){
     );
     playback->callback = callback;
     playback->setCallbackFrequency(callbackFrequency);
-    thread = new boost::thread(
-        boost::bind(&SurveyPlayback::start, &(*playback))
+    thread = new std::thread(
+         std::bind(&SurveyPlayback::start, playback)
     );
 
     started = true;
 }
 void PyHeliosSimulation::pause (){
-    if(!started) throw PyHeliosException(
+    if(!started) throw HeliosException(
         "PyHeliosSimulation was not started so it cannot be paused"
     );
-    if(stopped) throw PyHeliosException(
+    if(stopped) throw HeliosException(
         "PyHeliosSimulation was stopped so it cannot be paused"
     );
-    if(finished) throw PyHeliosException(
+    if(finished) throw HeliosException(
         "PyHeliosSimulation has finished so it cannot be paused"
     );
 
@@ -213,13 +206,13 @@ void PyHeliosSimulation::pause (){
     paused = true;
 }
 void PyHeliosSimulation::stop (){
-    if(!started) throw PyHeliosException(
+    if(!started) throw HeliosException(
         "PyHeliosSimulation was not started so it cannot be stopped"
     );
-    if(stopped) throw PyHeliosException(
+    if(stopped) throw HeliosException(
         "PyHeliosSimulation was already stopped so it cannot be stopped again"
     );
-    if(finished) throw PyHeliosException(
+    if(finished) throw HeliosException(
         "PyHeliosSimulation has finished so it cannot be stopped"
     );
 
@@ -228,16 +221,16 @@ void PyHeliosSimulation::stop (){
     stopped = true;
 }
 void PyHeliosSimulation::resume (){
-    if(!started) throw PyHeliosException(
+    if(!started) throw HeliosException(
         "PyHeliosSimulation was not started so it cannot be resumed"
     );
-    if(stopped) throw PyHeliosException(
+    if(stopped) throw HeliosException(
         "PyHeliosSimulation was stopped so it cannot be resumed"
     );
-    if(playback->finished) throw PyHeliosException(
+    if(playback->finished) throw HeliosException(
         "PyHeliosSimulation has finished so it cannot be resumed"
     );
-    if(!paused) throw PyHeliosException(
+    if(!paused) throw HeliosException(
         "PyHeliosSimulation is not paused so it cannot be resumed"
     );
 
@@ -256,57 +249,67 @@ bool PyHeliosSimulation::isRunning() {
 }
 
 
-PyHeliosOutputWrapper * PyHeliosSimulation::join(){
+py::tuple PyHeliosSimulation::join() {
     // Status control
-    if(!started || paused) throw PyHeliosException(
-        "PyHeliosSimulation is not running so it cannot be joined"
-    );
+    if (!started || paused) {
+        throw std::runtime_error("PyHeliosSimulation is not running so it cannot be joined");
+    }
 
     // Obtain measurements output path
     std::string mwOutPath = "";
-    if(exportToFile){
-        mwOutPath = survey->scanner->fms->write
-            .getMeasurementWriterOutputPath().string();
+    if (exportToFile) {
+        mwOutPath = survey->scanner->fms->write.getMeasurementWriterOutputPath().string();
     }
 
     // Callback concurrency handling (NON BLOCKING MODE)
-    if(callbackFrequency != 0 && callback != nullptr){
-        if(!playback->finished) {
-            std::vector<Measurement> measurements(0);
-            std::vector<Trajectory> trajectories(0);
-            return new PyHeliosOutputWrapper(
-                measurements,
-                trajectories,
+    if (callbackFrequency != 0 && callback != nullptr) {
+        if (!playback->finished) {
+            // Return empty vectors if the simulation is not finished yet
+            return py::make_tuple(
+                std::vector<Measurement>{}, 
+                std::vector<Trajectory>{},  
                 mwOutPath,
                 std::vector<std::string>{mwOutPath},
-                false
+                false 
             );
-        }
-        else{
+        } else {
+            // Return collected data if the simulation is finished
             finished = true;
-            return new PyHeliosOutputWrapper(
-                survey->scanner->allMeasurements,
-                survey->scanner->allTrajectories,
+            return py::make_tuple(
+                *survey->scanner->allMeasurements, 
+                *survey->scanner->allTrajectories,  
                 mwOutPath,
-                survey->scanner->allOutputPaths,
-                true
+                *survey->scanner->allOutputPaths,   
+                true 
             );
         }
     }
 
     // Join (BLOCKING MODE)
-    thread->join();
-    if(playback->fms != nullptr) playback->fms->disconnect();
+    if (thread && thread->joinable()) {
+        thread->join();
+    }
+    if (playback->fms != nullptr) {
+        playback->fms->disconnect();
+    }
     finished = true;
 
     // Final output (BLOCKING MODE)
-    if(!finalOutput) return nullptr;
-    return new PyHeliosOutputWrapper(
-        survey->scanner->allMeasurements,
-        survey->scanner->allTrajectories,
+    if (!finalOutput) {
+        return py::make_tuple(
+            std::vector<Measurement>{}, 
+            std::vector<Trajectory>{},  
+            mwOutPath,
+            std::vector<std::string>{},
+            false 
+        );
+    }
+    return py::make_tuple(
+        *survey->scanner->allMeasurements, 
+        *survey->scanner->allTrajectories,  
         mwOutPath,
-        survey->scanner->allOutputPaths,
-        true
+        *survey->scanner->allOutputPaths,   
+        true 
     );
 }
 
@@ -406,26 +409,18 @@ PyHeliosSimulation * PyHeliosSimulation::copy(){
     return phs;
 }
 
-// ***  GETTERS and SETTERS  *** //
-// ***************************** //
-void PyHeliosSimulation::setCallback(PyObject * pyCallback){
-    callback = std::make_shared<PySimulationCycleCallback>(
-        PySimulationCycleCallback(pyCallback)
-    );
+void PyHeliosSimulation::setCallback(pybind11::object pyCallback) {
+    callback = std::make_shared<SimulationCycleCallbackWrap>(pyCallback);
 
-    if(survey->scanner->cycleMeasurements == nullptr) {
+    if (survey->scanner->cycleMeasurements == nullptr) {
         survey->scanner->cycleMeasurements =
-            std::make_shared<std::vector<Measurement>>(
-                std::vector<Measurement>(0)
-            );
+            std::make_shared<std::vector<Measurement>>(0);
     }
-    if(survey->scanner->cycleTrajectories == nullptr){
+    if (survey->scanner->cycleTrajectories == nullptr) {
         survey->scanner->cycleTrajectories =
-            std::make_shared<std::vector<Trajectory>>(
-                std::vector<Trajectory>(0)
-            );
+            std::make_shared<std::vector<Trajectory>>(0);
     }
-    if(survey->scanner->cycleMeasurementsMutex == nullptr){
+    if (survey->scanner->cycleMeasurementsMutex == nullptr) {
         survey->scanner->cycleMeasurementsMutex =
             std::make_shared<std::mutex>();
     }
@@ -440,7 +435,7 @@ std::shared_ptr<DynScene> PyHeliosSimulation::_getDynScene(){
         );
     }
     catch(std::exception &ex){
-        throw PyHeliosException(
+        throw HeliosException(
             "Failed to obtain dynamic scene. Current scene is not dynamic."
         );
     }
diff --git a/src/pybinds/PyHeliosSimulation.h b/src/python/PyHeliosSimulation.h
similarity index 86%
rename from src/pybinds/PyHeliosSimulation.h
rename to src/python/PyHeliosSimulation.h
index 61a5e9d67..ac2127d6c 100644
--- a/src/pybinds/PyHeliosSimulation.h
+++ b/src/python/PyHeliosSimulation.h
@@ -1,20 +1,28 @@
 #pragma once
 
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
 #include <string>
+#include <memory>
+#include <vector>
+#include <thread>
+#include <mutex>
+
 #include <Leg.h>
 #include <SurveyPlayback.h>
-#include <memory>
 #include <noise/RandomnessGenerator.h>
-#include <PySimulationCycleCallback.h>
-#include <PyPlatformWrapper.h>
-#include <PySceneWrapper.h>
-#include <PyHeliosOutputWrapper.h>
-#include <PyHeliosException.h>
 #include <XmlSurveyLoader.h>
-#include <PyScannerWrapper.h>
-#include <PyScanningStripWrapper.h>
+#include <scene/Scene.h>
+#include <Survey.h>
+#include <platform/Platform.h>
+#include <SimulationCycleCallback.h>
+#include <scanner/Scanner.h>
+#include <sim/comps/ScanningStrip.h>
+#include <Measurement.h>
+#include <Trajectory.h>
+#include <HeliosException.h>
+#include <SimulationCycleCallbackWrap.h>
 
-namespace pyhelios{
 
 /**
  * @author Alberto M. Esmoris Pena
@@ -22,24 +30,25 @@ namespace pyhelios{
  *
  * Helios++ simulation wrapped to be used from Python
  */
+
 class PyHeliosSimulation{
 private:
     // ***  ATTRIBUTES  *** //
     // ******************** //
     std::shared_ptr<XmlSurveyLoader> xmlreader = nullptr;
-    bool started = false;
-    bool paused = false;
-    bool stopped = false;
-    bool finished = false;
+    bool started = false; 
+    bool paused = false; 
+    bool stopped = false; 
+    bool finished = false; 
     size_t numThreads = 0;
     size_t callbackFrequency = 0;
-    std::string surveyPath = "NULL";
-    std::vector<std::string> assetsPath;
+    std::string surveyPath = "NULL"; 
+    std::vector<std::string> assetsPath; 
     std::string outputPath = "NULL";
-    std::shared_ptr<Survey> survey = nullptr;
+    std::shared_ptr<Survey> survey = nullptr; 
     std::shared_ptr<SurveyPlayback> playback = nullptr;
-    boost::thread * thread = nullptr;
-    std::shared_ptr<PySimulationCycleCallback> callback = nullptr;
+    std::thread * thread = nullptr;
+    std::shared_ptr<SimulationCycleCallback> callback = nullptr;
     std::string fixedGpsTimeStart = "";
     bool lasOutput = false;
     bool las10     = false;
@@ -73,7 +82,7 @@ class PyHeliosSimulation{
      */
     PyHeliosSimulation(
         std::string surveyPath,
-        boost::python::list assetsPath,
+        const std::vector<std::string>& assetsPath,
         std::string outputPath = "output/",
         size_t numThreads = 0,
         bool lasOutput = false,
@@ -145,17 +154,19 @@ class PyHeliosSimulation{
      *
      * @return Scanner used by the simulation
      */
-    PyScannerWrapper * getScanner()
-        {return new PyScannerWrapper(*survey->scanner);}
+    void setSurvey(Survey & survey) {this->survey = std::make_shared<Survey>(survey);}
+
+    Scanner * getScanner()
+        {return survey->scanner.get();}
     /**
      * @brief Obtain the platform used by the simulation
      *
      * @return Platform used by the simulation
      */
-    PyPlatformWrapper * getPlatform()
-        {return new PyPlatformWrapper(*survey->scanner->platform);}
-    PySceneWrapper * getScene()
-        {return new PySceneWrapper(*survey->scanner->platform->scene);}
+    Platform * getPlatform()
+        {return survey->scanner->platform.get();}
+    Scene * getScene()
+        {return survey->scanner->platform->scene.get();}
     /**
      * @brief Obtain the number of legs
      *
@@ -187,7 +198,7 @@ class PyHeliosSimulation{
      * @param stripId The identifier for the strip
      * @return Created empty scanning strip
      */
-    PyScanningStripWrapper * newScanningStrip(std::string const &stripId);
+    std::shared_ptr<ScanningStrip> newScanningStrip(const std::string& stripId);
     /**
      * @brief Associate given leg with given strip
      * @param leg The leg to be associated with given strip
@@ -196,7 +207,7 @@ class PyHeliosSimulation{
      *  was updated. False if this is the first strip to which the leg is
      *  associated.
      */
-    bool assocLegWithScanningStrip(Leg &leg, PyScanningStripWrapper *strip);
+    bool assocLegWithScanningStrip(Leg& leg, std::shared_ptr<ScanningStrip> strip);
     /**
      * @brief Obtain callback frequency
      *
@@ -243,7 +254,7 @@ class PyHeliosSimulation{
     /**
      * @brief Set the simulation callback to specified python object functor
      */
-    void setCallback(PyObject * pyCallback);
+    void setCallback(py::object pyCallback);
     /**
      * @brief Clear simulation callback so it will no longer be invoked
      */
@@ -252,12 +263,13 @@ class PyHeliosSimulation{
         survey->scanner->cycleMeasurements = nullptr;
         survey->scanner->cycleMeasurementsMutex = nullptr;
     }
+
     std::string getFixedGpsTimeStart(){return fixedGpsTimeStart;}
     void setFixedGpsTimeStart(std::string const fixedGpsTimeStart)
     {this->fixedGpsTimeStart = fixedGpsTimeStart;}
     bool getLasOutput(){return lasOutput;}
     void setLasOutput(double lasOutput_){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify LAS output flag for already started simulations."
         );
         this->lasOutput = lasOutput_;
@@ -265,7 +277,7 @@ class PyHeliosSimulation{
 
     bool getLas10(){return las10;}
     void setLas10(double las10_){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify LAS v1.0 output flag for already started "
             "simulations."
         );
@@ -274,14 +286,14 @@ class PyHeliosSimulation{
 
     bool getZipOutput(){return zipOutput;}
     void setZipOutput(bool zipOutput_){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify ZIP output flag for already started simulations."
         );
         this->zipOutput = zipOutput_;
     }
     bool getSplitByChannel(){return splitByChannel;}
     void setSplitByChannel(bool splitByChannel_){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify splitByChannel flag for already started "
             "simulations."
         );
@@ -290,7 +302,7 @@ class PyHeliosSimulation{
 
     double getLasScale(){return lasScale;}
     void setLasScale(double const lasScale){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify LAS scale for already started simulations."
         );
         this->lasScale = lasScale;
@@ -298,7 +310,7 @@ class PyHeliosSimulation{
 
     int getKDTFactory(){return kdtFactory;}
     void setKDTFactory(int kdtFactory){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify KDT factory for already started simulations."
         );
         this->kdtFactory = kdtFactory;
@@ -306,7 +318,7 @@ class PyHeliosSimulation{
 
     size_t getKDTJobs(){return kdtJobs;}
     void setKDTJobs(size_t kdtJobs){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify KDT jobs for already started simulations."
         );
         this->kdtJobs = kdtJobs;
@@ -314,7 +326,7 @@ class PyHeliosSimulation{
 
     size_t getKDTSAHLossNodes(){return kdtSAHLossNodes;}
     void setKDTSAHLossNodes(size_t kdtSAHLossNodes){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify KDT SAH loss nodes for already started simulations."
         );
         this->kdtSAHLossNodes = kdtSAHLossNodes;
@@ -322,7 +334,7 @@ class PyHeliosSimulation{
 
     int getParallelizationStrategy(){return parallelizationStrategy;}
     void setParallelizationStrategy(int parallelizationStrategy){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify parallelization strategy for already started "
             "simulations."
         );
@@ -331,7 +343,7 @@ class PyHeliosSimulation{
 
     int getChunkSize(){return chunkSize;}
     void setChunkSize(int chunkSize){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify chunk size for already started simulations."
         );
         this->chunkSize = chunkSize;
@@ -339,14 +351,13 @@ class PyHeliosSimulation{
 
     int getWarehouseFactor(){return warehouseFactor;}
     void setWarehouseFactor(int warehouseFactor){
-        if(started) throw PyHeliosException(
+        if(started) throw HeliosException(
             "Cannot modify warehouse factor for already started simulations."
         );
         this->warehouseFactor = warehouseFactor;
     }
 
 
-
     // ***  CONTROL FUNCTIONS  *** //
     // *************************** //
     /**
@@ -372,7 +383,7 @@ class PyHeliosSimulation{
     /**
      * @brief Cause caller thread to wait until simulation has finished
      */
-    PyHeliosOutputWrapper * join();
+    py::tuple join();
 
     // ***  SIMULATION CONFIGURATION FUNCTIONS  *** //
     // ******************************************** //
@@ -421,4 +432,4 @@ class PyHeliosSimulation{
     std::shared_ptr<DynScene> _getDynScene();
 };
 
-}
+
diff --git a/src/python/ScannerWrap.h b/src/python/ScannerWrap.h
new file mode 100755
index 000000000..4c80e2951
--- /dev/null
+++ b/src/python/ScannerWrap.h
@@ -0,0 +1,795 @@
+#include <scanner/Scanner.h>
+#include <pybind11/pybind11.h>
+#include <maths/WaveMaths.h>
+#include <functional>
+#include <memory>
+
+#if DATA_ANALYTICS >= 2
+    #define SUBRAY_ADDITIONAL_ARGS , bool&, std::vector<double>&
+    #define PULSE_RECORDER_ARG , std::shared_ptr<HDA_PulseRecorder> pulseRecorder
+    #define INTENSITY_RECORDS_ARG , std::vector<std::vector<double>>& calcIntensityRecords
+    #define PULSE_RECORDER_MACRO_ARG , pulseRecorder
+    #define INTENSITY_RECORDS_MACRO_ARG , calcIntensityRecords
+#else
+    #define SUBRAY_ADDITIONAL_ARGS
+    #define PULSE_RECORDER_ARG
+    #define INTENSITY_RECORDS_ARG
+    #define PULSE_RECORDER_MACRO_ARG
+    #define INTENSITY_RECORDS_MACRO_ARG
+#endif
+
+class ScannerWrap : public Scanner {
+public:
+
+    ScannerWrap() : Scanner("", std::list<int>()) {}
+
+    ScannerWrap(
+        std::string const& id,
+        std::list<int> const& pulseFreqs,
+        bool writeWaveform=false,
+        bool writePulse=false,
+        bool calcEchowidth=false,
+        bool fullWaveNoise=false,
+        bool platformNoiseDisabled=false
+    ) : Scanner(id, pulseFreqs, writeWaveform, writePulse, calcEchowidth, fullWaveNoise, platformNoiseDisabled) {}
+
+    ScannerWrap(Scanner& scanner) : Scanner(scanner) {}
+
+    std::shared_ptr<std::mutex> cycle_measurements_mutex;
+
+    // Getter for cycle_measurements_mutex
+    std::shared_ptr<std::mutex> get_mutex() const {
+        return cycle_measurements_mutex;
+    }
+
+    // Setter for cycle_measurements_mutex
+    void set_mutex(std::shared_ptr<std::mutex> mutex=nullptr) {
+        if (!mutex) {
+            cycle_measurements_mutex = std::make_shared<std::mutex>();
+        } else {
+            cycle_measurements_mutex = std::move(mutex);
+           
+        }
+         Scanner::cycleMeasurementsMutex = cycle_measurements_mutex;
+         Scanner::allMeasurementsMutex = cycle_measurements_mutex;
+    }
+    
+    std::shared_ptr<Scanner> clone() override {
+        // Create a copy of the current ScannerWrap object
+        // This can be a shallow or deep copy depending on your needs
+        return std::make_shared<ScannerWrap>(*this);
+    }
+    void prepareSimulation(bool const legacyEnergyModel) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            prepareSimulation,         
+            legacyEnergyModel          
+        );
+    }
+
+    std::shared_ptr<ScannerSettings> retrieveCurrentSettings(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            std::shared_ptr<ScannerSettings>, 
+            Scanner,                         
+            retrieveCurrentSettings,         
+            idx                              
+        );
+    }
+    
+
+    void applySettings(std::shared_ptr<ScannerSettings> settings, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            applySettings,             
+            settings, idx              
+        );
+    }
+
+    void applySettingsFWF(FWFSettings fwfSettings, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            applySettingsFWF,          
+            fwfSettings, idx           
+        );
+    }
+
+    void doSimStep(unsigned int legIndex, double const currentGpsTime) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            doSimStep,                 
+            legIndex, currentGpsTime   
+        );
+    }
+
+    void calcRaysNumber(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            calcRaysNumber,            
+            idx                        
+        );
+    }
+
+    void prepareDiscretization(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            prepareDiscretization,     
+            idx                        
+        );
+    }
+
+    double calcAtmosphericAttenuation(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            calcAtmosphericAttenuation,
+            idx                        
+        );
+    }
+
+    Rotation calcAbsoluteBeamAttitude(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            Rotation,                  
+            Scanner,                   
+            calcAbsoluteBeamAttitude,  
+            idx                        
+        );
+    }
+
+    bool checkMaxNOR(int const nor, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            bool,                      
+            Scanner,                   
+            checkMaxNOR,               
+            nor, idx                   
+        );
+    }
+
+    void computeSubrays(
+        std::function<void(
+            Rotation const&,
+            int const,
+            NoiseSource<double>&,
+            std::map<double, double>&,
+            std::vector<RaySceneIntersection>&
+            SUBRAY_ADDITIONAL_ARGS
+        )> handleSubray,
+        NoiseSource<double>& intersectionHandlingNoiseSource,
+        std::map<double, double>& reflections,
+        std::vector<RaySceneIntersection>& intersects,
+        size_t const idx
+        PULSE_RECORDER_ARG
+    ) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            computeSubrays,            
+            handleSubray, intersectionHandlingNoiseSource, reflections, intersects, idx
+            PULSE_RECORDER_MACRO_ARG
+        );
+    }
+
+    bool initializeFullWaveform(
+        double const minHitDist_m,
+        double const maxHitDist_m,
+        double& minHitTime_ns,
+        double& maxHitTime_ns,
+        double& nsPerBin,
+        double& distanceThreshold,
+        int& peakIntensityIndex,
+        int& numFullwaveBins,
+        size_t const idx
+    ) override {
+        PYBIND11_OVERLOAD_PURE(
+            bool,                      
+            Scanner,                   
+            initializeFullWaveform,    
+            minHitDist_m, maxHitDist_m, minHitTime_ns, maxHitTime_ns, nsPerBin,
+            distanceThreshold, peakIntensityIndex, numFullwaveBins, idx  
+        );
+    }
+
+    double calcIntensity(
+        double const incidenceAngle,
+        double const targetRange,
+        Material const& mat,
+        int const subrayRadiusStep,
+        size_t const idx
+        INTENSITY_RECORDS_ARG
+    ) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            calcIntensity,             
+            incidenceAngle, targetRange, mat, subrayRadiusStep, idx
+            INTENSITY_RECORDS_MACRO_ARG
+        );
+    }
+
+    double calcIntensity(
+        double const targetRange,
+        double const sigma,
+        int const subrayRadiusStep,
+        size_t const idx
+    ) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            calcIntensity,             
+            targetRange, sigma, subrayRadiusStep, idx  
+        );
+    }
+
+    void onLegComplete() override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            onLegComplete,             
+        );
+    }
+
+    ScanningDevice& getScanningDevice(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            ScanningDevice&,           
+            Scanner,                   
+            getScanningDevice,         
+            idx                        
+        );
+    }
+
+    int getCurrentPulseNumber(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            int,                       
+            Scanner,                   
+            getCurrentPulseNumber,     
+            idx                        
+        );
+    }
+
+    int getNumRays(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            int,                       
+            Scanner,                   
+            getNumRays,                
+            idx                        
+        );
+    }
+
+    void setNumRays(int const numRays, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setNumRays,                
+            numRays, idx               
+        );
+    }
+
+    double getPulseLength_ns(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getPulseLength_ns,         
+            idx                        
+        );
+    }
+
+    void setPulseLength_ns(double const pulseLength_ns, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setPulseLength_ns,         
+            pulseLength_ns, idx        
+        );
+    }
+
+    bool lastPulseWasHit(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            bool,                      
+            Scanner,                   
+            lastPulseWasHit,           
+            idx                        
+        );
+    }
+
+    void setLastPulseWasHit(bool const lastPulseWasHit, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setLastPulseWasHit,        
+            lastPulseWasHit, idx      
+        );
+    }
+
+    double getBeamDivergence(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getBeamDivergence,         
+            idx                        
+        );
+    }
+
+    void setBeamDivergence(double const beamDivergence, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setBeamDivergence,         
+            beamDivergence, idx       
+        );
+    }
+
+    double getAveragePower(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getAveragePower,           
+            idx                        
+        );
+    }
+
+    void setAveragePower(double const averagePower, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setAveragePower,           
+            averagePower, idx         
+        );
+    }
+
+    double getBeamQuality(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getBeamQuality,            
+            idx                        
+        );
+    }
+
+    void setBeamQuality(double const beamQuality, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setBeamQuality,            
+            beamQuality, idx          
+        );
+    }
+
+    double getEfficiency(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getEfficiency,             
+            idx                        
+        );
+    }
+
+    void setEfficiency(double const efficiency, size_t const idx = 0) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setEfficiency,             
+            efficiency, idx           
+        );
+    }
+
+    double getReceiverDiameter(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getReceiverDiameter,       
+            idx                        
+        );
+    }
+
+    void setReceiverDiameter(double const receiverDiameter, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setReceiverDiameter,       
+            receiverDiameter, idx     
+        );
+    }
+
+    double getVisibility(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getVisibility,             
+            idx                        
+        );
+    }
+
+    void setVisibility(double const visibility, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setVisibility,             
+            visibility, idx           
+        );
+    }
+
+    double getWavelength(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getWavelength,             
+            idx                        
+        );
+    }
+
+    void setWavelength(double const wavelength, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setWavelength,             
+            wavelength, idx          
+        );
+    }
+
+    double getAtmosphericExtinction(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getAtmosphericExtinction,  
+            idx                        
+        );
+    }
+
+    void setAtmosphericExtinction(double const atmosphericExtinction, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setAtmosphericExtinction,  
+            atmosphericExtinction, idx
+        );
+    }
+
+    double getBeamWaistRadius(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getBeamWaistRadius,        
+            idx                        
+        );
+    }
+
+    void setBeamWaistRadius(double const beamWaistRadius, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setBeamWaistRadius,        
+            beamWaistRadius, idx      
+        );
+    }
+
+    glm::dvec3 getHeadRelativeEmitterPosition(size_t const idx = 0) const override {
+        PYBIND11_OVERLOAD_PURE(
+            glm::dvec3,                
+            Scanner,                   
+            getHeadRelativeEmitterPosition, 
+            idx                        
+        );
+    }
+
+    void setHeadRelativeEmitterPosition(glm::dvec3 const &pos, size_t const idx = 0) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setHeadRelativeEmitterPosition, 
+            pos, idx                  
+        );
+    }
+
+    glm::dvec3 &getHeadRelativeEmitterPositionByRef(size_t const idx = 0) override {
+        PYBIND11_OVERLOAD_PURE(
+            glm::dvec3 &,              
+            Scanner,                   
+            getHeadRelativeEmitterPositionByRef, 
+            idx                        
+        );
+    }
+
+    Rotation getHeadRelativeEmitterAttitude(size_t const idx = 0) const override {
+        PYBIND11_OVERLOAD_PURE(
+            Rotation,                  
+            Scanner,                   
+            getHeadRelativeEmitterAttitude, 
+            idx                        
+        );
+    }
+
+    void setHeadRelativeEmitterAttitude(Rotation const &attitude, size_t const idx = 0) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setHeadRelativeEmitterAttitude, 
+            attitude, idx            
+        );
+    }
+
+    Rotation &getHeadRelativeEmitterAttitudeByRef(size_t const idx = 0) override {
+        PYBIND11_OVERLOAD_PURE(
+            Rotation &,                
+            Scanner,                   
+            getHeadRelativeEmitterAttitudeByRef, 
+            idx                        
+        );
+    }
+
+    double getBt2(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getBt2,                    
+            idx                        
+        );
+    }
+
+    void setBt2(double const bt2, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setBt2,                    
+            bt2, idx                 
+        );
+    }
+
+    double getDr2(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                    
+            Scanner,                   
+            getDr2,                    
+            idx                        
+        );
+    }
+
+    void setDr2(double const dr2, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setDr2,                    
+            dr2, idx                 
+        );
+    }
+
+    void setDeviceIndex(size_t const newIdx, size_t const oldIdx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setDeviceIndex,            
+            newIdx, oldIdx           
+        );
+    }
+
+    std::string getDeviceId(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            std::string,               
+            Scanner,                   
+            getDeviceId,               
+            idx                        
+        );
+    }
+
+    void setDeviceId(std::string const deviceId, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                      
+            Scanner,                   
+            setDeviceId,               
+            deviceId, idx            
+        );
+    }
+
+    size_t getNumDevices() const override {
+        PYBIND11_OVERLOAD_PURE(
+            size_t,                    
+            Scanner,                   
+            getNumDevices,             
+        );
+    }
+
+    std::shared_ptr<ScannerHead> getScannerHead(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            std::shared_ptr<ScannerHead>, 
+            Scanner,                      
+            getScannerHead,               
+            idx                           
+        );
+    }
+
+    void setScannerHead(std::shared_ptr<ScannerHead> scannerHead, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                         
+            Scanner,                      
+            setScannerHead,               
+            scannerHead, idx            
+        );
+    }
+
+    std::shared_ptr<AbstractBeamDeflector> getBeamDeflector(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            std::shared_ptr<AbstractBeamDeflector>, 
+            Scanner,                               
+            getBeamDeflector,                       
+            idx                                    
+        );
+    }
+
+    void setBeamDeflector(std::shared_ptr<AbstractBeamDeflector> beamDeflector, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                                   
+            Scanner,                                
+            setBeamDeflector,                       
+            beamDeflector, idx                    
+        );
+    }
+
+    std::shared_ptr<AbstractDetector> getDetector(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            std::shared_ptr<AbstractDetector>, 
+            Scanner,                          
+            getDetector,                      
+            idx                               
+        );
+    }
+
+    void setDetector(std::shared_ptr<AbstractDetector> detector, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                              
+            Scanner,                           
+            setDetector,                       
+            detector, idx                    
+        );
+    }
+
+    FWFSettings &getFWFSettings(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            FWFSettings &,                    
+            Scanner,                         
+            getFWFSettings,                  
+            idx                              
+        );
+    }
+
+    void setFWFSettings(FWFSettings const &fwfSettings, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setFWFSettings,                   
+            fwfSettings, idx                
+        );
+    }
+
+    std::list<int>& getSupportedPulseFreqs_Hz(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            std::list<int>&,                    
+            Scanner,
+            getSupportedPulseFreqs_Hz,
+            idx
+        );
+    }
+
+    void setSupportedPulseFreqs_Hz(std::list<int> &supportedPulseFreqs_Hz, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setSupportedPulseFreqs_Hz,       
+            supportedPulseFreqs_Hz, idx     
+        );
+    }
+
+    int getMaxNOR(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            int,                             
+            Scanner,                          
+            getMaxNOR,       
+            idx     
+        );
+    }
+
+    void setMaxNOR(int const maxNOR, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setMaxNOR,       
+            maxNOR, idx     
+        );
+    }
+
+    int getNumTimeBins(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            int,                             
+            Scanner,                          
+            getNumTimeBins,       
+            idx     
+        );
+    }
+
+    void setNumTimeBins(int const numTimeBins, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setNumTimeBins,       
+            numTimeBins, idx     
+        );
+    }
+
+    int getPeakIntensityIndex(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            int,                             
+            Scanner,                          
+            getPeakIntensityIndex,       
+            idx     
+        );
+    }
+
+    void setPeakIntensityIndex(int const pii, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setPeakIntensityIndex,       
+            pii, idx     
+        );
+    }
+
+    std::vector<double>& getTimeWave(size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            std::vector<double>&,                             
+            Scanner,                          
+            getTimeWave,       
+            idx     
+        );
+    }
+
+    void setTimeWave(std::vector<double> &timewave, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setTimeWave,       
+            timewave, idx     
+        );
+    }
+
+    void setTimeWave(std::vector<double> &&timewave, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setTimeWave,       
+            std::move(timewave), idx     
+        );
+    }
+
+
+    double getReceivedEnergyMin(size_t const idx) const override {
+        PYBIND11_OVERLOAD_PURE(
+            double,                             
+            Scanner,                          
+            getReceivedEnetgyMin,       
+            idx     
+        );
+    }
+
+    void setReceivedEnergyMin(double receivedEnergyMin_W, size_t const idx) override {
+        PYBIND11_OVERLOAD_PURE(
+            void,                             
+            Scanner,                          
+            setReceivedEnetgyMin,       
+            receivedEnergyMin_W, idx     
+        );
+    }
+
+    int calcTimePropagation(std::vector<double> &timeWave, int numBins, Scanner &scanner) {
+        return WaveMaths::calcPropagationTimeLegacy(
+            timeWave,
+            numBins,
+            scanner.getFWFSettings(0).binSize_ns,
+            scanner.getPulseLength_ns(0),
+            7.0  // 3.5 too many ops., 7.0 just one op.
+        );
+    }
+        
+};
diff --git a/src/python/ScanningPulseProcessWrap.h b/src/python/ScanningPulseProcessWrap.h
new file mode 100755
index 000000000..dc988f232
--- /dev/null
+++ b/src/python/ScanningPulseProcessWrap.h
@@ -0,0 +1,34 @@
+#include <scanner/ScanningPulseProcess.h>
+
+class ScanningPulseProcessWrap : public ScanningPulseProcess {
+public:
+    using ScanningPulseProcess::ScanningPulseProcess;  // Inherit constructors
+
+    // Override handlePulseComputation in Python
+    void handlePulseComputation(SimulatedPulse const &sp) override {
+        PYBIND11_OVERRIDE_PURE(
+            void,                     // Return type
+            ScanningPulseProcess,      // Parent class
+            handlePulseComputation,    // Function name
+            sp                         // Argument(s)
+        );
+    }
+
+    // Override onLegComplete in Python
+    void onLegComplete() override {
+        PYBIND11_OVERRIDE(
+            void,                     // Return type
+            ScanningPulseProcess,      // Parent class
+            onLegComplete              // Function name
+        );
+    }
+
+    // Override onSimulationFinished in Python
+    void onSimulationFinished() override {
+        PYBIND11_OVERRIDE(
+            void,                     // Return type
+            ScanningPulseProcess,      // Parent class
+            onSimulationFinished       // Function name
+        );
+    }
+};
\ No newline at end of file
diff --git a/src/python/SimulationCycleCallbackWrap.h b/src/python/SimulationCycleCallbackWrap.h
new file mode 100755
index 000000000..25b7450f5
--- /dev/null
+++ b/src/python/SimulationCycleCallbackWrap.h
@@ -0,0 +1,77 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <string>
+#include <cmath>
+
+namespace py = pybind11;
+
+class [[gnu::visibility("default")]] SimulationCycleCallbackWrap : public SimulationCycleCallback {
+public:
+    using SimulationCycleCallback::SimulationCycleCallback;
+    SimulationCycleCallbackWrap(py::object obj) : SimulationCycleCallback(), py_obj(std::move(obj)) {}
+
+    void operator()(
+        std::vector<Measurement> &measurements,
+        std::vector<Trajectory> &trajectories,
+        const std::string &outpath) override {
+
+        py::gil_scoped_acquire acquire;  // Acquire GIL before calling Python code
+
+        // Create a tuple with the required components
+        py::tuple output = py::make_tuple(
+            measurements,                       
+            trajectories,                       
+            outpath,                            
+            std::vector<std::string>{outpath},  
+            false                               
+        );
+
+        
+        py_obj(output);
+    }
+
+private:
+    py::object py_obj;
+
+};
+
+class PySimulationCycleCallback : public SimulationCycleCallback {
+public:
+    using SimulationCycleCallback::SimulationCycleCallback;
+
+    bool is_callback_in_progress = false;  // Flag to prevent recursion
+
+    void operator()(std::vector<Measurement>& measurements,
+                    std::vector<Trajectory>& trajectories,
+                    const std::string& outpath) override {
+        
+        if (is_callback_in_progress) {
+            return;
+        }
+
+        is_callback_in_progress = true;  // Set the flag to prevent recursion
+        
+        py::gil_scoped_acquire acquire;  // Acquire GIL before calling Python code
+
+        py::object py_self = py::cast(this, py::return_value_policy::reference);  // Reference to the Python object
+        
+        if (py::hasattr(py_self, "__call__")) {       
+            // Convert C++ vectors to Python lists
+            py::list measurements_list = py::cast(measurements);
+            py::list trajectories_list = py::cast(trajectories);
+
+            // Call the Python __call__ method with converted arguments
+            py_self.attr("__call__")(measurements_list, trajectories_list, outpath);
+        } else {
+            throw std::runtime_error("Python __call__ method is missing on SimulationCycleCallback.");
+        }
+        
+        is_callback_in_progress = false;  // Reset the flag after callback completes
+    }
+};
+
+
+
+
+
+
diff --git a/src/python/SimulationWrap.h b/src/python/SimulationWrap.h
new file mode 100755
index 000000000..8cf468fd3
--- /dev/null
+++ b/src/python/SimulationWrap.h
@@ -0,0 +1,31 @@
+#include <sim/core/Simulation.h>
+#include <pybind11/pybind11.h>
+
+class SimulationWrap : public Simulation {
+public:
+    using Simulation::Simulation;
+    
+    void onLegComplete() override {
+        PYBIND11_OVERRIDE_PURE(
+            void,
+            Simulation,
+            onLegComplete,
+        );
+    }
+
+    void doSimLoop() override {
+        PYBIND11_OVERRIDE(
+            void,
+            Simulation,
+            doSimLoop,
+        );
+    }
+
+    void shutdown() override {
+        PYBIND11_OVERRIDE(
+            void,
+            Simulation,
+            shutdown,
+        );
+    }
+};
\ No newline at end of file
diff --git a/src/python/utils.h b/src/python/utils.h
new file mode 100644
index 000000000..a56db7a08
--- /dev/null
+++ b/src/python/utils.h
@@ -0,0 +1,46 @@
+#include <pybind11/pybind11.h>
+#include <glm/glm.hpp>
+
+namespace pybind11 {
+size_t handlePythonIndex(long _index, size_t n) {
+    size_t index = static_cast<size_t>(_index);
+    if (_index < 0) {
+        index = static_cast<size_t>(n + _index);
+    }
+    if (index >= n) {
+        std::stringstream ss;
+        ss << "Index " << _index << " out of range";
+        throw pybind11::index_error(ss.str());
+    }
+    return index;
+}
+}
+
+int calcTimePropagation(std::vector<double> &timeWave, int numBins, Scanner &scanner) {
+    return WaveMaths::calcPropagationTimeLegacy(
+        timeWave,
+        numBins,
+        scanner.getFWFSettings(0).binSize_ns,
+        scanner.getPulseLength_ns(0),
+        7.0  // 3.5 too many ops., 7.0 just one op.
+    );
+}
+
+template<typename T, size_t N>
+py::array_t<T> create_numpy_array(T (&arr)[N]) {
+    return py::array_t<T>(N, arr);
+}
+
+template<size_t N>
+void from_numpy_array(py::array_t<double> arr, double (&out)[N]) {
+    if (arr.size() != N) {
+        throw std::runtime_error("Input array size does not match expected size.");
+    }
+    
+    // Create a buffer info object to access the data
+    auto buf = arr.unchecked<1>(); // Unchecked for 1D access
+    
+    for (size_t i = 0; i < N; ++i) {
+        out[i] = buf(i); // Copy each element into the output array
+    }
+}
\ No newline at end of file
diff --git a/src/scanner/Scanner.h b/src/scanner/Scanner.h
index a0139f266..bbd41024f 100644
--- a/src/scanner/Scanner.h
+++ b/src/scanner/Scanner.h
@@ -313,7 +313,7 @@ class Scanner : public Asset {
      *  the scanning device
 	 */
     virtual void calcRaysNumber(size_t const idx) = 0;
-    /**
+    /**calcAbsoluteBeamAttitude
      * @brief Non index version of the Scanner::calcRaysNumber(size_t const)
      *  method
      * @see Scanner::calcRaysNumber(size_t const)
diff --git a/src/scanner/SingleScanner.cpp b/src/scanner/SingleScanner.cpp
index 52054d9d8..5f4168228 100644
--- a/src/scanner/SingleScanner.cpp
+++ b/src/scanner/SingleScanner.cpp
@@ -19,12 +19,12 @@ SingleScanner::SingleScanner(
     double const receiverDiameter,
     double const atmosphericVisibility,
     int const wavelength,
-    std::shared_ptr<UnivarExprTreeNode<double>> rangeErrExpr,
     bool const writeWaveform,
     bool const writePulse,
     bool const calcEchowidth,
     bool const fullWaveNoise,
-    bool const platformNoiseDisabled
+    bool const platformNoiseDisabled,
+    std::shared_ptr<UnivarExprTreeNode<double>> rangeErrExpr // placed in the end to skip it 
 ) :
     Scanner(
         id,
@@ -135,7 +135,6 @@ void SingleScanner::doSimStep(
 ){
     // Check whether the scanner is active or not
     bool const _isActive = isActive();
-
     // Simulate scanning devices
     scanDev.doSimStep(
         legIndex,
diff --git a/src/scanner/SingleScanner.h b/src/scanner/SingleScanner.h
index 13009bac2..795a946c3 100644
--- a/src/scanner/SingleScanner.h
+++ b/src/scanner/SingleScanner.h
@@ -39,12 +39,12 @@ class SingleScanner : public Scanner{
         double const receiverDiameter,
         double const atmosphericVisibility,
         int const wavelength,
-        std::shared_ptr<UnivarExprTreeNode<double>> rangeErrExpr = nullptr,
         bool const writeWaveform = false,
         bool const writePulse = false,
         bool const calcEchowidth = false,
         bool const fullWaveNoise = false,
-        bool const platformNoiseDisabled = false
+        bool const platformNoiseDisabled = false,
+        std::shared_ptr<UnivarExprTreeNode<double>> rangeErrExpr = nullptr // placed in the end to skip it 
     );
     /**
      * @brief Copy constructor for the SingleScanner
diff --git a/src/sim/core/Simulation.h b/src/sim/core/Simulation.h
index 6c07c6c0f..a15e5b87c 100644
--- a/src/sim/core/Simulation.h
+++ b/src/sim/core/Simulation.h
@@ -192,6 +192,7 @@ class Simulation {
         bool const legacyEnergyModel=false
     );
 
+    virtual ~Simulation() = default; 
     // ***  SIMULATION METHODS  *** //
     // **************************** //
     /**
diff --git a/src/test/EnergyModelsTest.h b/src/test/EnergyModelsTest.h
index f365143f8..c576b6355 100644
--- a/src/test/EnergyModelsTest.h
+++ b/src/test/EnergyModelsTest.h
@@ -168,13 +168,14 @@ bool EnergyModelsTest::testEllipticalFootprintEnergy(){
         0.15, // receiverDiameter_m
         9.07603791e-6, // atmosphericExtinction
         1.064e-06, // wavelength_m
-        nullptr, // rangeErrExpr
         false, // Write waveform
         false, // Write pulse
         false, // Calc echowidth
         false, // Fullwave noise
-        false // Platform noise disabled
+        false, // Platform noise disabled
+        nullptr // rangeErrExpr
     );
+    
     std::shared_ptr<AbstractDetector> detector = std::make_shared<
         FullWaveformPulseDetector
     >(
diff --git a/src/test/SurveyCopyTest.h b/src/test/SurveyCopyTest.h
index 121f0748b..e8c00593b 100644
--- a/src/test/SurveyCopyTest.h
+++ b/src/test/SurveyCopyTest.h
@@ -54,11 +54,12 @@ bool SurveyCopyTest::run(){
         0.7,
         0.8,
         100,
-        nullptr,
         false,
         false,
         false,
-        true
+        true,
+        false,
+        nullptr // rangeErrExpr
     );
     survey->scanner->setScannerHead(std::make_shared<ScannerHead>(
         glm::dvec3(0.4, 0.7, 0.1), 0.067
diff --git a/tests/python/__init__.py b/tests/python/__init__.py
new file mode 100755
index 000000000..bb377e899
--- /dev/null
+++ b/tests/python/__init__.py
@@ -0,0 +1 @@
+import pytest
\ No newline at end of file
diff --git a/tests/python/test_bindings.py b/tests/python/test_bindings.py
new file mode 100755
index 000000000..16b016a85
--- /dev/null
+++ b/tests/python/test_bindings.py
@@ -0,0 +1,1477 @@
+
+import _helios
+import numpy as np
+import math 
+import threading
+from unittest.mock import MagicMock, patch
+import pytest
+
+
+def tuple_to_dvec3(t):
+    return _helios.dvec3(*t)
+
+def tup_add(v1, v2):
+    return (v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2])
+
+def tup_mul(v, scalar):
+    return (v[0] * scalar, v[1] * scalar, v[2] * scalar)
+
+def test_aabb_instantiation():
+    aabb = _helios.AABB()
+    assert aabb is not None, "Failed to create AABB instance"
+
+def test_aabb_properties():
+    aabb = _helios.AABB()
+    min_vertex = aabb.min_vertex
+    max_vertex = aabb.max_vertex
+    assert isinstance(min_vertex, _helios.Vertex), "min_vertex should be a Vertex instance"
+    assert isinstance(max_vertex, _helios.Vertex), "max_vertex should be a Vertex instance"
+
+def test_vertex_properties():
+    v = _helios.Vertex(1.0, 2.0, 3.0)
+    position = v.position
+    normal = v.normal
+    assert position == (1.0, 2.0, 3.0), "Position should be [1.0, 2.0, 3.0]"
+    assert normal == (0.0, 0.0, 0.0), "Normal should be [0.0, 0.0, 0.0] by default"
+
+def test_vertex_instantiation():
+    v = _helios.Vertex(1.0, 2.0, 3.0)
+    assert isinstance(v, _helios.Vertex)
+    assert v.position == (1.0, 2.0, 3.0)
+
+def test_vertex_default_instantiation():
+    v = _helios.Vertex()
+    assert isinstance(v, _helios.Vertex)
+    assert v.position == (0.0, 0.0, 0.0)
+    assert v.normal == (0.0, 0.0, 0.0)
+
+def test_triangle_instantiation():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    assert isinstance(triangle, _helios.Triangle), "Failed to create Triangle instance"
+
+def test_primitive_properties():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    assert triangle.scene_part is None, "scene_part should be None by default"
+    assert triangle.material is None, "material should be None by default"
+
+def test_triangle_face_normal():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    face_normal = triangle.face_normal
+    assert isinstance(face_normal, tuple) and len(face_normal) == 3, "face_normal should be a 3-tuple"
+
+def test_primitive_ray_intersection():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    ray_origin = (0.5, 0.5, 1.0)
+    ray_dir = (0.0, 0.0, -1.0)
+    intersections = triangle.ray_intersection(ray_origin, ray_dir)
+    expected_intersections = (0.5, 0.5, 0.0)
+    
+    # Verify the results
+    if intersections[0] == -1:
+        # No intersection, handle accordingly
+        assert False, "No intersection found"
+    else:
+        # Calculate the intersection point
+        t = intersections[0]
+        intersection_point = tup_add(ray_origin, tup_mul(ray_dir, t))
+        
+        expected_intersection_point = (0.5, 0.5, 0.0)
+
+    assert len(intersection_point) == len(expected_intersections), "Number of intersections does not match"
+    for i, intersection in enumerate(intersection_point):
+        assert intersection == expected_intersections[i], f"Intersection at index {i} does not match"
+    ray_origin = (0.5, 0.5, 1.0)
+    ray_dir = (0.0, 0.0, -1.0)
+    intersections = triangle.ray_intersection(ray_origin, ray_dir) 
+    assert len(intersections) > 0, "The intersections list should not be empty"
+    assert intersections[0] == -1 or isinstance(intersections[0], float), "The intersection should be a float or -1"
+
+def test_primitive_ray_intersection_distance():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    ray_origin = (0.5, 0.5, 1.0)
+    ray_dir = (0.0, 0.0, -1.0)
+    distance = triangle.ray_intersection_distance(ray_origin, ray_dir)
+    assert isinstance(distance, float), "ray_intersection_distance should return a float"
+    assert distance > 0, "The distance should be greater than 0"
+
+def test_primitive_incidence_angle():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    ray_origin = (0.5, 0.5, 1.0)
+    ray_dir = (0.0, 0.0, -1.0)
+    intersection_point = (0.5, 0.5, 0.0)
+    incidence_angle = triangle.incidence_angle(ray_origin, ray_dir, intersection_point)
+    expected_angle = 0.0  # This value depends on your implementation and expected result
+    
+    # Verify the result
+    assert abs(incidence_angle - expected_angle) < 1e-6, f"Incidence angle {incidence_angle} is not close to expected value {expected_angle}"
+    ray_origin = (0.5, 0.5, 1.0)
+    ray_dir = (0.0, 0.0, -1.0)
+    intersection_point = (0.5, 0.5, 0.0)
+    incidence_angle = triangle.incidence_angle(ray_origin, ray_dir, intersection_point)
+    assert isinstance(incidence_angle, float), "incidence_angle should return a float"
+
+
+def test_primitive_update():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    triangle.update()
+    # No assert needed; just ensure the method call does not raise an exception
+
+def test_primitive_num_vertices():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    num_vertices = len(triangle.vertices)
+    assert num_vertices == 3, "num_vertices should return 3"
+#GLMDVEC3
+def test_primitive_vertices():
+    v0 = _helios.Vertex(0.0, 0.0, 0.0)
+    v1 = _helios.Vertex(1.0, 0.0, 0.0)
+    v2 = _helios.Vertex(0.0, 1.0, 0.0)
+    triangle = _helios.Triangle(v0, v1, v2)
+    ray_origin = (0.5, 0.5, 1.0)
+    ray_dir = (0.0, 0.0, -1.0)
+    intersections = triangle.ray_intersection(ray_origin, ray_dir)
+   
+    assert len(intersections) > 0, "The intersections list should not be empty"
+    assert intersections[0] == -1 or isinstance(intersections[0], float), "The intersection should be a float or -1"
+
+
+
+def test_detailed_voxel_instantiation():
+    double_values = [0.1, 0.2, 0.3]
+    voxel = _helios.DetailedVoxel([1.0, 2.0, 3.0], 0.5, [1, 2], double_values)#[0.1, 0.2, 0.3])
+    assert isinstance(voxel, _helios.DetailedVoxel)
+    assert voxel.nb_echos == 1
+    assert voxel.nb_sampling == 2
+
+def test_detailed_voxel_properties():
+    double_values = [0.1, 0.2, 0.3]
+    voxel = _helios.DetailedVoxel([1.0, 2.0, 3.0], 0.5, [1, 2], double_values)
+    voxel.nb_echos = 3
+    assert voxel.nb_echos == 3
+    voxel.nb_sampling = 4
+    assert voxel.nb_sampling == 4
+    assert voxel.number_of_double_values == 3
+    voxel.max_pad = 0.6
+    assert voxel.max_pad == 0.6
+    voxel.set_double_value(1, 0.5)
+    assert voxel.get_double_value(1) == 0.5
+
+def test_trajectory_instantiation():
+    # Test default constructor
+    traj = _helios.Trajectory()
+    assert isinstance(traj, _helios.Trajectory)
+    assert traj.gps_time == 0.0
+    assert traj.position == (0.0, 0.0, 0.0)
+    assert traj.roll == 0.0
+    assert traj.pitch == 0.0
+    assert traj.yaw == 0.0
+
+    # Test parameterized constructor
+    gps_time = 1234567890.0
+    position = [1.0, 2.0, 3.0]
+    roll, pitch, yaw = 0.1, 0.2, 0.3
+    traj = _helios.Trajectory(gps_time, position, roll, pitch, yaw)
+    assert isinstance(traj, _helios.Trajectory)
+    assert traj.gps_time == gps_time
+    assert np.allclose(traj.position, position)
+    assert traj.roll == roll
+    assert traj.pitch == pitch
+    assert traj.yaw == yaw
+
+def test_trajectory_property():
+    traj = _helios.Trajectory()
+    # Test setting and getting properties
+    traj.gps_time = 123.456
+    assert traj.gps_time == 123.456
+    
+    traj.position = [4.0, 5.0, 6.0]
+    assert np.allclose(traj.position, [4.0, 5.0, 6.0])
+    
+    traj.roll = 0.4
+    assert traj.roll == 0.4
+    
+    traj.pitch = 0.5
+    assert traj.pitch == 0.5
+    
+    traj.yaw = 0.6
+    assert traj.yaw == 0.6
+
+def test_noise_source_instantiation():
+    noise_src = _helios.NoiseSource()
+    assert isinstance(noise_src, _helios.NoiseSource)
+    
+    # Check default properties
+    assert noise_src.clip_min == 0.0
+    assert noise_src.clip_max == 1.0
+    assert not noise_src.clip_enabled
+    assert not noise_src.fixed_value_enabled
+    assert noise_src.fixed_lifespan == 1 
+    assert noise_src.fixed_value_remaining_uses == 0
+
+def test_noise_source_properties():
+    noise_src = _helios.NoiseSource()
+    
+    # Test property setters and getters
+    noise_src.clip_min = -1.0
+    assert noise_src.clip_min == -1.0
+    
+    noise_src.clip_max = 2.0
+    assert noise_src.clip_max == 2.0
+    
+    noise_src.clip_enabled = True
+    assert noise_src.clip_enabled
+    
+    noise_src.fixed_lifespan = 0
+    assert noise_src.fixed_lifespan == 0
+    
+    noise_src.fixed_value_remaining_uses = 5
+    assert noise_src.fixed_value_remaining_uses == 5
+    
+
+def test_randomness_generator_instantiation():
+    rng = _helios.RandomnessGenerator()
+    assert isinstance(rng, _helios.RandomnessGenerator)
+
+def test_randomness_generator_methods():
+    rng = _helios.RandomnessGenerator()
+    
+    # Test uniform real distribution
+    rng.compute_uniform_real_distribution(0.0, 1.0)
+    
+    uniform_value = rng.uniform_real_distribution_next()
+    assert isinstance(uniform_value, float) or isinstance(uniform_value, np.float64)
+    
+    # Test normal distribution
+    rng.compute_normal_distribution(0.0, 1.0)
+    
+    normal_value = rng.normal_distribution_next()
+    assert isinstance(normal_value, float) or isinstance(normal_value, np.float64)
+
+
+def test_ray_scene_intersection_instantiation():
+    # Test default constructor
+    rsi = _helios.RaySceneIntersection()
+    assert isinstance(rsi, _helios.RaySceneIntersection)
+    assert rsi.primitive is None
+    assert rsi.point == (0.0, 0.0, 0.0)
+    assert rsi.incidence_angle == 0.0
+
+def test_ray_scene_intersection_properties():
+    rsi = _helios.RaySceneIntersection()
+    
+    # Test setting and getting properties
+    rsi.point = (1.0, 2.0, 3.0)
+    assert rsi.point == (1.0, 2.0, 3.0)
+    
+    rsi.incidence_angle = 45.0
+    assert rsi.incidence_angle == 45.0
+
+def test_scanning_strip_instantiation():
+    # Test default constructor
+    strip = _helios.ScanningStrip("custom_strip1")
+    assert isinstance(strip, _helios.ScanningStrip)
+    assert strip.strip_id == "custom_strip1"  # Correctly accessing property
+
+    # Test constructor with custom strip ID
+    custom_id = "custom_strip"
+    strip = _helios.ScanningStrip(custom_id)
+    assert strip.strip_id == custom_id   # Correctly accessing property
+
+def test_scanning_strip_methods():
+    strip = _helios.ScanningStrip("custom_strip2")
+    
+    # Create a leg and add it to the strip to test `has` method
+    leg = _helios.Leg(10.0, 1, strip)
+    assert strip.has(1)
+    assert not strip.has(2)  # Not in the strip
+
+def test_fwf_settings_instantiation():
+    # Test default constructor
+    fwf = _helios.FWFSettings()
+    assert isinstance(fwf, _helios.FWFSettings)
+    
+    # Check default values
+    assert fwf.bin_size == 0.25
+    assert fwf.min_echo_width == 2.5
+    assert fwf.peak_energy == 500.0
+    assert fwf.aperture_diameter == 0.15
+    assert fwf.scanner_efficiency == 0.9
+    assert fwf.atmospheric_visibility == 0.9
+    assert fwf.scanner_wave_length == 1550.0
+    assert fwf.beam_divergence_angle == 0.0003
+    assert fwf.pulse_length == 4.0
+    assert fwf.beam_sample_quality == 3
+    assert fwf.win_size == fwf.pulse_length / 4.0
+    assert fwf.max_fullwave_range == 0.0
+
+def test_fwf_settings_set_get_properties():
+    fwf = _helios.FWFSettings()
+    
+    # Set properties
+    fwf.bin_size = 0.5
+    fwf.min_echo_width = 3.0
+    fwf.peak_energy = 600.0
+    fwf.aperture_diameter = 0.2
+    fwf.scanner_efficiency = 0.85
+    fwf.atmospheric_visibility = 0.95
+    fwf.scanner_wave_length = 1600.0
+    fwf.beam_divergence_angle = 0.0005
+    fwf.pulse_length = 5.0
+    fwf.beam_sample_quality = 4
+    fwf.win_size = 1.25
+    fwf.max_fullwave_range = 100.0
+
+    # Verify values
+    assert fwf.bin_size == 0.5
+    assert fwf.min_echo_width == 3.0
+    assert fwf.peak_energy == 600.0
+    assert fwf.aperture_diameter == 0.2
+    assert fwf.scanner_efficiency == 0.85
+    assert fwf.atmospheric_visibility == 0.95
+    assert fwf.scanner_wave_length == 1600.0
+    assert fwf.beam_divergence_angle == 0.0005
+    assert fwf.pulse_length == 5.0
+    assert fwf.beam_sample_quality == 4
+    assert fwf.win_size == 1.25
+    assert fwf.max_fullwave_range == 100.0
+
+def test_fwf_settings_to_string():
+    fwf = _helios.FWFSettings()
+    expected_str = (
+        'FWFSettings "":\n'
+        'binSize_ns = 0.25\n'
+        'minEchoWidth = 2.5\n'
+        'peakEnergy = 500\n'
+        'apertureDiameter = 0.15\n'
+        'scannerEfficiency = 0.9\n'
+        'atmosphericVisibility = 0.9\n'
+        'scannerWaveLength = 1550\n'
+        'beamDivergence_rad = 0.0003\n'
+        'pulseLength_ns = 4\n'
+        'beamSampleQuality = 3\n'
+        'winSize_ns = 1\n'
+        'maxFullwaveRange_ns = 0\n'
+    )
+    assert str(fwf) == expected_str
+
+
+
+def test_rotation_instantiation():
+    # Test default constructor
+    rotation = _helios.Rotation()
+    assert isinstance(rotation, _helios.Rotation)
+
+    # Test constructors with parameters
+    rotation_q = _helios.Rotation(1.0, 0.0, 0.0, 0.0, True)
+    rotation_q = _helios.Rotation(1.0, 0.0, 0.0, 0.0, True)
+    assert math.isclose(rotation_q.q0, 1.0)
+    assert math.isclose(rotation_q.q1, 0.0)
+    assert math.isclose(rotation_q.q2, 0.0)
+    assert math.isclose(rotation_q.q3, 0.0)
+
+    axis = (1.0, 0.0, 0.0)
+    angle = math.pi / 2
+    rotation_a = _helios.Rotation(axis, angle)
+    assert rotation_a.axis == axis
+    assert math.isclose(rotation_a.angle, angle)
+
+def test_rotation_set_get_properties():
+    rotation = _helios.Rotation()
+    
+    # Set properties
+    rotation.q0 = 0.707
+    rotation.q1 = 0.0
+    rotation.q2 = 0.707
+    rotation.q3 = 0.0
+    
+    assert math.isclose(rotation.q0, 0.707)
+    assert math.isclose(rotation.q1, 0.0)
+    assert math.isclose(rotation.q2, 0.707)
+    assert math.isclose(rotation.q3, 0.0)
+
+    axis = (0.0, 1.0, 0.0)
+    angle = math.pi / 2
+    rotation = _helios.Rotation(axis, angle)
+    assert rotation.axis == axis
+    assert math.isclose(rotation.angle, angle)
+
+
+def test_scanner_head_instantiation():
+    # Test constructor with parameters
+    axis = (1.0, 0.0, 0.0)
+    head_rotate_per_sec_max = 1.5
+    scanner_head = _helios.ScannerHead(axis, head_rotate_per_sec_max)
+    assert isinstance(scanner_head, _helios.ScannerHead)
+
+def test_scanner_head_properties():
+    axis = (1.0, 0.0, 0.0)
+    head_rotate_per_sec_max = 1.5
+    scanner_head = _helios.ScannerHead(axis, head_rotate_per_sec_max)
+    
+    # Test readonly property
+    assert scanner_head.mount_relative_attitude is not None
+    
+    # Test read/write properties
+    scanner_head.rotate_per_sec_max = 2.0
+    assert scanner_head.rotate_per_sec_max == 2.0
+
+    scanner_head.rotate_per_sec = 1.0
+    assert scanner_head.rotate_per_sec == 1.0
+
+    scanner_head.rotate_stop = 0.0
+    assert scanner_head.rotate_stop == 0.0
+
+    scanner_head.rotate_start = 1.0
+    assert scanner_head.rotate_start == 1.0
+
+    scanner_head.rotate_range = 2.0
+    assert scanner_head.rotate_range == 2.0
+
+    scanner_head.current_rotate_angle = 1.0
+    assert scanner_head.current_rotate_angle == 1.0
+
+def test_material_instantiation():
+    # Test default constructor
+    material = _helios.Material()
+    assert isinstance(material, _helios.Material)
+
+    # Test copy constructor
+    material_copy = _helios.Material(material)
+    assert isinstance(material_copy, _helios.Material)
+
+def test_material_properties():
+    material = _helios.Material()
+
+    # Test read/write properties
+    material.name = "TestMaterial"
+    assert material.name == "TestMaterial"
+
+    material.is_ground = True
+    assert material.is_ground is True
+
+    material.use_vertex_colors = False
+    assert material.use_vertex_colors is False
+
+    material.mat_file_path = "path/to/material.mat"
+    assert material.mat_file_path == "path/to/material.mat"
+
+    material.map_kd = "path/to/mapKd.png"
+    assert material.map_kd == "path/to/mapKd.png"
+
+    material.reflectance = 0.5
+    assert material.reflectance == 0.5
+
+    material.specularity = 0.8
+    assert material.specularity == 0.8
+
+    material.specular_exponent = 32
+    assert material.specular_exponent == 32
+
+    material.classification = 1
+    assert material.classification == 1
+
+    material.spectra = "SpectraData"
+    assert material.spectra == "SpectraData"
+
+    # Test readonly properties (assuming ka, kd, ks are arrays in the material class)
+    ka_array = np.array([0, 0, 0, 0], dtype=np.float32)
+    kd_array = np.array([0, 0, 0, 0], dtype=np.float32)
+    ks_array = np.array([0, 0, 0, 0], dtype=np.float32)
+
+    assert np.array_equal(material.ambient_components, ka_array)
+    assert np.array_equal(material.diffuse_components, kd_array)
+    assert np.array_equal(material.specular_components, ks_array)
+
+
+def test_survey_instantiation():
+    # Test default constructor
+    survey = _helios.Survey()
+    assert isinstance(survey, _helios.Survey)
+
+
+def test_survey_properties():
+    survey = _helios.Survey()
+
+    # Test read/write properties
+    survey.name = "TestSurvey"
+    assert survey.name == "TestSurvey"
+
+    survey.num_runs = 5
+    assert survey.num_runs == 5
+
+    survey.sim_speed_factor = 1.5
+    assert survey.sim_speed_factor == 1.5
+
+    # Test readonly property
+    length = survey.length
+    assert isinstance(length, float)
+
+def create_and_modify_leg_with_platform_and_scanner_settings():
+    # Create ScannerSettings object
+    scanner_settings = _helios.ScannerSettings()
+    scanner_settings.id = "TestScannerSettings"
+    scanner_settings.head_rotation = 1.0
+    scanner_settings.rotation_start_angle = 0.0
+    scanner_settings.rotation_stop_angle = 2.0
+    scanner_settings.pulse_frequency = 10
+    scanner_settings.scan_angle = 180
+    scanner_settings.min_vertical_angle = -90
+    scanner_settings.max_vertical_angle = 90
+    scanner_settings.scan_frequency = 5
+    scanner_settings.beam_divergence_angle = 0.01
+    scanner_settings.trajectory_time_interval = 1.0
+    scanner_settings.vertical_resolution = 0.5
+    scanner_settings.horizontal_resolution = 0.5
+
+    platform_settings = _helios.PlatformSettings()
+    platform_settings.id = "TestPlatformSettings"
+    platform_settings.x = 1.0
+    platform_settings.y = 2.0
+    platform_settings.z = 3.0
+    platform_settings.yaw_angle = 45.0
+    platform_settings.is_yaw_angle_specified = True
+    platform_settings.is_on_ground = True
+    platform_settings.is_stop_and_turn = False
+    platform_settings.is_smooth_turn = True
+    platform_settings.is_slowdown_enabled = False
+    platform_settings.speed_m_s = 15.0
+    
+    # Create Leg object with ScannerSettings
+    leg = _helios.Leg(10.0, 1, None)
+    leg.scanner_settings = scanner_settings
+    leg.platform_settings = platform_settings
+    leg.length = 15.0
+    leg.serial_id = 2
+    leg.strip = None
+    
+    return leg, scanner_settings, platform_settings
+
+# Test basic functionality
+def test_leg_and_scanner_settings():
+    leg, scanner_settings, platform_settings = create_and_modify_leg_with_platform_and_scanner_settings()
+    
+    # Test properties and methods for Leg
+    assert leg.length == 15.0
+    assert leg.serial_id == 2
+    assert leg.strip is None
+    assert leg.belongs_to_strip() is False
+    
+    leg.length = 20.0
+    assert leg.length == 20.0
+    
+    leg.serial_id = 3
+    assert leg.serial_id == 3
+    
+    # Test properties and methods for ScannerSettings
+    assert scanner_settings.id == "TestScannerSettings"
+    assert scanner_settings.head_rotation == 1.0
+    assert scanner_settings.rotation_start_angle == 0.0
+    assert scanner_settings.rotation_stop_angle == 2.0
+    assert scanner_settings.pulse_frequency == 10
+    assert scanner_settings.scan_angle == 180
+    assert scanner_settings.min_vertical_angle == -90
+    assert scanner_settings.max_vertical_angle == 90
+    assert scanner_settings.scan_frequency == 5
+    assert scanner_settings.beam_divergence_angle == 0.01
+    assert scanner_settings.trajectory_time_interval == 1.0
+    assert scanner_settings.vertical_resolution == 0.5
+    assert scanner_settings.horizontal_resolution == 0.5
+
+    assert platform_settings.id == "TestPlatformSettings"
+    assert platform_settings.x == 1.0
+    assert platform_settings.y == 2.0
+    assert platform_settings.z == 3.0
+    assert platform_settings.yaw_angle == 45.0
+    assert platform_settings.is_yaw_angle_specified is True
+    assert platform_settings.is_on_ground is True
+    assert platform_settings.is_stop_and_turn is False
+    assert platform_settings.is_smooth_turn is True
+    assert platform_settings.is_slowdown_enabled is False
+    assert platform_settings.speed_m_s == 15.0
+
+# Test thread safety by modifying the same Leg and ScannerSettings object in multiple threads
+def test_leg_and_scanner_settings_thread_safety():
+    def thread_function():
+        leg, scanner_settings, platform_settings = create_and_modify_leg_with_platform_and_scanner_settings()
+        
+        # Perform concurrent modifications
+        for i in range(100):
+            leg.length = 10.0 + i
+            leg.serial_id = i
+            scanner_settings.head_rotation = i * 0.1
+            scanner_settings.pulse_frequency = i
+            platform_settings.x = i
+            platform_settings.y = i + 1
+            platform_settings.z = i + 2
+        
+        # Validate after modifications
+        assert leg.length == 109.0
+        assert leg.serial_id == 99
+        assert scanner_settings.head_rotation == 9.9
+        assert scanner_settings.pulse_frequency == 99
+        assert platform_settings.x == 99
+        assert platform_settings.y == 100
+        assert platform_settings.z == 101
+    
+    threads = [threading.Thread(target=thread_function) for _ in range(10)]
+    
+    for thread in threads:
+        thread.start()
+    
+    for thread in threads:
+        thread.join()
+
+
+def create_scene_part():
+    # Create a ScenePart object
+    scene_part = _helios.ScenePart()
+    scene_part.id = "TestPart"
+    scene_part.origin = (1.0, 2.0, 3.0)
+    scene_part.rotation = _helios.Rotation((0.0, 1.0, 0.0), 1.0)
+    scene_part.origin = (1.0, 2.0, 3.0)
+    scene_part.rotation = _helios.Rotation((0.0, 1.0, 0.0), 1.0)
+    scene_part.scale = 2.0
+    
+    return scene_part
+
+# Test basic ScenePart functionality
+def test_scene_part():
+    scene_part = create_scene_part()
+    
+    # Test properties
+    assert scene_part.id == "TestPart"
+    assert scene_part.origin == (1.0, 2.0, 3.0)
+    assert scene_part.rotation.axis == (0.0, 1.0, 0.0)
+    assert scene_part.origin == (1.0, 2.0, 3.0)
+    assert scene_part.rotation.axis ==(0.0, 1.0, 0.0)
+    assert scene_part.rotation.angle == 1.0
+    assert scene_part.scale == 2.0
+    
+    # Modify properties
+    scene_part.id = "UpdatedPart"
+    scene_part.origin = (4.0, 5.0, 6.0)
+    scene_part.origin = (4.0, 5.0, 6.0)
+    scene_part.rotation = _helios.Rotation((1.0, 0.0, 0.0), 2.0)
+    scene_part.rotation = _helios.Rotation((1.0, 0.0, 0.0), 2.0)
+    scene_part.scale = 3.0
+    
+    assert scene_part.id == "UpdatedPart"
+    assert scene_part.origin == (4.0, 5.0, 6.0)
+    assert scene_part.rotation.axis == (1.0, 0.0, 0.0)
+    assert scene_part.origin == (4.0, 5.0, 6.0)
+    assert scene_part.rotation.axis == (1.0, 0.0, 0.0)
+    assert scene_part.rotation.angle == 2.0
+    assert scene_part.scale == 3.0
+
+
+def test_scene_part_thread_safety():
+    # Create a ScenePart object
+    scene_part = create_scene_part()
+    lock = threading.Lock()
+    
+    modify_scene_part_in_threads(scene_part, lock)
+
+    # Debugging print statements
+    with lock:
+        final_rotation_axis = (scene_part.rotation.axis[0], scene_part.rotation.axis[1], scene_part.rotation.axis[2])
+        tolerance = 1e-6
+
+        # Check if the values are close to what you expect, considering numerical precision issues
+        assert math.isclose(final_rotation_axis[0]**2 + final_rotation_axis[1]**2 + final_rotation_axis[2]**2, 1, abs_tol=tolerance), \
+            f"Rotation axis should be a unit vector but got {final_rotation_axis}"
+
+def modify_scene_part_in_threads(scene_part, lock):
+    def thread_function():
+        with lock:
+            for i in range(100):
+                scene_part.id = f"ThreadPart-{i}"
+                scene_part.origin = (i, i + 1, i + 2)
+                # Assuming rotation is defined as (axis, angle)
+                axis = (i % 2, (i + 1) % 2, (i + 2) % 2)
+                angle = i * 0.1
+                scene_part.rotation = _helios.Rotation(axis, angle)
+                scene_part.scale = i * 0.1
+
+    threads = [threading.Thread(target=thread_function) for _ in range(10)]
+
+    for thread in threads:
+        thread.start()
+
+    for thread in threads:
+        thread.join()
+
+
+def test_scene_properties():
+    scene = _helios.Scene()
+    
+    # Test adding a new triangle
+    triangle = scene.new_triangle()
+    assert triangle is not None
+    assert isinstance(triangle, _helios.Triangle)
+
+    # Test adding a new detailed voxel
+    voxel = scene.new_detailed_voxel()
+    assert voxel is not None
+    assert isinstance(voxel, _helios.DetailedVoxel)
+
+
+def test_platform_properties():
+    platform = _helios.Platform()
+
+    # Test read-write properties
+    platform.last_check_z = 10.0
+    assert platform.last_check_z == 10.0
+
+    platform.dmax = 100.0
+    assert platform.dmax == 100.0
+
+    platform.is_orientation_on_leg_init = True
+    assert platform.is_orientation_on_leg_init == True
+
+    platform.is_on_ground = True
+    assert platform.is_on_ground == True
+
+    platform.is_stop_and_turn = True
+    assert platform.is_stop_and_turn == True
+
+    platform.settings_speed_m_s = 5.0
+    assert platform.settings_speed_m_s == 5.0
+
+    platform.is_slowdown_enabled = False
+    assert platform.is_slowdown_enabled == False
+
+    platform.is_smooth_turn = True
+    assert platform.is_smooth_turn == True
+
+    # Test read-only properties
+    assert platform.device_relative_position[0] == 0.0
+    assert platform.device_relative_position[1] == 0.0
+    assert platform.device_relative_position[2] == 0.0
+
+    assert isinstance(platform.device_relative_attitude, _helios.Rotation)
+    assert platform.device_relative_attitude.axis == (1.0, 0.0, 0.0)
+    assert platform.device_relative_attitude.angle == 0.0
+
+    assert platform.position_x_noise_source is None
+    assert platform.position_y_noise_source is None
+    assert platform.position_z_noise_source is None
+    assert platform.attitude_x_noise_source is None
+    assert platform.attitude_y_noise_source is None
+    assert platform.attitude_z_noise_source is None
+
+   
+    assert platform.target_waypoint[0] == 0.0
+    assert platform.target_waypoint[1] == 0.0
+    assert platform.target_waypoint[2] == 0.0
+
+    assert platform.last_ground_check[0] == 0.0
+    assert platform.last_ground_check[1] == 0.0
+    assert platform.last_ground_check[2] == 0.0
+
+
+    assert platform.position[0] == 0.0
+    assert platform.position[1] == 0.0
+    assert platform.position[2] == 0.0
+
+
+    assert platform.attitude.axis == (1.0, 0.0, 0.0)
+    assert platform.attitude.angle == 0.0
+
+    assert platform.absolute_mount_position[0] == 0.0
+    assert platform.absolute_mount_position[1] == 0.0
+    assert platform.absolute_mount_position[2] == 0.0
+
+    assert platform.absolute_mount_attitude.axis == (1.0, 0.0, 0.0)
+    assert platform.absolute_mount_attitude.angle == 0.0
+
+   
+    assert platform.cached_dir_current[0] == 0.0
+    assert platform.cached_dir_current[1] == 0.0
+    assert platform.cached_dir_current[2] == 0.0
+
+    assert platform.cached_dir_current_xy[0] == 0.0
+    assert platform.cached_dir_current_xy[1] == 0.0
+    assert platform.cached_dir_current_xy[2] == 0.0
+
+    assert platform.cached_vector_to_target[0] == 0.0
+    assert platform.cached_vector_to_target[1] == 0.0
+    assert platform.cached_vector_to_target[2] == 0.0
+
+    assert platform.cached_vector_to_target_xy[0] == 0.0
+    assert platform.cached_vector_to_target_xy[1] == 0.0
+    assert platform.cached_vector_to_target_xy[2] == 0.0
+
+class MockBeamDeflector:
+    def __init__(self):
+        pass
+
+    def __eq__(self, other):
+        return isinstance(other, MockBeamDeflector)
+
+class MockDetector:
+    def __init__(self):
+        pass
+
+    def __eq__(self, other):
+        return isinstance(other, MockDetector)
+
+class ExampleScanner(_helios.Scanner):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._max_nor = 10
+        self._bt2 = 0.5
+        self._dr2 = 0.1
+        self._head_relative_emitter_attitude = _helios.Rotation()
+        self._head_relative_emitter_position = (0.0, 0.0, 0.0)
+        self._active = True
+        self._write_waveform = False
+        self._calc_echowidth = False
+        self._full_wave_noise = False
+        self._platform_noise_disabled = False
+        self._fixed_incidence_angle = False
+        self._id = "TestScannerID"
+        self._device_id = "Device0"
+        self._num_devices = 1
+        self._time_wave = [0.0] * 10
+        self._scanner_head = _helios.ScannerHead((0.0, 0.0, 1.0), 1.0) 
+        self._beam_deflector = MockBeamDeflector()  # Use a mock or default implementation
+        self._detector = MockDetector()
+        self._supported_pulse_freqs_hz = [1, 2, 3]
+        self._fwf_settings = _helios.FWFSettings()
+        self._peak_intensity_index = 0
+        self._received_energy_min = 0.0
+    
+    def getScannerId(self):
+        return "TestScannerID"
+
+    def getNumDevices(self):
+        return 1
+
+    def getDeviceId(self, index):
+        return f"Device{index}"
+
+    def getAveragePower(self, index):
+        return 10.0
+
+    def getBeamDivergence(self, index):
+        return 0.01
+
+    def getWavelength(self, index):
+        return 0.000532
+
+    def getVisibility(self, index):
+        return 10.0
+
+    def prepareSimulation(self, legacyEnergyModel):
+        pass
+
+    def retrieveCurrentSettings(self, idx):
+        return _helios.ScannerSettings()
+
+    def applySettings(self, settings, idx):
+        pass
+
+    def applySettingsFWF(self, fwfSettings, idx):
+        pass
+
+    def doSimStep(self, legIndex, currentGpsTime):
+        pass
+
+    def calcRaysNumber(self, idx):
+        pass
+
+    def prepareDiscretization(self, idx):
+        pass
+
+    def calcAtmosphericAttenuation(self, idx):
+        return 0.0
+
+    def calcAbsoluteBeamAttitude(self, idx):
+        return _helios.Rotation()
+
+    def checkMaxNOR(self, nor, idx):
+        return True
+
+    def onLegComplete(self):
+        pass
+
+    def onSimulationFinished(self):
+        pass
+
+    def handleTrajectoryOutput(self):
+        pass
+
+    def trackOutputPath(self):
+        pass
+
+    def getCurrentPulseNumber(self, idx):
+        return 0  # Default implementation
+
+    def getNumRays(self, idx):
+        return 0  # Default implementation
+
+    def setNumRays(self, numRays, idx):
+        pass  # Default implementation
+
+    def getPulseLength_ns(self, idx):
+        return 0.0  # Default implementation
+
+    def setPulseLength_ns(self, pulseLength_ns, idx):
+        pass  # Default implementation
+
+    def lastPulseWasHit(self, idx):
+        return False  # Default implementation
+
+    def setLastPulseWasHit(self, lastPulseWasHit, idx):
+        pass  # Default implementation
+
+    def getBeamDivergence(self, idx):
+        return 0.0  # Default implementation
+
+    def setBeamDivergence(self, beamDivergence, idx):
+        pass  # Default implementation
+
+    def getAveragePower(self, idx):
+        return 0.0  # Default implementation
+
+    def setAveragePower(self, averagePower, idx):
+        pass  # Default implementation
+
+    def getBeamQuality(self, idx):
+        return 0.0  # Default implementation
+
+    def setBeamQuality(self, beamQuality, idx):
+        pass  # Default implementation
+
+    def to_string(self):
+        return "Scanner Info"  # Default implementation
+    
+    def getEfficiency(self, idx):
+        # Default value for simplicity
+        return 85.0
+
+    def setEfficiency(self, efficiency, idx):
+        pass
+
+    def getReceiverDiameter(self, idx):
+        # Default value for simplicity
+        return 12.0
+
+    def setReceiverDiameter(self, receiverDiameter, idx):
+        pass
+
+    def getVisibility(self, idx):
+        # Default value for simplicity
+        return 10.0
+
+    def setVisibility(self, visibility, idx):
+        pass
+
+    def getWavelength(self, idx):
+        # Default value for simplicity
+        return 550.0
+
+    def setWavelength(self, wavelength, idx):
+        pass
+
+    def getAtmosphericExtinction(self, idx):
+        # Default value for simplicity
+        return 0.2
+
+    def setAtmosphericExtinction(self, atmosphericExtinction, idx):
+        pass
+
+    def getBeamWaistRadius(self, idx):
+        # Default value for simplicity
+        return 1.0
+
+    def setBeamWaistRadius(self, beamWaistRadius, idx):
+        pass
+    
+    def getMaxNOR(self, idx=0):
+        return self._max_nor
+
+    def setMaxNOR(self, maxNOR, idx=0):
+        self._max_nor = maxNOR
+
+    def getHeadRelativeEmitterAttitude(self, idx=0):
+        return self._head_relative_emitter_attitude
+
+    def setHeadRelativeEmitterAttitude(self, attitude, idx=0):
+        self._head_relative_emitter_attitude = attitude
+
+    def getHeadRelativeEmitterPosition(self, idx=0):
+        return self._head_relative_emitter_position
+
+    def setHeadRelativeEmitterPosition(self, position, idx=0):
+        self._head_relative_emitter_position = position
+
+    def getBt2(self, idx=0):
+        return self._bt2
+
+    def setBt2(self, bt2, idx=0):
+        self._bt2 = bt2
+
+    def getDr2(self, idx=0):
+        return self._dr2
+
+    def setDr2(self, dr2, idx=0):
+        self._dr2 = dr2
+
+    def isActive(self):
+        return self._active
+
+    def setActive(self, active):
+        self._active = active
+
+    def isWriteWaveform(self):
+        return self._write_waveform
+
+    def setWriteWaveform(self, write_waveform):
+        self._write_waveform = write_waveform
+
+    def isCalcEchowidth(self):
+        return self._calc_echowidth
+
+    def setCalcEchowidth(self, calc_echowidth):
+        self._calc_echowidth = calc_echowidth
+
+    def isFullWaveNoise(self):
+        return self._full_wave_noise
+
+    def setFullWaveNoise(self, full_wave_noise):
+        self._full_wave_noise = full_wave_noise
+
+    def isPlatformNoiseDisabled(self):
+        return self._platform_noise_disabled
+
+    def setPlatformNoiseDisabled(self, platform_noise_disabled):
+        self._platform_noise_disabled = platform_noise_disabled
+
+    def isFixedIncidenceAngle(self):
+        return self._fixed_incidence_angle
+
+    def setFixedIncidenceAngle(self, fixed_incidence_angle):
+        self._fixed_incidence_angle = fixed_incidence_angle
+
+    def getTimeWave(self):
+        return self._time_wave
+    
+    def getScannerHead(self, idx=0):
+        return self._scanner_head
+
+    def setScannerHead(self, scannerHead, idx=0):
+        self._scanner_head = scannerHead
+
+    def getBeamDeflector(self, idx=0):
+        return self._beam_deflector
+
+    def setBeamDeflector(self, beamDeflector, idx=0):
+        self._beam_deflector = beamDeflector
+
+    def getDetector(self, idx=0):
+        return self._detector
+
+    def setDetector(self, detector, idx=0):
+        self._detector = detector
+
+    def getSupportedPulseFreqs_Hz(self, idx):
+        return self._supported_pulse_freqs_hz
+
+    def setSupportedPulseFreqs_Hz(self, supportedPulseFreqs_Hz, idx):
+        self._supported_pulse_freqs_hz = supportedPulseFreqs_Hz
+
+    def getNumTimeBins(self, idx):
+        return len(self._time_wave)
+
+    def setNumTimeBins(self, numTimeBins, idx):
+        self._time_wave = [0.0] * numTimeBins
+
+    def getFWFSettings(self, idx):
+        return self._fwf_settings
+
+    def setFWFSettings(self, fwfSettings, idx):
+        self._fwf_settings = fwfSettings
+
+    def getPeakIntensityIndex(self, idx):
+        return self._peak_intensity_index
+
+    def setPeakIntensityIndex(self, pii, idx):
+        self._peak_intensity_index = pii
+
+    def getReceivedEnergyMin(self, idx):
+        return self._received_energy_min
+
+    def setReceivedEnergyMin(self, receivedEnergyMin_W, idx):
+        self._received_energy_min = receivedEnergyMin_W
+
+    def getTimeWave(self, idx):
+        return self._time_wave
+
+    def setTimeWave(self, timewave, idx = 0):
+        self._time_wave = timewave
+
+    def calcTimePropagation(self, timeWave, numBins, scanner):
+        # Implement a dummy propagation calculation
+        return len(timeWave) * numBins
+
+        
+    def getHeadRelativeEmitterPositionByRef(self, idx=0):
+        return self._head_relative_emitter_position
+
+    def getHeadRelativeEmitterAttitudeByRef(self, idx=0):
+        return self._head_relative_emitter_attitude 
+
+
+# Test class to define the methods
+class TestScannerMethods:
+    @pytest.fixture
+    def scanner(self):
+        return ExampleScanner(id = "SCANNER-ID", pulseFreqs = [1, 2, 3])
+
+    def test_scanner_construction(self, scanner):
+        # Test default construction
+        assert scanner is not None
+
+        # Test parameterized construction
+        scanner1 = scanner
+        scanner = ExampleScanner(scanner1)
+        assert scanner.id == "SCANNER-ID"
+
+    def test_current_pulse_number(self, scanner):
+        # Mocking getCurrentPulseNumber with index
+        with patch.object(scanner, 'getCurrentPulseNumber', return_value=42) as mock_method:
+            assert scanner.getCurrentPulseNumber(0) == 42
+            mock_method.assert_called_once_with(0)
+        
+        # Mocking getCurrentPulseNumber without index (default version)
+        with patch.object(scanner, 'getCurrentPulseNumber', return_value=42) as mock_method:
+            assert scanner.getCurrentPulseNumber() == 42
+            mock_method.assert_called_once()  # No argument should be passed
+
+    def test_scanner_methods(self, scanner):
+        # Mocking methods to test calls
+        with patch.object(scanner, 'initialize_sequential_generators', return_value=None) as mock_method:
+            scanner.initialize_sequential_generators()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'build_scanning_pulse_process', return_value=None) as mock_method:
+            scanner.build_scanning_pulse_process(0, 1, 2)
+            mock_method.assert_called_once_with(0, 1, 2)
+
+        with patch.object(scanner, 'apply_settings', return_value=None) as mock_method:
+            settings = _helios.ScannerSettings()
+            scanner.apply_settings(settings)
+            mock_method.assert_called_once_with(settings)
+
+        with patch.object(scanner, 'retrieve_current_settings', return_value=None) as mock_method:
+            scanner.retrieve_current_settings()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'apply_settings_FWF', return_value=None) as mock_method:
+            fwf_settings = _helios.FWFSettings()
+            scanner.apply_settings_FWF(fwf_settings)
+            mock_method.assert_called_once_with(fwf_settings)
+
+        with patch.object(scanner, 'do_sim_step', return_value=None) as mock_method:
+            scanner.do_sim_step(1, 123.456)
+            mock_method.assert_called_once_with(1, 123.456)
+
+        with patch.object(scanner, 'calc_rays_number', return_value=None) as mock_method:
+            scanner.calc_rays_number()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'prepare_discretization', return_value=None) as mock_method:
+            scanner.prepare_discretization()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'calc_atmospheric_attenuation', return_value=0.0) as mock_method:
+            scanner.calc_atmospheric_attenuation()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'check_max_NOR', return_value=False) as mock_method:
+            scanner.check_max_NOR(100)
+            mock_method.assert_called_once_with(100)
+
+        with patch.object(scanner, 'calc_absolute_beam_attitude', return_value=None) as mock_method:
+            scanner.calc_absolute_beam_attitude()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'handle_sim_step_noise', return_value=None) as mock_method:
+            scanner.handle_sim_step_noise()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'on_leg_complete', return_value=None) as mock_method:
+            scanner.on_leg_complete()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'on_simulation_finished', return_value=None) as mock_method:
+            scanner.on_simulation_finished()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'handle_trajectory_output', return_value=None) as mock_method:
+            scanner.handle_trajectory_output()
+            mock_method.assert_called_once()
+
+        with patch.object(scanner, 'track_output_path', return_value=None) as mock_method:
+            scanner.track_output_path()
+            mock_method.assert_called_once()
+   
+
+    def test_scanner_to_string(self, scanner):
+        result = scanner.to_string()
+        assert isinstance(result, str)
+
+    def test_efficiency(self, scanner):
+        with patch.object(scanner, 'getEfficiency', return_value=0.9) as mock_get:
+            assert scanner.getEfficiency(0) == 0.9
+            mock_get.assert_called_once_with(0)
+        
+        with patch.object(scanner, 'getEfficiency', return_value=0.9) as mock_get:
+            assert scanner.getEfficiency() == 0.9
+            mock_get.assert_called_once()
+        
+        with patch.object(scanner, 'setEfficiency') as mock_set:
+            scanner.setEfficiency(0.8, 0)
+            mock_set.assert_called_once_with(0.8, 0)
+        
+    def test_receiver_diameter(self, scanner):
+        with patch.object(scanner, 'getReceiverDiameter', return_value=50.0) as mock_get:
+            assert scanner.getReceiverDiameter(0) == 50.0
+            mock_get.assert_called_once_with(0)
+        
+        with patch.object(scanner, 'getReceiverDiameter', return_value=50.0) as mock_get:
+            assert scanner.getReceiverDiameter() == 50.0
+            mock_get.assert_called_once()
+        
+        with patch.object(scanner, 'setReceiverDiameter') as mock_set:
+            scanner.setReceiverDiameter(55.0, 0)
+            mock_set.assert_called_once_with(55.0, 0)
+
+    def test_visibility(self, scanner):
+        with patch.object(scanner, 'getVisibility', return_value=10.0) as mock_get:
+            assert scanner.getVisibility(0) == 10.0
+            mock_get.assert_called_once_with(0)
+        
+        with patch.object(scanner, 'getVisibility', return_value=10.0) as mock_get:
+            assert scanner.getVisibility() == 10.0
+            mock_get.assert_called_once()
+        
+        with patch.object(scanner, 'setVisibility') as mock_set:
+            scanner.setVisibility(12.0, 0)
+            mock_set.assert_called_once_with(12.0, 0)
+
+    def test_wavelength(self, scanner):
+        with patch.object(scanner, 'getWavelength', return_value=500.0) as mock_get:
+            assert scanner.getWavelength(0) == 500.0
+            mock_get.assert_called_once_with(0)
+        
+        with patch.object(scanner, 'getWavelength', return_value=500.0) as mock_get:
+            assert scanner.getWavelength() == 500.0
+            mock_get.assert_called_once()
+        
+        with patch.object(scanner, 'setWavelength') as mock_set:
+            scanner.setWavelength(510.0, 0)
+            mock_set.assert_called_once_with(510.0, 0)
+
+    def test_atmospheric_extinction(self, scanner):
+        with patch.object(scanner, 'getAtmosphericExtinction', return_value=0.1) as mock_get:
+            assert scanner.getAtmosphericExtinction(0) == 0.1
+            mock_get.assert_called_once_with(0)
+        
+        with patch.object(scanner, 'getAtmosphericExtinction', return_value=0.1) as mock_get:
+            assert scanner.getAtmosphericExtinction() == 0.1
+            mock_get.assert_called_once()
+        
+        with patch.object(scanner, 'setAtmosphericExtinction') as mock_set:
+            scanner.setAtmosphericExtinction(0.2, 0)
+            mock_set.assert_called_once_with(0.2, 0)
+
+    def test_beam_waist_radius(self, scanner):
+        with patch.object(scanner, 'getBeamWaistRadius', return_value=1.0) as mock_get:
+            assert scanner.getBeamWaistRadius(0) == 1.0
+            mock_get.assert_called_once_with(0)
+        
+        with patch.object(scanner, 'getBeamWaistRadius', return_value=1.0) as mock_get:
+            assert scanner.getBeamWaistRadius() == 1.0
+            mock_get.assert_called_once()
+        
+        with patch.object(scanner, 'setBeamWaistRadius') as mock_set:
+            scanner.setBeamWaistRadius(1.5, 0)
+            mock_set.assert_called_once_with(1.5, 0)
+
+  
+    def test_max_nor(self, scanner):
+        assert scanner.getMaxNOR() == 10
+
+    def test_head_relative_emitter_attitude(self, scanner):
+        attitude = _helios.Rotation()
+        scanner.setHeadRelativeEmitterAttitude(attitude)
+        assert scanner.getHeadRelativeEmitterAttitude() == attitude
+
+    def test_head_relative_emitter_position(self, scanner):
+        position = (1.0, 2.0, 3.0) 
+        assert scanner.getHeadRelativeEmitterPosition() == (0.0, 0.0, 0.0)
+
+    def test_bt2(self, scanner):
+        assert scanner.getBt2() == 0.5
+
+    def test_dr2(self, scanner):
+        assert scanner.getDr2() == 0.1
+
+    def test_is_active(self, scanner):
+        assert scanner.isActive()
+
+    def test_is_write_waveform(self, scanner):
+        assert not scanner.isWriteWaveform()
+
+    def test_is_calc_echowidth(self, scanner):
+        assert not scanner.isCalcEchowidth()
+
+    def test_is_full_wave_noise(self, scanner):
+        assert not scanner.isFullWaveNoise()
+
+    def test_is_platform_noise_disabled(self, scanner):
+        assert not scanner.isPlatformNoiseDisabled()
+
+    def test_is_fixed_incidence_angle(self, scanner):
+        assert not scanner.isFixedIncidenceAngle()
+
+    def test_device_id(self, scanner):
+        assert scanner.getDeviceId(0) == "Device0"
+
+    def test_time_wave(self,  scanner):
+        assert scanner.getTimeWave() == [0.0] * 10
+
+    def test_scanner_head(self, scanner):
+        head = _helios.ScannerHead((1.0, 0.0, 0.0), 2.0)  # Replace with actual initialization
+        scanner.setScannerHead(head, 0)
+        assert scanner.getScannerHead(0) == head
+
+    def test_beam_deflector(self, scanner):
+        deflector = MockBeamDeflector()  # Use MockBeamDeflector
+        scanner.setBeamDeflector(deflector, 0)
+        assert scanner.getBeamDeflector(0) == deflector
+
+
+    def test_detector(self, scanner):
+        detector = MockDetector()  # Use MockDetector
+        scanner.setDetector(detector, 0)
+        assert scanner.getDetector(0) == detector
+
+    def test_supported_pulse_freqs_hz(self, scanner):
+        freqs = [1, 2, 3]  # Example frequencies
+        scanner.setSupportedPulseFreqs_Hz(freqs, 0)
+        assert list(scanner.getSupportedPulseFreqs_Hz(0)) == freqs
+
+    def test_num_time_bins(self, scanner):
+        scanner.setNumTimeBins(10, 0)
+        assert scanner.getNumTimeBins(0) == 10
+
+    def test_fwf_settings(self, scanner):
+        fwf_settings = _helios.FWFSettings()  # Replace with actual initialization
+        scanner.setFWFSettings(fwf_settings, 0)
+        assert scanner.getFWFSettings(0) == fwf_settings
+
+    def test_peak_intensity_index(self, scanner):
+        scanner.setPeakIntensityIndex(5, 0)
+        assert scanner.getPeakIntensityIndex(0) == 5
+
+    def test_received_energy_min(self, scanner):
+        scanner.setReceivedEnergyMin(1.5, 0)
+        assert scanner.getReceivedEnergyMin(0) == 1.5
+
+    def test_time_wave(self, scanner):
+        time_wave = np.linspace(0, 1, 100).tolist()
+        scanner.setTimeWave(time_wave, 0)
+        assert np.allclose(scanner.getTimeWave(0), time_wave)
+
+    def test_scanner_head_default(self, scanner):
+        head = _helios.ScannerHead((1.0, 0.0, 0.0), 2.0)  # Replace with actual initialization
+        scanner.setScannerHead(head)
+        assert scanner.getScannerHead() == head
+
+    def test_beam_deflector_default(self, scanner):
+        deflector = MockBeamDeflector()  # Replace with actual initialization
+        scanner.setBeamDeflector(deflector)
+        assert scanner.getBeamDeflector() == deflector
+
+    def test_detector_default(self, scanner):
+        detector = MockDetector()  # Replace with actual initialization
+        scanner.setDetector(detector)
+        assert scanner.getDetector() == detector
+
+    def test_supported_pulse_freqs_hz_default(self, scanner):
+        freqs = [1, 2, 3]  # Example frequencies
+        scanner.setSupportedPulseFreqs_Hz(freqs, 0)
+        assert list(scanner.getSupportedPulseFreqs_Hz(0)) == freqs
+
+
+    def test_get_head_relative_emitter_position_by_ref(self, scanner):
+        pos = (1.0, 2.0, 3.0)
+        scanner.setHeadRelativeEmitterPosition(pos)
+        pos_ref = scanner.getHeadRelativeEmitterPositionByRef()
+        assert pos_ref[0] == pos[0]
+        assert pos_ref[1] == pos[1]
+        assert pos_ref[2] == pos[2]
+
+    def test_get_head_relative_emitter_attitude_by_ref(self, scanner):
+        attitude = _helios.Rotation()  # Use appropriate initialization
+        scanner.setHeadRelativeEmitterAttitude(attitude)
+        attitude_ref = scanner.getHeadRelativeEmitterAttitudeByRef()
+        assert attitude_ref == attitude
+
+
+    def test_calc_time_propagation(self, scanner):
+        time_wave = np.linspace(0, 1, 100).tolist()
+        num_bins = len(time_wave)
+        scanner.setTimeWave(time_wave)
+        result = scanner.calcTimePropagation(time_wave, num_bins, scanner)
+        assert isinstance(result, int)  # Replace with expected value if applicable
+
+
+def test_simulation_initialization():
+    sim = _helios.PyheliosSimulation()
+    assert sim is not None
+
+def test_simulation_initialization_with_params():
+    sim = _helios.PyheliosSimulation(
+        "surveyPath",
+        ("assetsPath1", "assetsPath2"),
+        "outputPath",
+        4, # numThreads
+        True, # lasOutput
+        False, # las10
+        True, # zipOutput
+        False, # splitByChannel
+        3, # kdtFactory
+        2, # kdtJobs
+        64, # kdtSAHLossNodes
+        2, # parallelizationStrategy
+        64, # chunkSize
+        2 # warehouseFactor
+    )
+    assert sim is not None
diff --git a/tests/python/test_leg.py b/tests/python/test_leg.py
new file mode 100755
index 000000000..05de28e0b
--- /dev/null
+++ b/tests/python/test_leg.py
@@ -0,0 +1,14 @@
+# from helios.leg import Leg
+# import numpy as np
+# from pydantic import ValidationError
+
+
+# def test_belongs_to_strip():
+#     leg = Leg(serial_id=1)
+#     assert leg.belongs_to_strip is False
+#     leg.strip = "Some Strip Object"  # Replace with an actual ScanningStrip object
+#     assert leg.belongs_to_strip is True
+
+# def test_invalid_serial_id():
+#     with pytest.raises(ValidationError):
+#         Leg(serial_id=-1)  # NonNegativeInt should prevent negative serial_id
\ No newline at end of file
diff --git a/tests/python/test_platform.py b/tests/python/test_platform.py
new file mode 100755
index 000000000..1af78d84a
--- /dev/null
+++ b/tests/python/test_platform.py
@@ -0,0 +1,38 @@
+
+# import numpy as np
+# from helios.platform import Platform
+# from helios.platformsettings import PlatformSettings
+
+# def test_current_settings():
+#     platform = Platform()
+#     platform.settings_speed_m_s = 10.0
+#     platform.is_on_ground = True
+#     platform.position = np.array([100.0, 200.0, 300.0])
+    
+#     current_settings = platform.current_settings
+#     import pytest
+#     assert current_settings.speed_m_s == 10.0
+#     assert current_settings.is_on_ground == True
+#     assert current_settings.position == [100.0, 200.0, 300.0]
+
+# def test_apply_settings():
+#     platform = Platform()
+#     settings = PlatformSettings(speed_m_s=20.0, is_on_ground=False, position=[500.0, 600.0, 700.0])
+    
+#     platform.apply_settings(settings)
+    
+#     assert platform.settings_speed_m_s == 20.0
+#     assert platform.is_on_ground == False
+#     assert np.array_equal(platform.position, np.array([500.0, 600.0, 700.0]))
+
+# def test_update_static_cache():
+#     platform = Platform()
+#     platform.origin_waypoint = np.array([0.0, 0.0, 0.0])
+#     platform.target_waypoint = np.array([100.0, 100.0, 0.0])
+#     platform.next_waypoint = np.array([200.0, 0.0, 0.0])
+    
+#     platform.update_static_cache()
+    
+#     assert np.allclose(platform.cached_origin_to_target_dir_xy, np.array([100.0, 100.0, 0.0]))
+#     assert np.allclose(platform.cached_target_to_next_dir_xy, np.array([100.0, -100.0, 0.0]))
+#     assert platform.cached_end_target_angle_xy == pytest.approx(np.pi / 2)
diff --git a/tests/python/test_scannersettings.py b/tests/python/test_scannersettings.py
new file mode 100755
index 000000000..a7e038c0e
--- /dev/null
+++ b/tests/python/test_scannersettings.py
@@ -0,0 +1,59 @@
+# from pydantic import ValidationError
+# from typing import Optional, Set
+# import numpy as np
+# from helios.scannersettings import ScannerSettings
+
+# def test_has_template():
+#     template = ScannerSettings(name="Template")
+#     settings = ScannerSettings(name="Settings", _basic_template=template)
+#     assert settings.has_template is True
+#     assert settings.basic_template == template
+
+# def test_no_template():
+#     settings = ScannerSettings(name="Settings")
+#     assert settings.has_template is False
+#     with pytest.raises(ValueError):
+#         _ = settings.basic_template
+
+# def test_has_default_resolution():
+#     settings = ScannerSettings(name="Settings")
+#     assert settings.has_default_resolution is True
+#     settings.vertical_resolution = 1.0
+#     assert settings.has_default_resolution is False
+
+# def test_fit_to_resolution():
+#     settings = ScannerSettings(name="Settings", pulse_frequency=100, vertical_resolution=1.0, horizontal_resolution=1.0)
+#     settings.fit_to_resolution(np.pi / 2)
+#     assert settings.scan_frequency == pytest.approx(31.831, rel=1e-2)
+#     assert settings.head_rotation == pytest.approx(31.831, rel=1e-2)
+
+# def test_create_preset():
+#     preset = ScannerSettings.create_preset(
+#         name="Preset",
+#         pulse_frequency=1000,
+#         horizontal_resolution=0.5,
+#         vertical_resolution=0.5,
+#         horizontal_fov=90,
+#         min_vertical_angle=-10.0,
+#         max_vertical_angle=10.0
+#     )
+#     assert preset.name == "Preset"
+#     assert preset.pulse_frequency == 1000
+#     assert preset.horizontal_resolution == 0.5
+#     assert preset.vertical_resolution == 0.5
+#     assert preset.horizontal_fov == 90
+#     assert preset.min_vertical_angle == -10.0
+#     assert preset.max_vertical_angle == 10.0
+
+# def test_to_file(tmp_path):
+#     settings = ScannerSettings(name="Settings")
+#     file_path = tmp_path / "settings.json"
+#     settings.to_file(str(file_path))
+#     assert file_path.exists()
+
+# def test_load_preset(tmp_path):
+#     settings = ScannerSettings(name="Settings")
+#     file_path = tmp_path / "settings.json"
+#     settings.to_file(str(file_path))
+#     loaded_settings = ScannerSettings.load_preset(str(file_path))
+#     assert loaded_settings == settings
diff --git a/tests/python/test_scene.py b/tests/python/test_scene.py
new file mode 100755
index 000000000..570672f2b
--- /dev/null
+++ b/tests/python/test_scene.py
@@ -0,0 +1,28 @@
+# from helios.scene import Scene
+# from helios.scenepart import ScenePart, ObjectType
+
+# def test_add_scene_part(sample_scene):
+#     scene_part = ScenePart(object_type=ObjectType.STATIC_OBJECT)
+#     sample_scene.add_scene_part(scene_part)
+#     assert len(sample_scene.scene_parts) == 1
+#     assert scene_part in sample_scene.scene_parts
+
+
+# def test_specific_scene_part(sample_scene_with_parts):
+#     scene_part = sample_scene_with_parts.specific_scene_part(1)
+#     assert scene_part is not None
+#     assert scene_part.object_type == ObjectType.DYN_MOVING_OBJECT
+
+# def test_specific_scene_part_out_of_range(sample_scene_with_parts):
+#     scene_part = sample_scene_with_parts.specific_scene_part(10)
+#     assert scene_part is None
+
+# def test_delete_scene_part(sample_scene_with_parts):
+#     initial_len = len(sample_scene_with_parts.scene_parts)
+#     assert sample_scene_with_parts.delete_scene_part(0) is True
+#     assert len(sample_scene_with_parts.scene_parts) == initial_len - 1
+
+# def test_delete_scene_part_out_of_range(sample_scene_with_parts):
+#     initial_len = len(sample_scene_with_parts.scene_parts)
+#     assert sample_scene_with_parts.delete_scene_part(10) is False
+#     assert len(sample_scene_with_parts.scene_parts) == initial_len
\ No newline at end of file
diff --git a/tests/python/test_scenepart.py b/tests/python/test_scenepart.py
new file mode 100755
index 000000000..d23f4dc5a
--- /dev/null
+++ b/tests/python/test_scenepart.py
@@ -0,0 +1,114 @@
+# from helios.scenepart import ScenePart
+# from helios.scene import Scene
+# import numpy as np
+    
+
+# ### different checks for transformation
+# def test_no_transformation(scene_part):
+#     initial_origin = scene_part.origin.copy()
+#     scene_part.transform()
+#     assert np.allclose(scene_part.origin, initial_origin)
+
+# def test_translation_only(scene_part):
+#     translation_vector = np.array([1.0, 2.0, 3.0])
+#     scene_part.transform(translation=translation_vector)
+#     assert np.allclose(scene_part.origin, np.array([1.0, 2.0, 3.0]))
+
+# def test_scaling_only(scene_part):
+#     initial_scale = scene_part.scale
+#     scene_part.transform(scale=2.0)
+#     assert scene_part.scale == 2.0 * initial_scale
+
+# def test_translation_and_scaling(scene_part):
+#     translation_vector = np.array([1.0, 2.0, 3.0])
+#     initial_scale = scene_part.scale
+#     scene_part.transform(translation=translation_vector, scale=2.0)
+#     assert np.allclose(scene_part.origin, np.array([1.0, 2.0, 3.0]))  # Check translation
+#     assert scene_part.scale == 2.0 * initial_scale  # Check scaling
+
+# def test_not_on_ground(scene_part):
+#     translation_vector = np.array([1.0, 2.0, 3.0])
+#     scene_part.transform(translation=translation_vector, scale=None, is_on_ground=False)
+#     assert scene_part.is_on_ground is False
+
+# def test_apply_to_specific_axis(scene_part):
+#     scene_part.transform(translation=np.array([1.0, 0.0, 0.0]), apply_to_axis=0)
+#     assert np.allclose(scene_part.origin, np.array([1.0, 0.0, 0.0]))
+
+# ### IMPORTANT In general, think about usage of quaternions for rotation in the project!!!!!!!!!!!!!
+
+# def test_rotate_using_axis_and_angle(scene_part):
+#     scene_part.rotate(axis=np.array([0, 0, 1]), angle=90)  # Rotate 90 degrees around z-axis
+#     assert np.allclose(scene_part.rotation.quaternion, [0, 0, 0.70710678, 0.70710678])
+
+
+# def test_rotate_with_origin(scene_part):
+#     origin = np.array([1.0, 1.0, 1.0])
+#     scene_part.rotate(axis=np.array([0, 0, 1]), angle=90, origin=origin)
+#     assert np.allclose(scene_part.origin, [1.0, 1.0, 1.0])  # Origin remains unchanged
+
+# def test_rotate_with_custom_origin(scene_part):
+#     custom_origin = np.array([2.0, 2.0, 2.0])
+#     scene_part.rotate(axis=np.array([0, 0, 1]), angle=90, origin=custom_origin)
+#     assert np.allclose(scene_part.origin, [2.0, 2.0, 2.0])  # Origin is updated to custom_origin
+
+
+# ### motion tests
+# def test_make_motion_translation_only(scene_part):
+#     translation = np.array([0.5, 0, 0])
+#     scene_part.make_motion(translation=translation, loop=1)
+#     expected_origin = np.array([0.5, 0.0, 0.0])
+#     assert np.allclose(scene_part.origin, expected_origin)
+
+
+# def test_make_motion_translation_and_rotation(scene_part):
+#     translation = np.array([0.5, 0, 0])
+#     rotation_axis = np.array([0, 0, 1])
+#     rotation_angle = 90  # degrees
+#     scene_part.make_motion(translation=translation, rotation_axis=rotation_axis, rotation_angle=rotation_angle, radians=False, loop=1)
+#     expected_origin = np.array([0.5, 0.0, 0.0])
+#     assert np.allclose(scene_part.origin, expected_origin)
+
+# def test_make_motion_with_loop(scene_part):
+#     translation = np.array([0.2, 0, 0])
+#     loop = 50
+#     scene_part.make_motion(translation=translation, rotation_axis=None, rotation_angle=None, loop=loop)
+#     expected_origin = np.array([0.2 * loop, 0.0, 0.0])
+#     assert np.allclose(scene_part.origin, expected_origin)
+
+# def test_make_motion_with_rotation_center(scene_part):
+#     translation = np.array([0.5, 0, 0])
+#     rotation_axis = np.array([0, 0, 1])
+#     rotation_angle = 90  # degrees
+#     rotation_center = np.array([1.0, 1.0, 0.0])
+#     scene_part.make_motion(translation=translation, rotation_axis=rotation_axis, rotation_angle=rotation_angle, radians=False, rotation_center=rotation_center, loop=1)
+#     # Verify the origin and rotation
+#     expected_origin = np.array([1.5, 1.0, 0.0])
+#     assert np.allclose(scene_part.origin, expected_origin)
+
+
+# ## test motion_sequence
+# def test_make_motion_sequence_translations_only(scene_part):
+#     translations = [np.array([1.0, 0.0, 0.0]), np.array([0.0, 1.0, 0.0]), np.array([0.0, 0.0, 1.0])]
+#     scene_part.make_motion_sequence(translations=translations, rotation_axes=None, rotation_angles=None)
+#     expected_origin = np.array([1.0, 1.0, 1.0])
+#     assert np.allclose(scene_part.origin, expected_origin)
+
+
+# def test_make_motion_sequence_translation_and_rotation(scene_part):
+#     translations = [np.array([1.0, 0.0, 0.0]), np.array([0.0, 1.0, 0.0]), np.array([0.0, 0.0, 1.0])]
+#     rotation_axes = [np.array([0, 0, 1]), np.array([0, 1, 0]), np.array([1, 0, 0])]
+#     rotation_angles = [90, 90, 90]  # degrees
+#     scene_part.make_motion_sequence(translations=translations, rotation_axes=rotation_axes, rotation_angles=rotation_angles, radians=False)
+#     expected_origin = np.array([1.0, 1.0, 1.0])
+#     assert np.allclose(scene_part.origin, expected_origin)
+
+
+# def test_make_motion_sequence_with_rotation_centers(scene_part):
+#     translations = [np.array([1.0, 0.0, 0.0])]
+#     rotation_axes = [np.array([0, 0, 1])]
+#     rotation_angles = [90]  # degrees
+#     rotation_centers = [np.array([0.0, 0.0, 0.0])]
+#     scene_part.make_motion_sequence(translations=translations, rotation_axes=rotation_axes, rotation_angles=rotation_angles, radians=False, rotation_centers=rotation_centers)
+#     expected_origin = np.array([1.0, 0.0, 0.0])
+#     assert np.allclose(scene_part.origin, expected_origin)