diff --git a/cmake/MultipersCodegen.cmake b/cmake/MultipersCodegen.cmake
index 4807bdc6..afe81f6f 100644
--- a/cmake/MultipersCodegen.cmake
+++ b/cmake/MultipersCodegen.cmake
@@ -4,15 +4,15 @@ set(MULTIPERS_CORE_GENERATED_FILES
   "${MULTIPERS_GENERATED_ROOT}/tools/core/filtrations_instantiations.inc"
   "${MULTIPERS_GENERATED_ROOT}/tools/core/simplextree_instantiations.inc"
   "${MULTIPERS_GENERATED_ROOT}/tools/core/simplextree_conversion_instantiations.inc"
-  "${MULTIPERS_GENERATED_ROOT}/tools/core/slicer_instantiations.inc"
-  "${MULTIPERS_GENERATED_ROOT}/tools/core/slicer_conversion_instantiations.inc"
+  "${MULTIPERS_GENERATED_ROOT}/tools/core/slicer_instantiations1.inc"
+  "${MULTIPERS_GENERATED_ROOT}/tools/core/slicer_instantiations2.inc"
+  "${MULTIPERS_GENERATED_ROOT}/tools/core/slicer_instantiations3.inc"
   "${MULTIPERS_GENERATED_ROOT}/multipers/_slicer_nanobind_registry.inc"
   "${MULTIPERS_GENERATED_ROOT}/multipers/_mma_nanobind_registry.inc"
   "${MULTIPERS_GENERATED_ROOT}/multipers/gudhi/filtrations_extern_templates.h"
   "${MULTIPERS_GENERATED_ROOT}/multipers/gudhi/simplextree_multi_extern_templates.h"
   "${MULTIPERS_GENERATED_ROOT}/multipers/gudhi/simplextree_conversion_extern_templates.h"
   "${MULTIPERS_GENERATED_ROOT}/multipers/gudhi/slicer_extern_templates.h"
-  "${MULTIPERS_GENERATED_ROOT}/multipers/gudhi/slicer_conversion_extern_templates.h"
 )
 
 set(MULTIPERS_CODEGEN_DRIVER "${CMAKE_SOURCE_DIR}/tools/tempita_grid_gen.py")
diff --git a/cmake/MultipersCore.cmake b/cmake/MultipersCore.cmake
index 173f2fab..8f47af75 100644
--- a/cmake/MultipersCore.cmake
+++ b/cmake/MultipersCore.cmake
@@ -12,10 +12,10 @@ function(multipers_add_core_object_library target_name source_file)
   target_link_libraries(
     ${target_name}
     PRIVATE
-      multipers::project_options
-      multipers::project_warnings
       multipers::gudhi
       multipers::phat
+      multipers::project_options
+      multipers::project_warnings
   )
   multipers_apply_common_build_flags(${target_name})
 endfunction()
@@ -34,8 +34,18 @@ multipers_add_core_object_library(
   multipers_core_filtrations_obj
 )
 multipers_add_core_object_library(
-  multipers_core_slicer_obj
-  "${CMAKE_SOURCE_DIR}/tools/core/slicer_core.cc"
+  multipers_core_slicer_obj1
+  "${CMAKE_SOURCE_DIR}/tools/core/slicer_core1.cc"
+  multipers_core_filtrations_obj
+)
+multipers_add_core_object_library(
+  multipers_core_slicer_obj2
+  "${CMAKE_SOURCE_DIR}/tools/core/slicer_core2.cc"
+  multipers_core_filtrations_obj
+)
+multipers_add_core_object_library(
+  multipers_core_slicer_obj3
+  "${CMAKE_SOURCE_DIR}/tools/core/slicer_core3.cc"
   multipers_core_filtrations_obj
 )
 multipers_add_core_object_library(
@@ -65,7 +75,7 @@ if(MULTIPERS_BUILD_GRAPH_MPH0_BENCHMARK)
   )
   target_link_libraries(
     multipers_benchmark_graph_mph0
-    PRIVATE multipers::project_options multipers::project_warnings multipers::gudhi
+    PRIVATE multipers::gudhi multipers::project_options multipers::project_warnings
   )
   multipers_apply_common_build_flags(multipers_benchmark_graph_mph0)
 endif()
@@ -76,7 +86,9 @@ add_library(
   $<TARGET_OBJECTS:multipers_core_backend_log_policy_obj>
   $<TARGET_OBJECTS:multipers_core_filtrations_obj>
   $<TARGET_OBJECTS:multipers_core_simplextree_obj>
-  $<TARGET_OBJECTS:multipers_core_slicer_obj>
+  $<TARGET_OBJECTS:multipers_core_slicer_obj1>
+  $<TARGET_OBJECTS:multipers_core_slicer_obj2>
+  $<TARGET_OBJECTS:multipers_core_slicer_obj3>
   $<TARGET_OBJECTS:multipers_core_hera_obj>
   $<TARGET_OBJECTS:multipers_core_graph_mph0_obj>
 )
@@ -84,9 +96,9 @@ add_dependencies(multipers_core_shared multipers_codegen)
 target_link_libraries(
   multipers_core_shared
   PRIVATE
-    multipers::project_options
     multipers::gudhi
     multipers::phat
+    multipers::project_options
     multipers::backend_hera
     multipers::tbb
     multipers::openmp
diff --git a/cmake/MultipersExtensions.cmake b/cmake/MultipersExtensions.cmake
index 7afea721..37ff4284 100644
--- a/cmake/MultipersExtensions.cmake
+++ b/cmake/MultipersExtensions.cmake
@@ -15,11 +15,11 @@ add_dependencies(
 target_link_libraries(
   multipers_nanobind_runtime_obj
   PRIVATE
+    multipers::gudhi
+    multipers::phat
     multipers::project_options
     multipers::project_warnings
     multipers::python
-    multipers::gudhi
-    multipers::phat
     multipers::backend_mpfree
     multipers::backend_muphasa
     multipers::backend_function_delaunay
@@ -71,10 +71,10 @@ function(multipers_add_extension)
   target_link_libraries(
     ${_target_name}
     PRIVATE
+      multipers::gudhi
       multipers::project_options
       multipers::project_warnings
       multipers::python
-      multipers::gudhi
   )
   if(NOT ARG_PHAT_MODE OR NOT ARG_PHAT_MODE STREQUAL "NONE")
     target_link_libraries(${_target_name} PRIVATE multipers::phat)
diff --git a/docs/notebooks/ops/AIDA.ipynb b/docs/notebooks/ops/AIDA.ipynb
index 445e3ec7..bb538474 100644
--- a/docs/notebooks/ops/AIDA.ipynb
+++ b/docs/notebooks/ops/AIDA.ipynb
@@ -82,16 +82,7 @@
    "metadata": {
     "lines_to_next_cell": 2
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Check sanity 0\n",
-      "Check sanity 0\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "presentation1 = [[],[],[],[0,1],[0],[1],[2],[2],]\n",
     "dimension1 = [0,0,0,1,1,1,1,1]\n",
@@ -244,8 +235,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def get_immuno(i, DATASET_PATH=\"~/Datasets/\"):\n",
-    "    immu_dataset = read_csv(DATASET_PATH+f\"SpatialPatterningOfImmuneCells/LargeHypoxicRegion{i}.csv\")\n",
+    "def get_immuno(i, DATASET_PATH=\"/home/hschreiber/Datasets/SpatialPatterningOfImmuneCells/\"):\n",
+    "    immu_dataset = read_csv(DATASET_PATH+f\"LargeHypoxicRegion{i}.csv\")\n",
     "    X = np.array(immu_dataset['x'])\n",
     "    X /= np.max(X)\n",
     "    Y = np.asarray(immu_dataset['y'])\n",
@@ -284,20 +275,13 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Check sanity 0\n"
-     ]
     }
    ],
    "source": [
@@ -341,8 +325,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "66558\n",
-      "33279 batches : [##################################################] 100%\n"
+      "66398\n",
+      "33199 batches : [##################################################] 100%\n"
      ]
     }
    ],
@@ -367,7 +351,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -402,7 +386,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████| 17602/17602 [00:07<00:00, 2376.69it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████| 17726/17726 [00:08<00:00, 2191.34it/s]\n"
      ]
     }
    ],
@@ -431,7 +415,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -453,13 +437,13 @@
     {
      "data": {
       "text/plain": [
-       "array([[0.00408662, 0.0046928 ],\n",
-       "       [0.00409012, 0.0046955 ],\n",
-       "       [0.00415106, 0.00469863],\n",
+       "array([[0.00402657, 0.00463041],\n",
+       "       [0.00408837, 0.00468624],\n",
+       "       [0.00413438, 0.00467408],\n",
        "       ...,\n",
-       "       [0.01765638, 0.03080151],\n",
-       "       [0.02642419, 0.03080151],\n",
-       "       [0.03254546, 0.04179183]], shape=(15202, 2))"
+       "       [0.02411361, 0.02626792],\n",
+       "       [0.02411361, 0.02849555],\n",
+       "       [0.03282797, 0.03939006]], shape=(15344, 2))"
       ]
      },
      "execution_count": 13,
@@ -493,7 +477,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 17,
    "id": "3c5d974a-361a-4a17-883b-14c80af61177",
    "metadata": {},
    "outputs": [
@@ -501,7 +485,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████| 17602/17602 [00:13<00:00, 1320.42it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████| 17726/17726 [00:08<00:00, 1992.33it/s]\n"
      ]
     }
    ],
@@ -521,7 +505,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 18,
    "id": "47577d11-5c6f-4e2d-b378-afec8d40d7b7",
    "metadata": {},
    "outputs": [],
@@ -535,13 +519,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 19,
    "id": "52cc066d-d44d-4d86-b3b8-c39084793092",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGzCAYAAAAlqLNlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA20RJREFUeJzsnQd0HPW1xr8p26XVqliSezemGtNLqAkQMKb3FkJ7QAjFoZpqG9vYmB4gOPRuCB1MKCF0CL3bxlWyZXVp1bbPzDv3PzvbtKtmy437yxl2d/qu/M58797v3isZhmGAYRiGYRiGEcjmC8MwDMMwDMPiiGEYhmEYJgOOHDEMwzAMw6TA4ohhGIZhGCYFFkcMwzAMwzApsDhiGIZhGIZJgcURwzAMwzBMCiyOGIZhGIZhUmBxxDAMwzAMkwKLI4ZhGIZhmBRYHDEMwzAMw6TA4ohhtgAeffRRSJKEr776Kuv2ww8/HCNGjFina7z33ns466yzMH78eHg8HgwePBhHHnkkvv76a2zuv9uqVat6ddynn36Km266CX6/v9/ujWGYjQeLI4ZhesT9998vRMQll1yChQsX4q677kJdXR322GMPIZw2RyZNmoTPPvsMAwcO7LU4mjZtGosjhtlCUTf2DTAMs3lw7733orS0NG3dH//4R4wZMwazZs3CgQceiE2FQCAAt9vd7X4DBgwQC8MwTCocOWIYpkdkCiMiLy8P22yzDVavXt2jc1AqitJY3377LY455hh4vV4UFBTgtNNOQ319faf9ly5dilNOOUVc2+FwYOuttxYiLds5v/nmGxx33HEoLCzE6NGjxTY653nnnYehQ4eK40kI7b333nj33XdzptW6O4aud8UVV4j3I0eOFMfT8v777/f6nn/++WecfPLJ4jcoKysTacuWlpZOv8PixYvFfrQPnXPYsGE444wzEA6He/VbMQzTMzhyxDBbEJqmIRaLdVpvGEa/XI8e5CRKehs1Ovroo3HCCSfg/PPPFwLh+uuvxy+//IL//e9/sNlsYh/6vNdeewkhcNttt6G8vBxvvfUWLr74YjQ0NODGG29MOyeJrZNOOkmcs6OjQ6w7/fTTxf3NnDkT48aNE2kw+tzY2Jjz3ro75pxzzkFTUxPuuecevPjii4mUHInE3t7zscceixNPPBFnn302fvzxR1xzzTVi/cMPP5zY5/vvv8fvfvc7lJSUYPr06Rg7diyqq6vx6quvIhKJCCHU2+syDNMNBsMwmz2PPPIIqZ8ul+HDhyf2v++++4yJEycaqqoaN954Y5+ve+qpp4pzfPXVVz3an65F93LZZZelrX/qqafE+ieffDKx7pBDDjGGDBlitLS0pO170UUXGU6n02hqako75w033NDpenl5ecall17a7e+2cuXKHh9D3HrrrZ2O68s9z507N22/Cy+8UOyn63pi3YEHHmj4fD6jrq4u5/309LoMw/QMTqsxzBbE448/ji+//LLTQpGHVCjaQYbio446qs/XomjPU089hTvuuAM777xz2jaKXqUumZGrU089Ne0zRZFUVcV///tf8TkUCuE///mPiDCRdyj1XIcddpjY/vnnn3eKwmSy2267idTZzTffLPaPRqPdfq++HNPXez7iiCPSPu+www5iPzK6W96pDz74QPw+ubxRfbkuwzBdw+KIYbYgyGeyyy67dFrI05IKiaLJkyd3Wt9TSFiReKDU00UXXZS2jfw7lBpLXegBnwqlfVIhYVRcXJxIXdErPdwpdZV5LnrgE5QuSiVbxdmCBQvwpz/9CQ8++CD23HNPFBUVCa9OTU1Nzu/Wl2P6es/0nVOhFBkRDAbFa3Nzs0iVDhkyZL1el2GYrmHPEcMwvRZGZCimZerUqZ22Dxo0SESrUtlqq63SPpPQoD5JFvRwp4e8JRbIVK0oivD//OUvf8l6H2SGToUMzpmQT+fOO+8US2VlpfDpXH311SIy8+9//zvreftyTF/vuTtImNE516xZs0GvyzC/dVgcMQzTY2bMmCFE0XXXXZfT5Gu320W0qisoHZeainvuueeEQNp///3FZ0oPHXDAAaKqjVJNdM51hczKFOWiFNQnn3yyTsdkRnj6655dLhf2228/PP/88yJKR8Itk/64LsP81mFxxDBMj6AqqBtuuEH0NqLmiZk+FmoG2VOoyotSaQcddFCiWm3ChAnCW2NBTSbJK7XPPvvgggsuEB2+29rasGzZMrz22mvdNp6kSjoSDVTeTl298/PzRUSLoj9U2bYux2y//faJe6QUHKWwKDq2rvecjdtvv12cc/fddxcRLOorVVtbKyJaDzzwgLjH/rguw/yWYXHEMEyPoIcsQUIhW3qpN+0CSBxRBIq6blM6jPxPlMZKjXpQaTyV0FO0iiJVlNby+XyilN3y0nSF0+kUguKJJ54QPigyVlMk6KqrrsKVV165TsdQhIvK7h977DH885//hK7rwkxO69flnrNBovGLL74QkTq6Joke8mxR+wTr91rX34phmHQkKlnLWMcwzBaOVc1EUQby/tADlaIf5F3pT0gQkWeJGi1mSxExDMNsCnC1GsP8BqFKM/KzUMk6eVnoPUVLGIZhGBZHDPObhCI4FDROXc4888yNfVsMwzCbBJxWYxiGYRiG2VBptQ8//FAYLanvCZkuX3755W6PoWZxVOJLxshRo0bhH//4R6d9XnjhBWFApHJaen3ppZf66RswDMMwDPNbo1/FEQ1/pEqLv//97z3af+XKlaKygspRqWcHNZijwYkkhiw+++wzMaiRGp7RQEZ6pfJfGljJMAzDMAyz2aTVKHJEEZ6uZjlRuSz17li0aFFiHU3YJhFEooggYdTa2oo333wzsQ/1XaEusc8880w/fwuGYRiGYbZ0Nqk+RySADj744LR1hxxyCB566CHRb4RKjWmfyy67rNM+1CMlF+FwWCwW1JOkqalJjCrINnKAYRiGYZhND4rnUK8vsuvIsvzbEEc0b6msrCxtHX2mfiw0OJEGS+bap6uhkLNnzxa9VRiGYRiG2fxZvXp1lwOZtyhxRGRGcqysX+r6bPt0FQGirrJTpkxJGxFAXW/px/V6vZ32n1dwIGbga8w7dSecc+9N+KaxEj832eEPA7Ur1iJaOgixuGHLpms45pUnc38hA3h43Ini7Vm/LkisDmoaFtW145+frMRVe47C78cMwJUFJ2Fuy7O43HuS2KdKK4SuSqCfQNLN34H+Wxipp18BqiSBvnZE01HdFhK/waU1j2Og1wGbzQ6pF6q6JRjBzPcWIRCNX8cA5DwvZsy7HcOHDxfraIJ7pjBlGIZhmA0F2WqGDh0qxub0J5uUOKKW+JkRIGqDTzOYrGndufbp6qFNVW3WoMhUSBhlE0fO+M/isivwej3Ii7jgitgRsklwuJ2QPC7IkIQ4choa9hpu3ls2SGS86M0T7/caUSw+E23RGKI64LDJmFjmRanHAbvLjdKYAw6nR+xj09zQVLoSEDWoc7EBmx5DgT0fMd2AQyZxJCEU06FGZCGUJpQXYEShG3aHs9fdjnccVIyWUASrmjtw4zu/QNY0zJx6dWK7K9+Lh558SsycYhiGYZiNRX9bYjYpcbTnnnsm5jdZvP3222LCN/mNrH3eeeedNN8R7bPXXnthY+CP2HDLNoeI91f/8tYGuWZX8aBV/gCiuo6SfGCQz4MrG/+Y2Da3uPM8rFTK851iIRRJwvT9dkeJ2yU++0NhTP/ka5x92ql44fU3hEhlGIZhmC2RfhVH7e3tYip0aqn+d999h6KiIpHWonRXVVUVHn/88URlGpX9Uwrs3HPPFeZrMmOnVqFdcskl2HfffTFnzhwceeSReOWVV/Duu+/i448/xoai3F+Dsnwn5GIfvqnV0JRnRp+e3uugxD6nfPoOpg46AjOrXl3n6w3XGrFMLu1iD0orUqINmP6fxSKqlOey45mT91yn65IwGltSlPh8w94749rPv4Pf72dxxDAMw2yx9Ks4+uqrr3DAAQckPlu+nz/96U9iplN1dTUqKysT20eOHImFCxeKqNC9994r3Oh33303jj322MQ+FCF69tlnxaDM66+/HqNHj8aCBQvEJO3+psRp4OGrbsfBs6+ArAJX+jSc+sEb0FqTlXDE9UMPx59GnC7enznydLRH7RgZbjR/g8JjUCEX4tGaB3p1bbsRE36j1L4L9N4KLNLrQLcTyrn3YK+35+CJVatR19oOw5XcZ13xOTunJhmGYRhmS6NfxdH++++fMFRngwRSJvvttx+++eabLs973HHHiWVjoSgyalxezFkr428SIDuT3h49pPXpnEZUR4VcjPPyTkWFbEZrYroMVdYxv/kJ/F/eaVilpHubMkUPGbQdioIdiwrw1Ko1gKEL05NBxm2sPygCmA2fz8cRJYZhGGazZ5PyHG1OlIfbcOWYPMS+Tl8vhJJsSpEIFNiRLpZub34RlxYcg+sGHI/2ghiKhgeBymQVGzFCN6NMyzAg67Vzy00JLQEPnhr9Z0jfXo4KfxCn4wlyrsFut2NJfW6JVOC0J/xGufA6HXBoGq699OKs28mwzX4khmEYZnOHxVEvCPctKJSGZbC/uf55fFrRhDuHn9Lrc5DhOn62rNvJTO2QFMx6b4nYRTMMqKqtS3e/0ybjqZP26FIgleV58OCkA9AaSk8jEhUtrZj77SL2IzEMwzCbPSyOesmpT81DgyajjiI4JT7IxxwF7el/ddpvmOHHMil3iX9fIGnT1ayXiK7DgAFVlvDAnhPRFA7DUBTUBIIYMnw4HPbsniESNnM+/FSU8XcXPSKBRAvDMAzDbKmwOOoD5TZTgBCSrwC2445A9F+5q9LybBHcuublRKBntVKIqcUn4PCKf2B9oMT7HdUGQ/BKeaJardTlQKFDhaGqcCgyRhb54HSaZfk9hUQTpdJYDDEMwzC/JVgcrSdIIFlIP8UjK/4NdG1ZxkifC8Gojo4OM4K0LpD/iNJsFE1yKDY8dMxhLJAYhmGY3wwsjnrJZFcAA9w2DMhLpqiM0kzjdKDLcwzVmjGj8Tl82sNrnldwBipR2K1Agg3oAFAdCKEuGBaRo75AqTXyH31f3Yzp7y4SHiOOHjEMwzC/FfpvpC2TIBCz4cqyI9N+EUqrWVS0BFHbHs7a24gq1+a3PC4aQQ7TGjEw2oArKx7A1RXzQfEhapVgdUsggWRXZJDzqDUaWae/AAmkEYXsLWIYhmF+e7A46gURHTjpmBvw0F/nIfrIc127o0ncQBPl/AYkVNl8omN2KvlOFbIkYcany3Daa98JM3VXkGXJLvxFEAKIqtbCumEasTP6SQnR1JsvxzAMwzCMgMVRL7Bn/Fp6kx9Gc2dj0ZqQijVBBVFJEQ0YNV0S76vsBWn7lXgcGFnkwY2HbI2Q1jOfEBmvqdnjQI9DGK1JLGV2zl7fkDF7aUMTatspaccwDMMwWzbsOVpHqAm1lKFMhuRJQDSGirAkIkddcbv/RVQUunt3UUkSKTTR9zrz4nFaIrHenZOG1jani5/a9hAkyRDGbKIn5uzU7tncMZthGIbZHGFx1I8M05pRqRQiBBV6DwZ46AYQiiU7TVLqLNbLyjNKuZFsmvnDEvx9jwkoyaO0HrrvfK3YhPk6lYF7Xo3yPQ5PfG764rZedc/mjtkMwzDM5giLo37gln1skGr9CD/9uvAZtaIUkmFgUKRFbL+z5UW0RWOoju9f4LLBaVOEh4jM2RaSx8CKQBC1HWE8gCfFOkq/reri2hRNGpzvxI+GLq5REIkiFo0iHA7n7HNEkSCKCHXufP1d2idvF1GjzO7ZVsfsb7/9VgwUtuBoEsMwDLOpw+JoHYg99px4dZxydKdtl/+Qj1jZEahSfKDxarohIRqRcXnJUZhb/1KnyrCnT9sVpykyBhYlxcdaTULEMOAPR1GW0jqgJ00hieqAKVRaolHY1lTB4/ZAtdn6rfN16jnMSNJPneawcTSJYRiG2dRhcbSJQAKJzNbUfNFC1rpPxVlIGbPVnKqMeb/8Kj6rkHDtxG0wOBCA2+3OKZDWJ9nmsPH8NYZhGGZzgMVRL9l7+hS0OxX8I8+J879+p8t9q+y+LqVMRvW9YBWKMAJNXZ5XSsxZS/Y4sohpMmyyhCcm74iWcEyk6aZ/vBQd0RiqVldCUhSMGTN2nQTSzLoJ4vXa0u+73C9XNCrVtJ0Jp90YhmGYjQ2Lo/VA+On0NBlhUE8jSqnRjyzrGBlpxNyGV8yNEjVslDBv8Om4q+35xDHvaPcn3p+rnGju6hmMWQXnwamaVW93NTxmnj/NZk3v06NMt3lOAzxAqIDK6S7HQI8b5W6XGEIb02IbJHrUE9N2Jpx2YxiGYTY2LI56yejRg9BcVSveJ6I2VFHfy/NQ6otY2xbCSJ8bf3GaYmiVUYy3Y/d3eRwdWROIiE7ZJS47agNhDPe4RXfs46QLsx+oxcwRI/RWS1bEbUiypdpS4bQbwzAMsynA4qiXNOkytOIS1Chy2oBXEia9EUgkVCh6RGfQDAMPRE1z93nKiV2W3tMxJKaCMQ1r28PQU/Jqua5vrRftIg0Dqysr1ym11l06rSvWh/GbYRiGYfoT7pDdRzqg4MHdDhFiRdDbFtXWYaRXrNeMJUraVbGnHXaR7WRxTRJjPcV32HTzWrEYSuwqdE0TqbVNlebm5o19CwzDMMxvGBZHvaRA1iE3NGBkoBn1bi/m73Jw2vYbhk/Kehw1g6QyfloSpmpKkcVTcuJVAv6pLxCvPdVbqZGjrrApMlRJFg0iszrBNwEsT9Llf70INTU1G/t2GIZhmN8oLI56yZHOEHwPPoy/fP0OygOt3e4/OGLOXlMUAy5XTCzXDz0cF+cfizVKIW4bfFrW4+ZrC8w0GAxMXTUfDzQ/IZZU7xH98RpD0R5HrUiMbcpQuu2GvXdGsK0Vfn/nmXUMwzAMsyFgcdSPWMLIrUahqrqIHtFC3N32AoZqzfhbldn5+v9sJ4glFVXSAC0Cf6hzCoxSa9QJm8imjap0n1g2N3zOnje7ZBiGYZj+gMXRJkZabIciPYod1xb+CefaT87ZCbtrNs0UGsMwDMNsqrA42oBDaK0lF1TGb/U3Sg6RpQG0gEZTaXuAquiYi+cxBM1iuajlCSgxA48MOjVtvw1Rzn/L2h36fCybshmGYZiNBYujdeCCr9/B/2V0yZ5e8Ubi/VqHTyxRSUGVvUAsGxurTxKV89NA2k0NNmUzDMMwGxsWR+vA3B0Oxrwd0qvVUonA7GrdU0ZIjfintgDrgznyvzBHfqHTelWWRLdsYwOU81896IdeR5TYlM0wDMNsbLgJZA+xyu1TufKHt0XKK2KN8zDMunxrN5uhYVDEj/q8/MQxVvSISv7XthXgoR2Og4N6FlV3vibNWFuKEki+IahWJJxvPxVVmg/nu0/FPwJPZb3PYbHGlE9mKk71DgJS0nmWVykSjiT/ISjqRhkpkg02ZTMMwzAbExZH64glhKLCE2SKkd40aLSokIrSPp9nnJCz4zUJJGoGOU97KtHrqD0Wg0GRqkSwyhxN21VqjQbRJvZeDwNpGYZhGGZLgMXROjBnWzOlduXPb8e7XBumSOqBd3qNanqR1gWFDNuSBJJFdaGw2Vm7wMCV0vFiOxmzs6HKMoYX5EOPjz+JaPoGH0hrpdZypd4YhmEYZmPB4mh9pdwogiPybn0rnR9uNHVatwpF4sRaSxVQNCTrfLaRBS6ENF1Us1W1h3p8dTGENj6IFtg0R4msXLlSvPp8PpSXl2/s22EYhmF+I7A46gUtEQnv62bjxa4g/1GqSBkSy97tudnofK7zbCckhtBmshpFiEGGPUXM0FgQiv/osnlF+q8OA2bibPPEqli79tKLxWdXvhcvvP4GCySGYRhmg8DiaD2S6j+iFJulkFYaxYl9RkqNWBQoE+9Dug0/tg/HLgWrs56PDNmrjEJEXrgKA8+8C/VqibjGcL0Ja4xCXKycZKbzZOC26NPCSxQTqTJyhRu4Qj4e5+JRbGp0l0p71L8HHpwEtIbCqGhpxdxvF+Hbb7/FyJEjO+3LUSWGYRhmfcPiqBcMcRvYPhDCKzm2k3ChyjMSLJRhG6I1ixjOoLBf9Duy2NpdmxBIBAkp0lI9HX1WKRdB1pKxqWrdJ8aJDPO6YIMszhXTDWHUptck6RGtTZWrhvwIwCPK+s0o0k+JKFImHFViGIZh1jcsjvpAQ0cES+ra8Ke2V1Een2+W6T/qqlosExJKHYodiWkgfenNKElw2xQoMUmk1ejyFMFaGySjdRXO9L8Aw5tHSgw3OycnhNj14Tc2aNfs3kIC6cFJB4goUiZWVImG1LIniWEYhllfsDjqAy//XI0PVzbCocp4+uRdOgmkVGlkyaOBYb9YN73WFCPHDzgrua8ExGSlS5dQWNOhK0lfUeI1RX9JKedzKBJE4Vx8O3mQcp1fluVE1+xNsZyfBBItDMMwDLPFdMi+7777hF/E6XRi5513xkcffZRz3zPPPBMS9eHJWLbddtvEPo8++mjWfUKh0Ib4Orjs4K1w01HbIxzT0RLMHeahMvtkJCkdSq1ZWLLF0jl0XhI1IiMmAbbj5qDGNgARSY03nVQRhooKuQgVitkfybrGrerzmCU9h3nKv3CLlDR2V3YEURfsHH2Z4ZiEW1yT8VTpyRukazbDMAzD4LcujhYsWIBLL70U1157rTDV7rPPPjj00ENRWZlsQJjKXXfdherq6sSyevVqFBUV4fjjzd49Fl6vN20/Wkh8bSjIJxSKaljZ1IGatp6LshSfdhoF7qBYvO4gVrUEcYX/EVzlf0SYskcVe2BX5U6epFThZb1eETseU40TEvvk2VUhHOf9shT/99l3oh9Stjvoqd+JYRiGYbZ0+j2tdvvtt+Pss8/GOeecIz7feeedeOutt3D//fdj9uzZnfYvKCgQi8XLL78sJrT/+c9/TtuPHvgbw2dyyB+vhEcBnHYFfh2Y+t+lyFNkPHfyzmnptdlrXxWvV5YdkVhHkiQSb7z4c3vSkG1FmSxGeF0ijVbdERbHULm+rAEajSfppaW6xG3HSIcLF+w9FjM+WYrWCEeGGIZhGGajiaNIJIKvv/4aV199ddr6gw8+GJ9++mmPzvHQQw/hD3/4A4YPH562vr29XawjE/GOO+6IGTNmYOLEiVnPEQ6HxWLR2tqKvvLvt+fg1/few+ghxVjTHMDqaj9uvuc/WN7YkdV7ZFEBs5yfqsrMUSO5IS9TJkMVP1brBYgaMmRTXyFqmB22zWRbtl5L8dlqCnXEdmFLhZtFMgzDMJtNWq2hoUGIl7Ky9CgJfa6pqen2eEqVvfnmm4mok8X48eOF7+jVV1/FM888I9Jpe++9N5YuXZr1PBShsiJStAwdOrTP34kiVuPGDsS4EcXYd8IQbD+mFJphoNIf6PK4MBSxXF5yTGKdLiJBXfN3aQHmq8+JZaDWkLaN2gTQYr5PhwQYLTGD/EtZxJiRvlhvaRhtKBQUSyzal7K5jdMs8pQjJ+PYwyf16N8VwzAMw2z0ajUSFKnQwzpzXTZIAFGTv6OOOipt/R577CEWCxJGO+20E+655x7cfffdnc5zzTXXYMqUKWmRo3UTSIAzHiXy+dwoLfJgRUOHKO8nClw23D0+Pt+sykyvHV+anhbs9TW72R73bsf3lWCXZdHniBAiKR6ton2u8L/QyWNE29fEYlizujJ5nk18GG1qmT+X9TMMwzCbhTgqKSmBoiid/r/5urq6TtGkTEhAPfzwwzj99NNht9u73JdK0XfdddeckSOHwyGW9YuE6TWDcTzqxacFP1Zh4a91GHz59aZ4shdgcKSl01GVUiH6k9vU59N8TNQ1m7CEkipLIrVnitOkQlIlA0PcLih2G25zHCF+/5OaFmzQYbR9gcv8GYZhmM0qrUaihkr333nnnbT19Hmvvfbq8tgPPvgAy5YtE2bu7qAH+XfffYeBAwdiQyPFBcdFB47DjUduh5J8B3QaH9LN0NeB4RaRFLMbGgZF/P16f4R1P5YkInFETSethT7T93AoSqI1AsMwDMP8Fun3tBqlsyj6s8suu2DPPffE/PnzRRn/+eefn0h5VVVV4fHHH+9kxN59992x3XbbdTrntGnTRFpt7NixIkVGqTQSR/feey82ND6vEy6XDY//UAMjGsOgcWGRxnJl8/nE6Y3uiGhJs7U4ZR80ywWhJxBOOcfM/GPEaa7reLn3J2MYhmGYLZx+F0cnnngiGhsbMX36dGGwJrGzcOHCRPUZrcvsedTS0oIXXnhB9DzKBo2LOO+880S6jgzWVKX24YcfYrfddltv951Lg7zS4QTytsHbfhV1MRXzMR773zoNmqbjjOC3WFLxFS665XXsddeDYv+pgydjVtVrnc59W8vzOL7w/7Je6JKCY3Bb8wsirLe2PVllF1ENQBSoZVdJndYayZeorotlRVsHQpom9lva2p7cVcxj02GzRxAu1EQ0rqKtA1qTHw57MGGA5k7VDMMwzJbOBjFkX3jhhWLJZbrOhARPIJC7+uuOO+4Qy8agRZcBxYk2TYLXpcOn6oALuLigDsBgGHbTn+Py1yPkMH9e0SSyNHmOy3zHmLqFgkI5okGU4hrpc0OLG6mp79GFdQ9jqnoqJFc5JDnpw6KO2ZfIJyXOc5f2rHi1ivmpmq4+FEZzOIpbfvgVwwcFxb4Xffq92I9SaEIcGTpU1YZB+00W4uiKL35Gyao62OKeI6oMIwM0CySGYRhmS4Znq+WgN9mr2lXV2G3affjdrJm4oqgV3nwnmj0D0NCwVmy/qOTQtHOuVn3idUSkscvrkECi5fzo8bhLWYASjwMjPR7UR2XEqOIvnnGjcv7VkjlGhLjQfSr+EXgqMU+NTNkDnA4UOuy4bPwYfOB2QpUkXL3LBMSgw253iKhRdTCAocOG41mbF2FNw+qSEsz5+30YNWqU6CVEJfNUGbYpiyOr5xFBlY48kJZhGIbpLSyOekkBdWCMhOCKR4UuLqjGy3W/4NGIHWs7gHud2+Gwu+ehok1F6ZBCRKMaqmpbIRldeI0y7UlduLkfUJ/D32LHodIoRBSK2RYBwHC9MbHPXYEF5hsp+UKl/TZJwifjz4M9fv6R+R7oMOBwOEXKza5IGFXkgyNofjen3S6EEfWVsqCS+U2Ruo4AjHBYCDgLV74XL7z+BgskhmEYplewOFrPiHEfqgxZBuqMfEChNUlBMdxoTuwXE/VqJv4OJ3yens1ouzfvRUxuNav45PgJ1hjJFgGXSCfiLiMukDKg8SV2SCLyVB0MoczVucVBdcwtRFMqFIUhsTH320XYWAwfd17ifcWv8zttl1LaNdC+sqzg9nlfYu68yRvsHhmGYZjNHxZH6wzVwad9SsqKLiJAtN/drS+anakNAzeOODxxmpvqXu/1JFjyHdmRe26a16HCaZNRGwpDjrcauOTLb3H3rjtiSEYfqYFqAOFYDCsz0lS33HEn2trakJ+fjwEDBmBD888HFifez7413eSejYcfXJrwSzEMwzBMT2FxtA6G7CQSBtsjKFJjmDG8CuGYjuvCo8WWyoAjZ88gq+eQEd9uaSlqBWAXjRpz38cwuRmVug8xQzZFVTdaqszjwBOTJ2KO7IKkG8LgXWcYWORvRXtMg9eVnAt3fdE3qG3vwDm6hmsvSaapLFzejZOucjpXJd6npvpyYbOZ+197zb8T62bO/mM/3R3DMAyzpcDiqJcUKabnyBn3HKUSicSwZEW9KEILhYeJdYZhN7tTZxmZMqX46MR7DyJp20RsJ2X2WtejansGCSRnVBHiiLpnUyTp7l+Xi212WcE1E7bGqNTRHIcdgNaUgb1Epb9VpNaonQKbnRmGYZgtERZHfUDXdFREbBiuRnB3cxmWoRlhDaj3B3HUjBeEsBn1fyPFvvZiJ8KaAUnTIemSMD7bFLkHnazTI0cX6yfgb3gM6wubImHikbNxVuBJVLQGcfPHy9Aei23Sozko6pMaBerJ/qnQsZnHcySJYRiGyYTFUQ5IvuQ5O/tVDneHEFz1Ld4dshv+6lyNe0JDkV9cgNqYHWMLi3DA5ReJSFGDd4jYXzdk5A8ZivZW6iVkiJRbNnHUFf+wPY9gTEd6q0xqndSEtShBX6ExJmML80SPo64HnmxZVFf237gWhmEYZvOHxVEX+DxdD7yd2zEULtGxGvApMTjtKoqLBwlx1NgaD/sY5mDcSEM1DE1DMN8hehcRCg2B7aVQykQzYrDTLDQAQySzEs6qWDMUIOzTcWnzI4n1s2wv4tqwmc4jQUSNH6lyjRpFknjbkrGiRNdf+ebGvhWGYRhmE4bFUR9YWDoRbhmY4jIjRyvanRh/8RRoqh1V0eQstFTEMFdZQn1HBA2BqLmOBI3XCYe6bgKJRA7JoyrNbC5JDFa6jo6YcsqMHllibW1HUPQLGpZizmYYhmGY3xosjnoJRVe2+fY9bDNyAKiwPFQ8EIMdHVgazk8r5rfJNL9MQluEUnMSVEXHoPJ8KPFIUSSq4cOpF0P/60wRQdoh3w5bXKT0FDqOjgj5q8SokTokex2lQnKNqtMIMmLPdLyUslWCz2GDy6bgyRUVeGltHR4+9vBNymuULfpD3qH14Reyokgz5ppdzBmGYRiGxVEviWk6rr71LZFy2+q6v8HjsaO1xo+Y3SOEk+hYnUPjkCxy2hTRJDIkSyh22sXSFI6KGWqp4ijHyLW0RpDEEY1/RtAAIiR+4gEo6pxtRZFEHyUYqAmFhFijSwzzuEXEKLWK7dFJE/BjfRvmfFEhKtQ2VXHEMAzDMP3NuuVzfoNQtEbRdNx6+LYYWeSGXZUxqMCFn+bOgRYMIhqFuegyIoYEm6rBbtOgGTIqazuwtNKPxiYDHe0yCs66GY3OchgFQ3H2t89hesUbietQVVtPHEAkdkiMVbWFsu5P24Z5XRhR4MKgPAdojq1oLZBBqceBYV53zuvMqp8gFoZhGIbZ0uHIUS8h75CsSCjJc4goEKWpyDNkV2QYuiFmqZnRGlWEbUiHUATIPXAwYlFqAxBDdf1acZxSMgSSaoNBaso6f9wHJMSRONhyB+W6H8DpGyIiR1Go8X2T4kePmfdGs9UkkWBjGIZhGKYrOHLUa5LC46rl72OU1gpXnhs+G/Dd9BuhSoYQS1ZqTXTBjv9HFh4hCYM8DgzPd8YFi7njXWNOTTSFtLJr1CmbRE93RWSZaTwbtLTP18ZO6DRfjcRXtu+2OVWs9abnEcMwDMP0FI4crSNLyNtT4MOE887Ax/c/AU2xQ09VKylv7XoQbY31OP7rhzHc68Zd25+Namex6I1tGabVmI7athDK8p0i/UUCyUyw9V20rJGKcJl8Im7VnxFCalr0WDImiYjSLMfLif2sOW/hUAShYAiKqmyRs8nYfM0wDMN0BYujHPSkbmzm8AOh6eaegTE7YuwVg9LnpEnU+JEiRqZJW1dt0GUFV35RJfYp37EYrvi51raGxGteNIJTnvoST5+6qxBIdKYYpet0A3Psp8ERkfEP9YUui/pF8CdlHi4ZtGkdya/B+U6oIUmcMxuapmF1ZQXkpgbIioLRY8dskgJpXSvVetLriEUUwzDMbxMWR+sgjq6teA83Dz1QvA9L+bBTjCcaEcKIvD6ySj+vAspgCfuQrCJv4CDsf8kF8Nc1YHXDWowsUUQER/OaMsnullAV1dASjKI83wmHIosIEo0n6epeRQMBoXfMobJEav8kEmeUxrMJoSYJGZWZQXvcfgqG7h+Et+Vl5CkqWqIRBAIBuN25jdoMwzAMs6XB4igHXdugOyOiLCUerCVjtgFhvu6cCTMjSMWDyuFwu7C6RsLqtjCk/BHYylZn/kEyOmbTXZB5O/0s6eKNNpMQisajWHSOKAmkjOuTl0mPD7Ol/5LviBYl5fx0SFMogDzFfL+6ohKqqsIo2bnT4FyGYRiG2RJhcdRHVjV2iNdQuRml0eO/5HCjFaGYhl9qw3AUF0NxeUSqS+wTFyskSPJ8BciLFqFi3kUYcvlDWBwpE9vyXOFO16KjKerTnUCyPnfXS3K66wXRr2lNWxi64RLiyIw+xQ3jLjeGuT1itAgUFfWRcPeNlxiGYRhmC4HFUR9wOhRMe/MX8X70sN+LV7nYhxUNHRhV4kmIFQU6IlFz+JrwHklmKsts+EhpNlPwDDGqsQaD0q5xs+/PcBpJQXSP9GzifSIdJq1bvyYL692fIk/h/A9+QtW4MUIMkRHc57ZcUZ258qZ3MPemg/p+EwzDMAyzCcLiqA/c9uc9UF5o+nAeKzPHhlQbMsI0wFU3hPAgWRNsaoYywBs/SkkTN+QjInFU/OfpqJBLIWvpJfnX+R/BvAFni/f/lJ6DadeOV5PFPUWp6bB1gdJl1FvJ61DhUCXcvmRpYptLUTB1wjb4m/cLOF1OLG00169cuRLBUAyXXbsQd8w8bL3cB8MwDMNsCrA46gMlBU6MH2KO56BGkISU7OOItXIh8gdJKAk1oyJNwJi5L8tHRKXyecVFopTfoqE5D9LJtwJ6MlJEWKmviG6goiUoBBYFf4ao/kTkZ4VWLErSNCiQFLqvLlzcGdD9DM134cnJE9ESjoos2gp/ALM/XY72WCyx3zPR/TB4+51w7SUXY9AOF0JWZNTU1KC8vLx3PyLDMAzDbKKwOFpHbgz9T7wuXuPHGbf/F9NO2xXPTDgWEU3GKlsx9LhJOpXFwcFCjAQ1G2xyVKSwRirVomrtm8AwKAMG4678U5Fvi+L2RnNIrCpLonKNRAuNAgnHdFR3hDHX84JYf1nLUYnzS1rf/rIUQRqY5xQLRbaylfuT2XtEQT6uOWB3PBx0oiYQgt/v3+zEUWqZfq6yflrP5fwMwzC/PVgc9YGXtj4Q/7aruLz5q5z7zPa/lXi/uKYVV408B4ZqF5+jsk3k1qgnkmZzQjIk1NmLQP2yHZqGSCD7OS3TtTOloi0hvXrQI/IS6UTcYSzo6deMnza7QHpePwB2RUuk2Cx8Pt9mJ5QYhmEYJhUWR/1QxUbVajWtIZR7qYkj0oVMSiCJhtIWudvgD9gQFTYi6k4tw5AcCERN4bGkrk28kkSJegzYFAkXho7FmkgByuRG3IOXhGi6s/BlXOo/CisjReYfNkbHJEVUbciLwYo/1frUc3KMFBGpPsMQKTYLl9eLF15/gwUSwzAMs9nCs9XWEz6PHU6HKqrYSCCd/NBnQiBZLJ/xVzgdUbgcsfQ/gKpAsdmgqKrZNDLuUVrbHsFyfwjHv/hLYlneFEBUM3I2gbzLlxwFsj7JFZSyUmx/P2B3sVw5cWsEW1tFmo1hGIZhNlc4crSeoOq15678PfwdEdxX7EGlpmNVQ0en6BFRUBAWnbTJY0SypsDqbWQYaIRHKJ380lI0+70YeP4/sJXzezTXNeD7p6fh/mO2wVal+fhL9Og0I7eFTdIQo3Eh5glz1vtTMIhSZu0xTXiLyNNEyPHKtVS0mIZoLAZnDoE0ttiMVm2usK+IYRiGSYXFUS95I+iGQ26BQwbuKd4Ff238Kk0g0TK1+UOc4FBxzSs/YMLUW6ANNzDsgkmIxhTYbWYZfi4cDg2hkIqmdp/oi6TaVRQNLu/x2NkhthasihXB0MwxJpJMPifyNwGGLCV8S9Zd1IXM6JYqmYKINNIwjzvRJoD+WxMMYXVTM0ZRp2wyadM5umgjkOpBykZ/+pKuvebf62X2Wi6zNgsphmGYLR8WR/0ACaQ5Z+6GSx74VPQ9spCC7ShuWEEKCPUxFS3qmH4byUHjRMQYk0SUKKXbtkIz1oDRPjdi8ao0VZLEcNvqduqabQhxVOBQ4VQVPLWqEgsqqnDjxG1xtHNZYiDtrf5d0q7pdThg17U0D1I2yJc0756/Y+TIkexNYhiGYTY5WBz1E4UeR+K92RTSQKCpGe/ffz8iqh1b//lMoJfZqJ5Ej+70vYwTQmdgqGr6flZEi6FrUeoFkO5RkuIiiXonadQLG8JcnUqZx4HHD98RPza04uZPliHfZkeZ04XaUFCk2qYO+D59/zwPHjzsALSGO49AsfAHw5j+6df4y5/O2CzM2xwpYhiG+e3B4mgdyUytZcOmyBhT4hFRpIsPHYNLXv8V0UAIalwctYcd6X+UeIl8NoweiKTB9hbcVvSqEEHHVZ+R1gpyin5C2r63y88JkUTRoojWuXS/1GPHsEj6CBHaNxwJiyaWNhvJq3SBREtXkID6qbYec79dtN57JK2vdFo2brhioXidfit3BGcYhtmSYXHUSya5AtA+ew/bDytKiCNaLHIJJRJI1Ex7RHHXwkHL0jQyo8d2j0aqTWk6stO6VHt2XdAcezLFdYIQSGb/7c7XtNJutFS3t0E1NGiGgTUVlaLCjtJrmQKpO0g8dRVd2lRhUcQwDPPbgMXROmKJoVSB1FNGOVaLqM3P0aEI6WaDyFQGlAYw3lWX5hda35BIugbHYKb7xbT15IWyy2ZHbpssCU9SmdOJIW4XYrqOqGGgSdNEeq234mhLwIoiESyaGIZhtixYHPUzf6n4F8aXm8Nnr8g7NFEuT54fGv9B0CBZQzIS0RvdkEWYZ219PqrDeSgsCSKmlqSZu7vi9sJXElVplFazBtZGNV1EsHoKCSSJZrjF78why2IQrSbLCGgaEOv57DaGYRiG2VzYIE0g77vvPlGZ5HQ6sfPOO+Ojjz7Kue/7779vPpQzlsWLF6ft98ILL2CbbbaBw+EQry+9ZM4g60/irYBENIV8N7SQ6OgtZNAeUuTGiBIPBvnS/TxOZ3qTSDo9zVEjYVMfCOP76hYsrmtDKKaL9b/Wt4su2jVtyYaTyJKGo0q0VS0BxLSuWwlkPUEXq2IkkhiGYRhmC6LfI0cLFizApZdeKgTS3nvvjQceeACHHnoofvnlFwwbNizncUuWLIHXa0ZciAEDBiTef/bZZzjxxBMxY8YMHH300UIYnXDCCfj444+x++679/dXipuXLZFBA2F7fw5KVVGZfCZOKYagqCFDcmyI3wnDcGDUibNxy7+uEMe5Dzta+IDOXvi1eS6bgqdP2xVl+emtGofa/FgNHwq0Bvzy7+tx0aHbY6viPFyNY3qdpvNHkm0nlXhkak1lZZ98R5s7nEpjGIbZcun3yNHtt9+Os88+G+eccw623npr3HnnnRg6dCjuv//+Lo8rLS0VVUzWoihJIUHnOOigg3DNNddg/Pjx4vX3v/+9WL8hUGUZd5fsLpbso1mzc2t79unvOcM9Ge5r6mI9Y+9x+Och22FQnlP0Irrpd2Nw/d5jEIpqaAlGs54uCgV+pQS+30/D7fbTsKSxHWt0X2LpjgKnDU6bjFk/LUFdyEwFKpKMgR439LjviGEYhmG2FPpVHEUiEXz99dc4+OCD09bT508//bTLYydOnIiBAwcK0fPf//43bRtFjjLPecghh+Q8ZzgcRmtra9rSHbmiKq8G3Hh9mwPT1t1k2ws/dxRgQzDS58a4Ig+uankMwTeuE59fGnoB8g69udO+Rsb3Ia/T2vYQznnzR0Rievr2+BemSjSKSGX2O7p5360Q0XWs7ggk1ltdtBmGYRhmS6JfxVFDQwM0TUNZWVnaevpcU1OT9RgSRPPnzxeeohdffBFbbbWVEEgffvhhYh86tjfnnD17NgoKChILRa66I7O03eIIdwCTf3kv53Fn4GCxPFB6CAZfdi0e3OpoXFdyUEqHonTh8VPj4G7vRdMk6LoMpTC5b+LuDODSlkfR/uZ1aceIrtjxy9lB0R0ZHu8gjCjyYIfJswHFhphhRuOM+P8ssUMCKZPhBW4RPZr54+JE9KgvfiuGYRiG2dTZIIbszBEZ9FDNNTaDxNC5556LnXbaCXvuuafwKk2aNAnz5s3r8zkp7dbS0pJYVq9ejfXJTdFPsa2npYs90nNkJWfcgFXK1uvn4hmpN6v7tbWkbifBRwKHUmzpp5BwbcexiehRNlKjR62RqFn9Fo32OKXIMAzDMJsL/SqOSkpKhFcoM6JTV1fXKfLTFXvssQeWLl2a+EwepN6ckyrayNyduqwLr2x9ICrUfCxHAS4v/j0u9h2Q2BaDLJYWp9lk0eK6EjMN6HPbhZm5vbEJ7c0t2K64Km0/f4cTEpX1SwYK84JQ5PTqspnFZ+I89SQ0BJLm6Eyy2JXWCz6nabq2znuf58h4eIphGIZhthz6tVrNbreL0v133nlHVJVZ0Ocjj+zcwTkX3377rUi3WVBEic5x2WWXJda9/fbb2GuvvbAhoGo1p2ygRZMwWOsQ686o/Uy8fumYJF4Lgm1oznJsudeJoVEXVjUHEQ4EoObnpW33ebKX5BOSasOaDtN0fdnHyyH3piy/B0ppWug4nI7HsSFZuXJlj/f1+Xyb9Bw2hmEYZsug30v5p0yZgtNPPx277LKLEDXkJ6qsrMT555+fSHlVVVXh8cfNhzJVnI0YMQLbbrutMHQ/+eSTwn9Ei8Ull1yCfffdF3PmzBEi65VXXsG7774rSvk3BDt+9Bq+2ecItMpFwthMVDWbRmW9zNQhVOrvHlQOvyon+iPdO34//GXx+6LPUSrFyjIM9zqzlvZ/UD8yxaYkwVY6XERrOgwF7nWI2hhaFKoiY4hsDqhNhbpfR3UdNrn7wCJ5lXLNWesKr8MBu67h2ksu7vExm8OgWoZhGGbzp9/FEfUjamxsxPTp01FdXY3tttsOCxcuxPDhw8V2WkdiyYIE0eWXXy4Ek8vlEiLpjTfewGGHJYd9UoTo2WefxXXXXYfrr78eo0ePFv2UNkSPI+KLvQ6HmzpNG0CtwweboeP5kQfh0oaPzACNZFaG0Ss1b7Sr1GMa+L69WKTXCqMhNNwxHbj0guT31kjoaPiuYYS5QgL2KFsNtzOKUFCFrpsWccOQIUkkyPohnSWZFWiN4TCawxEMz3N3LZAMiDL+ylUVIn06YtQouN3pTS27mq9GA2h7OmOt0t/aL4NqGYZhGGajjA+58MILxZKNRx99NO3zlVdeKZbuOO6448SysRDm7xR9QsEgmpNWEmsRgiKqyEIUichS6sTXDCiKlDZKJF5GL7pad5E2KzxhJmRdBzqe7LW5qMjWgjXNbRjiJSGTjFbRaYZ6XQjFNNR0hEX0K5c4sozfNHPNoFlrmoZVK1dg7LhxPY4gkUCipTc0N2dLVjIMwzDMZlattiVC6SSHrMEpaxiktwsD9bzivdDk8KLWRj4impXWPSQ+Rg3IE6NEaHGoMuyKJPRUsgt3xrWN9DPf6T1T9Dla1RzIOUYkG3R+EkK0UBqNJI9bleGKp/eylfSnckngVQzP82Cox41SpwOGpvdbQ0grDXf5Xy/K2bKBYRiGYdYHPHi2D0z6/h3sPLJYCAqaXC9SaHGulvfGCr0QAakYCJvFXHpUwwipc6m/v65BvDrcbuQVmk0kzbQcpdAMVLWHe5Q8o1QYqdxpby1KjBEpj48Rub3kVUxpOAJrYwUYovohxQA73ZQs44eFUxPncCoynpy8IyTJ0WVJP7G6Iyh8SUSx0ymEUVRU1fVfp2yKMN2w18647vPvhImbU2sMwzBMf8HiqA+Y3abN99T3x6FYc+uBmyIf4izl8MS+gagNkmEgrJvRmFvbF6KmNYRPFAPfPf28WKfbnRh24V3YfXBt4vw2RTZbRmaqI8pYZUwJsSmS6JR9xN5jMOOTZWKMiCWOLIFknevUqtPEulHFwK0n7SzeU8SJhNWqliDK8hw5v3eBwxwjcvvipQnR5pBl3LfHTvBkMZOvb4b5vInoERuzGYZhmP6CxVEf8o1v7ngwPnSoccFhNp+8vP6LrPsqCKMo0oyzV72M28tPxHk4DIpPQtGU8/BI9d+xqjGAy99chlg4gsaqamjRUkiyDClllpzTFUMgZPp45JghRI7TXYZw+1pMLT0LMb0IxdE6NAYjiOoGwpqBULyKjpjaeCRmFb+S6M8txJcsY6tSsxdTgYtEj4LrPlwiokf5TjVnI8gnJk9ESygKGj5S0RrEzR8vQ1MoDLfHJc4dThlO2xN6U+WWGj1iYzbDMAzTX7A4yokEb7zpYSpnnjgdk26/ptN6a1IZ/bdUN1NolG5b2diGlR0KLnNPAuQCaA1rIRcNgS6pGF/uFU0h8xUDgaYmvL/gfniOnQFDkuEtG5D216F0mKEC9jwN4RYFsmyD3TMIVIjvMBRUqyW49P0V8EBDVVsIdruS5i2iqFBipEhG2oyiTLMO2xZTXvkB/nA0pziyBBIt9EXNGjzTlC1Se4aBqpTKw54gKwpGjx3TY4Hkc+WObDEMwzDM+oDFUReUeJOpKYJ0xfl3X4TVJFRS1xtGwjytUbVZXJeosoRRZflo76A4lIRqQ4GvyIPq+NHn60cBecBLZwNXqG5ce9oErGp8TESS8i74R5d/OIpWqXFBIekGZFWFL98FdySIwflOjChIltTbG2UM97rQEdWAYPbzFbo6ixPyFYU1TYi8TlVr8RbcViduEkgDnQ6odnuPq+eokq82GBQm7t70SGIYhmGY/oTFUR849Lu3scsocz7ZbQN2E69Uxk/YZLIFycKsTQLGrkpw2c0UnByR4HcUQdJU6JqE1XIBhuotomv2E3gVcHceazKhrBJOVcZXa8yhs7sMqsKnrcMgRSkyFU+dKWYFGwkUVZHgkCVhsCbEdSUJ1zcfhesLXkSp3Cyq4W4tfz3n96MokNXvqCksCX/VME/unkdCqNE2w4CNIkiUFuzO1S2I9WAfhmEYhtmwcCl/H7Em2U+p/5/4fPuA3UWaiTRBjZyPtUrROrVp1GIxhFpbE593GVIlFsLtiAqTt6H3fnpanV6IqpgPV9RMTiyZUMSL+h1R9GlQngMUDKORKV0hpTTxDIfDIprGMAzDMJsjLI76gMdjg2JXRIUa/W95pEAsmURjWq8FkuVBCjY14/P7/okOf7IFwHcrk/PlsjHwsJtQdspjWB+QQHIoSiIiZjGtdbJYUhGmdIqaUQSJemOScOuPDt4MwzAMswFgcbQOWH6brqAAyh2e9zHX+R5eKnwFA2ItMKJUi0/l/SqWoRgXIjmEl1JsL529G8rybIgFAggHgvi6crBY1gc3uR4w76ub/aa1H4PrW4/qtN+N3tfEkgql0GgxGxr0PprVF7hTNsMwDNNfsDhaD4yxt2C0PRnhiUIR/bHrlQKsRR6m6r9LbBPeHBFdyS1QSCClRmx2HlYlFosdR1ZDkuNjRozkYisYBCg2/M12MZbUtYlu2alSZZr/6KwNHjNTa9Yu5Ggi71SPo0AbQBdxp2yGYRimv2FxtA7MLNhdLBVGHiqNPPF+dsEeQqlQh2vTq5OuGOYPeB+DqVt2LAKbEYM93lX6QhzRq2s7nTEhkFzOKJzOKBy2MKJtNZB1A3o4hr/6j8axz37Xq3EiFmTgllP+cdAYkVh85tvGxup1FGxtFb2OGIZhGGZ9w9Vq64GyaEendQ5JQ4nWAnuWztE0bBaKHdEM4dR9sis3sqqI3khahwRJscNROBT6/tfju6onEPJq4pq0/D18AqJG7m7WFS1mrX8IutifvEc9mbOWiUEiTYwU6Xof8ie1tbcjHAlDlhXYVLXbBpFWryMaI+Lz+XiUCMMwDLNeYXHUj1BajaRFOKQAPepdaImlpBChtJbV7bo7faIoSmK6Ge0a03VMffNnDDo4INJpI4s8YptN0jC37DWxzrpiTZvZJXvGp8vE57K9g2JbnRw278MwxL1kK+enWWsWeTYVhQ67qFrrDhJcuhbD2tWrE+uod5PUTYNIK7V27SUXw+X18igRhmEYZr3C4qgviHRZfMBaZroph+/mqvABuMP9QXKFFoFNUsUp7sMr4sCzQ8ckLnBZ03x8IAEVq2tQHzCHqYVRAn9TM3xFhVmvkeonovdu7yBcsfc4vOxxoLojLBpUZnqOrLsvy3eKgbU0l424q8WJ6tYQ2iNm1Il6HvkjkbR+R9astdsW/Zo4Hw3ivX+PnVDqSm+gmYuReXlCJFEEKWYYsNvtkGQp0SAyEAjC7UaaQKLU2oOHHYCfausx99tFPEqEYRiGWa+wOOoD0XhHbKuXT298yAkp5V8Do3A4SqNNWNxM/YwkRPN1MXB2pVaEB8rPw8iCS1H9hlkZRp6fAZOG4d9P34/DL/8L2ba7/IsaMXO4Bw2kvSzyFM5570fMOn4nMVbkn9ETzX0ydB0JJGtgraPdFEDUWHKI1yWEVXV7OK3fUWLWWjiaSMnN+Hgp2qIxlCcbdHcJiSmCYmMRTYNDVSBLMhRJhxQ0x5FkiyCRQGoNhxPptUw43cYwDMP0FRZHfYAqyUjE9JTRzhbcZHwIw6BjDNxsexMnPfMeYsdOwyoAf376KygnzgL0AoyCWfVmUyS8du7u8AfM9NTKhnbMJB9PKCjK+3vK3flniNeCg4O4V3ZD1iQ0ab7EuBPCkjskpqgzNl37//KexzXNk/BP6RTYAzJu8LzQ9ay1FFoikTT3VF+K2Cg6NdzrRTAayzliJDW9lgmn2xiGYZi+wuKoD5h9fXJvd8oaojFZRJaGSu2J9dbM1zKfG89ecSCuCuSL9ddOOQDXhTyoMuxYIxVBomo3yUC51yEWOoqaQyqVEvyhKGIpwiYX5LnWdQkxxTRfx1QFQUnCqf6H8ILjDFxYlyzft8zadG+Xqc9iZIG70/koe0gl/eH4tbPNW7PSbDN/XIz7d5+IUqcpmkQGMsfoka6M3BS1sqvmceFIpJNB20qvWREki0p/K6fbGIZhmD7D4qiXUFZpRU0rCtw2oLOGSCNiqFiteTFcbcXlgd8nYjTz3O+hyOuCM0pdtoHxZT7YV8nUIClLi0kj0fuozOtC+PiZ0IyaXt2zEhdz5CG6YeEvGHBACDG7nCb2RhS5RWUaiSDyAGVqP1pHS00wFG/4CAzLS5+3RhGkm/fdCpf/Z5FIrZW5nInUoyUMc2F921QjN11HEQbtrtNrtDAMwzDM+oLFUS+gh/e00+fCpwIFeXYccPs+oqljT2as3uN9P0UoyIj2IPqTxDxOkfqWqKI0GUWDSNxMOXR73OdwJcQRpdfWxr1E5PVJpfaT6Zh56PZ4HKfBRmX9koQSp13cTUMwIo7NjB75nJ1L73sCfSO7Qs0z4984Xh1Hwq679Fou2IvEMAzD9AUWR72kOM+Bg+ddhYY2s/rLgC48SAm5YnQRGYmrKMvU/EDpO2Jd4hAtgoGSX5TUdz7aQKNaAkch7V2bZauJw2MW84falU4CiWIwWxV74AzJmGM3PURLGjtw9ts/4i8n7IRR+R6saUv/GmSyjhYaIqpEqbTGcFQIF5oatzYYwgglPXq0vsaxGBTtikeSHOQtiqfXegJ7kRiGYZh1gcVRDlLkTvoPpkj43fuvYMarP2HgPdPNMSD0n5Tw0Wh3M/5S+xEutB+FQVI7blE+yXouSmGRNKIjr1NewFnNh2BtyVDIRvcTyoJhm1nitR6wrmWW1JvCyOtM9j0q3zuAbwKtyLOryHMoKHXb0RHVUB+IpFWvrU/EIFtZRqQ340visBeJYRiGWRdYHOWgq1TZV384GhN2+SP8Tm9inS8UD7nEuaNkb9iCOmbq1NsoPYpjRpAk0aSRXu2KBJ/HLiIzIt2mQ5S05yYuFhRg+7G1cUFDJu6kqPry20GJvetC5n2WOltzfFkqqSeDddJoTiX9T522KyqaApjbCFz+30VivVOR8fjkCfDYzX86JF6ymbNTv6uVTuw1PclX5oC9SAzDMExf4dlqfYAaVn9/wzzxXnSZloAWV75YHKqcNjSWMFIW4sLGA3FZyx9wactBScN1oRujyvNho/RRPBp1bvRonBu1GkMmhUI0x5yznkqJOc4Xsh5LIif1PCSQ9hhehFFFHjx80s644ZCtEdJ0+EMxc/6aJKEmGEZlR0D4gxiGYRhmS4AjR31kqxuugCwbIA/zcCRnq13m/xKhqI4VDe24yXcSrsb+kGOm3Jjn/KDLaAgJo0G6H6ua2zCwyIP57pdxbsvROAdHie0xyQZZNbAqOhG2Dahsya/0WPhEnFm4QHyuaAnAbVcwvMCFcIwM3aGs5uz1hZjBJvxdDMMwDNP/sDjqJbGYDj1eaeZq98NhU+A3DJy89D2RGkOhW/QMesD3R7EPeXIsPUQz0ih1lcl5NQeL19TsU2pPoUxkQzN37kJoqY4w2vx1iHjs5j30qRVjur+8wGX6kGZ+tlx0tr5pn7Fw2xS0R2Li/GTOXp+klvdT+i4WjSIai6Fng0kYhmEYpm+wOOoDsizBNagMzWSMXmtWjv3p9vfhdChYcOXvUe5zi+qqAaFWRGEgppnCZJW/XQgnTUmmrijycnfxv0V05rzqP6IGhZCKvKhRZfzVsFJqJjZZEwIr3NQMOdQIT8lQfL8sfYzIhDFmDySaT0ZhrTUdEXjsJI4MRLWk1LkqdKx4PQuPd/p+NKrEHrc80X3OHrowvsWcv7aqKYCpC3/GvYFjseaLWWKfWftthWGeLmaGkNk7Q8xJvSjvt4zfum6N1mUYhmGY/oE9R32AytrJW0TLyAEe0UDxhoPHIxTW4O+IiKc6+XFIIFFEhYQPvS/Lc4hQDA1VJVEUjmmobOzAqsZ2rKhv7zTrjKgwfGKxzM1OVUZ5nh32woEwZAlRp4JA1C4WxEUELYqiwFs+APllpTDyYmiP1CEY01Dbkd5N2uL+4Am4sWay+Aexti2Ea1YfhqmrD+uUyqL5a7sPLxJm7ZFFHuFDollzFD3qCvJQGVR5lrL0pNJNeKFS2iB0dATQ1taOaDStYybDMAzDrDdYHPWBg/7zsnhYa4oi0kwkWL44/CRsddOVeGbsgZhdsFtaZMR6wFMKaoTPjTrJBwcJJoUGrEoY4KTUV+cWSSJVldeMkXl+PFjwMoYrzeK61lw3Mck+EjOFB72PRtG4tkYssWhM+HTEeUQvJUlEkY5745esAukC13OYM/gNDM53JjoECBN5xn2lmrVJHI4oNFNpdAylASnqlIklbMyxK8lFRJN6+JtTA0oKhtXX1GD50qVY+utSFkgMwzBMv8DiqA80BqMoaPNDFdGPzqJmSWshqpCXMM1EUszEFHUSP3y87J40QuoQ24EiWQdEowoWBUrSUmEWlJqjE+qxGNrq6qBFo2KJtstYsmiAWDrW1iaWWMgGp6cMDk96Ci4b4txx6N3UNYd1uf/DfjP11xKOoSYUwlrqYt0PvY/I7D0qLw+D3S4hlHRNE92yGYZhGGZ9w+Io5w+T2xFT5rGLqElZxBwqS5ValhygdBlFcShlFI5q0DXzNRjRsKSqBTX+QM7z0nFWOb3ZXBJY2dARHzWSFBwksGg3MkWP8jrhUOTEMjLfIZZR3uSSun37E27BLO+fsFoq6vE/Ekqv5epkTWIq36Hiwe9XxyNY6603ZVaB5OinijiGYRiGseAnTR/6DwovUXyYqxjdYVAkyFzWNgZgtK5CTNdQLXuwqq4NFXVt4vXPd76Pk+b9t1PHZyV+bESjsRzW+U0FQiKLxpRk2pcjgRoUSk2iKaPwXkuABgUNaolI89F6a7F6MZlRqp5VrV1b9ipuHPh6QqRl/Y2EYJEw67BtRZ+jmo6I+G791TWbYRiGYTYELI7WtYwvrjUoNTaq2IORRW6xWIbtwV4nFEhwDBiKrf92C1xT/oFovGN2RawAt+BIMbx2pNeFR0rfFMtoZwsckgYpZsBwj0RVqBjntJi9jqKajHrNB1v+QFS1h0RDyIFqCwapLbAbWrqEyqKDqjSfWCIOBbMd/xJipvR3NwhD9tVVk4QHSpiy28NY1RIUPiJasqX3LIYXuYX36uZPlqExGEFLJIrGcKSnvyDDMAzDbFJwKX8uMibU9+jHpMn1cc+OFAG2L6jDkd+/gst9ZlpKeIuaq6AWjhCfh6stuDT2Clm1oSpy4o+RpRVSGjFDhV2JocOAqECDqogIzhCpSWTfJD3eW8mQcKu0AJfJJ2cVSpJoMZC+gc4z0ucWviGKAF3neg0NwQg0wwU1R7ckMmdT9Oiyl38QrQYoybi0pR3FDrOCjqCUm2XMtvhX/rGQcuTgSKSRaLzMeDP376D1zXO0cuVK+Hw+lJd378FiGIZhfnuwOOpnTNO1hOJgHY74/CHc/NEyFF/zOIJRTQiGFbWtCLdHxXw1i6CiCaN38gxmeu3v3pdwVOOfxWfaTPYbivCQmBpZ4EK9XIxhWmPK1VMSeJ0zc2neIfJKEUvqkjPiaI01YNYlSxgWr0zLPAfhc1HPbqCuIywq1u5YtBTuX03R5lLVbJeHge/T1o3Y45rEe/pOwz1u3CEfKj6niiRT+BlYU1mJ0WPHwGYzr90dXocDdl3DtZdcDJfXixdef4MFEsMwDLNxxNF9992HW2+9FdXV1dh2221x5513Yp999sm674svvoj7778f3333HcLhsNj/pptuwiGHHJLY59FHH8Wf/2yKhFSCwSCczk23f3K+wyZSVlHqb6QWA1oEF/z9IxQ4bEJEkLlZOWkOpGIfYChpYiBzuCvFcEaV5CEQ0eAPeqEZyaGys7Ag4d+mSrlbtKeEQCNDNumKa4Lx5pIuwOdUIQUkVLcGxao/f/x14jxkHaJZai2hGIYUOLHgjN0wML/z7ytZ3bPtCl5eWme2AJCAEHS0R3VcPWEcxuTHq/dSyVBMz8ebSJLBnWa2UfQq+z9QCQNcLjSEw6JirafiiIbRPnjYAfipth5zv10kIkgcPWIYhmE2uDhasGABLr30UiGQ9t57bzzwwAM49NBD8csvv2DYsGGd9v/www9x0EEHYdasWSL18cgjj2Dy5Mn43//+h4kTJyb283q9WLJkSdqxG1oYGZrZX0i8zxIa+am1LD4VjbxCBv61+5nYeQ+gQpcQhiRSaUWqikgkJjpBz95/PP5J4iPSiLVyCaKGDkWymX2SdAPntxyFCIkmqlSDJtJ0DtW8vj9aYDqZRBUb9TWKX5faCMQH2YrmkBmprTKPA6M0V6I/0cxDtk+oFqqS+6Lajzu/XCUiXd+vbUFLYVREiSiVlgp9furUXfH1Gj9mvL0IZ247BDFdx23/W4lF/nbYKE0pAfmqipH5HpS6HJ0moDh6YYGzml32dpwICSTCrv+Ey/96EUePGIZhmA0vjm6//XacffbZOOecc8Rnihq99dZbIjo0e/bsTvvT9lRIJL3yyit47bXX0sQRRUL68//r76qUn7hqyXvilQTEyuaAeFAv2P3w+L0l93t+7yMgL6LUVBgNQQlDvM6EiKL9bp+0HX5tbMP8/1WgxGWHU1WwSilGjGaM6MlmjfN9rwgvz0G1Z2VNkSUw0tN5VO5PuieWUkE22/Vi2iHk7VHjumS8z5OoNiPBRKZvuyrBJkmY/tYisZ7M19Qh2zrj9csPwfTRbwmBtMNALzx2FU8uqhJVdjEYeHx5ZaJ/Ev233OXEQ3vtJARSb5ElWUiohkBARJZWV1Zg7LhxPY4eWQLphr12xnWffwe/38/RI4ZhGGbDiSMaGPr111/j6quvTlt/8MEH49NPP+3ROXRdR1tbG4qK0vvytLe3Y/jw4dA0DTvuuCNmzJiRJp5SofQcLRatrckUVC4yIyy5oOjNyELTwEzVaaQrqKzditYsbi+DayCtNxCorhLnHavWY1msFINjzdih3Iu2SCzFY5Sd8zQzBmXtFolXvCWwNgg/Tvom06PTo6+Dqe3HYFaeKZ6o7L/c4xDpvNn7bYUSj11UsM38dBlag1GsjRR0Op7Gizx56i5oDcWwqjmAG//9C67ZfTRGFLjF7/JdXSvmf12Jyo5AInpk3fffYM5wW9rRjr9+/gOO224chnnc8JLwiQspSj8O83gQM3QEYjE0xmIIBAJwu929Eki+PggzhmEY5rdBv4qjhoYGIV7KysrS1tPnmhpzQGp33Hbbbejo6MAJJ5yQWDd+/HjhO9p+++2F0LnrrrtEyu7777/H2LFjO52DIlTTpk3D+mTOVgcmIkgkkOixbPU+sktWbyFJiCKbzUy/lZQG8ZevXsLDO50uNMxaRyFuHn0cDqicn3buEVojQjENFW1BDC3OQ61WhBWxIoxSmxL7SAagRnU4dAPRF85BNGag4ISHsEYqwt9wIm4j31EWugo6ZSKliMT2aAwlsIv8IaXqwpqBcmdrWpTMelvscYhFpPQAjPK5sW1JvvAvBTUdLpuCmT8swfy9JiaiR6lpyRfzjseoPSfhX3HhJGvAcMMtIlyCuC48R39VeI4qV1VAUVWMHTe2VwKJYRiGYTZan6PMEu5sZd3ZeOaZZ4QZm3xLpaWlifV77LEHTjvtNEyYMEEYu5977jmMGzcO99xzT9bzXHPNNWhpaUksq1evRn9ifbdtvbUY66lJvBIUTSHhQymy1F6JPW2cmFl8T1GdW47ZESFdR6nWINatgSmQsiG6WPd4ohlQ6CKzuIybPlqKM1/7Hte+vwSNgSiq2kKi/xHddnXQixuWH4IbVxwiTN/2+GK1NSCRZFHitmPaPuMQNnTRDylbk0k6bnieG8PyXCh3OURULahpCGua8DFZ/NM+Ga/kHwdJ1xEJhxEKZR+qyzAMwzCbTOSopKRETIfPjBLV1dV1iiZlQoKIvErPP/88/vCHP3S5ryzL2HXXXbF06dKs2x0Oh1j6WzVaPiRiasmh1L4oAXluqOJs+oe/omRCEFGPqOlCVKaRIYA/HMV3dS0IjTZ796R6hHJRAZ94vW/gmQCSVWaxuGl7CpLRNsP0Q4v/3GYs6LIDeCpD8p3Ya9Is4a06uPURUR0398uVGOC2UzlamswS7+Ndw61hu0RdMCxSahY+Rzy6E+/aLY6NiyTJSq/JwG04zGxKKUFUr6WW+FMUiSr2yMhOHqaqQBC6zrPWGIZhmE1cHNntduy888545513cPTRRyfW0+cjjzyyy4jRWWedJV4nTZrU7XUoGkKl/5RmW184JKWL6/XuXBT5IHE0otiNi0/eGQ8WubFKk0QqjCJGY4s8Yj7ZnV9XwLmtWVKf6xJ21RQAkVjy/mrbfXAcMRP9BVW/qZKCET43WkNR4fsho3dX3LDsYISiOkbuegjesjnwaZP5T+1kNXu6LxdWFIk8XVaJf0TXEyk20lb/tE3GYXiOB9EyDMMwm0e12pQpU3D66adjl112wZ577on58+ejsrIS559/fiLlVVVVhccff1x8JkF0xhlnCB8Rpc+sqJPL5UJBgWkAJv8QbSN/EXmO7r77biGO7r333vV232o3HbKvXPJej7w7FAkxB8eaOOyq6U1KcU4P8jpxz+E7wGtXcGuhG5GYjqrWUI+jOwhJcLgHAmkNIDsrLPGxD2PPaNyIFbVpCkXNPkaZ3zPjtSu0Xt6E6DwOKRFFqg6GEtEjcc34bLqammrke/PZd8QwDMNs2uLoxBNPRGNjI6ZPny6aQG633XZYuHChqDQjaB2JJQvqgxSLxfCXv/xFLBZ/+tOfhAmboPLr8847TwgnEkxUpUb9kXbbbbf1dt89nM/aJaKUnkaGpDAo39lJGlAkiirBRnhdYmhsKjWxQkQNBWPRhPnKy0Cxuf7QxjM6Xa9GLYEW/5OuNAZAVTQM1U0Tt/V1sgmbnjI4z4kVzQEzBdaLs1DUx4JETH28wWM20lZLnUXSQJFCC2VEjySUOZ2oj8YQDke6FEe3VWyLvw3/ucf3zjAMw/z22CAdsi+88EKxZMMSPBbvv/9+t+e74447xNKf2LpIq6E3FV8Z4R97hvghMUAPeuop1BOfUVfQ0TZJQwyyeC2zt+K2kJnGsirnqGN2t8PbMhis+M17pw7bkhn5sZpGEgNdrZg+4q1Ox5k+KxopEoFbVcTx84LnIc/eiOF7hPCEywm7bv4e54ZeRpnb0W1pHZ0jW/SITOPU+nJ1RQXG9KJqjeesMQzDMJnwbLWNiikyZow+Xvhprl/2fMKYbGRRBmeH42M/MrASdJS+kzMiVVdHj0+/ogHMtj0vquXM9F7PEcNt810ivVXpDyCsUrWaIc6ROpONONX7gnj9LtiCee8vxZ9+N1aU9D+FE9AWMaNJ1YGQMKkT5/3vW1y/41YosCdFTditdxJHdG0repQ6XuQB9XDoKjCp5TlRtdadOOI5awzDMEwuWBxtYOjhbooZU/5UtQZFE0n6QANewz5dVHZRd2mbbwiihgo7NfrpBkm1C+d3RCIzuRk1ygWd3xRGhojEWE0fu/McESU0Q02RMePtxRi2Z0Ckuuj7/PnNZLWcxZCdp4rX0bsBH7hc+CAENBk+FMpNUEnkuB2i9J9ETq0MXP+N2YHbYvjunc34FDUqdtjFrxdOqYAj6FNlewBaYxPyI5Gs3yUc0zBr+Xgc7/sUU/eYiKWNTXho0Qp88803GDVqFLqDRtrwPDaGYZgtGxZHG/oHF/PQZEgxU1TQA12jEnYSHk47HLLZZZsiKrGWNXAW0fy5HsR3ehgCsppTkkgjUdLTnlNRKLi+5UjMKHgFDx+6Pd5d1YB/S8CgPIcQWNMPzVYp+FqidJ8G01a0BPF09ERENCkxCNehmOnLRw7cAa3RWNrRTyvmIFoLut+1HSHUhUzPUk0wFDe2J/nvz79C/XVlIiKVyegdtxWvt/nN1yXfzIU/FMbVf72wR6k4Z74XL7z2BgskhmGYLRgWR70cH7LHjCl4t9CFHZZ82K0eWdxRgvEeszGjBR0z178Q50qHY42SPn5jzlYnoKqj0BQszR2mOVlk1zp7kRYWPyaaMP4Vx6Amkmd6lzQNEmyISAoq1SIMizVhrv1f4hSnBc3ZdsT1xglCJNExc+zPo7fQsNrB+U6s/WQmRh9yM5yyjK2K87o8hrpjE7mM3OQ3KpfSPUc3Gm8kKvZuCU4Wr2Rap1Sk1ViSUn2pAmnK/ttBtdmgCC9SvOlSCgti6YLrkgO3R3V7EGUDy+F0umBTc/+fxKrmVsz63xKex8YwDLOFw+IoB/ZuDNlmp+nspEYtvmoeJF6dcgzbFdSJ97lEFRmyM88rvEQxBasDXsSiUiLFJjnMyIukSRhY2oG1tZ6EgVkcHwTW6l6saQuJRo6Wqdq8975XrPWWaXXmMF663inqAkQ18zv2FTJe22TAIczluui3ZP3edNYxLk9cUJnCiHptpUbGnM3pf9fxvnw4ZcDoaIUc6sDIsWNgU3kECcMwzG8ZFkd9QFR9abqILtFctcT6+DZiVsOb5vw1j7nt+6YysZwy4GSUh9qA9lx+JLOqLPk5N9bWmrr4RSQa1BtNbKf5Z6e89h2enjwByGwQ3guBYgkrSqnd4D9CHNrmoRTY9T0+B93pk9ET0GD4UITkjLiecrXLTNFZ3NJxOGTd7MJda3hRLreIa9wdPgJXuN8wRaWuIRJO9x791f0qHA5nimBSMKIgH8FoDHe1Hgrbr3ZcNe67LgUSVbilwj4khmGYLQsWR71EolLygnzYjj5MPPGjL72ZEEg3DjpEvE5f+1bPz0deGt1IzCGzVtLDm9ZbcSRz9hoJJ3OXxTWm4TpWZKar6HDyMqWGhOjYqAE0B2Np4siKrHQXweluSG1v4z+9q43rO8JXFR8tkgp9XXOMSfo3U2UFrrgWikYiWL50GUZniSAVOB1w6Bquu+zitPXsQ2IYhtmyYHHUSz6bOg/Ft1+Nuc0ydnzteYw54Y/Q3/1QbDu19nkxKmRJ/LkbG6MLA3ZX0AN7TWsQpR7T2DzWvUas32fFPzDlrV9Q5LIh7/i50KhLtHcQQv41UPIH4wK/6cExnroE40+6DdW6DyMowpOiP1ZKPgw87jHcRGIhXvBGFWrUHJIYgiYhE7oaettV00g6jg4Vr73o/bQ+uNT5qqhMG+Z0467wEWLdle43MDcwCXM7so+cucLzRs7zkUCi35++i05DbqmZZIY4Kst34/Fj9kNLyoBb9iExDMNsebA46iXuPBf+fflc8f5F8rz8by2MgDkPLZWyC66Gq70E2+Y1CIE0oag2bUDtJNuZ0KBAlSAMxrUdYZFGow7aNkUS89bKXHacNnoQXpSAgR4HWhUZ5fku1CkSyrwukdpbEdGgxUvaK6PJkvthNr9puo4LMKmLWE6uyq7kXkmRNN33qlj3c0MbviIzdPzQm+onY9qA9NRXNkqkZpwsP4cL//cTTps4GtsX5wsztmW4TuUqZ/fns0TR+oB+DYrAkYBcU1mJIcOGQc2IPhXYZBS58tiXxDAMswXD4qiXPD3/YgTaQ+I9pWgcRV7oLSkGongIZdXqVXg6HEbU5RSdolNNwYY1D4yqr4o9wqRMEYuaFrOxoY0e0/HRI8VOR+I9HeNUFVAv6NQxI3+zPYd7cTKklK7VVUEvDCOeyEqpdlOlGMptZkpuhv6cuNmp7enNJXP1PZIyZs/R2c+0PScG0s5uOrLH0aM8uyLuf/a3y0XrAirjv9ptCqFsIqkrco0hyUo3u15R9I54DWt5WN3ajsoMb5GFrChZ024MwzDMlgGLo1w/TI6nfPmAAtjLC4VQCcd0OEoKEW5oTmy/8dd8TBvXJrpVG2vJuG3g144yIYQsTi89CRG/+dMv0wabK0n4DAigWZZQEmyA124TQuj+XyoQ+ekKTDl0Bzww7Dyx4xA0467wM7hAOgGew27GrTEP3F38JbsTLN01gczUFlIft1v6MAYDDx++A35paMfNHy9DSziGUpcj+zlzCBqKsj0rnSCq8oRwjK+v0dPbIxBk1jbvz4x/6boBWc7d38mhqMKkbQmvu5oPwSWFpo8sEtNQQ925Y1qaOGpuTv4bYBiGYTZvWBzlwCF39dPQyAxJGKCN5pa04bL0vLUrUqL/Dr2mbUy8zx7JoGhUVVtIPMhn/mE8Ll74kzBmWyX6uYTHPeVv4OK1hyU+D3a1JlNqElDZ5hPRqShUVEpF4kRTHKfi7+Gnu/ieGbcbFwu5REVq+i35S6VDKUO6D7dNwQC33RQgwoDe+XxzQpNzVq7ZqFJQlsx+Rz0MWYk2CfQbRMLigulVa509SNa/AJJeJJiyYZm0L7/4Ijz0xFMYP3589zfCMAzDbNJ07RZmOuEoLoBSWADJ54Xs80IpNBfSQKZfxfTwWD6eruw8TikKu6FB1TXYDA1D9RaUhJrFA7yyJQif04xMSFZTyvjMNet/qdCnuwctTCzZsDpyg7KCfWg1ZAmJXIdOa5gs/kGlLlLGYv02DaEo6oNhNIYiYukLPensnbZ//H+KRFV9FEGi2XDmfLi+Qibtew7bA0ZLM84+/VTU1NT0+VwMwzDMpgFHjnKRPrarV1yzyINQeDhiHgmrdRkRQ4WmJXWoR410inbQ83lltFT4gwyswJ3bn4wgRlPrRFBt2erWIM435ieUyf+VnY1ozHywm9Ea8zWZYOqMNU8txZrUK0RkSHTW7izOenOOkT63iIZ1RCjBBvza3IGR+W5hzO4L4l7oxnJgpdpSXV+io3gkHF8nwe6gZpHk6+p9zd24AYWYfsBEXPXBD9w9m2EYZguAxVEObBRd6AUUSTJJHxKbiEqkGHIydVdq5o0SduVeF6pbg6bYkYCmcBQ3frxUDGu1cB8VFINmKUUVilHFmiGM391nmHLk87qAmj/SXDVxr/HO06k9ixKDdHuY4aJ0GPV1KnbbkG9X8dCS1ViwvBoPHbBDr2KZf3O9hor2AHQaThdH+JCQ7kOyuK19kvjtrV/gEvdr8V/CQCTcfaotlXAkDEVVEr6jwrhnir1HDMMwmz8sjnLglLseH5KL2Vt3iNeauhZcuSgqzL+QRkCHOdNLFvInSTBmg0tNdrUWKTTZbABJcRUtvvNfth6BHUuSZuO781xi3EhVRwhVrSGcXzsZ/xz4enL7oIXQ6aGv6UIonLD0pIRY02IS1KAOf8iD03EuCgsCnb5Hb7xIphAhYWaKtVThlEssSfEZbXcfsi2aA1HM+XQ5fmxsQ6jQlI5k46JRId2JrOF57rSKNVswtw+pxvChVDK7fZPotM4vjo63VOhO3pldyw1UVa5Oq1pL9R7xYFqGYZjNGxZH/UR5aQFGBxXENB2La2yIJvsGdh9ZUczIigoJO143B2vbQuh47Z/w2tVE6skZ779DVV5rqXqqC9/M5asORSwlrWem1hQoVmfI9dGROj7I1hwIm7yXeGPvnN+5xG3HEI9TlPbP+W45hu9q9oyS4kNmeyKQqPVB8l56HhmzfGFW9/GeHEdGbWvcSGrVGnmPOLXGMAyzZcDiKAf2LGm1QKyXP66qiEWWJXgcMUQiUdjj/YlUVcNopR5L9VKMcTSkHfdj8xCEJQ2yZqCuIywExl0/rMTzy6vx8AET0rw5Sg8sMvNGvIkrVv5RvF8VLYCmkSk5mdxrbonPZkvhooJTehw9ShUbNAzXIrXzdqrsMD1PSdcSRZCePGJH+MNRPB42m1tWt4eh6SR+0C9Ynb2te+uN00h001Y7CykrtcYwDMNs3rA4yoErpZSfHpz0kLbHH9S3LTOrq/42xt77XzzlSWxOqKfeOekupKhkPXx1xDRDpICoy3ZrJCaWbMZlSpdR3yWKOGVGWzIf45QY0vVk2lBV1sF9nnnuFJVhuX4yg1qReEdvkcaKbySBRCNUbsab+LWpHef890dctc92GJvnSSvpl+KNIjMH0WYbK5Iq1IjLW09FneFL/CC3Bg4X+ydOTL94Nz2QGIZhmC0fFkdd4HN3Fj/0LL9stK1TZMQadmpx5Y/5KChK5tLEs1aCiIpQfyT6uCpaJtbTKzHWWZee8rFK5w2KVqQ/rG9tfEa8flrThAs++wnXnr4rVrnyhCdmZIELqpw0JIuGlPF+R4NlPyq1PETb1prXgYShPkpfpZ9/drhnjSErWoLie5EpXLQbSIE+3lSW9EFNqztcvN7SeETi96MmmfaohGuKkmKH1lGaMLUFgPgdsG6UqmYzyFTssiy8WSTUxKDeHvRAYhiGYbZsWBx1QbnPNFGnQuKG6PTYlCBETyotTWaEx27TML48hI5AGD9X5eXs+kyCiDbZoSEWkQBNRiQyFlpDJQ4fWI7/1NZ3OqbYaUexw46BbidKnHY0hCLiQa/I5kVsiiyiSrOGLxTv6b6nLD0YmsMjIk1r/UFh/s4UR93hc6pwKjJmfLxMfB68O/U4klCbF8Y/Oo4V624se71T30uL1J+AfEoV7cn5dOShot5H1YEQhnldWdNzswKm0CKmOF4Vwiz1O1jRqVToNPWx9A7aEQdJI0PcA52b/oRiVl0sBil+PtojrKXnVKlTNh1BVWuJ7xHrZd6VYRiG2SRhcZQFN1Qx8yuTmJEUMQmvT9zHKyIP8SxRroCDw64mokem7cY8YUgzI1TftQ2CU4kgpKvQqCszoonrvVVTm1VUicaKMs1ek+BRFTQmolgptxc3KVMECfFqOJuspJ2vt74b0yc0Af4Q1dQZmB92YG1HWPiGckFiKRUSPYGoHm+e6Uys7wjHhC/pf7V+hHUdu+CRxEw2EoCZVEbN32igy5lwMt0ZMqNTFicZzyEimUIo7diOQKfRJ+K3CIbThNCt9X8Q709QX0jrZk4Daq2I4er2EMLhMFasWIHNFZ/Ph/Ly8o19GwzDMBsVFkdZKJAc8Midh4rSA/vXpVVZ0zsFXg+GDiqEVJAvts/5nbmedMmsxVEYmmnQtttsiESjYh9qDin2MZIP4pagC4ZBwix5FfLirBCz3DQRURmLpIHa7Pncmcw+RFRun0sMWaLO6qvUG4FEC4mc/2v6F85570dU7DMGIYcpwpY0pgzkjeNz2FCWZ0bUbq45vJMou778DVHB5nWoeK2yDm+urk9LgT2w33adPFeUgqsOhlEVCKaJoWz4ZLOU36/7evw9SRANcjtFqpKkM0ECtyYYwkC3C3ZVEdG3itYONDU04LL/Ow8eV+eo4+aAy+vFQ0/yGBSGYX7bsDjqJWefd3ci+kD/FXPP6KHicuCZxy7HwDJf4oE/9XObeLOm3fyZqUosGJHhcQKBkJTwtNgdyT8DbTeJ925WbCId5rYraI1Gcf1XS/DkgRN73U1aiCUpQ9aljDixSvF7G0GyKLDSbB8tw5B4Of457/7YaT8q2X/yyB0TAqnzfUJsu+eQbZFvs8EeV2urWoOY8dGvCMR0EfVKxQYDwzyuLtsZiP1CKYIxnnUb4jFFjNnjKHkTdrtDpNUoalTd1i6EkdU+IRUSRmLumgJsU+zDII8TsWgY0/bfHcXuzUsg+YNhTP/0a5x92ql44fU3OILEMMxvFhZHveSxuacnIjDkTVnTGsLqqibc/+h/0NLagaEDCxMP2pl7RMXD/oz/JFNBLruOCcMC+OJXG4JRUwgN9yT9Mf62ztdsdA7Aw0ftiI/WNOKB/1XkrFhLpa8ipy+QsCp12/H45B3QEo7hsagpCm46dPu0/SpaA5jxyXKRessljqy7pujRsHw3nGq6IKGfNmak+4nis2sTfYtycVlKhdtdHWYF3D2B9PQbcYnnNThURYwT6Q4ST+R3ovL+QXluzNxrG1z1ySIhjMYWF2Fz44a9dsZ1n3/HY1AYhvlNw+Kolwz58lvEgoAjHr0Yf+pB+N7tSBus6hCT55Om4I6QAo9Tw8QR6WmmaC/Kr24tPxvHtN4jBNmqtmRHa3pPYozaAlhRLMs0ngo9wMlr1B+I1J4ElOc5UeYx4Gw0RcWzxkm4sSR7yb2VQpteMynndvoepj9KFgqMIm00A83hTPqTqPSeKsxInPTm23Wto7o/E/2e9LemqBK9jigsEPdQ4DDTsZX+VvHqdThQlte5j9Smio97NTEMw7A4WleomzUtFtnbHpqfU6e/7zrOj89/KRTCKRWR3oprm3KjEZWaDwbNTIs3nm6JxDD1f4uFh8gSEGHZwJdVzaLKi+5kZX26CMt32lDqdWKEKPHv/OC3xFSqmXxJY4eoSCNPUU/p/dQ2dDJDJ0Z0SBAdqEWn7AJLXJj5v9SIjiyb09J6EjlKv9fs+/Z0oC4JNhpdEoxpwntEKT36/zRIHDkVCbe8/4nYz2Gz4cYD9+kkOjY30cQwDPNbgiNH6xF6rFoVYamPWIoaUVDnu4o88Xnrwa3i4b/HNs348lcf/rl/0nS8+7PDzDcycH374zin4xj48hyI2hQ8OfpClHsuRTiaEhmSgPZIFHe+uRjtsZgwPJO4SH3IU5XcrSdNxNB8MhUnRQFFZUhQUJVZJud8+BOcsoydD54hSuSrtJ4bmHtKalWdkSE8RhaYwoM6ZQejmhBwVB1GhvQNgdkMUofRRTQuG2VuJx45eCe0hKNiufHzxZj61nud9iPR9NAxkzZZgbRy5UquXGMY5jcLi6NeQhVTIqNG5mZdQuDxt1Ff2YDG+lasqaiHTZIxeszAtGOeOTiGKR/aoOsSqsOGMFgLEWUAu40zGxOe9R+zEWQCA5jlOxOyuxgNsQiGo1mYgsl7RGKBZAWJiAp/ADe8txinDRuOR1euxNljhojKKjqBx6aiJRrFnB9Xoi3UucSeRM+oAXmJdFzCTCVJuOjI7XHTKz/2qQdSr8gIN5Goo6iOSKVR54N4BGltRxBNoQimfvITnj1sdyFC+ut2iGjEFGEUESIBeXdb7vTfSbYX0xpg0r1Z92cJpVQqWwOY9dUytIbDm5w4ooiWXddw7SUXi8o1NmYzDPNbhMVRH7h/r4PE64WfvCteS9wOlHjsGOx1YWShB3pjq2gcGIhqaOgIY4SPyr9LE5GSbFLj4d/XiteTXi/CijaP2GetXCx8NoZqhx41R1qUeZxwqwqihi6EmDnaRMZYbx4GHjUbr8BAy2vXi3PR+IyrdxrVZbJLDG5NET+Wkdu85ySDFbMEvj8R7Q00XaQMLYFEESQSKLS+wKGKKNn39X6M8HpECqvUZZrdxbCVHNVq4jfvccpNEgI4MT5X1zGswIsrJPNvnQ1FKsCdTYeI9zUxL8rVVlxe8m4noZStOmxTg8Tag4cdgJ9q6zH320X49ttvMXLkyLR9uBcSwzBbOiyO1hMUOVhb3ZTokq3FxVF9exjtbgeisWKoVPJNGTObCmjJ9NDMqozGhlpERJdGys1YiiLxkKZu1pQGu9h9Cpp0H54I3QtNSibPihwODPOYQuKmnSdidUcAty9eIo7rTd2aFcjppip+vXFD+Rtpg2ApY0iXnlFzWHz7QpDFudTlQL5dxZpwCNM+X2QatSUZN++5DQa7VLG9K0jw9FQg0X5SitgSncV7ULlGpAqjXFi+pGnvfbTRUmt3rthGvF466pdO26z7ses/iQhSJhxRYhhmS4fFUS8wIxDAX79421xhA7SojAKnDQ4YuHGmOe+MIElC0Q4/pbMMYPyUGRg6sAS6zYFge1BUsrXVtyHcEcSy1q3FMWO8i9DWPgqGvxYlXidCevKBXGsrMS8py7BrGj6vbhaf7YY5HiSiaVDjIzTG5Oel3XUuSWDpn7VBLwa7Wjt9zw2kj8xrStag2uxXpdL/J47cET83tAkhtbYthNmfLsflH/+AArsdDx+8U9YIjVnNFtmgrQ26g+5z2h7jRcn/pphaS40g0f2lQlV4FFHy+/3cB4lhmC0WFke9wJYjeFCW58TjkyeiJcXX06HFUBsOwa3I+LG2FW/GYvjmhosxdNq9+Gq5FyF/M3544AHo0eQxX1LPoxOuoTgUqlACo6kKar65zRzDaiBC/iBNx9y8M7H2tWlwQsOAyTPwydf3ITBOgztLo8JULOnRU+FzFp7BVl7z4X19y1GYUfAK+hsSe1Tmb8m6m6vNKNJ1AxeK6jmKji1t6kCxy4Yjx5Tj5V9rsLothHJPeiowWc226WGV/G/KkEDaFIUbwzBMf8PiqJc8sOtBQlmc91k8epQikGixaItF4QopGF3oxmCfC+9KEm7cdQTeaGvBGnkAwsEoRp04BQ5fMbT2ZLWaokdgeIdCjsQw0NGMWqNUrDdkA4ZmA5QoZMUOpXgERpx2N8ItjTCiMbyz0wVofXYKHtx9VyCLSEhGZ7JHUKzIytqOuBrLM6UJ9VASggzAtXkvwYjHd3rKtAaz2WJX/Y7S7jE+iJbq7SzvUSoUOUtNs722vBZ1wQiu+eQnPHXobv1m1O4vKBLDZf0MwzCbFiyOesl5X74DLaILpUExCcsY3R0kTMjkfNeal3Hc8HPFuuVPzsHwyWfAWZwc9EneaKpFI6pd4yFb027jGoGq3ERsSNLFwFmSETJV0Ok6IoYuRox0eR+QMG/02wkxRMbx0346Puf+lKajER6iTYEYrmsaw7uiryksOi0JItN7ZHR5HkqzPXnERHxf14rrPliCYCyGH+tbgAFm2mpTJ7Uf0qZe1s8wDPNbg8VRH4jGy7vNRJchBNLc7Q4X2679eWHO41b54xPghwOK6oBdUVDx+hOd9htx0tXQ4xpHiemQ48Zgh6cM4dY62PNMMdUeaEbLwmkYdMh1MOIqojESQVjT8MiIU1BUehSMmsdy3o+VWhsY9xulptru9R8N4HMhpui75qoEy6QXfRh77D2idFpqes1aRwJpeNhsbBnWgRs//1n8prP23g6jCjybtEiy+iGRoNsYZf3ZjNgMwzCMSc9KcNaR++67T5QDO51O7Lzzzvjoo4+63P+DDz4Q+9H+o0aNwj/+8Y9O+7zwwgvYZptt4HA4xOtLL720/m64i74+S+rbcMfOB2HOxN9j3k5/gNOeLhxmbpt8gFuQYVsuGYL7djwNV444RkR/7N5C7PWn/8NO517caXGXlKKwrEgszgFD4SoZLBZZtcMumekmKtMf5XPiuSO2wlCvUwgKGuo695fF+MHfjBiNLjGA1e3BrANZrZYCqU0YaSn3mMPdrNZHK1sCqG4P9dijJCTjenJyU5Squ47V1PTSY1PgUM0+CfXBMK76+Ef8+e2vUBsIYVOGBNIwb/YUKMMwDLMFR44WLFiASy+9VAikvffeGw888AAOPfRQ/PLLLxg2LN4NOqMz72GHHYZzzz0XTz75JD755BNceOGFGDBgAI499lixz2effYYTTzwRM2bMwNFHHy2E0QknnICPP/4Yu++++3q5b1fG5HeLM576CsZTX4nKMJddwekn7oIBNEQ1ZeJ9WNdEN2eL8nwnRhp+nN/wMlY1BXDbiNPE+tUPTk/LG+WdM1O8xmxOxOKChjruaLp5L/RfR+FwxDTzoBqU4p6is6AGY+I8l+0xGnd/vhIeRYVDUUTE56FFq9EOHVX+IH6tbRMl7an43HahkDMlCJXKl+53I2Z+ME10yn5s0vYoivcU6gnrWh3WnfcoM71Gw2ypArCqLYRozMCcz1aI5otWH6T+hsr35zX8Qbyn1+7K+Td36P9OM+H+RwzDbCn0uzi6/fbbcfbZZ+Occ84Rn++880689dZbuP/++zF79uxO+1OUiEQT7UdsvfXW+OqrrzBv3ryEOKJtBx10EK65hiq7IF4p2kTrn3kmWU5vEQ6HxWLR2posW89FvpK9mui6nUbDq9qw2N+Gx5auRX0wgkKPPU1c3JwSPaIHOwWi1DYJ40ryExPkS/McuPzw7UUayEpF3eEzp9kvjiajLx5PBLFWcwcdMuzQEE35s1VKRVBUDVJhEQqaVHFuuib5hKjv0WFjRmPWosW4+dWfUOy2d+p27bQr2HHy5LT5cITos1SShwvjnbJ/qGvD4HwnSlw2DEwxnmclnhUTXyFlREh/eI8sgURLSNPEce0hrVO0zOzd1L1fiul5B+1MuP8RwzBbCv0qjiKRCL7++mtcffXVaesPPvhgfPrpp1mPoagQbU/lkEMOwUMPPYRoNAqbzSb2ueyyyzrtYwmqTEiETZs2DeuDEV4XBthdwvhMD9yqlqCIIp3w8bOJfW7d9wLR1bAw1CAe8PRAFgNiyTQdf9jTw5u8S5KuY4DbLqJLTjUerYomvTuiq7b1PKf3JDpSg1oRCZpBUSLg+aHnwXtEGFjzvNhEQmhbnxf5siren7vNYCFwLKraw/jnz2tECs6WpQUACaY3cQZK92sXESS6b6cs4anDJ3Q5kPameGWaJUgogkVVayHRkPLHdfYeZYP8SHStMP3Omo7G4DdiDttY5InfTaQZe9gMcl6bKW6n5L2RNmct4w5/k0Kru/5HmR21OZrEMMzmSL+Ko4aGBmiahrKy9Llh9LmmpibrMbQ+2/6xWEycb+DAgTn3yXVOiixNmTIlLXI0dOjQdeqG7XWokA3gxrcXYeyNNyS2rZw+A8PHrRaP9HbD7GpN/wt02NDUHkGJyy7EQkNHBBe//pM4hrxCTx23E+4wnhOfD8n7K6JmTVonwlDj08e69uJcV/cibi49RtyrQ5HgUhU88sOaNMd0KKahVdeEYCPJlPqor4mX9JMHaUSJB3P/vDtWNnZg2qs/wR+KdSmOOnXbjpfyL2nswMcAKlqC6AkU/KHIEQm73K0sk99FHBM/jl5/bWoTxuxSlxO6rqc1g7w8f2GPrp86Zy3zyzkczvUmkDbFUSK96X9kRpQ6d9TmaBLDMJsjG6RaLfMB0l16I9v+met7c04ybdOyviDBsWNhIf6x7/ZY1daBTz1ONBWYHaz3vWU2tKgk/C814SAGiRSUhGXtMbSFY9hqQD4ebn0VDcEIbCdOxMyyM7C2NYSpPpeIHN3R9LQQQInslyxhhN4k3q4xfGJbLrLJJRJn5D+6YaexwgCc2qVoVVsA079fmkiBZfv1xOw2Rca4cm+vG0gaacZqeoAqwkg+46NlPTzeEH2W6PcmQdk1PyTeUVSOjnvo55VYsHQNHjl4l5zeIytKlA0SUNactczvZUai1r3v9qYwSqS/Ikq5okkWHFViGOY3KY5KSkqgKEqniE5dXV2nyI9FeXl51v1VVUVxcXGX++Q65/pkZIFTdMqWJQPjnC7Rb+grYRg2Ia/PgY89j9WBDtxZsQhXHbkjFhxwkjkYVTzuDZR7nSjKs4tjrlr7OM557mtMOXJHbFuWTy2du74B4eEx4DBi4qNhB5SIhpihoME5EJItilnFUzD1+9txUtvj+OewUxD94lsUO+0YW+DpJDLULNcbFK9YE+en0SXtHkxd/Af8yfdivN+R3iNZkDkMpDzPiScm74DWsNXJqWvIlL6mjaJMEgbnmSX7PYUqAte2hzHjk6WiXH67knz4shzfXQTJmrOWilWdmEy39T3FljpKhIa9krjYXJtCpkaUaHYbtbjINZ+N4KgSwzC/SXFkt9tFSf4777wjqsos6PORRx6Z9Zg999wTr72W3k357bffxi677CL8RtY+dI5U3xHts9dee2FDYk17pyhCcWuDWHfc60/j7B8XiV5DHVIENaFQoqx+eWOHiGiUuO0o8tihSrKI7JjCKTkFzYEYooaCPKeZzhm9c4t4lb8wUIEi8X4YzNlqFShE1K7ACEbF+Szx8tevvxPbB5Qeg7pwGHXBMMb4PKDatL4+yIX/KUUgWL2euoL2sbxHBKXjBub1/PojClxY0xYSJe/ObkajZDLAHRbRuNlfLYZDVvCPfbcTIqunZEaVLCFl3X0i3RZPsfW1Qs38bmZDSGJLaQpJ3cz33elyaLqOY4s/T9vGM9oYhvlNp9XI63P66acLcUOiZv78+aisrMT555+f8ANVVVXh8ccfF59p/d///ndxHJXzk/mazNipVWiXXHIJ9t13X8yZM0eIrFdeeQXvvvuuKOXfkJBYGFfohiNupCYNNNjlwb+P2gXLWjpw6Wc/o9zpipfV65j57hJohg6PXcVjJ+2MoQXurI2mhmtNWKYMSHz+ZLHZ8mAQ/FluwjRpR2wK8o1GuBVTsFz8+63E5jWND0I/6hY873Jgt+iLoFuVrMhHvIvQ0erTOGDEAFy/6tCc33VN2It7/ceiZN9DAPwrrcx+WuMRuKn4VfQHJB77CgmxJyfvKLpoUwSpNRLD4PVwTyQurXSblWIjTxN1LO9LFMlqCEmtBypbAxulKWRPoGhQb5tIinEvsoyxxaaoZxiG2Rzod3FE/YgaGxsxffp0VFdXY7vttsPChQsxfPhwsZ3WkViyIG8Cbaeo0L333otBgwbh7rvvTpTxExQhevbZZ3Hdddfh+uuvx+jRo0U/pfXV46grVraEMNjpEYLH7tCEQLrmoxfFtkhYAeLRDXp4lk6ZhkcLPLj1h9dw5agjcOMfJ+CbuiY89E0lWkIxDC3o/nqBdhWIkQfJQIVU2OW+tR2RRLRln0FmCvKXhja8qCWjPVbVFtJ8MxDVdJ3rsbJDBmlaSCDROel/qY0ws6WiNhYkkIYXmNEif6Tr0Sq9wfqOVkQsM4rUF4G0KXf07s9+Sew9YhjmN2nIpiaOtGTj0Ucf7bRuv/32wzfffNPlOY877jixbMrYygYDIT+uH3ck6u2FGFuUh5pQ9kqtypagMCsXOFXMx1M4ougC7DdyFT5eMhwdNHC2C+g57FBlDMh3iCaI1N2a0kjiHmQJv748FQduMwy28cPE/xdPTHMci7BdhyxdLdJ55M8hgZQJ3VOn68VHilDkyOpDZA2nNbdbjRs3DaiLtlORMfPrpXjogB1R5nYkUqL9EUVaH0btzR2KLKVGmlLfEyeXfpnol8TeI4ZhNjV4tto6ICJFfaSiOSCaMtJoEZdNxewPlwqRQw/xm/8wHkY8C/G7rSqSabWIHxVSUZeNE7NVQ1HbgeeWV+OI4WUYGvfcWI9uqgQb5HFgWJ4L9qbk8SLKZFBEiIy2HWL/sOkBR0WrOSOOhFyp2zSWW8Np0YsBtT0iftJU4Ub3bIm8nkaPbt5vK/ztP7+gKRRBkdPWo55H2czat7Wkpx7/VvBmIorU2aj92+6J1JPqNjKhU0Wb3+8XhRYMwzCbAiyOcuCWs/809NDPNqvs1gOOQrWnEGVtpi/omFeeSHuoG/HgT77DHO0x453FcNoU3PzHbXDDQVuhPaLBH4xi/ucr8bd//wL3NjreXz5CPHRVI34OSmHFn7FWOidBjmdvqceBq383BrM+WorPapoRKjHPdSoeF6X8XxgGqpoD5vDWeK8gRfhEJCGOyNxNQoSe7eT/oYjR/fbTgBAghySMhAt50DoNpxUm84zP1Dgoc30mmSk50nt07ZqOUNo+I7zuXgkkn9NmRnkcdtjs9rSeR72BxFA2kSTuCzn6IpFwtdtTBFL3YokMy5ta1dr6HlZL3y2zmSTDMMymAIujHPjU3DO5somjK/77ctrnWruphho8ZqTHkBXcOP5InPvt03jo8IlY0xrEDR8uwt9eS/bnsSBj77CiX1Ddsq3oS2QNX63xFMAImu9XyUUYGG2AEf8Lpox2S3C1dow4NjBEA6QpuOGrX1HqdCREBQmfhmgU17/yoxA3pfsdkrg+jQ6h/SIpaSI1vp6qj0j0rfUHEYhqUGMarmw4XBw7xfkCCl02ET1KxYokdRJ1GdA+lMqzpAPdw8gCF6zAEd1PdXsYwZgGTTF6H02inknrYPLu7t6z9UWi3zkSThFMXfiSrL5HVLlGVWt3TPoDm5kZhmE2MCyO+si0008Wrzc+kayim7Of2a7gqg9eEr6WYaFmVLuKhUAhK7AWFwwUzRma78bDh++EJS1teHaHv+CyXx9KeI9u+exX8V70hRbl8+ZDlGRSalxFpIW6aMp4i2IaxTuMGP79u7GY+9FynD5iOAa6TONvdSCER1asxDXbjcJwup88lxi9URsMi3slMWRdzbqGqkhQqfqOtkmmV6kpGEPVV7MweJepuNJzFhwdMgapftxYZFaw0demUSl0EjXHQN9kVE7vlJIzK57M94oudYok9TWa1B9kM6OnCqbufElW5RpVrd34+WJc9sa7W0RZP8MwzOYEi6Ne8ue3fsZR86djUFM7jpz/PuqQn9z29LsoHZxsoDj9ixdx3Y4nIqxrqCs2S/PnTzwFNnqAShKu/OlfGCFTjxsZ/9jmPNxT9yzsspIQQLsPWw6XTcGncc/RHtuuwQdfjUicP5flmaI6tR3hxIgPEjlD8l3ItytYULk6sR8JlqZoFPk2FeN8HsyKvYRFzW249ItFGHTkbLNLd1ycdXrgKzJGleSJB70rGMPMs/bAvZUuNEStx76E6U1mL6sbil4xxY4YuivlvG9NMvtBdQWl+0YWuNOid/R9KZpE67q2rm98wdRVSjGzcs1qDrkplvUzDMNsybA46gVa/LnmmP44ti8cgBUZ272qHaUAZu19TGKdLapBEwNXxSQQgRlFMXDzNsfgrG+eSuiBiKEj36GYlV5xj08qn/88RDSHtKjMKO23PEE1HWFcGJyMEXY3brOZ6T5qPPnIERMRiia7Uy9r7sCU//yMtqjptKarkXmbLNaUMqOH+pAiN+zUGynL72GLR5GcMR1P1h+FNiMPkogM5e6ALcr+rQaaWc46p/EI3FD6es7jE60EfgPVYJRiYxiGYTY8LI56iwQ8UbkSz1UlezNZOGUZb4zYMeehNc5iIQjKw40i/UPpI/LKCAxD+Gm8Thv+MWkCnvHSmJLuBcBQvUkc1xwrhF/yYmQhhABq84cSaTxLfVEkKbU03/QTAWsDYSz1dyR2vXbHMaha+wheHPRn8xzdOJenb/eeEGWXf7MfqoL5pos69ScT39Hsh0RpMwublIySpXJz/WRcNyC9S3rquXLdCkWQuvMeUaNFhmEYhukKFke9RJFkXLTt7zDYk97BcW2gFfMXfZrVrE0RHUmLCN8RiYQKfxAjfG6R7iJRISJJZOIOhYRYIBGTbeYZYY/PVMsFCQM9xahsTajPlq+yxn/c/1MFHl9SlbaNhFvZoKSISjVJZ3Ll8kPEtupIHiSFrhRDKKaJ7y0q3SjaRvcV90wZif5IptXciiJZsufK4lcR6dxySTC3/nDRVfy68jcS60gQWT6kXN4j0etIVXDj57/g4YN2yjpnbVOFKteITa16jWEYZkuFxVEvoUcqCaMR+bnHIUz9xDRCp3LdLseKKAwJjRrNQEwzcOuqlxF05aHOXiL2KXW4UBcOCkFz3DsvYpjHhXv3mYS9xlcm0moRJNNqcoxmq5VAUjXIMaoES71LSQg1iYSZVf+fQbHLLmaNhSM6rt9uaxQ5zAq91R1BzPp5kXhvRa96UvauKrpoB9DRVg2KQ9GhVGkm7ig+5sR8NSNJsU5RpHiqzfoeknl9+t/M2kmJfY0cPiSqYMvlPRK9jvYdh8vfIw9PDD7Xpp+ySq1cI6h67cYD94HP5WChxDAM04+wOFrPfLtcxiiPadJONWdbIzeQEvi5ZqTpTVKCOgaH/aKqKZMpn/4bt+/1x4Qh+z9fj0puJGsPRYZiCuDQE+qlLZgPWWoW3bKnKEdidrxqDVkEw6wDxuPyt38RwmhMft46fXezU7cCe+FgIdQC/qpkai9tR7OCi0hGkUyDOZ3DrGizxFMyppR6pkyxRr+tlqUJZmavo1S66rnUXQdtq9+RRWrfo8xtfSV15hotVL029a33tqjhtKljRLqCR4wwDLMhYXG0gbjxi3+J18u2OQGhoIpWVcbq/BIMNWqFkKhy+DBtq2MQNTRMXWTua46k6L66KUEIaJCoD5EMW/FQdPjXYOKyu7G4pAD14RBCYV2IEurKbVWyUbppfTHAF0jeSkzH0ndnYdrB2wEwH+DTG45I2/+GErPUX/Q+StEhZm+nZI+gVNFYEzPTmdRyoKtUX9eIEry0OXPZ6K6D9oYgdeZa5nBaSrdtyuKoJ00jX27eC2NHboeH76R+Xz9g+coHs+7HI0YYhtmQsDjqAXbFfIiuy2Pyhp1PwPSvn8PVXz2Bcz74DksMHQMum4ZVIqW0HCML3ZAkGdQCuzESEamhqKHjUucpGGuYXbczMeyAKgbGJp07EeoKqRgYqjdjhSThufJz8aqrHJpehaa3bjKjO4qCxydPTAgkK5Vm0ZTasHA9kqkzUrtqJ91H8X2p6aSkIGaYlW/XlpmjPG6uPSyxDx1riZfe/G0q2wLwOryiF1U2aPwHdbkWcaselN6b959yfBfH9ELq5hRKVrpt2nsfbfbRoyvGLEZte0eyU/aIzsOjSQTSiJFvv/1WDKbe1OCoFsNsebA46kfqqpI9kKLby+KzhHzM2ep3aI1FgNfeRFWwA/dV/IzpR+6IJ/Y8TUQrHtrxNJzz3ZOwSTJWy8UYJ7WIc3TXXTqBBKxVijGqkKIjBppjMgb43Lj1mB2FGXzGf5egJRQV4oiiSE67gjuWmI0nzeuYx1kVYJIumfPCMiRImqE6Q/lYo0i6YlrDZFxfbEaPUrm54TBcV9J5rhlxXdlCIZDm1k9OrLtywGtm2q2bn8cyZc/+arEQiI8cvEsiKpOKLBs9iiyl8te8ZPuBaHeHSesmtTfFHkipg2V7O2aE7r+r70BGdLv+kxhSuynCUS2G2fJgcdRD6FGm0ENzHZl7YHpqiRpEFoQ6cI/PjUajCB1tpil65sBz8EDr0z0+L92ZppoJKTlmPtypD5FZKSehQSnBA84/4Xzp8bTjSCA9ceREIZaIitYgbnp/iWhU+f3rU1HltqMlEkWRy54wZ5fse0PieI88IOdzfuiuU/G47sJMdN23qLdkXo4q0yj9Zom11CG1qdCg3AcP2x4/1rfh5k+W4ft6P0Z4czyUzWFw6B8kINievC+HDU8EDsflJe/2ugeSVcm2savZ1vfctWxDajfFOWxWVIsH5zLMlgWLo/XI6GlT8YqD+hMpOOzxdBM0DXHtCTt41+KH1ngNfRY8zvSU14D2FqyWChPeJCqWt6hAkXgOD3M0xf1L8eG1hlmePzVwlNiPsnlwm8eE7NQr6Cqct9UY3L90Oc4aPRgPLanEudsMxqB8M8ryWjwdZY7CaDHHjGQRSKdG/4US2Y4ljfFzx5thpvJrU0e8P5EizmHts6SpzRR8ho4Slx3lnvQIT7pB23xH0S5a1rabJf25IJHXFIzgps9/FZGkjQ2lyPbZK5ku7Esl26Zk0raiSOtTMHUXXWIYhlmfsDhaT+TbHCLtVBs2Z35d9dPXadsH/nEyGuLbskECgURLiDxEhoFaVxGuLT0a0ToF7y4eDSfV7Ys/WHq6qjZWgKFqs9AHlYbZEsBwAiVqW7ynEBCEHXdHzSjUryQgDAPVwRDOcjwpRMRwjxvTO8xRH0pMR/l+N+A97yCM3sbARy3LEf55Nm77MllNNGjvSjOSZnNCdXqhxvsMZXL1+4sz1phDdofsNjWx5pwvfkyk8IhRu5kl+3/+4vuEJ8ljU3HzfuNQGK82O872nHgtcKgi8kXf89b6w8V3PcH+HIrd1NU7XfTQuazeURFdQZHbhWsP+B2G+9L7VW2MyAMJnP1jz6E2kJc1zdddJZs4T9ykvamk2RiGYTZnWBz1AWr4aAmiYqf5IKLX89/8CW3RMP5z0gE4fec/pu3/CgysCZpdqFMRDQxpn7YQ0LYG/7v3OihnzBGG7G8WXA31wme7vBc6ui7mQ5mabtomvSFJZpSIhItVUi+GutLD1eHEAIdTVLGlNq4UI0hkINhahY5gK776zzxISnpFW/MXz4pz7LbPJXDai+FUWkQ0hsRHqkY6b7fRyLMrGNDJ+Jzsfm0ctD2CWizhp5qPweJ17wOm4cDQE2iLarj3mwpc9m7nKATNnXv08B0wND/eSykugpoCwc6/EzWHLCwQ90jjWWyKjAKHs8cT729ftW3a5ykjfsb6IqrpuOTDxXCpCp47bGKvBFLmvtwwkmEYZt1hcdQDIlqylJzKx/+5+FPx3qaomDrhD4mGkCSQaHEoalqTSBJRzXfMxMOXXQdbgRmpKGsxTdaqJGOoKy8hUK4cvxvutbtQHQ4gENFSxtqaxGzJiMjvxlVgzcfUm8iAEaWJ9WZKStE1NCAfBc4WIY6CbXm4KnYU/k9/GlVtYTQGo2iLaMKULCrcdIpWxf9BSBJG+txCTDWjFaX5Hmw78Tjk5xWL7dSTqD4QgSPSBtnQYNMlBFuCaI/fP6XYLB6TTkL9p7Px5KQJaZVxmZiHmsfL9eY7hypjlM8t3s/cZxzaI/EGURJQaPOgqj2E279ZKho60o90bdkbkGUJUd289/S/nzmYNqJpQhyZKSkZ0//7ER48um9pKBJL60MgkU9IURTUBmKQoOPDNQ2YMMD8N0L32VOhlK1h5MZOsVF6rT+9SAzDMP0Fi6Nect/OO8GvSWiJRnDLz79g1vfvYvYukxIRpGzQtr9uuw9um3cTdrhqHhyiyWHKH0GSocY1xSiPF3/5+En87YdPIdsAVSdRkNrcMFny/vGvwyHLpiAapjcl9pDje9F5qR2AxQM4GboXGHtoB572uvF6TEVY1UFzTZoN84E8wGgSoz4a4EMrAgjAI1JUljdHimni6hQpMmiOmSSjyOVESNNEC4BiR9K4TaJraSiK5c2BLsWRmZLLzMtJKHM6RZRnmMedOF9tMIRSRz4c9ONkgczZtoxekMKUThV8re0ielSW58SM/cbjivd+2ehpKLr2zQfthwsXfoy2iIHZ36yGTTZHueSpBu4/YFuMK8zvVZqNU2ybXhPL7uB2AAyzacHiqJdsvasHdT+bQuHqbbfBTT/QVPtwl+LIih71FK9qF+M0mqMhjAvXY7sdkhVJ6Q0KgU8bhorPlXIRDN2c0aHFTHXg78hDntv0HtWqAzA9eg+ag1GctvArHL7bGOw5pFBEWaxASww6WiIRlLuceFI+CU41AkVR8e1XpseHoP394SgKVBtawkHsc9ANoCsI8zRk1IVi4r5M8zdQFbHhso9W4O79RqHQaVbidYWeEu35oq4Jg1zuxHBeEkftWhRFNh3R+Iy5ipZg2hy1VO+Tz2kXooy2D853Yk2rOYxXlZHwL/mDG78CqsTjEkJ2wvhJGFVUIsRzMBrAJz++gAv++zOe/uOOPYogZUuzbWy29OiR2WZAW+c2A9wOgGE2LVgc9RJbgYKyncz3B2qFGLv7Tvg13Xu9zpQ4nLhqq4m4Zfk38bEjyYc/eXPMyjczglTqbBNBl7pgPLpgJLtLxwxTxBX4gkI0yPUS/NGIMDnP/Xxpp+G2dG7aVuiwQ5FM8/Q2u1+KaDTdw1P35f04bmgZHq1shMtdBFVRxbGUcqP2AdYAWaqg226X01C16FWc/0FFj3r7TNzflEctHRH87X9r4p6s5HEOKYbb9jPfKxJESb6IDGU5F0W7njrSbHZpCSyL9ZFaW99oehQOmwvFnkLxee/tj8Vn3z+NH+tb0OI1jde9Tbcx/cv6aDOQq8klR5MYZuPB4qi3SAZU0/8LFRK28ngw6oB21P9kGqLJEAzsnPPwU994RqTOuqPQbhfRBHrsp0oYXYRluh4Dm5RHqeskzBtwNkKFGoaeGUCRy42Tf3kpbZ/KpiY8/MNXmDJuLIZ5TLHwQmFpp3PN2WM3tEajeLrKD0VWoCg2IY40SYeiyIlmkdR5qLB4OMYdcD6g5a7USyUcT5d58odgz33+Twg46/u3tDXip2//hTzFhuEFLtOLFI1hoMuVJiCJitYAZn+5DM3BCMo8nSNWvU2t5fIXpRq1++pBouiDWwV+WPwKqirzsf8+N0GWFMje7aDLDlz7P+qjnoTSbT2NJjH9z7q2GcjV5JKjSQyz8WBx1IvxIbmwOSQUjgF+/qFFVEUd+tyHQDdpNoub9z466/pT3n6sR8fX5MVL0T1AtN0UCK9E5mNK7BhUyoWJCE7m/FenouKA4emjGH6xO/HszypG5+djrNeMRG0T+ndi+zyPWWY/xOPGsrZkE8PuUO15sCveHvWEDoetvQy480uFp8kK+oR1XTR7pD5GhDBpixRe8stZ+9IaimRRei4Y1cxWCRnXslJrGxt6sM45eC9c8trb0PUQDDLWK4oQSJP2OA/hSDJy5+9oxDeLXhLeIhZHW270KTOaxFEkhtmwsDhaR6yHMUUuJkzw4fvv/T3yIK0vqGLNMmfnggRF0O+By9chysapseLa9jbUBzowwN37+ySRdFTbAiF2NF0DYhFzwr1ugOzauhjsStEaGS5HGfxkD4oXm1kEw7VZz51vT0qYytagGT2L/8bt7Wal3VUfLBFVcf74/LNCuxqvvKNUmxltI4N4WywqWiSQqZvOStVs5piR5Ew2cR1/60btLk0Uu13C+B7KUHB5Tq9YNicsj1HqSBGmd9GnzGgSR5EYZsPC4mg9IVspL0qqDfDDrrSJ99UduUVLT6CIR2pnaREFgpE2qT6TCx0noE43Iz9UeUbP25BkmrgN2Yg3V9Sxyu/PKo4qOwJZz3t68AU8UXKseP9UwR8RVNegI2i2JJANEl2GaAVACsTlLhNmbiVHVZnXMzDx3iel9mhqFv9tjXpR4CiHR25NfNcAilCw31R899k8obWoCWUgFkXYkHDuyCFCKOUr1KFcRm0ojKcqViAYMRAMk09LF997SZjOL8Fut6EuEBEpyjkffgKHattkvEdbCluyEXtDRpN4RAnDbHhYHPUWwxRA87Y/MLHq8p/+k3i/7Q4FqP1VS+vInAoNms1Mn1F1GpmwU2mgijUoqG4Lofq/pmcm/Mw12HbuVUIgjS6iEvvcAskirlUEVGFP90TmZCrxv/mz/+LBQ49OCKRCt0tsn/tTcghtKk5Vxh6TjhFz1zyuAhy23zkIR8xKuj80vonZP/+C87YZJsTYPYvrscc+/4fCgvLE8X7DZ95T3AOlx8w7a5fM1GCxwxSUjeF86KBIUFQIIysq5MgrhF1pwT4H3QIpUikGw65oXItF3/0L9y5egWBME7+NJMnwKk74tQiu/GAR9tjrhsx5I2bkSAK23vNshIO14n4erS/AVXmL0BssnxF5j9aH/4i6hZPIMyUtdUzXxN8r01NF5fq5WNXagVBMQ4XfFK4WGzs6xvQOHpnCMBsPFkfrA4Om1suQ4j2HGkLt4uFb6sxDsXOFWFfkNGBXVNy9PHOkBuCUZdyxw+5CIN24mxmZIYbufQq0eHH7eR88DozfDV/f9hzmr/4FRx28PcYUefDioceIh6eVXrNo+c6NcECB3x8fmhZ/2FI12YhCN9rCMVQaMfxcX4eh3uQIjam/OwCtoTA8NhuKnK7kA9ffhHu+/jwZHaJxbK4CsRDbRr1C5D2+uEo80BujKpbXV8PVEU6b9kbQ4YNpVppjpJmai29t8teY21EDwzYi3hwyHRJlsYgNcI0GScat7S7U/OqFEQvBrpqVfG3hIA4v2lrs/17Tz5hQ+yxKnab4pJTid2UnQbXZxN+oAwoKPB7xG8Y0HZUNTSiN91XqDZmput4i0iiqipZgDCtWfwyPy2wiSh2P6KwjfD5Rxeawu7KatDPTqI0h4Jp3v4KaIqDzbBJm/X5P+FyOjSqYUtNtHF1iGGZThMXReoQeYhTpGORyoToURG2wLblNknDFDgeIobSp0GiR+Ys+RWss0il6RL4aVURQzOaQRHMkjEjMwIz3Td/Ntnv+UYgN6mpNIzFSocaQ1INFXN8AWmCen6IQTpsMz4mzcG9cukSevzbtWGqyeO/BRySiSgo1gZQozaclRn2k0hgO47LxY9ERi6ElEsW9y9dg7c+vxH8XKVFKT+KFKt2W2SnlZq6jF3N7UlxsvdsU4V+KttQi35W9CaLd7oLHU4g/HPAXROKm5ebWenz0v6fwbuNPomrOHwvh70uWJK5Pd76bNwwpZJpfPZ48VHUk/04nvf0q5uy6PYqdPe9LRYTVbeBwOvsskEig3H34Qbjw9fdRVfF2Yj21VvCHQvhSdeGkfS+Az+3rZNLudC+6hrUdYQzKzxOCiwhFAvjk++dw8b/N7u6pgunJYw/ZKBGl2jBX2zEMs2nC4qiPXP7je2mfbQUytDZhRYZbVTHc7UmMBBGdnUMh7DTAjx8bizvNZesNhXYHSmwOXDF+PIZ6XHjN4UBdONypGs1itutl8cC+puNI3Bc2mzlSOqqivQMNHRE8Zztd3PN5R++UEiUKYPp/F4uo0rYDSoVAKvJ44HG68PXb08Q+Q/a7Ju06dxWYg2uJNR/MhkM2oBoxaNGYmBl20/bboMjhQFM4jGk//YIoVWVpyZEs03YZi1K3S9zLAvvxokN3U8taaGopPvzgNrEfpSrNVgkmhuLEAftfIKJJtFiCqdBTACMaFDG3PJsDu+4+BQPsduxW/7zwHn3tcsBms0OSJbRDwZACU3hGNQ3LVQVehx3D8nv+tyHBCNJa1iC7PrJt2QA8d+JhnXrmvLtsFW797CcEIgEhjrozaQszOoIo8hbAERdHxGF7XYBwSs8qf3sDvvnlRfxUWy8+byiBlGrYztYkkiNLDMNsbFgc9ZJoC0VOzPd2X3oUSPGan2+bNBl/e+OlxI8rGhlKZrpt2jdfJuay0diRvkCRHzpfgd2W8OOEtfR2A9miOxbkK6LeQLSLQ5eF4BhXnHzYFjjtcKky7vj6o7QI0v2HHpl4cC9w5J5mf/nBk817CoXx5a9L8NyaFUIYjc7PE8sje+yK1qhZvrY6EMDti5eg2GnH2AKPiDI5IjLK9BYs+uoWDNntargM84Ful2Rcu832QiCuCQQw89eVaGhajUheMBlJchXg9/tfmIgktbY3mAZsRcH+5eWI6BrG6wsxetgYOJ1O3L6afEJxT1eMZq8pYt9UUbGxfSaWd6ixrUE0ifRkCKNsnqSEaEvBac9DXlxEEnQuQ7Ljuv9+vVEjSJlwqo1hmI0Ni6Ne0vizjuJtFSE+Iv70h09SMEm4bdIxIokzbfFraF0eS0SS7th5ItYEOnDbol9FyX8m0754ofO6HY8Wy43fvSR8PXZJwbyffhURlwNOnSyiLWTczqxyi2lG+li2FKyUVjaoQeKTx++G72v8IoJEgojEkbUQjnDufzqjC02/TCgYQqUj6VuyGOB0YkA3GRVKGT7x+50wH25cfeAEVLYFMfub5UIYUR8mr82GPMkQTSG7iyQ1tUqoDoZQL4WEoOyOyvbcZudskAgJyxokTTNl1jpEj7IxMC8PshHD+9//CzbVhT0nngmnI5lqpD/xCK87IZBILNG76oxeVCSCR/gKoMYFNQkliibVNq8WEaQNPWcuVQRxtIhhmE0JFkf9ipQWraEfe/syBeO0fIwt2RqD3H58XW9WcPUU8iXdvsNeWNTWjHtX/CQeeDSYNTWtRmk8jFiOiz77N1CcZ66kMFEv0j4kkEb4em9MzgVFiLJBbQMozUcm4rBGLiMpEZkrsKuwx2QMy3OZYk/XsbojWe13TdzjRNSEQphfsRbtwXbRdNKC3rvdNgQ6mvCz349ytwtNegBGkx8Oh11Eiyzo/JSCnP19zyvWtpp4hXjV9CDkQAinSwsxwONGlX8QAimRm38175l4f1zhZ+gNdlXB3Yfth1/qG/DUT6tQ4JBRmJ+XSAU2dARFpZ6mJP8RDPQ4hV/Jghpi1gcjCMRicMTXk4gigZSaamMYhmFYHPUaMX9MlIsnGwpmcnPVwuSHfBWFO6Zr0I4OHfgmIFI8E0qaen0PJJAGx5L/Hz51kc7dftpIiA1RUUVvJNMgTTqJRAmlkfqLPFU1I10/Z28PQIKoTY+iJhSGO2D+ThFVTwgqek+vNaEgmiMRzP5pcSKVmHmeZgOoDobRpqY/7PNhF14jOpYiZm16BANW18KmUhTpf2n7ap48s0N1D1m89AHz+tEoAi0t2HPbMVgbDOPeT39EUEsazidM3C5xzBnv/xd9IRKLwh+Moq49iKBhik1qXUBtsNZ0RLrsQE7/BMR+rR3xYCL5t4BRhZteg8ktfVgtwzCbPhw5ykFejuaF1B/oq69CkAwDg535GJh85uHmbSdBUiVEI8nH1KzqFKEUR07xIFkRi75C1V9d1VWljmSd2nEkZue9muY7QtTA2pgX1zUekvwexW91e92/OX5MvL8tvH3aNvpsbac02KytdxPiJRtrgh24u+IHUVnmVV2wS6roik2U2b1QIYvXdpuMfNWFk8v3QnkWM3JNqBXza75BiT0PBY707ZGIDAUyTh+8t/j8dMdPmPP3+zBq1Cjx+aH7kpGisy80WwD0lvr6elx64QV4or4FkVgM1R0R7LD1UXC7isS/lXxPSWLfA3c7r0/X8LfX473vXoHHVZg4HwnfqK6JAcXWTLtc4khEFONQH6VgyJ8oGmA2fVauXCleeZQIw/Q/LI5yUKxmlxx2hwNDysqwpnK1eLDUfJt84ERHAvRc/8trC1G6rbk+Gq9kS4UeZORBCmqaSAfReTKbQ1qQxyjXeorI1ASCIlVk9R6yzNk9eeZZvqOBSgtuLn47IZDotScCKZtQShVIFGMLD9sO51W9A3tGC4NUSAzVBiL4EY0iqhXx0W8n4Q4cCr9cgMr2EGoCETEahITRUFdhzvOEAk2dzMmyWioifZaockTsQhiNHz9efHY6zYcOYa3rLXTcG++8C7/fjxUrVuCiv0xB2aBBcDt9qK2m/k0SVMX8P7did7IxZm+RxaBfFapiincxtiUmi2gm9TRKFcOZKIoZRSSRZB5hrJMwZzYM5igRjUeJMMyWIo6am5tx8cUX49VXzWjFEUccgXvuuUf8fz7ZiEajuO6667Bw4ULxgCkoKMAf/vAH3HLLLRg0aFBiv/333x8ffPBB2rEnnnginn32WfQ3zuHDYYRyT5g3aL5YOArDoIoy80EVbTEfQJZIUp3AgJ1No3Kx3wHbh0rW5pDierKMEbudmIimpKbWxpwyD3WV+aijz8OWZaT+IHwoJJS6Ml9bkCCqihVgsJreVXl9EKWa/YxnMKX1SOzkq3Y4ZRX//GmNSH21xqLYdb9g4rdzeLy4Q/8jXMVl2GrPWuTVZvcD5SkOUCOAn797Pm39TrtfDLfdBrenFD8O21c01Ryn7YT77vwODvsiESmif3c227oPoS0vLxcL/fsuKvbhp8WvQNM01NfVYd/dL0dRfimULkRiX6Bfifpbmf2n4g2tegCJIurGvaalDW4pKhpgUlUcd9HePEaJUBSJ/q0xDLMZiqNTTjkFa9aswb//bU52P++883D66afjtddey7p/IBDAN998g+uvvx4TJkwQ4urSSy8Vouqrr75K2/fcc8/F9OnTE59dlCLqZ1oiEt4/Yhv8f3tnAt5UnfX/k6ZJutAWSqEglEVEdmWTzXlFRwVU9B10RNx1GHVUQAXHATdAR1AZxoVFGQYVxW0cdFQYF3SEP8o6CJRN5AWVtZSldE+a5f6f80tvenNzs7U3+/fzPCHNzc1tcvsj+eac7zln8D++92wzWho+VCesdL9OOYEk+5ECNQbkez4eOUiIH7U5W24QKYy1GoewcNl5mlFEANopeiZZXU46bqsV88Wyqnm6u4GkQLYkBSyQZLHE/XLaXDSKiIpDeKTGa6tv7Fjm8hWTnGpqY8oRIm9Oj6FU6aijMnsdPbtvu3hMS1MzIZ6IzcLmXLIa0qiFJZdamLVN4rz9ibMvoyqndwXgNnMzqhXC0kDV5mwRabFIWXT4l0Pi/t+OeoSaNc+lf32+UrcPGz7OihX/ElEkhsX+NyutYkhvmiGNbPUmclkkytVjjcXtfzN4pc2CP8Yt3tmoXVJbTSdrrPSnVRspP9McNyX9wLfFgzyQ9uGJE2j5Cv3WLAAgSuJoz549QhRt2LCBBg8eLLYtXryYhg4dSnv37qVu3br5PIYjRatWrfLaxpGmQYMG0cGDB6lDhw6e7VlZWTF/Y2CvhxphdA7lwZJBiJpfKmtpzcFsurqjiy5oXU4najuH/TxEbyDVByyn2b4bcyO1XPkhnaqzkbW5uxLseJWVCnMahOQ96f8Q40OeLvffc6nc5j9SFizVNpd602ddb6AJtMVzX11dHR365aBIJxoN7igYX/iVP3ZuX5q1dg4N73ARdc9p+Pt+3vZ8kbP8d7u+nm2VxkzKcbrN11ce2SYEUgvyFk+707jizf38K9LdTSZNBiPlGt37nWc5l/555kchZHg9PfHIZ5qv5+nnr2hUFEn2I33z77UiUiMZXHSwstpLJHbKy2mSQBKd2bmDeVj+ISOZcwpJ4oG85KQMSzPq2K4fHTq2Keol/SB0+O/y5LAB9PiGbZ41CwBIIHG0fv16IXZkYcQMGTJEbFu3bp2mONKivLxcfMNVp+LefvttWrZsGRUWFtIVV1xB06dPp5wc7TETNptNXGQqKtzDUv1hzND2+eSZJer+7mZKN5spzZhGJ+s/dJXIRu1QW93wa1v8wzoa0KqH+LnSVu3TOXv8+mWe8SGh4BZoBjpWaaP7Pi2mM3Yb9RhdKz5Eb/l/W2jZdQNFqX7Q46S5G0Q+u2GN1ygRJS9V96IHsgMMWRXmcwNlqEaj+IMjYBajgd44vI7+1GWUJ1I06hhHlMhLHIXCyOPuxzFfFJ7fcEdauhBLB3qNpT6Si56buZXaF/1ERw77phXbtfff8DIUWrVqRXt+Wkbn97qWLKZzyWxpTwWtM6jOZqMjh9zetab+R5SrEMPBaGBBZqTMjFwypWfQnkNbqdZaTcXHOFHrBmm2+EM5Gw8AkGDiqKSkhFq3bu2znbfxfaFgtVpp6tSpIj2Xm9sgDm6++Wbq3Lmz+Na0c+dOmjZtGm3fvt0n6iQze/ZsmjnTPfaiqdz95X/o8cEDKbtlAUmKyFGu2UJ56UZh1LY6HXSo2DcS0H6g921zpoE6ZmfRmnuHktnorjx78+sTxLIx2GiR57pdTSUZeeSwun/Ptr1txXXfbsdEJVpRprvp5EUd+9AL/7ed2mRkiEjVSbuLym32kMQRG8fb5WTQUZfd0wgy0nAEaUqX3jTrxx20v+YEFTpzhZ9IFkkcIdISScrb8j7ByHXUUp3LQVXOGmpfdI5PdMhfFClcWNg3b5ErPEg9z76dmue2odMnbZRf0LgPuarqk2Q2ZQmztx7wcYYPnkAny36mDduW0sw1W8hUH8nKSjfQ8yN+RQXZmRBKAICUIWxxNGPGjKBCY/PmzX69NqFOL2eT7Lhx48jlctHChQt9/EYyvXv3pq5du9LAgQOFX6l//4YZYTIsniZPnuwVOSoqKqJw+bkqjS6ccz89OfVVn/vMTictuOQivxElplDyFhcmShO+mnQDnyuXSItwFCmc0SLp9U0MW56sH57azbvp5P6Hb6AB1tFU+6O7a3XPZ6fS8uZZNO2/X4V0/FDM3KGgLO8PNXr03hF3D6L0tHSvKJISZWqtKdjqbPTDDz9EpFSaj3X5r6YJT92hQ4fJJTn5Lx/2cXjcB6+NbXuWkzHNJASNngKpoEUnys7MJ7vTRnYXD7110enaGpr02TpRCRdPI0YAACCuxNGECROEaAlEp06dqLi4mI4fP+5zH/svOBUWTBiNHTtWVGT85z//8YoaacGCiKuN9u3bpymOLBaLuOhBl65d6a766jsZfp6PPfAA/VBWRmfVR5Q4ksSdkr2fR5nnZ/Z61NTU0fFiHrzKH5RpdMJqpSk9zvU7WkTJn/Z+6hNJYg5914xOGnOojc1tBuZqtWNWF7UznhaRo+1LZtE1l3SjnXlZZHe6yEZOKqo/vf4q1dpc9CgdqljrtY3TLXIkiVNrTMD0WrhdwHsNFibtI9YamnfgB2G0VvqJODokfEiKlFtj4P5HLErZoP3bUU+IbbJBO1yfUSB4fZ4pqyOHQyK73UU8uu1kqZUslgKqc1ZpPzeVWZu7WV/7q7vFuI/VxZ9Snb1GN3HE8LEuGTJRHJdxOh1UXVtG7XOzqcZ6JiYjRoB/+H0HPY8AiBNxVFBQIC7BYOM1+4U2bdokDNXMxo0bxbZhw4YFFUYsdL755htq2dI9xT4Qu3btEo9r29adWook/CGn7IUzfcMqurdfP8rMzaW5O3Z7RZL+NuLX1Dq74YOk6lTD86u1WunAvv+jtuZsr5lj7e2+HzyvDb5ZCKgntv8rJLE0t8uVPv6j7R9Oo9ajnqSWl06npbnt3HemE9krjtI55c38NpKUfUc8hFaJPJA2UsgmbZnjNrdPTJlia4ooUr6+Nuk5osT/8tyB4vcoDdp68dScK+m+3y2iMrdmFbgDqAYqqdGONGqZtZXjPji9xuidYpOP5XDaKS3NRPm5OWSO0SBeELjvEb/voGoNAP2J2Dtejx49aNSoUSIFtmjRIk8p/+jRo73M2Cw02BM0ZswYcjgc9Nvf/lakx1asWCF6xMj+pPz8fDKbzbR//35hxr7yyiuFSNu9ezdNmTKF+vXrRxde6O6AHCk6NXPR2C5c2u7NKz/voOEvPCWeL3PmtJOOHDxErzTLpoz0dPrTzobS/2AsHHY7ZZx/Pb2RlSNSbpl9L/J0MX76/N8EFEj+BrgWZTajyb0H0weZzcjmclCNIq3JTSqdPJjNT/qMfUedW2TTn8c0ROR+PlPjGUhbP9DeL6Gm0vzBfZBCTbE1RSBxBMnTXDJw0E432hc1F6Le4cwTUSQ2acsEMmsr02vu569vik0N91Dirt/cC2n9wSOiH1K2yUxn5zdHFCmGfY92Hj8heh5t3bpVeDARRQJAPyL6dZBFDDeBHDFihLjN/Yrmz5/vtQ+X9XM0ieGeSHLDyL59vQ23HEXi5o8skL7++mt66aWXqKqqSniHrrrqKlGtZtR5Rhg3dAwnoiQ3EnyoZxHdNPURKnpkatjtAB7euIwe2LKFjpKRbjvnAnr7wqupNCef2lefET6ixsACiavdMoxGEYHKcbj9SXaHgzavmkmzrx9Ey2is/9eWZqA36XrPbWsO9z+qoXezmovj/TG96RGccFJsHN1pjDjiyjWvijUVfB8btGmnd08tvXG57ORwpFFV9Wlqlp0v1k1Rh9Cq+ZTpNY4gnak6KVJsp88cpLrshuG+ekSTuCcTh7eOVNSQ1eaicruBpq92m91ZX3fMy6TnL7/QUz2FyrboIac2uecRR5AYRJEASBBxxNEeLrcPhHJwK3uVtAa5KmExpO6OHa/86rNPqENuLu1TbMvLsIhUG6dKtMzb3P3oz+edR48XF9OSvesp48KrRfsaOYLA0SOZcKJIcqptyv6GWW/Pt71MXP9duo5O1Td/jESH7FA6Zy8rcD+X20997W7+qJFik6NI6jJ/LWQ/khI90nBNISMjm77f9RLZ7XXUvEUmuVxpdPWIPwqBFC4skPiijiLJcDRpQO9xZFado3BEE48qyctuJYzZPMvtsmFThB+Jm1lWVh2nX37+jCZ9vq7hOZkMtHD0xdS1ZfivB4Nm9emcjSgSAPoAI0ETmTnkco/3SIbD22oPkpYX6ZyuXcmhGMjKqRRuBdCxWTYtuOAC2l1+hrzjbPryv3s/IK4rtDlcJKW7Ram1vvotEHXOps3jSk/n+WBGKnM2CMMRxz8W1yWSRC2NWWTiGWIaIkku81cbtEOBBVMggSRHlc7tcbcYRjvn5cbNWfMHi6Cxv3mUrNZquvr6DvTgA4+InxsjjrSiSDLWuhr6euty2lT8ls/+4abgWCDJlXXysFv2InFfpO5D7yHJVef5nd9t/wfdt2I1zbp0qFcvHkSUotc5G1EkAPQB4igCqD1IzJ1tunqq2naUnqAOuTZPFEkLpTnbXn2MRq5+k9plZnuZtB/vfTX9buPbnkG0SgNzKDQ3WShdSqOjFbVkznULniOUR3WVR0W7BUum/6rCjMw8KpeMZHAQzXWGXqbPpJtMdM6555BDJcT4fHHn7JPOWjI43eNF1AIpN73pM9BCLe1nv5veHYhZCPGFPSLMmXLfik7GWmejiqpSOu60+AzSVcJmeXV37QxzFl1y/m+oThWVrKw5Q5t/XEMnTh+gZlkFIoqUmRF+g0snpx6JKDsjlywKo/alF9xBX29+wyuaJF6zyeAjmBiIpuhEkaINvE8gGYA4ihBKD5JsPFdHlLQq2tSwTZply5wfvcvk88/j9JqB/rRzi2dA7QvnDQ5LIBVmZtGLvYfRWxnZdEYhQlqYM8VzrwgwJNU9Nc3NcSn8uXYskPiihkVTTU2t13iRaMGepLK6GvpLyRr6cU86HT38B5r/95t1E0hcsSbDwisnN5u27GgYlNury220a/+b4md5YK0Uwry0gkwLpYXgR3O4nKID9sZt7t9hMmXSkL53UoZFu7N8INi/z5WQSlrmtqErh93rE8XiiJJaMDGx7Jv04oGeSZfS8xdFijbwPoFkAOJI5/SaGjndxte8z/IVK0SZuBxFKrfa/IqjXJPJXUQmEaWrVELNu0/SA70uouYDRnkG1FY46typJ4WvSO07UnuPWCCxUZsjEDLVme72CZLLQCbZFBQlWDCZzcFTe5GCfUwPtxkuunMXO100d9Z6mvPyGN1/j3o4LbNkwW7qcs5MGn9/T09PsMrK+uaeGnABw4uznqEnBp9HHZuHFgE6VVNLVXV1dLSiiuZt+oEypDLKM4Zv9Of1Ul4dvKyPo1iDe4/xEkxMVW057f9lDfomhcjxqmp3dWiIPDqkH1Xb3SnPUGhmNlPLrKYP79aKWiGSBBIRiKMooxxIGqyCjcXRX4qXU6XDTtS/oXrvWE0tvbh3H9U47VRkak5nZYU2d82faGJa2xuM2KUm/qDllpFCl4U0SHeOo8EA3ZTqtXkVPUVXdFthD9FB/Henv6FYCCQeW6LsnM3ChWHhotebvXotzJnn7XFS9tPSgp/Xq3+ZI4RRqCbori0bPmzfKt5HO/a6vV6xgCNHHOUAgeG/1a3Lv6AquxTRv8VbOkTxtKJWHEn6y7z51KKFu1UGxBJIBCCO4gjNCrY0okyz9zf7Fi4j8SZ51Mjt51wgth+pbZj2rqQxfiSlJJLfkkPNcMlCqTEiaWLubrLWWullWw8hz17Lv8RzH1eyqZtCyiibQzJsvNaqWAsVPp6yc3a3bu6RNb8d9SdPB+14mYjO39ZDRfb58IVTWuFEI/QGnqPQ4L8RC6MBPcZQXr0pXk/Kq0/Slj0f6RLFU3qfmDO1Nnpq3Ra6//bbPPsg7QYSAYijGHOwosJjzGafj7qCTQ1XtNHBQ/TigAFUarPSs7t202s/bhQG6pf3u2eDqWE/0pSuvUUkKhShxFEkFkQnDc2oeV3DyBNubmMxm6nU4PsGesLREAFolW5rUjSJq9lYiDk8sSs3JfZKyko3eTWF9DxGozmkv8o0da8j9hqp4ePInbNb9X5QbOt78FvqYzlXdNDmtGisxZHsYeM0RqhwZ2X+8JIFEkaBNPiP4t17xMKoIDc+BHkg1OtKKZbktJveHegB0BuIoxh5kZTmbDZmPz54IOWFkGLgNM+h6mo6OzOX+ue3pKm9etKM4l30QO/h1Nzs6xngGW3zdq2lZ/YWh2XcFoZrA5Gp3qjNEsUhuchWV0eSxf3GZ4ig78iSkeHV84p/lgwGapFu8TSFlPE3f02vztky3EF7Z9H/UDf7RfTQvRNiHj3i382jI5S+pUC4fW6T4PPREEIskJQmba19QOOACAeJCMRRTD/YVogPrIcnTqQn/7s1pMfxuAmuYmpjyaDHevemuvpqJhZGnXK0fSezL7hKiCS1cTsYBa4quv9EQyprQatLyS65PJ3DJYPbmBsJOBLGFxn2IfmbuxZo/lpT0IoocWsB7sNEhTfExbffUDxsIDiBhBBEEwCpB8RRGLhYDUTgg02uYAuFAwcO0KTf3001VTX0+PYdlEYSuchAR6rdhuock4VaZninvfi2epuSCce+DOl3s1gxk7F+YKqw5AiBFAl5xN4jmQVneohf9lmr0ZRuSKO0+t94e9k3UZu/JjPiRDEdqi2jBRU8YsQ9ePfJP/7bb8k+SA3hFK9RpuO24F+CHOn1g6gBAB4gjuKAcL79czquVZtCKj95mmrrbFRb6RZFrx4ppgyzmdLtTvpzz0sCiqEmEcW+Q1qwIHMZ3JGrOkVV37M9B1KVw05H61Ns/1d9gtrUV5ypEfPTFLDYCQe1GRwAAEByAXEUA/7w4Xf06rUXNuqxLKI++rfbZ8J9cB68916x/cVXXhGDeKfeP0mk0AKJI39VbcGw1YsR2Qokiv1F9MhbMdk0DOX7K09TY+FUXnp9ms0puTwe7VKn4nUYibKMaWRxGqhSstE71TvJUmfWPqBqsOx3jXhOXLHGQlWOFKmjRwAA/7CdQAnK+0G8AXGUwJEm7oOz8quvPNu4700gOOVmNqZ7qtraX/6ouDbntqW6imOe/Q6vmqX5+I6t3eZyk+iD5DZJC2+Qar/Dtiqfxz68xbdDcqiYHGtpar8LKNuYTk6Hk74wX0TpaWn0n6LrfPa91LqaWp0+SpMenUY9evSgVq1aUSTAmzlQp9fiNbUWT7j7IDl9unejvB/EGxBHCU44ZlyOJsnmbObfWW6RU55mpIL6n5l21zxLVxxZ7fP4LxT7szCyc/ds9iGZze7StnrO6nCOz2NfnPEJNYaysjKaMmEiPb3je8+2zt36U4dmuZozx1rl5VKWIY1emfMX8Yb74coVMCwH6YuEfkP6kOgCSbkuIrUm1H2Q5N+L8n4Qb0AcpRhKc/Z95e5qrCX5A2h8+XZxLXBJmpVv5voBp62cNeK61mGnUnsNdWjblU6caSitz8zwNYH+bflRn21/fezXIT1nFjiyYZ3D8X9bsItcnF5TlNnLtMrKpgXDL6NdJ0rppR93xUU/onjBX18k/ib/5LABYjAshFJyUWixBjVnpxnSyGUw0xPfuOc06tkxW/M5ob8WSAAgjhrBc9s+9/z8p76jou47CgaX7PurXNMTLmuPFI8++gXNmjXSj2HdewivlkDq1ao1mXYXi6gTokf++yJxZO7hiRPo8Q3bfJpEgviCh/hGgrQ0I40e8gey1s+/kztmc0QH6wCkKhBHYWCsr5JqrCCKRmQgq3kuvV7qjgyEWrk2/nTDN8ZA3Fnu/gCVWdSsj7h2OL2rv44c9m1L0K6927wcrkBSc9ttHUN6LAsk9ilxOk45BDPVfUNalZGyYJKbRO48fsIr7YFoUmzh88+RnG93fEC/6nO9GOYrk2HKpGaZeWFFkbQiSNVphUT1PWizTEXkMqykx75eT89cOlREFJXPBYIJpAIQR0mEspKNP+hCqVzTYvyZBn9PIEQDSIno8MGDlNW8nVfTxnigKDePTA4nPTrpAc379fQkafU2kivY4r3vkSyYAqXdEE2KHSxGFoy+mO5fsZrWFb/tdR+nwzjqE6pAUqfatMQSR5L+Z/CjVFFzipYcbehSX1w8P6LpNgDiCYijJCOaHZO5Yqy1OUv4jri8X09tJKfU1JGkRX/7gcyZPHzTnQJQIxpGKm8Pdw/uVHOoolx4kpRRpVSMJAVLu2HkSHzQtWW+ECVqIzP7hDgdFo44CoV0o4maZ7eq9/a54cG3eg2oBSDegTiKA3737gZ67cYhsX4amum11/P6eqXT5jYfSgXOGrq9cruX70iSXORypQmBFOkIks12kv43eyd1aa49LkUpkv5RN9CnceX9zfeI9AB7kpRRJVS3YRxJPOPPyMweoabgMhWJaJEa3sbTBZWDb6PZ+0hNqn95AdEF4igGsBH7rg/Wi8tPJ6vJ5TLQrxe4Z5h1LsimJTfEXij5QymMlKm1Opu7Wo2FkSXDEvMUGwsgrUiSuqpN/iauFUmSwZuyb/l/JIGvJfTzxGkujuY0hVBTcyfrg1bLTw2hjPLwPjoCtTjw1/tIDXohgWgCcRQHsCBSc+sbm8T1W3cMoniGU2vtMnLI5agR4zxOOWqpqG1XylCU8x8q0f+D9SMaQpaKdL/z2ALBgonFEwskvjBakSSZVI4o+fMhRRJ4nEKDo0jqVFu4NCY156wfPB3J3kdq0AsJRBuIIxAUTq3JnDZk0tKc870XkUYzRjVyBZuyam3yM/9pVN+jSKCOJMmkujdJy4cUSfxVzCVKVCnajSCj2TOIK+M4ynSksoo6t8jTbMLaWND7CMQbEEcxYvH1Q8X1Za+4x3+A2KOMJMnAmxRdH1KwSJWyYWU8YHV4t7Fg9p1q/BzBaPPLmXKyO11U53BovhYl6aZsGtTzWrK5iGrtdnLWN4UNhaaek0ikdXncUklJSUy/6KTSF61EA+IIhEW+VOvxHLE5W7k9HpG9R40lFG8S3uCiE6lSN6yMDzZ6furS+ffi+oVKd/+v/T/9neIda10dnbba6GhNLVUZgg+krrATrd86h9q3yqEMHhsUIt9Q02HRLA971oNbbrmFbDYH1dkCi8JIkpPbjFas+BcEUhwCcRSn6OU1krtly0Sqazan25qR78DZeGLh6e6en+/LDzykV0kwb1Iqe5KiHamKZoovXF6f5925/emXPqV458CBAzTh/slU1KEjtWzRLuj+p8oyad+R1vTErOnUr18/iiZ6fwl5+umn6cEH/kh9e/yGCvLbU7QpKz9OW3Z+INYz3jviD4ijODBjL75euzrtttfc30rf/N3gJnfLluGu2fd1GiBEUmPFktKDpKTSyMepIludt1eEh9TGunotXEHUmEgSf1go3+TivfljIhLNFF+4PLegQXxPn7KS3l2833N75tyrKF4xmdLJYjF7FVH4Iy83n4xpFpo796WEj3jIkV8WRgX5RTF7HhwRBfEHxFGceI8i2S1b+Z9w8v0T6OUjDWmJUEeMaDHlzHqv26es1TQvpzcdOXjQa7spuzAuyvvDiS4FElL+IkmIIAEtMcRCiS/xLJBCpVl2C/qfQbfSd1veQMSjiWRYmpHLaaSJEx9KeKGZjEAcpdi3bKVgasqIES34GKKsn9tl18Pl/eWS5OmgrZy7Fu68Ne6azSbKG69+hH5zbi8xHkQWKGojdWPREkWvnOxG9xbsDRhJ2nWiVESQECIHavyJIhZMwfaJRzIzmlEywemtcEUNi0Q9hSb6q8UfEEcphpZgUvuSZDjldidt85taU3fP9lfW76gppcKCDpSVlUmmdJPf3kehlPbL1UwsRGR4fhoLFL0EUrjw75WFGgCpQqKng/i9hA3R7PsJB472XHP5H3URSC3y2ojjsfdJDczasQXiKAFoiveoMb4kPVJu6g7anGpLMxqpS9euQiAVtcmlvzSirxELOzY/K6NfnNJiD1CsxBEAqRRRSpZ0ED9vfv7hGPz5/YaFjNVWpVv0iIUWH08JzNqxB+IojtFbDIXiS5IJlHJTN4EMpYO21ekQ3bOdDqcnetSU561+Q2ZjtN4ptqbMh0J5P0hWksl3FA8Gfz6f/oQWv5/gvSQ2QBylOI19c5DTaW9mu4XSbdUN89a0BJJZCr1hXDio02yxSrEJY7bD6SnxhzkbJDPJ5juK1+gcR6mQXosNEEcgqijL/Nlc3dRvRco0WyxTbMoSf7m8P9G/VQMAYoOcbjtWuh+9kGIExBHQFbVBW2Zxznke75HM5Cf2CR/S318c22SBpHy8nGKLdppNa/wIAOHCPiOl7yhWFVuhVGUh7RM5+Ny3yCuM4G8AMRNHXM0wadIk+uSTT8Tta665hubNmxewBfwdd9xBS5cu9do2ePBg2rBhg+e2zWajhx9+mN59912qra2lSy+9lBYuXEjt20e+y6n1s6niuuTTOuq08K8R/33Jguw9Upf5sw9JrwhLvFWyJXo1D0h+AlVsBarKSvW0T621KiZeRgYepCQQRzfddBMdPnyYPv/8c3H77rvvpltvvZU+/TRwW/1Ro0bR66+/7rltVs3wefDBB8Ux3nvvPWrZsiVNmTKFRo8eTVu2bCFjGMMQG4OpTxey73B3vv3zli882x8fMDKivzcZ0Crz15NIVrJxryMZfz2P1P6jKRMmYqwIaBTRqlLzV7EVrCorVdM+sphcu+ktYUqPtPeqqrqMbFanV6l/KorRpBJHe/bsEaKIIz4c+WEWL15MQ4cOpb1791K3bg0fNmosFovfP3x5eTktWbKE3nrrLbrsssvEtmXLllFRURF99dVXNHJkZESKKU0il0SUVl5Hlg5F1Gnh/WT7yD1Y8mhWPj3+7df0519dGpHfnUzptrcyz/NsczmdlF7nolf/vpcyMn7xbH/2zyMjUsnW2FQbiyGlOFL+LN+vhI89td8F9PSO71PmQwOkXlFGKqZ9+DwtW/YG3XLLHaJaLxpYMiL7hR9EWRytX7+e8vLyPMKIGTJkiNi2bt26gOJo9erV1Lp1a6HShw8fTs8884y4zXB0yG6304gRIzz7n3XWWdS7d29xXC1xxGk4vshUVGg3PQwHadcCMuW5ZxF1zsumxwckpzBSNojUe2htlZjFVk02W524zVE/k6lpZf7B0myNTbVpRYtkkaQllvIswedUAQASj+7du4fdH0lPkFZLcHFUUlLiETRKeBvf548rrriCrr/+eurYsaMI7T7xxBP061//WogijijxYznN1qKFd6i3sLDQ73Fnz55NM2fO1OFVERl63e/52f5jfeTIXu2VYkuGVJtWg0i5KSTl6PVbuEGk5DFpu5tEnhOxNBuDppEA6E+qGbPjoT8SiDNxNGPGjKBCY/PmzeJaa9BosAntN9xwg+dnjgYNHDhQCKWVK1fStdde6/dxgY47bdo0mjx5slfkiNNwTeXpMb8X15xSs9YSHav2Tt/c+NEn1KuDJSEFk7pBpLIppF7wX6tdRi65JFe9OdtKTqeTpj7+RZNSa0rwJgZA5FAbsznlxJEVAFJOHE2YMIHGjRsXcJ9OnTpRcXExHT/uWx564sQJEeUJlbZt2wpxtG/fPs+HXV1dnagEUkaPSktLadiwYZrH4IgTXyKF7DVSR492HXQLiR0/u9NGzIOla+jFK4ZTIs9hszmd9HPlaXG7LsMhrk9ZqxuVcnObtCNr1I4lyioTJpW+XYPkRzZml5WXCJMye3FgFgYpKY4KCgrEJRhsvGbz9KZNm2jQoEFi28aNG8U2fyJGi1OnTtGhQ4eESGIGDBggfCmrVq2isWPHim3Hjh2jnTt30vPPPx/uywGNSLO1b3cJPfOze95bh7z+4vrx3d80eQ5bMqHumC2Dztkg2ZDHXyTLSBEAIuo56tGjhyjJv+uuu2jRokWeUn4uuVeasTkEy56gMWPGUFVVlUjbXXfddUIM/fzzz/Too48KMcb3M2zoHj9+vCjf5zL+/Px80fOoT58+nuq1SPPsNndrAmZq31FB9+/TqaEVwclSSkiUabYFb+yjuc80tGMQKbftRtpbfoLOCpJ2qzO7I02MZJSozum+zWm1ZELZMVtG7py9detW6tevHz5AQFIhl7Wnmv8IJCcR7XP09ttviyaQcmUZN4GcP3++1z5c1s/RJLlaaceOHfTmm2+KD2EWSJdccgm9//77lJPT4AJ+4YUXKD09XUSO5CaQb7zxRkR7HInh8lLogkjJ9gN2Ov9sdxVWoqTUAqXZMjMO0WvvHaLnZ1zu17ztj445/Tw/WyyZdNqQSTbbSY8hO9J9qvREXcGmrF7j+9Qds0U0aXexiCYhggSSjVRvDAmSi4iKI47qcA+iQLCRWiYzM5O++MK36ktNRkaG6LTNl0jR8KyaDgsjpUBKdGRRJPPCwmIaOvIpuvv2LkEfyz2NZE6WWsW1JcPd2bywbbaupfyxRBZIWtGkXSdKMXsNJB2p2hgSJCeYrQZ0gUVNKFUqymaPaWneKbhkEUaBYIFUlJsX66cBQERQNobE+ByQyEAchUCotVTqMv3JJ1fT6ZNEx0QjxTQRPZpU8v/o5asuaszfCsQ5gTppBxs5AkCypdcmTnwIqTWQsEAc+UFyed8uaubweI4ag5xSe3xA8gmj555q6FYeDK3+RY8+Wp9KdREdPur2n912xz/Edfuz8mjWrMToDQUAIK/KNRQfgEQF4ihKyD2POJrE/HXkxdH61SDOeyChsgckGy3y2sCcDRIaiKMwujnradIGqYu6BxIq10CyAXM2SHQgjkDMUabNeHSI131+xog8Nq2h19Qzs8NrrSD3HGKREs7w2VDw5y2S/Udyib/cA0nufYTKHhCPlJX7TjmQfUUsgEI1Z6NTPEg0II5ASsEpLI7UsCDhnkMsUvQWSKGg7oEEQLz9P+FeRVySrwUbrrlsP5hAUvY+UoI+SCDegTiKAm2zcusr1kAohm119EhPuO/KhytXCKMop7U4ehMPIgVlzyCe4P8n3MRRHjythKNALHastqqQokcsonhfZTQKfZBAvANxFGaX7HBQmq4nf7Gadh+tpqoKd+NDEBr+hFLJkXJq1y6v0W/8nTt3jotu2g6Xi0yOtTRlwkSaO3+e1zBlGRi2QbwMnm7K7DUAEgmIoyjBQunGjz6hqorEGY8RK+Ry/0ARpDYdmtMzfvxIiYBSLF055H9o2oa1dN9tt2vuC8M2AABEF4gjkNKwIToQkTBtq+nSIt9nSK0MDNsgkczaoRi1ZTCgFsQzEEcgYeHIklZTyXCN2YHgkvtomLZh0AbJYNYOxaitHlA7b94LIp2M9DGIJyCOokivDhY6esj9IXvfv76lhb/5VTR/PdAwZmsZTpXfbNm0zYNi5Xlo0YgkAZCIZu1QjdqySbusvITWbnqL7rj9LrEdFWwgnoA48oPNppofQkROKUxHtgayIGJxBOLbcKoVXYpWJAmAZDZryyZtuZINFWwg3oA4AiDE6JIcSYqX8n8AEh1UsoF4BeIoijw+wNsfg9Ra6pQzAwAASBwgjuKIO97e6Pn5jZsHx/S5AAAAAKkKxJEGzXt0JDrunpgeKbTM2LIgYpGkFErK+1IJdSWaVt8jrW2NrWCLZ5SzqVDVA5IVlPeDeAHiKE45cKyazm4LX0uqw9VxbAJnr5MMmkKCZEOrvJ+72COlDWIFxFEgJIliAUeJbnttY0pGi4A3bPxWNoiUm0LybDitESiIKoFERKu8H6X9IJZAHAXD5VvSD0A0UTaIFJGk3cVekSQliCqBWFNrbRgy29jy/mOl+0WTSf4S0K9fP0SQQNSBOIojxr+/QVwvuWFIrJ9KwnqQkt2HpI4kKQkWVWIQWQKR7pzNkZ9gXbIDwY9r27qLV5qNm04ixQaiCcRRHAFRBJoyaiRYVIlBZAlEChYv7BXilBhHflrkFYY9b01GK4KkFPwQ+SDSQBwFRSKjITbeIwD0iir5iyzhQwboCa8r9dy1UOathRJBUoJoEog0EEch0PShIY2DTdnMm7+DMRs0fYCtVmQJkSQQyblroc5b84dyxIiMPGoERQkgkkAcARAmHIFRkijDaP1VvvEHGfwcIJJd5VnQ6IUp3Uw2q9MnmiSDqBLQA4gjAEJEaxBtog2j1YosofEeiLRJW5lm0wNLhlHX4wGgBuIoTlGm0u78m7uK7fW7UcXWmOq1SA2iVQ6j3XWilIpy8xIqoqRsMIn0GohGmi0awEcH9ADiKAGAKIrflIG/aFIiRJTkNBsLO6TXQKTA8GaQiEAchUiaQaL0mFmzQbyiFU1SRpTY3xOv4ojh56aOeAEAQKoDcRQMlzMqfwiQuOCbMQAAJBcQRwBEsbItEbxIAACQ6kAcBaOu1vNj+0w0g0xU1GbtSI8TSUQvEqcClcDYCgBIVSCOQNIQ7eq1ZPEiKavWlKCCDQCQqkAcAZDiXiStsSPqUSOIIgEAUom0SB68rKyMbr31VsrLyxMX/jlYvwuDwaB5mTNnjmefiy++2Of+cePG6f8CkEUDKQILpC4t8j2XXq1ae6JJN159DV171WgqKSmJ9dMEAIDEjxzddNNNdPjwYfr888/F7bvvvlsIpE8//dTvY44dO+Z1+7PPPqPx48fTdddd57X9rrvuoqeeespzOzMzU/fnD0CqoowmYWAtACDViJg42rNnjxBFGzZsoMGD3d2eFy9eTEOHDqW9e/dSt27dNB+nTkN8/PHHdMkll9DZZ5/ttT0rKytqKQuzUSKDPSq/CuhIqKbrJx75LOg+Tz9/BekJC454r1qTR41gYC1IJqZPWel1e+bcq2L2XEAKiqP169eLVJosjJghQ4aIbevWrfMrjpQcP36cVq5cSUuXLvW57+2336Zly5ZRYWEhXXHFFTR9+nTKycnRPI7NZhMXmYqKisa9KAOaQAL9qthMu4vjsmpNDQbWgmRCSwzJgglCCURcHLE/oXXr1j7beVuo3gUWRSx4rr32Wq/tN998szCJcuRo586dNG3aNNq+fTutWrVK8zizZ8+mmTNnNvKVAKB/FRsbnf3NZIsFwaJY/gbW+gMGbgBASomjGTNmBBUamzdvFtdslFYjSZLmdi1ee+01IYQyMjJ8/EYyvXv3pq5du9LAgQPp+++/p/79+/sch8XT5MmTvSJHRUVFIT0HkPzonTILRSD169fPbx+kWBBO7yV/pf9K0AYAJBKIGIEmi6MJEyYErQzr1KkTFRcXi7SYmhMnTohUWDDWrl0rvEnvv/9+0H1ZEJlMJtq3b5+mOLJYLOICQLzgrw9SLJB7L4UTxZp8Xn+qqGtIVSspra6m5ccOideWCK0MAACgyeKooKBAXILBxuvy8nLatGkTDRo0SGzbuHGj2DZs2LCgj1+yZAkNGDCAzj///KD77tq1i+x2O7Vt2zbEVwFA7ImXPkiBunk3Fj4eHxcAABKRiHmOevToQaNGjRIpsEWLFnlK+UePHu1lxu7evbvwBI0ZM8Yr7fXBBx/Q3LlzfY67f/9+Yca+8sorhUjbvXs3TZkyRaQpLrzwQooojrrIHh+AJIliwXMEAEhkItrniEXMpEmTaMSIEeL2NddcQ/Pnz/fah1NnHE1S8t577wlv0o033uhzTLPZTF9//TW99NJLVFVVJbxDV111lahWMxqNuj13iRtA2py6HQ+AeCZeolgAAJD04ig/P1+U2weCRZAajjDxRQsWQ2vWrNHtOQIAAAAARG18SKLjrNA2nAIAAAAgeYE4AgAAAABQAHEEAAAAAKAA4ggAAAAAQAHEEQAAAACAAoijoLh4EIr7RwyeBQAAAJIeiCMNrtn8SvT/EgAAAACICyCOAsEtmHzbMAEAAAAgiYE48oNGb0oAAAAApAAQR36QZJ+REkNEG4oDAAAAIA6AOAIAAAAAUABxBAAAAACgAOIIAAAAAEABxFGI1DpwqgAAAIBUAJ/4AAAAAAAKII4AAAAAABRAHAVBspaL68x0HiMCAAAAgGQH4igE5I5H7aSCyP41AAAAABBzII78UFlrjO5fAgAAAABxAcQRAAAAAIACiCMAAAAAAAUQRwAAAAAACiCOglFxIuguAAAAAEgeII5CQUIZPwAAAJAqQBwBAAAAACiAOAqRAosj1F0BAAAAkMBAHAEAAAAAKIA4ChVJCnlXAAAAACQuEEd+yOvewWebofnVkf57AAAAACDGQByFgMXpjPxfAgAAAABxAcRRACRJHjkLAAAAgFQB4ggAAAAAQAHEEQAAAACAAogjAAAAAAAFEEcAAAAAANESR8888wwNGzaMsrKyqHnz5iE9RpIkmjFjBp111lmUmZlJF198Me3atctrH5vNRhMnTqSCggLKzs6ma665hg4fPhyZF+F0z1WT7JivBgAAAKQCERVHdXV1dP3119O9994b8mOef/55+utf/0rz58+nzZs3U5s2bejyyy+nyspKzz4PPvggffTRR/Tee+/Rt99+S1VVVTR69GhyouQeAAAAAPEsjmbOnEkPPfQQ9enTJ+So0YsvvkiPPfYYXXvttdS7d29aunQp1dTU0DvvvCP2KS8vpyVLltDcuXPpsssuo379+tGyZctox44d9NVXX0XstRiPV0Xs2AAAAACIH9Ipjvjpp5+opKSERowY4dlmsVho+PDhtG7dOrrnnntoy5YtZLfbvfbhFBwLKd5n5MiRPsflNBxfZFhgMRUVFX6fS42jjiqsdrJUWanSZCZ7lTXg/gAAAACILPLnMAdTUkYcsTBiCgsLvbbz7V9++cWzj9lsphYtWvjsIz9ezezZs0UUS01RUVHgJ7SJiKavUGx4MtSXAgAAAIAIcerUKcrLy4sfccRmaS2hoYS9QgMHDmz0kzIYvDtTs0JUb1MTaJ9p06bR5MmTPbfPnDlDHTt2pIMHD0b05KaKimeReejQIcrNzY3100locC5xHuMNrEmcy3iDMz8dOnSg/Pz8iP6esMXRhAkTaNy4cQH36dSpU6OeDJuvGY4AtW3b1rO9tLTUE03ifdjoXVZW5hU94n24Mk4LTs3xRQ0LI3yg6wOfR5xLnMt4AmsS5zIewbrUh7S0tPgSR1w+z5dI0LlzZyF+Vq1aJYzWDAuhNWvW0HPPPSduDxgwgEwmk9hn7NixYtuxY8do586dotINAAAAACBuPUectjp9+rS45jL7bdu2ie3nnHMONWvWTPzcvXt34QkaM2aMSItxmf6sWbOoa9eu4sI/c5+km266yRPtGT9+PE2ZMoVatmwpQmsPP/ywqIjj6jUAAAAAgLgVR08++aQoxZeRo0HffPONaO7I7N2711M9xjzyyCNUW1tL9913n0idDR48mL788kvKycnx7PPCCy9Qenq6iBzxvpdeeim98cYbZDQaQ3penGKbPn26ZqoNhAfOpX7gXOI8xhtYkziXqbomDVKk6+EAAAAAABIIzFYDAAAAAFAAcQQAAAAAoADiCAAAAABAAcQRAAAAAIACiCMAAAAAgGQURwsXLhRNJDMyMkSjyLVr1wbcnxtL8n68/9lnn02vvvqqzz7Lly+nnj17ipJBvv7oo48o2dH7PHKLBe5fpb5YrVZKdsI5l9zIlHt5devWTXR+5X5fWqTimozEuUzVdRnOefzwww/p8ssvp1atWomuzkOHDqUvvvjCZz+sSX3OZaquyXDX5bfffksXXnih6HOYmZkpeiVyex/d16WUBLz33nuSyWSSFi9eLO3evVt64IEHpOzsbOmXX37R3P/AgQNSVlaW2I/358fx4//5z3969lm3bp1kNBqlWbNmSXv27BHX6enp0oYNG6RkJRLn8fXXX5dyc3OlY8eOeV2SnXDP5U8//SRNmjRJWrp0qdS3b1+xv5pUXJOROpepuC7DPY98/3PPPSdt2rRJ+vHHH6Vp06aJx3///feefbAm9TuXqbgmG7Mu+Zy988470s6dO8X/9bfeekt8Di1atEjXdZkU4mjQoEHSH/7wB69t3bt3l6ZOnaq5/yOPPCLuV3LPPfdIQ4YM8dweO3asNGrUKK99Ro4cKY0bN05KViJxHvk/fF5enpRqhHsulQwfPlzzAz0V12SkzmUqrsumnEeZnj17SjNnzvTcxprU71ym4prUa12OGTNGuuWWW3RdlwmfVuPZa1u2bKERI0Z4befb69at03zM+vXrffYfOXIk/fe//yW73R5wH3/HTHQidR6Zqqoq6tixI7Vv355Gjx5NW7dupWSmMecyFFJtTUbyXKbautTjPLpcLqqsrPSaho41qd+5TLU1qde65HPE+w4fPlzXdZnw4ujkyZNiblthYaHXdr5dUlKi+RjerrW/w+EQxwu0j79jJjqROo+cD+Zc+ieffELvvvuuyClzvnjfvn2UrDTmXIZCqq3JSJ7LVFuXepzHuXPnUnV1tWfgN4M1qd+5TLU12dR1yQKS/UQDBw6k+++/n37/+9/rui4jOlstmrBxTQmnDNXbgu2v3h7uMZMBvc/jkCFDxEWG/7P379+f5s2bRy+//DIlM5FYP6m4JiPxulN1XTb2PPKH9YwZM+jjjz+m1q1b63LMREfvc5mqa7Kx55JN2xxp27BhA02dOlUMtL/xxht1W5cJL44KCgrEwFm1IiwtLfVRjjJt2rTR3J+H2bIDPtA+/o6Z6ETqPKrh6qELLrggqb8NNeZchkKqrclInstUW5dNOY/vv/8+jR8/nj744AO67LLLvO7DmtTvXKbammzquuTqNqZPnz50/PhxIThlcaTHukz4tJrZbBalf6tWrfLazreHDRum+Rguo1Tv/+WXX4rwnMlkCriPv2MmOpE6j2pYvW/bto3atm1LyUpjzmUopNqajOS5TLV12djzyFGOO+64g9555x266qqrfO7HmtTvXKbamtTz/zefK5vNpu+6lJKoFHDJkiWiFPDBBx8UpYA///yzuJ9d77feeqtPCfpDDz0k9ufHqUvQv/vuO1EK+Oyzz4pSQL5O9rLpSJzHGTNmSJ9//rm0f/9+aevWrdKdd94pzuPGjRulZCbcc8nw+eHLgAEDpJtuukn8vGvXrpRek5E6l6m4LsM9j1wuzedkwYIFXqXlZ86c8eyDNanfuUzFNdmYdTl//nzpk08+ES0R+PLaa6+JFgiPPfaYrusyKcQRw4uuY8eOktlslvr37y+tWbPGc9/tt98uSnqVrF69WurXr5/Yv1OnTtIrr7zic8wPPvhA6tatm/jDcWnh8uXLpWRH7/PIC71Dhw7i/latWkkjRowQPShSgXDPJX9XUV/48am+JiNxLlN1XYZzHvlnrfPI+ynBmtTnXKbqmgx3Xb788stSr169xBdzFkX8+bNw4ULJ6XRKeq5LA/8TepwJAAAAACC5SXjPEQAAAACAnkAcAQAAAAAogDgCAAAAAFAAcQQAAAAAoADiCAAAAABAAcQRAAAAAIACiCMAAAAAAAUQRwAAAAAACiCOAAAAAAAUQBwBAAAAACiAOAIAAAAAoAb+P1R1J4wSDv7aAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
diff --git a/ext/gudhi-devel b/ext/gudhi-devel
index 6fec7057..efaf27a8 160000
--- a/ext/gudhi-devel
+++ b/ext/gudhi-devel
@@ -1 +1 @@
-Subproject commit 6fec70571e70c4dcdb659532b5a55bcc265b250a
+Subproject commit efaf27a82109db7ac7f5583f0b4768a0558294a2
diff --git a/multipers/_2pac_interface.cpp b/multipers/_2pac_interface.cpp
index b527edf7..e8c79157 100644
--- a/multipers/_2pac_interface.cpp
+++ b/multipers/_2pac_interface.cpp
@@ -47,7 +47,7 @@ nb::object minimal_presentation_for_target(nb::object target,
       backend_name,
       [&] {
         return multipers::twopac_minpres_contiguous_interface(
-            input_wrapper.truc,
+            input_wrapper.get_slicer(),
             degree,
             full_resolution,
             use_chunk,
@@ -57,7 +57,7 @@ nb::object minimal_presentation_for_target(nb::object target,
       },
       [&] {
         return multipers::twopac_minpres_with_generators_contiguous_interface(
-            input_wrapper.truc,
+            input_wrapper.get_slicer(),
             degree,
             full_resolution,
             use_chunk,
diff --git a/multipers/_aida_interface.cpp b/multipers/_aida_interface.cpp
index d73d5ed0..165dc593 100644
--- a/multipers/_aida_interface.cpp
+++ b/multipers/_aida_interface.cpp
@@ -4,12 +4,12 @@
 #include <nanobind/stl/vector.h>
 
 #include <algorithm>
-#include <cstdint>
 #include <stdexcept>
 #include <utility>
 #include <vector>
 
 #include "ext_interface/aida_interface.hpp"
+#include "interface_helper_structs.h"
 
 #if !MULTIPERS_DISABLE_AIDA_INTERFACE
 #include "ext_interface/nanobind_registry_runtime.hpp"
@@ -28,15 +28,15 @@ inline nb::object ensure_supported_target(nb::object slicer) {
 }
 
 inline nb::object to_colexical_target(const nb::object& target) {
-  return nb::cast(multipers::nanobind_helpers::colexical_slicer_copy(nb::cast<const CanonicalWrapper&>(target)));
+  return nb::cast<const CanonicalWrapper&>(target).build_colexical_permuted_slicer(false);
 }
 
 multipers::nanobind_helpers::BifiltrationMinpresDegreeBlock build_input_from_slicer(const CanonicalWrapper& wrapper) {
-  const int degree = multipers::nanobind_helpers::slicer_minpres_degree(wrapper);
+  const int degree = wrapper.get_min_pres_degree();
   if (degree < 0) {
     throw std::runtime_error("AIDA takes a minimal presentation as an input.");
   }
-  if (wrapper.truc.get_number_of_parameters() != 2) {
+  if (wrapper.get_number_of_parameters() != 2) {
     throw std::runtime_error("AIDA is only compatible with 2-parameter minimal presentations.");
   }
   return multipers::nanobind_helpers::extract_bifiltration_minpres_degree_block(wrapper, degree);
@@ -64,19 +64,14 @@ nb::object summand_to_slicer(nb::object target,
 
   nb::object compact_grid = nb::none();
   if (is_squeezed) {
-    std::vector<std::vector<int64_t>> used_coordinates(2);
-    used_coordinates[0].reserve(filtration_values.size());
-    used_coordinates[1].reserve(filtration_values.size());
-    for (const auto& degree : filtration_values) {
-      used_coordinates[0].push_back(multipers::nanobind_helpers::squeezed_raw_index_from_value(degree.first, 0));
-      used_coordinates[1].push_back(multipers::nanobind_helpers::squeezed_raw_index_from_value(degree.second, 1));
-    }
-    auto compacted =
-        multipers::nanobind_helpers::compact_squeezed_filtration_grid(filtration_grid, std::move(used_coordinates));
-    compact_grid = compacted.filtration_grid;
+    auto usedCoordinates =
+        Gudhi::multi_persistence::detail::Compacted_squeezed_filtration_grid::collect_used_squeezed_coordinates(
+            filtration_values);
+    Gudhi::multi_persistence::detail::Compacted_squeezed_filtration_grid compact(filtration_grid, usedCoordinates);
+    compact_grid = compact.filtrationGrid;
     for (auto& degree : filtration_values) {
-      degree.first = multipers::nanobind_helpers::remap_squeezed_coordinate(degree.first, 0, compacted.remap);
-      degree.second = multipers::nanobind_helpers::remap_squeezed_coordinate(degree.second, 1, compacted.remap);
+      degree.first = compact.remap_squeezed_coordinate(degree.first, 0);
+      degree.second = compact.remap_squeezed_coordinate(degree.second, 1);
     }
   }
 
@@ -85,9 +80,9 @@ nb::object summand_to_slicer(nb::object target,
   nb::object out =
       multipers::nanobind_helpers::build_canonical_contiguous_f64_slicer_object_from_complex(target, complex);
   auto& out_wrapper = nb::cast<CanonicalWrapper&>(out);
-  multipers::nanobind_helpers::mark_slicer_minpres(out_wrapper, degree);
+  out_wrapper.set_min_pres_degree(degree);
   if (is_squeezed) {
-    out_wrapper.filtration_grid = compact_grid;
+    out_wrapper.set_filtration_grid(compact_grid);
   }
   return out;
 }
diff --git a/multipers/_end_curves_interface.cpp b/multipers/_end_curves_interface.cpp
index 7c4bf56c..5fdc7ac1 100644
--- a/multipers/_end_curves_interface.cpp
+++ b/multipers/_end_curves_interface.cpp
@@ -184,11 +184,11 @@ inline index_curves birth_curve_indices(const CanonicalWrapper& wrapper,
   if (inf_indices.size() != 2) {
     throw std::invalid_argument("birth_curves expects two infinity sentinel indices.");
   }
-  const int degree = multipers::nanobind_helpers::slicer_minpres_degree(wrapper);
+  const int degree = wrapper.get_min_pres_degree();
   if (degree < 0) {
     throw std::runtime_error("birth_curves expects a minimal presentation.");
   }
-  if (wrapper.truc.get_number_of_parameters() != 2) {
+  if (wrapper.get_number_of_parameters() != 2) {
     throw std::runtime_error("birth_curves is only compatible with 2-parameter minimal presentations.");
   }
 
@@ -276,16 +276,16 @@ inline index_curves death_curve_indices(const CanonicalWrapper& wrapper,
   if (inf_indices.size() != 2) {
     throw std::invalid_argument("death_curves expects two infinity sentinel indices.");
   }
-  auto complex = multipers::persistence_algebra_death_curve_contiguous_interface(wrapper.truc, degree);
+  auto complex = multipers::persistence_algebra_death_curve_contiguous_interface(wrapper.get_slicer(), degree);
   CanonicalWrapper death_wrapper;
-  multipers::build_slicer_from_complex(death_wrapper.truc, complex);
-  multipers::nanobind_helpers::mark_slicer_minpres(death_wrapper, degree);
-  death_wrapper.filtration_grid = wrapper.filtration_grid;
+  multipers::build_slicer_from_complex(death_wrapper.get_slicer(), complex);
+  death_wrapper.set_min_pres_degree(degree);
+  death_wrapper.set_filtration_grid(wrapper.get_filtration_grid());
   if (aida_sort) {
-    death_wrapper = multipers::nanobind_helpers::colexical_slicer_copy(death_wrapper);
+    death_wrapper.sort_slicer_co_lexically();
   }
 
-  const auto& dimensions = death_wrapper.truc.get_dimensions();
+  const auto& dimensions = death_wrapper.get_slicer().get_dimensions();
   if (std::find(dimensions.begin(), dimensions.end(), degree) == dimensions.end()) {
     return {};
   }
@@ -358,8 +358,7 @@ NB_MODULE(_end_curves_interface, m) {
 #else
         nb::object target = multipers::nanobind_helpers::ensure_canonical_contiguous_f64_slicer_object(slicer);
         if (aida_sort) {
-          target = nb::cast(multipers::nanobind_helpers::colexical_slicer_copy(
-              nb::cast<const mpendcurves::CanonicalWrapper&>(target)));
+          nb::cast<mpendcurves::CanonicalWrapper&>(target).sort_slicer_co_lexically();
         }
         return mpendcurves::birth_curve_indices(nb::cast<const mpendcurves::CanonicalWrapper&>(target),
                                                 inf_indices,
diff --git a/multipers/_graphcode_interface.cpp b/multipers/_graphcode_interface.cpp
index 7ea984bc..f1047f3e 100644
--- a/multipers/_graphcode_interface.cpp
+++ b/multipers/_graphcode_interface.cpp
@@ -23,11 +23,11 @@ using CanonicalWrapper = multipers::nanobind_helpers::canonical_contiguous_f64_s
 inline multipers::graphcode_interface_input input_from_slicer(nb::object slicer) {
   nb::object target = multipers::nanobind_helpers::ensure_canonical_contiguous_f64_slicer_object(slicer);
   const auto& wrapper = nb::cast<const CanonicalWrapper&>(target);
-  const int degree = multipers::nanobind_helpers::slicer_minpres_degree(wrapper);
+  const int degree = wrapper.get_min_pres_degree();
   if (degree < 0) {
     throw std::runtime_error("graphcode expects a minimal-presentation slicer.");
   }
-  if (wrapper.truc.get_number_of_parameters() != 2) {
+  if (wrapper.get_slicer().get_number_of_parameters() != 2) {
     throw std::runtime_error("graphcode expects a 2-parameter minimal-presentation slicer.");
   }
 
diff --git a/multipers/_hera_interface.cpp b/multipers/_hera_interface.cpp
index 36a1d320..e5270966 100644
--- a/multipers/_hera_interface.cpp
+++ b/multipers/_hera_interface.cpp
@@ -180,12 +180,12 @@ template <bool IsKcritical, typename Func>
 decltype(auto) with_native_f64_slicer(const nb::handle& input, Func&& func) {
   using NativeSlicer = native_f64_slicer_t<IsKcritical>;
   return multipers::nanobind_helpers::visit_const_slicer_wrapper(
-      input, [&]<typename Desc>(const typename Desc::wrapper& wrapper) -> decltype(auto) {
+      input, [&]<typename Desc>(const typename Desc::interface& wrapper) -> decltype(auto) {
         // Monte Carlo fast path always runs on non-vine float64 matrix slicers.
         if constexpr (std::is_same_v<typename Desc::concrete, NativeSlicer>) {
-          return std::forward<Func>(func)(wrapper.truc);
+          return std::forward<Func>(func)(wrapper.get_slicer());
         } else {
-          NativeSlicer copy(wrapper.truc);
+          NativeSlicer copy(wrapper.get_slicer());
           return std::forward<Func>(func)(copy);
         }
       });
@@ -198,8 +198,8 @@ multipers::hera_module_presentation_input<int> module_input_from_slicer(nb::obje
     throw std::runtime_error("Input has to be a slicer.");
   }
   return multipers::nanobind_helpers::visit_const_slicer_wrapper(
-      slicer, [&]<typename Desc>(const typename Desc::wrapper& wrapper) {
-        if (wrapper.truc.get_number_of_parameters() != 2) {
+      slicer, [&]<typename Desc>(const typename Desc::interface& wrapper) {
+        if (wrapper.get_slicer().get_number_of_parameters() != 2) {
           throw std::runtime_error("Matching distance only supports 2-parameter slicers.");
         }
         if constexpr (Desc::is_kcritical) {
@@ -207,7 +207,7 @@ multipers::hera_module_presentation_input<int> module_input_from_slicer(nb::obje
         }
 
         auto block = multipers::nanobind_helpers::extract_bifiltration_minpres_degree_block(
-            wrapper, multipers::nanobind_helpers::slicer_minpres_degree(wrapper));
+            wrapper, wrapper.get_min_pres_degree());
 
         multipers::hera_module_presentation_input<int> out;
         out.generator_grades = std::move(block.row_grades);
@@ -225,11 +225,11 @@ multipers::hera_module_presentation_input<int> module_input_from_slicer(nb::obje
 
 inline monte_carlo_slicer_metadata metadata_from_slicer(nb::handle input) {
   return multipers::nanobind_helpers::visit_const_slicer_wrapper(
-      input, [&]<typename Desc>(const typename Desc::wrapper& wrapper) {
+      input, [&]<typename Desc>(const typename Desc::interface& wrapper) {
         monte_carlo_slicer_metadata out;
         out.is_kcritical = Desc::is_kcritical;
-        out.is_squeezed = multipers::nanobind_helpers::has_nonempty_filtration_grid(wrapper.filtration_grid);
-        out.num_parameters = static_cast<std::size_t>(wrapper.truc.get_number_of_parameters());
+        out.is_squeezed = multipers::nanobind_helpers::has_nonempty_filtration_grid(wrapper.get_filtration_grid());
+        out.num_parameters = static_cast<std::size_t>(wrapper.get_number_of_parameters());
         return out;
       });
 }
diff --git a/multipers/_mma_nanobind.cpp b/multipers/_mma_nanobind.cpp
index ee4fad6c..c6e7fc4e 100644
--- a/multipers/_mma_nanobind.cpp
+++ b/multipers/_mma_nanobind.cpp
@@ -103,9 +103,9 @@ void bind_float_module_methods(Class& cls) {
              "directions"_a = nb::none(),
              "degree"_a = -1,
              "keep_inf"_a = true)
-        // .def("evaluate_in_grid", nb::overload_cast<const std::vector<std::vector<T>>&>(&Module::evaluate_in_grid))
-        .def("evaluate_in_grid", nb::overload_cast<const std::vector<NDArray1>&>(&Module::evaluate_in_grid))
         .def("evaluate_in_grid", nb::overload_cast<NDArray2>(&Module::evaluate_in_grid))
+        .def("evaluate_in_grid", nb::overload_cast<const std::vector<NDArray1>&>(&Module::evaluate_in_grid))
+        // .def("evaluate_in_grid", nb::overload_cast<const std::vector<std::vector<T>>&>(&Module::evaluate_in_grid))
         .def("_compute_landscapes_box",
              &Module::template compute_landscapes_from_box<std::int32_t>,
              "degree"_a,
@@ -150,8 +150,8 @@ void bind_float_module_methods(Class& cls) {
              "p"_a,
              "normalize"_a = false,
              "n_jobs"_a = 0)
-        // .def("distance_to", &Module::compute_distance_to_iterable, "pts"_a, "signed"_a = false, "n_jobs"_a = 0)
         .def("distance_to", &Module::compute_distance_to_tensor, "pts"_a, "signed"_a = false, "n_jobs"_a = 0)
+        // .def("distance_to", &Module::compute_distance_to_iterable, "pts"_a, "signed"_a = false, "n_jobs"_a = 0)
         .def("get_interleavings", &Module::compute_interleavings)
         .def("get_interleavings", &Module::compute_interleavings_from_box);
   }
diff --git a/multipers/_mpfree_interface.cpp b/multipers/_mpfree_interface.cpp
index 4682ff8c..a676ad3b 100644
--- a/multipers/_mpfree_interface.cpp
+++ b/multipers/_mpfree_interface.cpp
@@ -37,11 +37,11 @@ nb::object minimal_presentation_for_target(nb::object target,
       "mpfree",
       [&] {
         return multipers::mpfree_minpres_contiguous_interface(
-            input_wrapper.truc, degree, full_resolution, use_chunk, use_clearing, verbose);
+            input_wrapper.get_slicer(), degree, full_resolution, use_chunk, use_clearing, verbose);
       },
       [&] {
         return multipers::mpfree_minpres_with_generators_contiguous_interface(
-            input_wrapper.truc, degree, full_resolution, use_chunk, use_clearing, verbose);
+            input_wrapper.get_slicer(), degree, full_resolution, use_chunk, use_clearing, verbose);
       });
 }
 
diff --git a/multipers/_multi_critical_interface.cpp b/multipers/_multi_critical_interface.cpp
index 90b4723b..2d0e7129 100644
--- a/multipers/_multi_critical_interface.cpp
+++ b/multipers/_multi_critical_interface.cpp
@@ -381,9 +381,9 @@ nb::object output_to_slicer(int target_template_id,
   auto complex = multipers::build_contiguous_f64_slicer_from_output(output.filtration_values, output.boundaries, dims);
   nb::object canonical_out = nb::borrow<nb::object>(nb::type<CanonicalWrapper>())();
   auto& canonical_wrapper = nb::cast<CanonicalWrapper&>(canonical_out);
-  multipers::build_slicer_from_complex(canonical_wrapper.truc, complex);
+  multipers::build_slicer_from_complex(canonical_wrapper.get_slicer(), complex);
   if (mark_minpres) {
-    multipers::nanobind_helpers::mark_slicer_minpres(canonical_wrapper, degree);
+    canonical_wrapper.set_min_pres_degree(degree);
   }
   return multipers::nanobind_helpers::astype_slicer_to_template_id(canonical_out, target_template_id);
 }
@@ -449,7 +449,7 @@ NB_MODULE(_multi_critical_interface, m) {
           {
             nb::gil_scoped_release release;
             auto input =
-                multipers::multi_critical_detail::multi_critical_input_from_kcontiguous_slicer(input_wrapper.truc);
+                multipers::multi_critical_detail::multi_critical_input_from_kcontiguous_slicer(input_wrapper.get_slicer());
             out = multipers::multi_critical_resolution_interface<int>(input, use_logpath, true, verbose);
           }
           return mpmc::output_to_slicer(target_template_id, out, false, -1);
@@ -459,7 +459,7 @@ NB_MODULE(_multi_critical_interface, m) {
           {
             nb::gil_scoped_release release;
             auto input =
-                multipers::multi_critical_detail::multi_critical_input_from_kcontiguous_slicer(input_wrapper.truc);
+                multipers::multi_critical_detail::multi_critical_input_from_kcontiguous_slicer(input_wrapper.get_slicer());
             outs = multipers::multi_critical_minpres_all_interface<int>(input, use_logpath, true, verbose, swedish);
           }
           return nb::object(mpmc::tuple_from_size(outs.size(), [&](size_t i) -> nb::object {
@@ -471,7 +471,7 @@ NB_MODULE(_multi_critical_interface, m) {
         {
           nb::gil_scoped_release release;
           auto input =
-              multipers::multi_critical_detail::multi_critical_input_from_kcontiguous_slicer(input_wrapper.truc);
+              multipers::multi_critical_detail::multi_critical_input_from_kcontiguous_slicer(input_wrapper.get_slicer());
           out =
               multipers::multi_critical_minpres_interface<int>(input, degree + 1, use_logpath, true, verbose, swedish);
         }
diff --git a/multipers/_muphasa_interface.cpp b/multipers/_muphasa_interface.cpp
index d6880bd7..e95f92b2 100644
--- a/multipers/_muphasa_interface.cpp
+++ b/multipers/_muphasa_interface.cpp
@@ -32,8 +32,8 @@ inline multipers::packed_morphism_columns packed_columns(
 
 void require_grid_squeezed_integer_slicer(const nb::object& slicer) {
   multipers::nanobind_helpers::visit_const_slicer_wrapper(
-      slicer, []<typename Desc>(const typename Desc::wrapper& wrapper) {
-        if (!multipers::nanobind_helpers::has_nonempty_filtration_grid(wrapper.filtration_grid)) {
+      slicer, []<typename Desc>(const typename Desc::interface& wrapper) {
+        if (!multipers::nanobind_helpers::has_nonempty_filtration_grid(wrapper.get_filtration_grid())) {
           throw std::invalid_argument("Muphasa backend expects a grid-squeezed slicer.");
         }
         if constexpr (std::is_floating_point_v<typename Desc::value_type>) {
@@ -51,8 +51,8 @@ nb::object minimal_presentation_for_target(nb::object target, int degree, bool f
     nb::gil_scoped_release release;
     try {
       auto complex =
-          multipers::muphasa_minpres_contiguous_interface(input_wrapper.truc, degree, full_resolution, verbose);
-      multipers::build_slicer_from_complex(out_wrapper.truc, complex);
+          multipers::muphasa_minpres_contiguous_interface(input_wrapper.get_slicer(), degree, full_resolution, verbose);
+      multipers::build_slicer_from_complex(out_wrapper.get_slicer(), complex);
     } catch (const std::exception& exc) {
       error = exc.what();
     } catch (...) {
@@ -76,8 +76,8 @@ nb::object algebra_operation_for_targets(CanonicalWrapper& source_wrapper,
   {
     nb::gil_scoped_release release;
     try {
-      auto source_input = multipers::muphasa_detail::convert_contiguous_slicer_to_input<int>(source_wrapper.truc);
-      auto target_input = multipers::muphasa_detail::convert_contiguous_slicer_to_input<int>(target_wrapper.truc);
+      auto source_input = multipers::muphasa_detail::convert_contiguous_slicer_to_input<int>(source_wrapper.get_slicer());
+      auto target_input = multipers::muphasa_detail::convert_contiguous_slicer_to_input<int>(target_wrapper.get_slicer());
       if (source_input.num_parameters != target_input.num_parameters) {
         throw std::invalid_argument("Muphasa source/target parameter counts must agree.");
       }
@@ -86,7 +86,7 @@ nb::object algebra_operation_for_targets(CanonicalWrapper& source_wrapper,
       auto converted = multipers::muphasa_detail::convert_raw_to_output<int>(std::move(raw), degree);
       auto complex = multipers::build_contiguous_i32_slicer_from_output<int>(
           converted.filtration_values, converted.boundaries, converted.dimensions);
-      multipers::build_slicer_from_complex(out_wrapper.truc, complex);
+      multipers::build_slicer_from_complex(out_wrapper.get_slicer(), complex);
     } catch (const std::exception& exc) {
       error = exc.what();
     } catch (...) {
diff --git a/multipers/_persistence_algebra_interface.cpp b/multipers/_persistence_algebra_interface.cpp
index bb53d954..466c09c9 100644
--- a/multipers/_persistence_algebra_interface.cpp
+++ b/multipers/_persistence_algebra_interface.cpp
@@ -51,7 +51,7 @@ inline nb::list cast_columns(const Matrix& matrix) {
 inline nb::object minimal_presentation_for_target(nb::object target, int degree, bool full_resolution) {
   auto& input_wrapper = nb::cast<CanonicalWrapper&>(target);
   auto complex =
-      multipers::persistence_algebra_minpres_contiguous_interface(input_wrapper.truc, degree, full_resolution);
+      multipers::persistence_algebra_minpres_contiguous_interface(input_wrapper.get_slicer(), degree, full_resolution);
   return multipers::nanobind_helpers::build_canonical_contiguous_f64_slicer_object_from_complex(target, complex);
 }
 
@@ -65,22 +65,22 @@ inline nb::object algebra_operation_for_target(nb::object source,
   auto& target_wrapper = nb::cast<CanonicalWrapper&>(target);
   if (op == "kernel") {
     auto complex = multipers::persistence_algebra_kernel_contiguous_interface(
-        source_wrapper.truc, target_wrapper.truc, columns, degree);
+        source_wrapper.get_slicer(), target_wrapper.get_slicer(), columns, degree);
     return multipers::nanobind_helpers::build_canonical_contiguous_f64_slicer_object_from_complex(owner, complex);
   }
   if (op == "image") {
     auto complex = multipers::persistence_algebra_image_contiguous_interface(
-        source_wrapper.truc, target_wrapper.truc, columns, degree);
+        source_wrapper.get_slicer(), target_wrapper.get_slicer(), columns, degree);
     return multipers::nanobind_helpers::build_canonical_contiguous_f64_slicer_object_from_complex(owner, complex);
   }
   if (op == "cokernel") {
     auto complex = multipers::persistence_algebra_cokernel_contiguous_interface(
-        source_wrapper.truc, target_wrapper.truc, columns, degree);
+        source_wrapper.get_slicer(), target_wrapper.get_slicer(), columns, degree);
     return multipers::nanobind_helpers::build_canonical_contiguous_f64_slicer_object_from_complex(owner, complex);
   }
   if (op == "coimage") {
     auto complex = multipers::persistence_algebra_coimage_contiguous_interface(
-        source_wrapper.truc, target_wrapper.truc, columns, degree);
+        source_wrapper.get_slicer(), target_wrapper.get_slicer(), columns, degree);
     return multipers::nanobind_helpers::build_canonical_contiguous_f64_slicer_object_from_complex(owner, complex);
   }
   throw std::invalid_argument("Unknown Persistence-Algebra operation.");
@@ -111,8 +111,8 @@ NB_MODULE(_persistence_algebra_interface, m) {
 #if MULTIPERS_HAS_PERSISTENCE_ALGEBRA_INTERFACE
         nb::object target = multipers::nanobind_helpers::ensure_canonical_contiguous_f64_slicer_object(slicer);
         auto& input_wrapper = nb::cast<mppai::CanonicalWrapper&>(target);
-        auto first = multipers::persistence_algebra_detail::build_boundary_matrix(input_wrapper.truc, degree);
-        auto second = multipers::persistence_algebra_detail::build_boundary_matrix(input_wrapper.truc, degree + 1);
+        auto first = multipers::persistence_algebra_detail::build_boundary_matrix(input_wrapper.get_slicer(), degree);
+        auto second = multipers::persistence_algebra_detail::build_boundary_matrix(input_wrapper.get_slicer(), degree + 1);
         auto first_sorted = first;
         first_sorted.sort_rows_lexicographically();
         const auto relation_row_permutation = first_sorted.sort_columns_lexicographically_with_output();
diff --git a/multipers/_simplex_tree_multi_nanobind.cpp b/multipers/_simplex_tree_multi_nanobind.cpp
index c056215d..890dca10 100644
--- a/multipers/_simplex_tree_multi_nanobind.cpp
+++ b/multipers/_simplex_tree_multi_nanobind.cpp
@@ -22,6 +22,7 @@
 #include <vector>
 
 #include "ext_interface/nanobind_registry_helpers.hpp"
+#include "interface_helper_structs.h"
 #include "simplextree_conversion_core.hpp"
 #include "nanobind_array_utils.hpp"
 #include "nanobind_object_utils.hpp"
@@ -39,7 +40,6 @@ using signed_measure_type = std::pair<std::vector<std::vector<indices_type>>, st
 
 using multipers::core::SimplexTreeConversion;
 using multipers::nanobind_helpers::cast_squeezed_coordinate_grid;
-using multipers::nanobind_helpers::compact_squeezed_filtration_grid;
 using multipers::nanobind_helpers::copy_simplextree_python_state;
 using multipers::nanobind_helpers::dispatch_simplextree_by_template_id;
 using multipers::nanobind_helpers::has_nonempty_filtration_grid;
@@ -50,7 +50,6 @@ using multipers::nanobind_helpers::reset_simplextree_python_state;
 using multipers::nanobind_helpers::simplextree_wrapper_t;
 using multipers::nanobind_helpers::SimplexTreeDescriptorList;
 using multipers::nanobind_helpers::SlicerDescriptorList;
-using multipers::nanobind_helpers::squeezed_raw_index_from_value;
 using multipers::nanobind_helpers::type_list;
 using multipers::nanobind_helpers::visit_const_simplextree_wrapper;
 using multipers::nanobind_helpers::visit_const_slicer_wrapper;
@@ -327,10 +326,10 @@ void copy_simplicial_slicer_to_simplextree(TargetInterface& out, const SourceSli
 }
 
 template <typename Desc, typename Wrapper, typename Interface>
-void build_from_slicer_desc(Wrapper& self, const typename Desc::wrapper& source, int max_dim) {
+void build_from_slicer_desc(Wrapper& self, const typename Desc::interface& source, int max_dim) {
   {
     nb::gil_scoped_release release;
-    copy_simplicial_slicer_to_simplextree<Interface>(self.tree, source.truc, max_dim);
+    copy_simplicial_slicer_to_simplextree<Interface>(self.tree, source.get_slicer(), max_dim);
   }
   reset_simplextree_python_state(self);
 }
@@ -340,7 +339,7 @@ bool try_build_from_slicer(Wrapper& self, nb::handle source, int max_dim) {
   if (!is_slicer_object(source)) {
     return false;
   }
-  visit_const_slicer_wrapper(source, [&]<typename D>(const typename D::wrapper& wrapper) {
+  visit_const_slicer_wrapper(source, [&]<typename D>(const typename D::interface& wrapper) {
     build_from_slicer_desc<D, Wrapper, Interface>(self, wrapper, max_dim);
   });
   return true;
@@ -730,34 +729,21 @@ bool try_copy_from_any(TargetWrapper& self, nb::handle source) {
   return true;
 }
 
-template <typename Wrapper>
-std::vector<std::vector<int64_t>> collect_used_squeezed_coordinates(Wrapper& self) {
-  std::vector<std::vector<int64_t>> used_coordinates(static_cast<size_t>(self.tree.num_parameters()));
-  for (auto simplex_handle : self.tree.complex_simplex_range()) {
-    auto pair = self.tree.get_simplex_and_filtration(simplex_handle);
-    const auto& filtration = *pair.second;
-    for (size_t generator = 0; generator < filtration.num_generators(); ++generator) {
-      for (size_t parameter = 0; parameter < used_coordinates.size(); ++parameter) {
-        used_coordinates[parameter].push_back(
-            squeezed_raw_index_from_value(static_cast<double>(filtration(generator, parameter)), parameter));
-      }
-    }
-  }
-  return used_coordinates;
-}
-
 template <typename Wrapper>
 Wrapper& clean_squeezed_filtration_grid_inplace(Wrapper& self) {
   if (!has_nonempty_filtration_grid(self.filtration_grid)) {
     throw std::runtime_error("No grid to clean.");
   }
-  auto compacted = compact_squeezed_filtration_grid(self.filtration_grid, collect_used_squeezed_coordinates(self));
-  auto coordinate_grid = cast_squeezed_coordinate_grid<double>(compacted.coordinates);
+  auto usedCoordinates =
+      Gudhi::multi_persistence::detail::Compacted_squeezed_filtration_grid::collect_used_squeezed_coordinates(self);
+  Gudhi::multi_persistence::detail::Compacted_squeezed_filtration_grid compact(self.filtration_grid, usedCoordinates);
+
+  auto coordinate_grid = cast_squeezed_coordinate_grid<double>(compact.coordinates);
   {
     nb::gil_scoped_release release;
     self.tree.squeeze_filtration_inplace(coordinate_grid, true);
   }
-  self.filtration_grid = compacted.filtration_grid;
+  self.filtration_grid = compact.filtrationGrid;
   return self;
 }
 
@@ -773,7 +759,7 @@ PySimplexTree<typename TargetDesc::interface_type, typename TargetDesc::value_ty
 
 template <typename TargetDesc, typename SourceDesc>
 PySimplexTree<typename TargetDesc::interface_type, typename TargetDesc::value_type> construct_from_slicer_wrapper(
-    const typename SourceDesc::wrapper& source,
+    const typename SourceDesc::interface& source,
     int max_dim) {
   using Wrapper = PySimplexTree<typename TargetDesc::interface_type, typename TargetDesc::value_type>;
   using Interface = typename TargetDesc::interface_type;
@@ -793,7 +779,7 @@ void bind_simplextree_source_constructors(Class& cls, type_list<SourceDesc...>)
 
 template <typename TargetDesc, typename Class, typename... SourceDesc>
 void bind_slicer_source_constructors(Class& cls, type_list<SourceDesc...>) {
-  (cls.def(nb::new_([](const typename SourceDesc::wrapper& source, int max_dim) {
+  (cls.def(nb::new_([](const typename SourceDesc::interface& source, int max_dim) {
              return construct_from_slicer_wrapper<TargetDesc, SourceDesc>(source, max_dim);
            }),
            "source"_a,
diff --git a/multipers/_skyscraper_interface.cpp b/multipers/_skyscraper_interface.cpp
index 2b39f623..136a46e9 100644
--- a/multipers/_skyscraper_interface.cpp
+++ b/multipers/_skyscraper_interface.cpp
@@ -58,10 +58,10 @@ struct SkyscraperInvariant {
 };
 
 hnf::Presentation presentation_from_slicer(const Wrapper& wrapper) {
-  const int degree = multipers::nanobind_helpers::slicer_minpres_degree(wrapper);
-  if (degree < 0 || wrapper.truc.get_number_of_parameters() != 2)
+  const int degree = wrapper.get_min_pres_degree();
+  if (degree < 0 || wrapper.get_slicer().get_number_of_parameters() != 2)
     throw std::invalid_argument("Each summand must be a one-critical 2D minimal presentation.");
-  if (multipers::nanobind_helpers::has_nonempty_filtration_grid(wrapper.filtration_grid))
+  if (multipers::nanobind_helpers::has_nonempty_filtration_grid(wrapper.get_filtration_grid()))
     throw std::invalid_argument("Summand coordinates must be unsqueezed physical coordinates.");
   auto block = multipers::nanobind_helpers::extract_bifiltration_minpres_degree_block(wrapper, degree);
   const auto finite_grade = [](const auto& grade) { return std::isfinite(grade.first) && std::isfinite(grade.second); };
@@ -611,7 +611,7 @@ NB_MODULE(_skyscraper_interface, m) {
         for (const auto& summand : summands) {
           auto canonical = multipers::nanobind_helpers::ensure_canonical_contiguous_f64_slicer_object(summand);
           const auto& wrapper = nb::cast<const Wrapper&>(canonical);
-          if (degree >= 0 && multipers::nanobind_helpers::slicer_minpres_degree(wrapper) != degree)
+          if (degree >= 0 && wrapper.get_min_pres_degree() != degree)
             throw std::invalid_argument("Summand degree does not match requested degree.");
           input.push_back(presentation_from_slicer(wrapper));
         }
diff --git a/multipers/_slicer_algorithms_nanobind.h b/multipers/_slicer_algorithms_nanobind.h
new file mode 100644
index 00000000..ae909b7b
--- /dev/null
+++ b/multipers/_slicer_algorithms_nanobind.h
@@ -0,0 +1,254 @@
+#ifndef MP_PY_SLICER_ALGO_NANOBIND_H_INCLUDED
+#define MP_PY_SLICER_ALGO_NANOBIND_H_INCLUDED
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/vector.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "ext_interface/nanobind_registry_helpers.hpp"
+#include "gudhi/Multi_persistence/Box.h"
+#include "gudhi/Module_interface.h"
+#include <python_interfaces/numpy_utils.h>
+#include "multi_parameter_rank_invariant/hilbert_function.h"
+#include "multi_parameter_rank_invariant/rank_invariant.h"
+#include <gudhi/multiparameter_module_approximation.h>
+#include "nanobind_array_utils.hpp"
+#include "nanobind_dense_array_utils.hpp"
+#include "nanobind_object_utils.hpp"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace mpnb {
+
+using tensor_dtype = int32_t;
+using indices_type = int32_t;
+using signed_measure_type = std::pair<std::vector<std::vector<indices_type>>, std::vector<tensor_dtype>>;
+
+using multipers::nanobind_dense_utils::matrix_from_array;
+using multipers::nanobind_dense_utils::vector_from_array;
+using multipers::nanobind_helpers::dispatch_slicer_by_template_id;
+using multipers::nanobind_helpers::SlicerDescriptorList;
+using multipers::nanobind_helpers::type_list;
+using multipers::nanobind_utils::cast_vector;
+using multipers::nanobind_utils::lowercase_copy;
+using multipers::nanobind_utils::numpy_dtype_name;
+using multipers::nanobind_utils::template_id_of;
+using multipers::nanobind_helpers::is_slicer_object;
+using multipers::nanobind_utils::owned_array;
+
+inline bool has_slicer_template_id(const nb::handle& input) { return is_slicer_object(input); }
+
+inline nb::tuple signed_measure_to_python(const signed_measure_type& sm, size_t width) {
+  std::vector<indices_type> flat_pts;
+  flat_pts.reserve(sm.first.size() * width);
+  for (const auto& row : sm.first) {
+    flat_pts.insert(flat_pts.end(), row.begin(), row.end());
+  }
+  std::vector<tensor_dtype> weights(sm.second.begin(), sm.second.end());
+  return nb::make_tuple(nb::cast(owned_array<indices_type>(std::move(flat_pts), {sm.first.size(), width})),
+                        nb::cast(owned_array<tensor_dtype>(std::move(weights), {sm.second.size()})));
+}
+
+template <typename... Ds>
+inline nb::object get_slicer_class(type_list<Ds...>,
+                            bool is_vineyard,
+                            bool is_k_critical,
+                            const nb::handle& dtype,
+                            std::string col,
+                            std::string pers_backend,
+                            std::string filtration_container) {
+  std::string dtype_name = numpy_dtype_name(dtype);
+  col = lowercase_copy(std::move(col));
+  pers_backend = lowercase_copy(std::move(pers_backend));
+  filtration_container = lowercase_copy(std::move(filtration_container));
+  bool matched = false;
+  nb::object result;
+  (
+      [&]<typename D>() {
+        if (!matched && D::is_vine == is_vineyard && D::is_kcritical == is_k_critical && D::dtype_name == dtype_name &&
+            lowercase_copy(std::string(D::column_type)) == col &&
+            lowercase_copy(std::string(D::backend_type)) == pers_backend &&
+            lowercase_copy(std::string(D::filtration_container)) == filtration_container) {
+          result = nb::borrow<nb::object>(nb::type<typename D::interface>());
+          matched = true;
+        }
+      }.template operator()<Ds>(),
+      ...);
+  if (!matched) {
+    throw nb::value_error("Unimplemented slicer combination.");
+  }
+  return result;
+}
+
+// inline nb::object get_slicer_class_from_template_id(int template_id) {
+//   return dispatch_slicer_by_template_id(template_id, [&]<typename Desc>() -> nb::object {
+//     return nb::borrow<nb::object>(nb::type<typename Desc::interface>());
+//   });
+// }
+
+template <typename... Ds>
+inline nb::tuple compute_hilbert_signed_measure(type_list<Ds...>,
+                                         nb::handle slicer,
+                                         std::vector<indices_type>& container,
+                                         const std::vector<indices_type>& full_shape,
+                                         const std::vector<indices_type>& degrees,
+                                         size_t width,
+                                         bool zero_pad,
+                                         indices_type n_jobs,
+                                         bool verbose,
+                                         bool ignore_inf) {
+  if (!has_slicer_template_id(slicer)) {
+    throw std::runtime_error("Unsupported slicer type.");
+  }
+  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
+    auto& wrapper = nb::cast<typename D::interface&>(slicer);
+    signed_measure_type sm;
+    {
+      nb::gil_scoped_release release;
+      sm = Gudhi::multiparameter::hilbert_function::get_hilbert_signed_measure(
+          wrapper.get_slicer(), container.data(), full_shape, degrees, zero_pad, n_jobs, verbose, ignore_inf);
+    }
+    return signed_measure_to_python(sm, width);
+  });
+}
+
+template <typename... Ds>
+inline nb::tuple compute_hilbert_signed_measure_sparse(type_list<Ds...>,
+                                                nb::handle slicer,
+                                                const std::vector<indices_type>& grid_shape,
+                                                const std::vector<indices_type>& degrees,
+                                                size_t width,
+                                                bool zero_pad,
+                                                indices_type n_jobs,
+                                                bool ignore_inf) {
+  if (!has_slicer_template_id(slicer)) {
+    throw std::runtime_error("Unsupported slicer type.");
+  }
+  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
+    auto& wrapper = nb::cast<typename D::interface&>(slicer);
+    signed_measure_type sm;
+    {
+      nb::gil_scoped_release release;
+      sm = Gudhi::multiparameter::hilbert_function::compute_hilbert_signed_measure_sparse_python(
+          wrapper.get_slicer(), grid_shape, degrees, zero_pad, n_jobs, ignore_inf);
+    }
+    return signed_measure_to_python(sm, width);
+  });
+}
+
+template <typename... Ds>
+inline nb::tuple compute_rank_tensor(type_list<Ds...>,
+                              nb::handle slicer,
+                              std::vector<tensor_dtype>& container,
+                              const std::vector<indices_type>& full_shape,
+                              const std::vector<indices_type>& degrees,
+                              size_t total,
+                              indices_type n_jobs,
+                              bool ignore_inf) {
+  if (!has_slicer_template_id(slicer)) {
+    throw std::runtime_error("Unsupported slicer type.");
+  }
+  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
+    auto& wrapper = nb::cast<typename D::interface&>(slicer);
+    {
+      nb::gil_scoped_release release;
+      Gudhi::multiparameter::rank_invariant::compute_rank_invariant_python(
+          wrapper.get_slicer(), container.data(), full_shape, degrees, n_jobs, ignore_inf);
+    }
+    return nb::make_tuple(nb::cast(owned_array<tensor_dtype>(std::move(container), {total})), nb::cast(full_shape));
+  });
+}
+
+template <typename... Ds>
+inline nb::tuple compute_rank_signed_measure_sparse(type_list<Ds...>,
+                                             nb::handle slicer,
+                                             const std::vector<indices_type>& grid_shape,
+                                             const std::vector<indices_type>& degrees,
+                                             size_t width,
+                                             bool zero_pad,
+                                             indices_type n_jobs,
+                                             bool ignore_inf) {
+  if (!has_slicer_template_id(slicer)) {
+    throw std::runtime_error("Unsupported slicer type.");
+  }
+  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
+    auto& wrapper = nb::cast<typename D::interface&>(slicer);
+    signed_measure_type sm;
+    {
+      nb::gil_scoped_release release;
+      sm = Gudhi::multiparameter::rank_invariant::compute_rank_signed_measure_sparse_python(
+          wrapper.get_slicer(), grid_shape, degrees, zero_pad, n_jobs, ignore_inf);
+    }
+    return signed_measure_to_python(sm, width);
+  });
+}
+
+template <typename Desc>
+inline Gudhi::multi_persistence::Module_interface<double> module_approximation_from_desc(
+    typename Desc::interface& wrapper,
+    const std::vector<double>& direction,
+    double max_error,
+    Gudhi::multi_persistence::Box<double> box,
+    bool threshold,
+    bool complete,
+    bool verbose,
+    int n_jobs) {
+  if constexpr (!Desc::enable_module_approximation) {
+    throw std::runtime_error("Unsupported slicer type for module approximation.");
+  } else {
+    Gudhi::multi_persistence::Module<double> mod;
+    {
+      nb::gil_scoped_release release;
+      mod = Gudhi::multi_persistence::multiparameter_module_approximation(wrapper.get_slicer(),
+                                                                          max_error,
+                                                                          box.get_lower_corner(),
+                                                                          box.get_upper_corner(),
+                                                                          direction,
+                                                                          threshold,
+                                                                          complete,
+                                                                          verbose,
+                                                                          n_jobs);
+    }
+    return {std::move(mod), box};
+  }
+}
+
+template <typename... Ds>
+inline Gudhi::multi_persistence::Module_interface<double> compute_module_approximation_from_slicer(
+    type_list<Ds...>,
+    nb::handle slicer,
+    const std::vector<double>& direction,
+    double max_error,
+    Gudhi::multi_persistence::Box<double> box,
+    bool threshold,
+    bool complete,
+    bool verbose,
+    int n_jobs) {
+  if (!has_slicer_template_id(slicer)) {
+    throw std::runtime_error("Unsupported slicer type for module approximation.");
+  }
+  return dispatch_slicer_by_template_id(template_id_of(slicer),
+                                        [&]<typename D>() -> Gudhi::multi_persistence::Module_interface<double> {
+                                          auto& wrapper = nb::cast<typename D::interface&>(slicer);
+                                          return module_approximation_from_desc<D>(
+                                              wrapper, direction, max_error, box, threshold, complete, verbose, n_jobs);
+                                        });
+}
+
+}  // namespace mpnb
+
+#endif  // MP_PY_SLICER_ALGO_NANOBIND_H_INCLUDED
+
+
diff --git a/multipers/_slicer_nanobind.cpp b/multipers/_slicer_nanobind.cpp
index 5214864b..8ee96cd1 100644
--- a/multipers/_slicer_nanobind.cpp
+++ b/multipers/_slicer_nanobind.cpp
@@ -5,49 +5,25 @@
 #include <nanobind/stl/tuple.h>
 #include <nanobind/stl/vector.h>
 
-#include <algorithm>
-#include <cctype>
-#include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
-#include <functional>
-#include <limits>
-#include <optional>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <unordered_set>
 #include <utility>
 #include <vector>
 
-#include <tbb/blocked_range.h>
-#include <tbb/enumerable_thread_specific.h>
-#include <tbb/parallel_for.h>
-#include <tbb/task_arena.h>
-
-#include "Persistence_slices_interface.h"
 #include "ext_interface/backend_log_policy.hpp"
-#include "ext_interface/nanobind_generator_basis.hpp"
-#include "ext_interface/nanobind_registry_helpers.hpp"
-#include "ext_interface/nanobind_registry_runtime.hpp"
 #include "graph_mph0/nanobind_interface.hpp"
-#include "gudhi/Multi_parameter_filtered_complex.h"
 #include "gudhi/Multi_persistence/Box.h"
-#include "gudhi/representative_cycle_intersection.hpp"
-#include "gudhi/slicer_conversion_core.hpp"
-#include "gudhi/slicer_helpers.h"
-#include "gudhi/Module_interface.h"
 #include <python_interfaces/numpy_utils.h>
-#include "multi_parameter_rank_invariant/hilbert_function.h"
-#include "multi_parameter_rank_invariant/rank_invariant.h"
 #include <gudhi/multiparameter_module_approximation.h>
-#include "nanobind_array_utils.hpp"
 #include "nanobind_dense_array_utils.hpp"
 #include "nanobind_object_utils.hpp"
-#include "nanobind_slicer_serialization.hpp"
-#include "slicer_landscapes.hpp"
+
+#include "_slicer_nanobind.h"
+#include "_slicer_algorithms_nanobind.h"
 
 namespace nb = nanobind;
 using namespace nb::literals;
@@ -58,59 +34,11 @@ using tensor_dtype = int32_t;
 using indices_type = int32_t;
 using signed_measure_type = std::pair<std::vector<std::vector<indices_type>>, std::vector<tensor_dtype>>;
 
-using multipers::core::SlicerConversion;
 using multipers::nanobind_dense_utils::matrix_from_array;
 using multipers::nanobind_dense_utils::vector_from_array;
-using multipers::nanobind_helpers::cast_squeezed_coordinate_grid;
-using multipers::nanobind_helpers::clear_slicer_current_line;
-using multipers::nanobind_helpers::colexical_slicer_copy;
-using multipers::nanobind_helpers::colexical_slicer_copy_with_permutation;
-using multipers::nanobind_helpers::compact_squeezed_filtration_grid;
-using multipers::nanobind_helpers::copy_slicer_python_state;
-using multipers::nanobind_helpers::dispatch_slicer_by_template_id;
-using multipers::nanobind_helpers::has_nonempty_filtration_grid;
-using multipers::nanobind_helpers::is_simplextree_object;
-using multipers::nanobind_helpers::is_slicer_object;
-using multipers::nanobind_helpers::permuted_slicer_copy;
-using multipers::nanobind_helpers::PySlicer;
-using multipers::nanobind_helpers::reset_slicer_python_state;
-using multipers::nanobind_helpers::simplextree_wrapper_t;
-using multipers::nanobind_helpers::SimplexTreeDescriptorList;
 using multipers::nanobind_helpers::SlicerDescriptorList;
-using multipers::nanobind_helpers::squeezed_raw_index_from_value;
 using multipers::nanobind_helpers::type_list;
-using multipers::nanobind_helpers::visit_const_slicer_wrapper;
-using multipers::nanobind_helpers::visit_simplextree_wrapper;
-using multipers::nanobind_utils::cast_matrix;
 using multipers::nanobind_utils::cast_vector;
-using multipers::nanobind_utils::lowercase_copy;
-using multipers::nanobind_utils::numpy_dtype_name;
-using multipers::nanobind_utils::numpy_dtype_type;
-using multipers::nanobind_utils::owned_array;
-using multipers::nanobind_utils::template_id_of;
-using multipers::nanobind_utils::tuple_from_size;
-using multipers::nanobind_utils::view_array;
-
-template <typename Persistence, typename = void>
-inline constexpr bool is_graph_persistence_v = false;
-
-template <typename Persistence>
-inline constexpr bool is_graph_persistence_v<Persistence, std::void_t<decltype(Persistence::is_graph)>> =
-    Persistence::is_graph;
-
-template <typename Concrete, typename Complex>
-void validate_complex_if_needed(const Complex& complex) {
-  if constexpr (is_graph_persistence_v<typename Concrete::Persistence>) {
-    multipers::graph_mph0::validate_graph_shape(complex.get_dimensions(), complex.get_boundaries());
-  }
-}
-
-template <typename Concrete>
-void validate_slicer_if_needed(const Concrete& slicer) {
-  if constexpr (is_graph_persistence_v<typename Concrete::Persistence>) {
-    validate_complex_if_needed<Concrete>(slicer.get_filtered_complex());
-  }
-}
 
 template <typename Desc>
 inline constexpr bool is_kcritical_contiguous_f64_matrix_slicer_v =
@@ -177,2229 +105,6 @@ static_assert(!std::is_void_v<KcriticalContiguousF64MatrixSlicerDesc>,
 static_assert(kcritical_contiguous_f64_matrix_slicer_desc_impl<SlicerDescriptorList>::matches == 1,
               "k-critical contiguous float64 matrix slicer template must be unique.");
 
-inline nb::tuple signed_measure_to_python(const signed_measure_type& sm, size_t width) {
-  std::vector<indices_type> flat_pts;
-  flat_pts.reserve(sm.first.size() * width);
-  for (const auto& row : sm.first) {
-    flat_pts.insert(flat_pts.end(), row.begin(), row.end());
-  }
-  std::vector<tensor_dtype> weights(sm.second.begin(), sm.second.end());
-  return nb::make_tuple(nb::cast(owned_array<indices_type>(std::move(flat_pts), {sm.first.size(), width})),
-                        nb::cast(owned_array<tensor_dtype>(std::move(weights), {sm.second.size()})));
-}
-
-template <typename T>
-nb::ndarray<nb::numpy, T> filled_array(size_t size, T value) {
-  return owned_array<T>(std::vector<T>(size, value), {size});
-}
-
-inline bool is_none_or_empty(const nb::handle& h) {
-  if (!h.is_valid() || h.is_none()) {
-    return true;
-  }
-  if (nb::hasattr(h, "__len__")) {
-    return nb::len(h) == 0;
-  }
-  return false;
-}
-
-template <typename Wrapper>
-void ensure_sorted_filtration_grid(const Wrapper& self) {
-  if (is_none_or_empty(self.filtration_grid)) {
-    return;
-  }
-  for (nb::handle row_handle : nb::iter(self.filtration_grid)) {
-    auto row = cast_vector<double>(row_handle);
-    for (size_t i = 1; i < row.size(); ++i) {
-      if (row[i] < row[i - 1]) {
-        throw nb::value_error("Found non-sorted grid.");
-      }
-    }
-  }
-}
-
-template <typename Wrapper>
-Wrapper& make_filtration_non_decreasing_inplace(Wrapper& self, bool safe) {
-  if (safe && !is_none_or_empty(self.filtration_grid)) {
-    ensure_sorted_filtration_grid(self);
-  }
-
-  {
-    nb::gil_scoped_release release;
-    auto& filtrations = self.truc.get_filtration_values();
-    const auto& boundaries = self.truc.get_boundaries();
-    const bool ordered = self.truc.get_filtered_complex().is_ordered_by_dimension();
-
-    bool modified = true;
-    while (modified) {
-      modified = false;
-      for (size_t i = 1; i < boundaries.size(); ++i) {
-        for (auto b : boundaries[i]) {
-          modified |= intersect_lifetimes(filtrations[i], filtrations[b]);
-        }
-      }
-      if (ordered) {
-        break;
-      }
-    }
-  }
-  return self;
-}
-
-inline bool has_slicer_template_id(const nb::handle& input) { return is_slicer_object(input); }
-
-template <typename... Ds>
-nb::object get_slicer_class(type_list<Ds...>,
-                            bool is_vineyard,
-                            bool is_k_critical,
-                            const nb::handle& dtype,
-                            std::string col,
-                            std::string pers_backend,
-                            std::string filtration_container) {
-  std::string dtype_name = numpy_dtype_name(dtype);
-  col = lowercase_copy(std::move(col));
-  pers_backend = lowercase_copy(std::move(pers_backend));
-  filtration_container = lowercase_copy(std::move(filtration_container));
-  bool matched = false;
-  nb::object result;
-  (
-      [&]<typename D>() {
-        if (!matched && D::is_vine == is_vineyard && D::is_kcritical == is_k_critical && D::dtype_name == dtype_name &&
-            lowercase_copy(std::string(D::column_type)) == col &&
-            lowercase_copy(std::string(D::backend_type)) == pers_backend &&
-            lowercase_copy(std::string(D::filtration_container)) == filtration_container) {
-          result = nb::borrow<nb::object>(nb::type<typename D::wrapper>());
-          matched = true;
-        }
-      }.template operator()<Ds>(),
-      ...);
-  if (!matched) {
-    throw nb::value_error("Unimplemented slicer combination.");
-  }
-  return result;
-}
-
-inline nb::object get_slicer_class_from_template_id(int template_id) {
-  return dispatch_slicer_by_template_id(template_id, [&]<typename Desc>() -> nb::object {
-    return nb::borrow<nb::object>(nb::type<typename Desc::wrapper>());
-  });
-}
-
-template <typename Wrapper>
-nb::object self_handle(Wrapper& self) {
-  return nb::find(self);
-}
-
-inline bool is_simplextree_multi(const nb::handle& source) { return is_simplextree_object(source); }
-
-template <typename Desc, typename Wrapper, typename Concrete>
-void build_from_simplextree_desc(Wrapper& self, simplextree_wrapper_t<Desc>& source) {
-  {
-    nb::gil_scoped_release release;
-    self.truc = Gudhi::multi_persistence::build_slicer_from_simplex_tree<Concrete>(source.tree);
-  }
-  validate_slicer_if_needed(self.truc);
-  self.filtration_grid = source.filtration_grid;
-  self.generator_basis = nb::none();
-  multipers::nanobind_helpers::mark_slicer_pres(self, -1);
-}
-
-template <typename Wrapper, typename Concrete>
-bool try_build_from_multipers_simplextree(Wrapper& self, const nb::handle& source) {
-  if (!is_simplextree_object(source)) {
-    return false;
-  }
-  visit_simplextree_wrapper(source, [&]<typename D>(simplextree_wrapper_t<D>& wrapper) {
-    build_from_simplextree_desc<D, Wrapper, Concrete>(self, wrapper);
-  });
-  return true;
-}
-
-template <typename Barcode, typename Value>
-nb::tuple dim_barcode_to_tuple(const Barcode& barcode) {
-  size_t dims = barcode.size();
-  return tuple_from_size(dims, [&](size_t dim) -> nb::object {
-    const auto& bc = barcode[dim];
-    std::vector<Value> flat;
-    flat.reserve(bc.size() * 2);
-    auto* data = bc.data();
-    for (size_t i = 0; i < bc.size(); ++i) {
-      flat.push_back(data[i][0]);
-      flat.push_back(data[i][1]);
-    }
-    return nb::cast(owned_array<Value>(std::move(flat), {bc.size(), size_t(2)}));
-  });
-}
-
-template <typename Desc, typename Wrapper, typename Value>
-nb::tuple compute_persistence_on_slices(Wrapper& self,
-                                        const nb::ndarray<const Value, nb::ndim<2>, nb::c_contig>& values,
-                                        bool ignore_infinite_filtration_values) {
-  using Barcode = decltype(self.truc.template get_flat_barcode<true, Value, false>());
-  using Concrete = std::remove_reference_t<decltype(self.truc)>;
-  const size_t num_slices = values.shape(0);
-  const size_t slice_size = values.shape(1);
-  if (slice_size != self.truc.get_number_of_cycle_generators()) {
-    throw nb::value_error("Expected one filtration value per generator.");
-  }
-  std::vector<Barcode> barcodes(num_slices);
-  typename Numpy_2d_span<Value>::Array gudhi_values(values);
-  Numpy_2d_span<Value> view(gudhi_values);
-  {
-    nb::gil_scoped_release release;
-    if constexpr (Desc::is_vine) {
-      for (size_t i = 0; i < num_slices; ++i) {
-        self.truc.set_slice(view[i]);
-        if (i == 0) {
-          self.truc.initialize_persistence_computation(ignore_infinite_filtration_values);
-        } else {
-          self.truc.update_persistence_computation(ignore_infinite_filtration_values);
-        }
-        barcodes[i] = self.truc.template get_flat_barcode<true, Value, false>();
-      }
-    } else {
-#if defined(GUDHI_USE_TBB)
-      using ThreadSafe = typename Concrete::Thread_safe;
-      tbb::enumerable_thread_specific<ThreadSafe> thread_locals(self.truc.weak_copy());
-      tbb::parallel_for(size_t(0), num_slices, [&](size_t i) {
-        auto& slicer = thread_locals.local();
-        tbb::this_task_arena::isolate([&] {
-          slicer.set_slice(view[i]);
-          slicer.initialize_persistence_computation(ignore_infinite_filtration_values);
-          barcodes[i] = slicer.template get_flat_barcode<true, Value, false>();
-        });
-      });
-#else
-      for (size_t i = 0; i < num_slices; ++i) {
-        self.truc.set_slice(view[i]);
-        self.truc.initialize_persistence_computation(ignore_infinite_filtration_values);
-        barcodes[i] = self.truc.template get_flat_barcode<true, Value, false>();
-      }
-#endif
-    }
-  }
-  return tuple_from_size(num_slices,
-                         [&](size_t i) -> nb::object { return dim_barcode_to_tuple<Barcode, Value>(barcodes[i]); });
-}
-
-template <typename Wrapper>
-nb::ndarray<nb::numpy, int32_t> dimensions_array(Wrapper& self) {
-  std::vector<int> dims;
-  {
-    nb::gil_scoped_release release;
-    dims = self.truc.get_dimensions();
-  }
-  std::vector<int32_t> out(dims.begin(), dims.end());
-  return owned_array<int32_t>(std::move(out), {dims.size()});
-}
-
-template <typename Wrapper>
-nb::object boundaries_object(Wrapper& self, bool packed) {
-  std::vector<uint64_t> indptr;
-  std::vector<uint32_t> indices;
-  size_t num_rows = 0;
-  {
-    nb::gil_scoped_release release;
-    const auto& boundaries = self.truc.get_boundaries();
-    num_rows = boundaries.size();
-    indptr.assign(num_rows + 1, 0);
-    size_t total_size = 0;
-    for (size_t i = 0; i < num_rows; ++i) {
-      total_size += boundaries[i].size();
-      indptr[i + 1] = total_size;
-    }
-    indices.reserve(total_size);
-    for (const auto& row : boundaries) {
-      indices.insert(indices.end(), row.begin(), row.end());
-    }
-  }
-
-  size_t total_size = indices.size();
-  auto indptr_arr = owned_array<uint64_t>(std::move(indptr), {num_rows + 1});
-  auto indices_arr = owned_array<uint32_t>(std::move(indices), {total_size});
-  if (packed) {
-    return nb::make_tuple(indptr_arr, indices_arr);
-  }
-
-  auto indptr_view = indptr_arr.template view<uint64_t, nb::ndim<1>>();
-  auto indices_view = indices_arr.template view<uint32_t, nb::ndim<1>>();
-  return tuple_from_size(num_rows, [&](size_t i) -> nb::object {
-    uint64_t start = indptr_view(i);
-    uint64_t stop = indptr_view(i + 1);
-    std::vector<uint32_t> row(stop - start);
-    for (uint64_t j = start; j < stop; ++j) {
-      row[j - start] = indices_view(j);
-    }
-    return nb::cast(owned_array<uint32_t>(std::move(row), {size_t(stop - start)}));
-  });
-}
-
-template <typename Wrapper, typename Value, bool IsKCritical, bool IsDegreeRips>
-nb::object filtration_value_to_python(Wrapper& self, size_t idx, bool copy, bool raw) {
-  auto& filtration = self.truc.get_filtration_value(idx);
-  nb::object owner = self_handle(self);
-
-  if constexpr (IsDegreeRips) {
-    size_t k = filtration.num_generators();
-    if (raw) {
-      if (copy) {
-        std::vector<Value> values(k);
-        for (size_t i = 0; i < k; ++i) {
-          values[i] = filtration(i, 0);
-        }
-        return nb::cast(owned_array<Value>(std::move(values), {k}));
-      }
-      return nb::cast(view_array<Value>(&filtration(0, 0), {k}, owner));
-    }
-
-    std::vector<Value> values(k * 2);
-    for (size_t i = 0; i < k; ++i) {
-      values[2 * i] = filtration(i, 0);
-      values[2 * i + 1] = static_cast<Value>(i);
-    }
-    return nb::cast(owned_array<Value>(std::move(values), {k, size_t(2)}));
-  } else if constexpr (IsKCritical) {
-    size_t k = filtration.num_generators();
-    size_t p = filtration.num_parameters();
-    nb::list out;
-    if (!filtration.is_finite()) {
-      for (size_t i = 0; i < k; ++i) {
-        out.append(filled_array<Value>(p, filtration(i, 0)));
-      }
-      return out;
-    }
-    for (size_t i = 0; i < k; ++i) {
-      if (copy) {
-        std::vector<Value> row(p);
-        for (size_t j = 0; j < p; ++j) {
-          row[j] = filtration(i, j);
-        }
-        out.append(owned_array<Value>(std::move(row), {p}));
-      } else {
-        out.append(view_array<Value>(&filtration(i, 0), {p}, owner));
-      }
-    }
-    return out;
-  } else {
-    size_t p = filtration.num_parameters();
-    if (!filtration.is_finite()) {
-      return nb::cast(filled_array<Value>(p, filtration(0, 0)));
-    }
-    if (copy) {
-      std::vector<Value> row(p);
-      std::memcpy(row.data(), &filtration(0, 0), p * sizeof(Value));
-      return nb::cast(owned_array<Value>(std::move(row), {p}));
-    }
-    return nb::cast(view_array<Value>(&filtration(0, 0), {p}, owner));
-  }
-}
-
-template <typename Wrapper, typename Value, bool IsKCritical, bool IsDegreeRips>
-nb::object pack_filtrations(Wrapper& self, bool raw) {
-  auto& filtrations = self.truc.get_filtration_values();
-  size_t num_stuff = filtrations.size();
-  std::vector<int64_t> indptr;
-  indptr.resize(num_stuff + 1, 0);
-
-  if constexpr (!IsKCritical) {
-    throw std::runtime_error("packed=True is only available for k-critical filtrations.");
-  } else if constexpr (IsDegreeRips) {
-    size_t total = 0;
-    {
-      nb::gil_scoped_release release;
-      for (size_t i = 0; i < num_stuff; ++i) {
-        total += filtrations[i].num_generators();
-        indptr[i + 1] = static_cast<int64_t>(total);
-      }
-    }
-    auto indptr_arr = owned_array<int64_t>(std::move(indptr), {num_stuff + 1});
-    if (raw) {
-      std::vector<Value> grades(total);
-      {
-        nb::gil_scoped_release release;
-        size_t offset = 0;
-        for (size_t i = 0; i < num_stuff; ++i) {
-          size_t k = filtrations[i].num_generators();
-          for (size_t g = 0; g < k; ++g) {
-            grades[offset + g] = filtrations[i](g, 0);
-          }
-          offset += k;
-        }
-      }
-      return nb::make_tuple(indptr_arr, owned_array<Value>(std::move(grades), {total}));
-    }
-    std::vector<Value> grades(total * 2);
-    {
-      nb::gil_scoped_release release;
-      size_t offset = 0;
-      for (size_t i = 0; i < num_stuff; ++i) {
-        size_t k = filtrations[i].num_generators();
-        for (size_t g = 0; g < k; ++g) {
-          grades[2 * (offset + g)] = filtrations[i](g, 0);
-          grades[2 * (offset + g) + 1] = static_cast<Value>(g);
-        }
-        offset += k;
-      }
-    }
-    return nb::make_tuple(indptr_arr, owned_array<Value>(std::move(grades), {total, size_t(2)}));
-  } else {
-    size_t total = 0;
-    size_t num_parameters = self.truc.get_number_of_parameters();
-    {
-      nb::gil_scoped_release release;
-      for (size_t i = 0; i < num_stuff; ++i) {
-        total += filtrations[i].num_generators();
-        indptr[i + 1] = static_cast<int64_t>(total);
-      }
-    }
-    std::vector<Value> grades(total * num_parameters);
-    {
-      nb::gil_scoped_release release;
-      size_t offset = 0;
-      for (size_t i = 0; i < num_stuff; ++i) {
-        size_t k = filtrations[i].num_generators();
-        for (size_t g = 0; g < k; ++g) {
-          for (size_t p = 0; p < num_parameters; ++p) {
-            grades[(offset + g) * num_parameters + p] = filtrations[i](g, p);
-          }
-        }
-        offset += k;
-      }
-    }
-    return nb::make_tuple(owned_array<int64_t>(std::move(indptr), {num_stuff + 1}),
-                          owned_array<Value>(std::move(grades), {total, num_parameters}));
-  }
-}
-
-template <typename Wrapper, typename Value, bool IsKCritical, bool IsDegreeRips>
-nb::object copy_filtrations(Wrapper& self, bool raw) {
-  auto& filtrations = self.truc.get_filtration_values();
-  size_t num_stuff = filtrations.size();
-
-  if constexpr (!IsKCritical && !IsDegreeRips) {
-    size_t num_parameters = self.truc.get_number_of_parameters();
-    std::vector<Value> out(num_stuff * num_parameters);
-    {
-      nb::gil_scoped_release release;
-      for (size_t i = 0; i < num_stuff; ++i) {
-        if (!filtrations[i].is_finite()) {
-          std::fill_n(out.data() + i * num_parameters, num_parameters, filtrations[i](0, 0));
-        } else if (num_parameters > 0) {
-          std::memcpy(out.data() + i * num_parameters, &filtrations[i](0, 0), num_parameters * sizeof(Value));
-        }
-      }
-    }
-    return nb::cast(owned_array<Value>(std::move(out), {num_stuff, num_parameters}));
-  } else if constexpr (IsDegreeRips) {
-    std::vector<std::vector<Value>> copied(num_stuff);
-    {
-      nb::gil_scoped_release release;
-      for (size_t i = 0; i < num_stuff; ++i) {
-        size_t k = filtrations[i].num_generators();
-        if (raw) {
-          copied[i].resize(k);
-          for (size_t g = 0; g < k; ++g) {
-            copied[i][g] = filtrations[i](g, 0);
-          }
-        } else {
-          copied[i].resize(k * 2);
-          for (size_t g = 0; g < k; ++g) {
-            copied[i][2 * g] = filtrations[i](g, 0);
-            copied[i][2 * g + 1] = static_cast<Value>(g);
-          }
-        }
-      }
-    }
-    nb::list out;
-    for (size_t i = 0; i < num_stuff; ++i) {
-      if (raw) {
-        out.append(owned_array<Value>(std::move(copied[i]), {copied[i].size()}));
-      } else {
-        out.append(owned_array<Value>(std::move(copied[i]), {copied[i].size() / 2, size_t(2)}));
-      }
-    }
-    return out;
-  } else {
-    std::vector<std::vector<Value>> copied(num_stuff);
-    std::vector<size_t> ks(num_stuff, 0);
-    std::vector<size_t> ps(num_stuff, 0);
-    {
-      nb::gil_scoped_release release;
-      for (size_t i = 0; i < num_stuff; ++i) {
-        auto& filtration = filtrations[i];
-        size_t k = filtration.num_generators();
-        size_t p = filtration.num_parameters();
-        ks[i] = k;
-        ps[i] = p;
-        copied[i].resize(k * p);
-        if (!filtration.is_finite()) {
-          for (size_t g = 0; g < k; ++g) {
-            std::fill_n(copied[i].data() + g * p, p, filtration(g, 0));
-          }
-        } else {
-          for (size_t g = 0; g < k; ++g) {
-            for (size_t j = 0; j < p; ++j) {
-              copied[i][g * p + j] = filtration(g, j);
-            }
-          }
-        }
-      }
-    }
-    nb::list out;
-    for (size_t i = 0; i < num_stuff; ++i) {
-      out.append(owned_array<Value>(std::move(copied[i]), {ks[i], ps[i]}));
-    }
-    return out;
-  }
-}
-
-template <typename Wrapper, typename Value, bool IsKCritical, bool IsDegreeRips>
-nb::ndarray<nb::numpy, Value> filtration_values_array(Wrapper& self) {
-  auto& filtrations = self.truc.get_filtration_values();
-  size_t num_parameters = self.truc.get_number_of_parameters();
-  size_t total = 0;
-  {
-    nb::gil_scoped_release release;
-    for (size_t i = 0; i < filtrations.size(); ++i) {
-      total += filtrations[i].num_generators();
-    }
-  }
-
-  std::vector<Value> out;
-  if constexpr (IsDegreeRips) {
-    out.resize(total * 2);
-    {
-      nb::gil_scoped_release release;
-      size_t offset = 0;
-      for (size_t i = 0; i < filtrations.size(); ++i) {
-        for (size_t g = 0; g < filtrations[i].num_generators(); ++g) {
-          out[2 * (offset + g)] = filtrations[i](g, 0);
-          out[2 * (offset + g) + 1] = static_cast<Value>(g);
-        }
-        offset += filtrations[i].num_generators();
-      }
-    }
-    return owned_array<Value>(std::move(out), {total, size_t(2)});
-  } else {
-    out.resize(total * num_parameters);
-    {
-      nb::gil_scoped_release release;
-      size_t offset = 0;
-      for (size_t i = 0; i < filtrations.size(); ++i) {
-        for (size_t g = 0; g < filtrations[i].num_generators(); ++g) {
-          for (size_t p = 0; p < num_parameters; ++p) {
-            out[(offset + g) * num_parameters + p] = filtrations[i](g, p);
-          }
-        }
-        offset += filtrations[i].num_generators();
-      }
-    }
-    return owned_array<Value>(std::move(out), {total, num_parameters});
-  }
-}
-
-template <typename Wrapper, typename Value, bool IsDegreeRips>
-Wrapper& normalize_filtrations_inplace(Wrapper& self, nb::object box_obj) {
-  if constexpr (IsDegreeRips) {
-    throw nb::type_error("Degree-Rips slicers cannot be affinely normalized in-place.");
-  } else if constexpr (!std::is_floating_point_v<Value>) {
-    throw nb::type_error("normalize_filtrations requires a floating-point dtype for unsqueezed slicers.");
-  } else {
-    const size_t num_parameters = self.truc.get_number_of_parameters();
-    std::vector<double> lower(num_parameters, std::numeric_limits<double>::infinity());
-    std::vector<double> upper(num_parameters, -std::numeric_limits<double>::infinity());
-
-    if (!box_obj.is_none()) {
-      auto box = cast_matrix<double>(box_obj);
-      if (box.size() != 2 || box[0].size() != num_parameters || box[1].size() != num_parameters) {
-        throw nb::value_error("box must have shape (2, num_parameters).");
-      }
-      lower = std::move(box[0]);
-      upper = std::move(box[1]);
-    }
-
-    {
-      nb::gil_scoped_release release;
-      auto& filtrations = self.truc.get_filtration_values();
-      if (box_obj.is_none()) {
-        std::vector<bool> has_finite(num_parameters, false);
-        for (auto& filtration : filtrations) {
-          for (size_t g = 0; g < filtration.num_generators(); ++g) {
-            for (size_t p = 0; p < num_parameters; ++p) {
-              const double value = static_cast<double>(filtration(g, p));
-              if (!std::isfinite(value)) {
-                continue;
-              }
-              lower[p] = std::min(lower[p], value);
-              upper[p] = std::max(upper[p], value);
-              has_finite[p] = true;
-            }
-          }
-        }
-        for (size_t p = 0; p < num_parameters; ++p) {
-          if (!has_finite[p]) {
-            lower[p] = 0.0;
-            upper[p] = 1.0;
-          }
-        }
-      }
-
-      std::vector<double> scale(num_parameters, 1.0);
-      for (size_t p = 0; p < num_parameters; ++p) {
-        if (upper[p] < lower[p]) {
-          throw std::invalid_argument("box upper corner must be coordinatewise >= lower corner.");
-        }
-        if (upper[p] > lower[p]) {
-          scale[p] = upper[p] - lower[p];
-        }
-      }
-
-      for (auto& filtration : filtrations) {
-        for (size_t g = 0; g < filtration.num_generators(); ++g) {
-          for (size_t p = 0; p < num_parameters; ++p) {
-            const double value = static_cast<double>(filtration(g, p));
-            if (std::isfinite(value)) {
-              filtration(g, p) = static_cast<Value>((value - lower[p]) / scale[p]);
-            }
-          }
-        }
-      }
-    }
-    return self;
-  }
-}
-
-template <typename TargetWrapper, typename TargetConcrete>
-bool try_copy_from_existing(TargetWrapper& self, const nb::handle& source) {
-  if (!has_slicer_template_id(source)) {
-    return false;
-  }
-  visit_const_slicer_wrapper(source, [&]<typename D>(const typename D::wrapper& other) {
-    {
-      nb::gil_scoped_release release;
-      self.truc = SlicerConversion<TargetConcrete, typename D::concrete>::run(other.truc);
-    }
-    validate_slicer_if_needed(self.truc);
-    copy_slicer_python_state(self, other);
-  });
-  return true;
-}
-
-template <typename TargetDesc, typename SourceDesc>
-typename TargetDesc::wrapper construct_from_slicer_wrapper(const typename SourceDesc::wrapper& source) {
-  using Wrapper = typename TargetDesc::wrapper;
-  using Concrete = typename TargetDesc::concrete;
-  Wrapper out;
-  {
-    nb::gil_scoped_release release;
-    out.truc = SlicerConversion<Concrete, typename SourceDesc::concrete>::run(source.truc);
-  }
-  validate_slicer_if_needed(out.truc);
-  copy_slicer_python_state(out, source);
-  return out;
-}
-
-template <typename TargetDesc, typename SourceDesc>
-typename TargetDesc::wrapper construct_from_simplextree_wrapper(simplextree_wrapper_t<SourceDesc>& source) {
-  using Wrapper = typename TargetDesc::wrapper;
-  using Concrete = typename TargetDesc::concrete;
-  Wrapper out;
-  build_from_simplextree_desc<SourceDesc, Wrapper, Concrete>(out, source);
-  return out;
-}
-
-template <typename TargetDesc, typename Class, typename... SourceDesc>
-void bind_slicer_source_constructors(Class& cls, type_list<SourceDesc...>) {
-  (cls.def(nb::new_([](const typename SourceDesc::wrapper& source) {
-             return construct_from_slicer_wrapper<TargetDesc, SourceDesc>(source);
-           }),
-           "source"_a),
-   ...);
-}
-
-template <typename TargetDesc, typename Class, typename... SourceDesc>
-void bind_simplextree_source_constructors(Class& cls, type_list<SourceDesc...>) {
-  (cls.def(nb::new_([](simplextree_wrapper_t<SourceDesc>& source) {
-             return construct_from_simplextree_wrapper<TargetDesc, SourceDesc>(source);
-           }),
-           "source"_a),
-   ...);
-}
-
-template <typename TargetDesc, typename Class>
-void bind_typed_source_constructors(Class& cls) {
-  bind_slicer_source_constructors<TargetDesc>(cls, SlicerDescriptorList{});
-  bind_simplextree_source_constructors<TargetDesc>(cls, SimplexTreeDescriptorList{});
-}
-
-template <typename Wrapper, typename Concrete>
-Wrapper construct_from_scc_file(const std::string& path, int shift_dimension) {
-  Wrapper out;
-  {
-    nb::gil_scoped_release release;
-    out.truc = Gudhi::multi_persistence::build_slicer_from_scc_file<Concrete>(path, false, false, shift_dimension);
-  }
-  validate_slicer_if_needed(out.truc);
-  reset_slicer_python_state(out);
-  return out;
-}
-
-template <typename Filtration>
-std::vector<std::vector<typename Filtration::value_type>> sorted_generators(const Filtration& filtration) {
-  using Value = typename Filtration::value_type;
-  std::vector<std::vector<Value>> out(filtration.num_generators(), std::vector<Value>(filtration.num_parameters()));
-  for (size_t g = 0; g < filtration.num_generators(); ++g) {
-    for (size_t p = 0; p < filtration.num_parameters(); ++p) {
-      out[g][p] = filtration(g, p);
-    }
-  }
-  std::sort(out.begin(), out.end());
-  return out;
-}
-
-template <typename Wrapper>
-std::vector<std::vector<int64_t>> collect_used_squeezed_coordinates(const Wrapper& self) {
-  const size_t num_parameters = static_cast<size_t>(self.truc.get_number_of_parameters());
-  std::vector<std::vector<int64_t>> used_coordinates(num_parameters);
-  const auto& filtrations = self.truc.get_filtration_values();
-  for (const auto& filtration : filtrations) {
-    for (size_t generator = 0; generator < filtration.num_generators(); ++generator) {
-      for (size_t parameter = 0; parameter < num_parameters; ++parameter) {
-        used_coordinates[parameter].push_back(
-            squeezed_raw_index_from_value(static_cast<double>(filtration(generator, parameter)), parameter));
-      }
-    }
-  }
-  return used_coordinates;
-}
-
-template <typename Wrapper, typename Value>
-Wrapper& clean_squeezed_filtration_grid_inplace(Wrapper& self) {
-  if (!has_nonempty_filtration_grid(self.filtration_grid)) {
-    throw std::runtime_error("No grid to clean.");
-  }
-  auto compacted = compact_squeezed_filtration_grid(self.filtration_grid, collect_used_squeezed_coordinates(self));
-  auto coordinate_grid = cast_squeezed_coordinate_grid<Value>(compacted.coordinates);
-  {
-    nb::gil_scoped_release release;
-    self.truc.coarsen_on_grid(coordinate_grid, true);
-  }
-  self.filtration_grid = compacted.filtration_grid;
-  return self;
-}
-
-inline std::optional<std::vector<std::vector<double>>> logical_filtration_grid(const nb::handle& grid) {
-  if (is_none_or_empty(grid)) {
-    return std::nullopt;
-  }
-  std::vector<std::vector<double>> out;
-  out.reserve((size_t)nb::len(grid));
-  for (nb::handle row_handle : nb::iter(grid)) {
-    out.push_back(cast_vector<double>(row_handle));
-  }
-  return out;
-}
-
-template <typename RawValue>
-double logical_filtration_coordinate(const RawValue& raw_value,
-                                     const std::optional<std::vector<std::vector<double>>>& grid,
-                                     size_t parameter) {
-  if (!grid) {
-    return static_cast<double>(raw_value);
-  }
-  if (parameter >= grid->size()) {
-    throw std::runtime_error("Filtration grid has fewer parameters than the slicer.");
-  }
-
-  const auto& row = (*grid)[parameter];
-  if (row.empty()) {
-    return std::numeric_limits<double>::infinity();
-  }
-
-  long long index = static_cast<long long>(raw_value);
-  if (index < 0) {
-    index += static_cast<long long>(row.size());
-  }
-  if (index < 0 || index >= static_cast<long long>(row.size())) {
-    return std::numeric_limits<double>::infinity();
-  }
-  return row[(size_t)index];
-}
-
-template <typename Filtration>
-std::vector<std::vector<double>> sorted_logical_generators(
-    const Filtration& filtration,
-    const std::optional<std::vector<std::vector<double>>>& grid) {
-  std::vector<std::vector<double>> out(filtration.num_generators(), std::vector<double>(filtration.num_parameters()));
-  for (size_t g = 0; g < filtration.num_generators(); ++g) {
-    for (size_t p = 0; p < filtration.num_parameters(); ++p) {
-      out[g][p] = logical_filtration_coordinate(filtration(g, p), grid, p);
-    }
-  }
-  std::sort(out.begin(), out.end());
-  return out;
-}
-
-template <typename Filtration>
-bool equal_logical_filtration(const Filtration& lhs,
-                              const std::optional<std::vector<std::vector<double>>>& lhs_grid,
-                              const Filtration& rhs,
-                              const std::optional<std::vector<std::vector<double>>>& rhs_grid) {
-  if (lhs.num_parameters() != rhs.num_parameters() || lhs.num_generators() != rhs.num_generators()) {
-    return false;
-  }
-  for (size_t g = 0; g < lhs.num_generators(); ++g) {
-    for (size_t p = 0; p < lhs.num_parameters(); ++p) {
-      if (logical_filtration_coordinate(lhs(g, p), lhs_grid, p) !=
-          logical_filtration_coordinate(rhs(g, p), rhs_grid, p)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-template <typename Concrete>
-bool equal_kcritical_filtrations(const Concrete& lhs, const Concrete& rhs) {
-  const auto& lhs_filtrations = lhs.get_filtration_values();
-  const auto& rhs_filtrations = rhs.get_filtration_values();
-  if (lhs_filtrations.size() != rhs_filtrations.size()) {
-    return false;
-  }
-  for (size_t i = 0; i < lhs_filtrations.size(); ++i) {
-    if (lhs_filtrations[i].num_parameters() != rhs_filtrations[i].num_parameters() ||
-        lhs_filtrations[i].num_generators() != rhs_filtrations[i].num_generators()) {
-      return false;
-    }
-    if (sorted_generators(lhs_filtrations[i]) != sorted_generators(rhs_filtrations[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-template <typename Concrete>
-bool equal_kcritical_filtrations(const Concrete& lhs,
-                                 const std::optional<std::vector<std::vector<double>>>& lhs_grid,
-                                 const Concrete& rhs,
-                                 const std::optional<std::vector<std::vector<double>>>& rhs_grid) {
-  const auto& lhs_filtrations = lhs.get_filtration_values();
-  const auto& rhs_filtrations = rhs.get_filtration_values();
-  if (lhs_filtrations.size() != rhs_filtrations.size()) {
-    return false;
-  }
-  for (size_t i = 0; i < lhs_filtrations.size(); ++i) {
-    if (lhs_filtrations[i].num_parameters() != rhs_filtrations[i].num_parameters() ||
-        lhs_filtrations[i].num_generators() != rhs_filtrations[i].num_generators()) {
-      return false;
-    }
-    if (sorted_logical_generators(lhs_filtrations[i], lhs_grid) !=
-        sorted_logical_generators(rhs_filtrations[i], rhs_grid)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-template <typename Wrapper, typename Concrete, bool IsKCritical>
-bool wrapper_equals(Wrapper& self, const nb::handle& other) {
-  if (!other.is_valid() || other.is_none()) {
-    return false;
-  }
-
-  Wrapper rhs;
-  if (!try_copy_from_existing<Wrapper, Concrete>(rhs, other)) {
-    return false;
-  }
-  if (self.truc.get_dimensions() != rhs.truc.get_dimensions()) {
-    return false;
-  }
-  if (self.truc.get_boundaries() != rhs.truc.get_boundaries()) {
-    return false;
-  }
-
-  auto lhs_grid = logical_filtration_grid(self.filtration_grid);
-  auto rhs_grid = logical_filtration_grid(rhs.filtration_grid);
-  if (!lhs_grid && !rhs_grid) {
-    if constexpr (IsKCritical) {
-      return equal_kcritical_filtrations(self.truc, rhs.truc);
-    } else {
-      return self.truc.get_filtration_values() == rhs.truc.get_filtration_values();
-    }
-  }
-
-  if constexpr (IsKCritical) {
-    return equal_kcritical_filtrations(self.truc, lhs_grid, rhs.truc, rhs_grid);
-  } else {
-    const auto& lhs_filtrations = self.truc.get_filtration_values();
-    const auto& rhs_filtrations = rhs.truc.get_filtration_values();
-    if (lhs_filtrations.size() != rhs_filtrations.size()) {
-      return false;
-    }
-    for (size_t i = 0; i < lhs_filtrations.size(); ++i) {
-      if (!equal_logical_filtration(lhs_filtrations[i], lhs_grid, rhs_filtrations[i], rhs_grid)) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
-
-template <typename Wrapper>
-multipers::nanobind_helpers::GeneratorBasisData extract_generator_basis(const Wrapper& self) {
-  return multipers::nanobind_helpers::generator_basis_from_object(self.generator_basis);
-}
-
-inline std::vector<std::vector<uint32_t>> expand_cycle_in_generator_basis(
-    const std::vector<uint32_t>& cycle,
-    const multipers::nanobind_helpers::GeneratorBasisData& basis) {
-  std::unordered_set<uint32_t> active_rows;
-  for (uint32_t generator_idx : cycle) {
-    if (generator_idx >= basis.columns.size()) {
-      throw std::runtime_error("Representative cycle refers to a generator outside `_generator_basis`.");
-    }
-    for (uint32_t row_idx : basis.columns[generator_idx]) {
-      if (row_idx >= basis.row_boundaries.size()) {
-        throw std::runtime_error("`_generator_basis` column support refers to a row outside `row_boundaries`.");
-      }
-      auto [it, inserted] = active_rows.insert(row_idx);
-      if (!inserted) {
-        active_rows.erase(it);
-      }
-    }
-  }
-
-  std::vector<uint32_t> rows(active_rows.begin(), active_rows.end());
-  std::sort(rows.begin(), rows.end());
-  std::vector<std::vector<uint32_t>> out;
-  out.reserve(rows.size());
-  for (uint32_t row_idx : rows) {
-    out.push_back(basis.row_boundaries[row_idx]);
-  }
-  return out;
-}
-
-inline std::vector<uint32_t> expand_cycle_cell_ids_in_generator_basis(
-    const std::vector<uint32_t>& cycle,
-    const multipers::nanobind_helpers::GeneratorBasisData& basis) {
-  if (basis.row_cell_indices.size() != basis.row_boundaries.size()) {
-    throw std::runtime_error(
-        "`_generator_basis` does not contain complete `row_cell_indices`; "
-        "use `expand_generator_basis=False` or rebuild it with the current Multipers version.");
-  }
-
-  std::unordered_set<uint32_t> active_rows;
-  for (uint32_t generator_idx : cycle) {
-    if (generator_idx >= basis.columns.size()) {
-      throw std::runtime_error("Representative cycle refers to a generator outside `_generator_basis`.");
-    }
-    for (uint32_t row_idx : basis.columns[generator_idx]) {
-      if (row_idx >= basis.row_cell_indices.size()) {
-        throw std::runtime_error("`_generator_basis` column support refers to a row outside `row_cell_indices`.");
-      }
-      auto [it, inserted] = active_rows.insert(row_idx);
-      if (!inserted) {
-        active_rows.erase(it);
-      }
-    }
-  }
-
-  std::vector<uint32_t> out;
-  out.reserve(active_rows.size());
-  for (uint32_t row_idx : active_rows) {
-    out.push_back(basis.row_cell_indices[row_idx]);
-  }
-  std::sort(out.begin(), out.end());
-  if (std::adjacent_find(out.begin(), out.end()) != out.end()) {
-    throw std::runtime_error("`_generator_basis.row_cell_indices` must identify distinct source cells.");
-  }
-  return out;
-}
-
-inline bool is_generator_basis_key(std::string_view key) {
-  return key == "degree" || key == "columns" || key == "row_boundaries" || key == "row_grades" ||
-         key == "column_grades" || key == "row_cell_indices";
-}
-
-inline nb::object generator_basis_value_for_key(const multipers::nanobind_helpers::GeneratorBasisData& self,
-                                                std::string_view key) {
-  if (key == "degree") {
-    return nb::cast(self.degree);
-  }
-  if (key == "columns") {
-    return nb::cast(self.columns);
-  }
-  if (key == "row_boundaries") {
-    return nb::cast(self.row_boundaries);
-  }
-  if (key == "row_grades") {
-    return nb::cast(self.row_grades);
-  }
-  if (key == "column_grades") {
-    return nb::cast(self.column_grades);
-  }
-  if (key == "row_cell_indices") {
-    return nb::cast(self.row_cell_indices);
-  }
-  throw nb::key_error("Invalid `_GeneratorBasis` key.");
-}
-
-inline void bind_generator_basis(nb::module_& m) {
-  using GeneratorBasisData = multipers::nanobind_helpers::GeneratorBasisData;
-
-  nb::class_<GeneratorBasisData>(m, "_GeneratorBasis")
-      .def(nb::init<int,
-                    std::vector<std::vector<uint32_t>>,
-                    std::vector<std::vector<uint32_t>>,
-                    std::vector<std::pair<double, double>>,
-                    std::vector<std::pair<double, double>>,
-                    std::vector<uint32_t>>(),
-           "degree"_a,
-           "columns"_a,
-           "row_boundaries"_a,
-           "row_grades"_a = std::vector<std::pair<double, double>>{},
-           "column_grades"_a = std::vector<std::pair<double, double>>{},
-           "row_cell_indices"_a = std::vector<uint32_t>{})
-      .def_prop_ro("degree", [](const GeneratorBasisData& self) { return self.degree; })
-      .def_prop_ro("columns", [](const GeneratorBasisData& self) { return self.columns; })
-      .def_prop_ro("row_boundaries", [](const GeneratorBasisData& self) { return self.row_boundaries; })
-      .def_prop_ro("row_grades", [](const GeneratorBasisData& self) { return self.row_grades; })
-      .def_prop_ro("column_grades", [](const GeneratorBasisData& self) { return self.column_grades; })
-      .def_prop_ro("row_cell_indices", [](const GeneratorBasisData& self) { return self.row_cell_indices; })
-      .def("__getitem__",
-           [](const GeneratorBasisData& self, const std::string& key) {
-             return generator_basis_value_for_key(self, key);
-           })
-      .def("__contains__",
-           [](const GeneratorBasisData&, const std::string& key) { return is_generator_basis_key(key); })
-      .def("keys",
-           [](const GeneratorBasisData&) {
-             return nb::make_tuple(
-                 "degree", "columns", "row_boundaries", "row_grades", "column_grades", "row_cell_indices");
-           })
-      .def("__reduce__",
-           [](const GeneratorBasisData& self) {
-             return nb::make_tuple(nb::borrow<nb::object>(nb::type<GeneratorBasisData>()),
-                                   nb::make_tuple(self.degree,
-                                                  self.columns,
-                                                  self.row_boundaries,
-                                                  self.row_grades,
-                                                  self.column_grades,
-                                                  self.row_cell_indices));
-           })
-      .def("__repr__", [](const GeneratorBasisData& self) {
-        return "_GeneratorBasis(degree=" + std::to_string(self.degree) +
-               ", columns=" + std::to_string(self.columns.size()) +
-               ", row_boundaries=" + std::to_string(self.row_boundaries.size()) +
-               ", row_cell_indices=" + std::to_string(self.row_cell_indices.size()) + ")";
-      });
-}
-
-template <typename Wrapper, typename Concrete, typename Value, bool IsKCritical>
-Wrapper construct_from_generator_data(nb::object generator_maps,
-                                      nb::object generator_dimensions,
-                                      nb::object filtration_values) {
-  Wrapper out;
-  if (is_none_or_empty(generator_maps)) {
-    return out;
-  }
-
-  std::vector<std::vector<uint32_t>> boundaries;
-  boundaries.reserve(nb::len(generator_maps));
-  for (nb::handle row_handle : nb::iter(generator_maps)) {
-    boundaries.push_back(cast_vector<uint32_t>(row_handle));
-  }
-
-  auto dims = cast_vector<int>(generator_dimensions);
-  if (boundaries.size() != dims.size()) {
-    throw std::runtime_error("Invalid input, shape do not coincide.");
-  }
-
-  std::vector<typename Concrete::Filtration_value> c_filtrations;
-  c_filtrations.reserve(boundaries.size());
-
-  if constexpr (IsKCritical) {
-    std::vector<std::vector<std::vector<Value>>> py_filtrations;
-    py_filtrations.reserve(nb::len(filtration_values));
-    for (nb::handle rows_handle : nb::iter(filtration_values)) {
-      py_filtrations.push_back(cast_matrix<Value>(rows_handle));
-    }
-    if (py_filtrations.size() != boundaries.size()) {
-      throw std::runtime_error("Invalid input, shape do not coincide.");
-    }
-    size_t num_parameters = 0;
-    if (!py_filtrations.empty() && !py_filtrations[0].empty()) {
-      num_parameters = py_filtrations[0][0].size();
-    }
-    for (const auto& rows : py_filtrations) {
-      typename Concrete::Filtration_value filtration(num_parameters);
-      auto inf = Concrete::Filtration_value::inf(num_parameters);
-      filtration.push_to_least_common_upper_bound(inf, false);
-      for (const auto& row : rows) {
-        filtration.add_generator(row);
-      }
-      c_filtrations.push_back(std::move(filtration));
-    }
-  } else {
-    auto py_filtrations = cast_matrix<Value>(filtration_values);
-    if (py_filtrations.size() != boundaries.size()) {
-      throw std::runtime_error("Invalid input, shape do not coincide.");
-    }
-    for (const auto& row : py_filtrations) {
-      c_filtrations.emplace_back(row);
-    }
-  }
-
-  Gudhi::multi_persistence::Multi_parameter_filtered_complex<typename Concrete::Filtration_value> cpx(
-      std::move(boundaries), std::move(dims), std::move(c_filtrations));
-  validate_complex_if_needed<Concrete>(cpx);
-  out.truc = Concrete(std::move(cpx));
-  reset_slicer_python_state(out);
-  return out;
-}
-
-inline std::vector<std::vector<uint32_t>> boundaries_from_generator_maps(const nb::handle& generator_maps) {
-  std::vector<std::vector<uint32_t>> boundaries;
-  boundaries.reserve(nb::len(generator_maps));
-  for (nb::handle row_handle : nb::iter(generator_maps)) {
-    boundaries.push_back(cast_vector<uint32_t>(row_handle));
-  }
-  return boundaries;
-}
-
-template <typename Wrapper, typename Concrete, typename Value, typename Index>
-Wrapper construct_from_dense_generator_data(nb::iterable generator_maps,
-                                            nb::ndarray<nb::numpy, const Index, nb::ndim<1>> generator_dimensions,
-                                            nb::ndarray<nb::numpy, const Value, nb::ndim<2>> filtration_values) {
-  Wrapper out;
-  if (nb::len(generator_maps) == 0) {
-    return out;
-  }
-
-  auto boundaries = boundaries_from_generator_maps(generator_maps);
-  const size_t num_generators = boundaries.size();
-  if (generator_dimensions.shape(0) != num_generators || filtration_values.shape(0) != num_generators) {
-    throw std::runtime_error("Invalid input, shape do not coincide.");
-  }
-
-  std::vector<int> dims;
-  dims.reserve(num_generators);
-  for (size_t i = 0; i < num_generators; ++i) {
-    dims.push_back((int)generator_dimensions(i));
-  }
-
-  std::vector<typename Concrete::Filtration_value> c_filtrations;
-  c_filtrations.reserve(num_generators);
-  const auto view = filtration_values.view();
-  const size_t num_parameters = filtration_values.shape(1);
-  for (size_t i = 0; i < num_generators; ++i) {
-    std::vector<Value> row(num_parameters);
-    for (size_t p = 0; p < num_parameters; ++p) {
-      row[p] = view(i, p);
-    }
-    c_filtrations.emplace_back(row);
-  }
-
-  Gudhi::multi_persistence::Multi_parameter_filtered_complex<typename Concrete::Filtration_value> cpx(
-      std::move(boundaries), std::move(dims), std::move(c_filtrations));
-  validate_complex_if_needed<Concrete>(cpx);
-  out.truc = Concrete(std::move(cpx));
-  reset_slicer_python_state(out);
-  return out;
-}
-
-template <typename Class, typename Wrapper, typename Concrete, typename Value, bool IsKCritical, typename Index>
-void bind_dense_generator_data_overloads(Class& cls) {
-  if constexpr (!IsKCritical) {
-    cls.def(nb::new_([](nb::iterable generator_maps,
-                        nb::ndarray<nb::numpy, const Index, nb::ndim<1>> generator_dimensions,
-                        nb::ndarray<nb::numpy, const Value, nb::ndim<2>> filtration_values) {
-              return construct_from_dense_generator_data<Wrapper, Concrete, Value>(
-                  generator_maps, generator_dimensions, filtration_values);
-            }),
-            "generator_maps"_a,
-            "generator_dimensions"_a,
-            "filtration_values"_a);
-  }
-}
-
-template <typename Wrapper, typename Concrete, typename Value>
-void validate_packed_indptr(const int64_t* indptr, size_t indptr_size, size_t flat_size, const char* name) {
-  if (indptr_size == 0) {
-    return;
-  }
-  if (indptr[0] != 0) {
-    throw std::runtime_error(std::string(name) + " must start at 0.");
-  }
-  int64_t previous = 0;
-  for (size_t i = 1; i < indptr_size; ++i) {
-    const int64_t current = indptr[i];
-    if (current < previous) {
-      throw std::runtime_error(std::string(name) + " must be nondecreasing.");
-    }
-    previous = current;
-  }
-  if (previous < 0 || static_cast<size_t>(previous) > flat_size) {
-    throw std::runtime_error(std::string(name) + " exceeds packed data length.");
-  }
-}
-
-void validate_packed_boundaries(const int64_t* indptr,
-                                const int32_t* flat,
-                                const int32_t* dimensions,
-                                size_t num_generators) {
-  for (size_t cell = 0; cell < num_generators; ++cell) {
-    const int dimension = static_cast<int>(dimensions[cell]);
-    if (dimension < 0) {
-      throw std::runtime_error("generator_dimensions must be nonnegative.");
-    }
-    const int64_t begin = indptr[cell];
-    const int64_t end = indptr[cell + 1];
-    if (dimension == 0 && begin != end) {
-      throw std::runtime_error("0-dimensional generators must have empty boundaries.");
-    }
-    for (int64_t idx = begin; idx < end; ++idx) {
-      const int32_t boundary = flat[idx];
-      if (boundary < 0 || static_cast<size_t>(boundary) >= num_generators) {
-        throw std::runtime_error("boundary_flat contains an invalid generator index.");
-      }
-      if (static_cast<int>(dimensions[boundary]) != dimension - 1) {
-        throw std::runtime_error("boundary_flat contains a dimension-incompatible generator index.");
-      }
-    }
-  }
-}
-
-template <typename Wrapper, typename Concrete, typename Value>
-Wrapper construct_kcritical_from_packed(
-    nb::ndarray<nb::numpy, const int64_t, nb::ndim<1>, nb::c_contig> boundary_indptr,
-    nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> boundary_flat,
-    nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> generator_dimensions,
-    nb::ndarray<nb::numpy, const int64_t, nb::ndim<1>, nb::c_contig> grade_indptr,
-    nb::ndarray<nb::numpy, const double, nb::ndim<2>, nb::c_contig> grades_flat) {
-  if (boundary_indptr.shape(0) == 0) {
-    throw std::runtime_error("boundary_indptr must contain at least one offset.");
-  }
-  Wrapper out;
-
-  const size_t num_generators = (size_t)boundary_indptr.shape(0) - 1;
-  if ((size_t)generator_dimensions.shape(0) != num_generators || (size_t)grade_indptr.shape(0) != num_generators + 1) {
-    throw std::runtime_error("Invalid packed input, shape do not coincide.");
-  }
-  validate_packed_indptr<Wrapper, Concrete, Value>(
-      boundary_indptr.data(), boundary_indptr.shape(0), boundary_flat.shape(0), "boundary_indptr");
-  validate_packed_indptr<Wrapper, Concrete, Value>(
-      grade_indptr.data(), grade_indptr.shape(0), grades_flat.shape(0), "grade_indptr");
-  validate_packed_boundaries(boundary_indptr.data(), boundary_flat.data(), generator_dimensions.data(), num_generators);
-
-  std::vector<std::vector<uint32_t>> boundaries(num_generators);
-  const int64_t* boundary_ptr = boundary_indptr.data();
-  const int32_t* boundary_vals = boundary_flat.data();
-  for (size_t i = 0; i < num_generators; ++i) {
-    const int64_t begin = boundary_ptr[i];
-    const int64_t end = boundary_ptr[i + 1];
-    auto& row = boundaries[i];
-    row.reserve((size_t)std::max<int64_t>(end - begin, 0));
-    for (int64_t idx = begin; idx < end; ++idx) {
-      row.push_back((uint32_t)boundary_vals[idx]);
-    }
-  }
-
-  std::vector<int> dims;
-  dims.reserve(num_generators);
-  for (size_t i = 0; i < num_generators; ++i) {
-    dims.push_back((int)generator_dimensions(i));
-  }
-
-  const size_t num_parameters = grades_flat.shape(1);
-  std::vector<typename Concrete::Filtration_value> filtrations;
-  filtrations.reserve(num_generators);
-  const int64_t* grade_ptr = grade_indptr.data();
-  for (size_t i = 0; i < num_generators; ++i) {
-    typename Concrete::Filtration_value filtration(num_parameters);
-    auto inf = Concrete::Filtration_value::inf(num_parameters);
-    filtration.push_to_least_common_upper_bound(inf, false);
-    const int64_t begin = grade_ptr[i];
-    const int64_t end = grade_ptr[i + 1];
-    for (int64_t row = begin; row < end; ++row) {
-      std::vector<Value> grade(num_parameters);
-      for (size_t p = 0; p < num_parameters; ++p) {
-        grade[p] = static_cast<Value>(grades_flat((size_t)row, p));
-      }
-      filtration.add_generator(grade);
-    }
-    filtrations.push_back(std::move(filtration));
-  }
-
-  Gudhi::multi_persistence::Multi_parameter_filtered_complex<typename Concrete::Filtration_value> cpx(
-      std::move(boundaries), std::move(dims), std::move(filtrations));
-  validate_complex_if_needed<Concrete>(cpx);
-  out.truc = Concrete(std::move(cpx));
-  reset_slicer_python_state(out);
-  return out;
-}
-
-template <typename Wrapper, typename Concrete, typename Value>
-Wrapper construct_contiguous_from_packed(
-    nb::ndarray<nb::numpy, const int64_t, nb::ndim<1>, nb::c_contig> boundary_indptr,
-    nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> boundary_flat,
-    nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> generator_dimensions,
-    nb::ndarray<nb::numpy, const double, nb::ndim<2>, nb::c_contig> grades_flat) {
-  if (boundary_indptr.shape(0) == 0) {
-    throw std::runtime_error("boundary_indptr must contain at least one offset.");
-  }
-  Wrapper out;
-
-  const size_t num_generators = static_cast<size_t>(boundary_indptr.shape(0) - 1);
-  if (static_cast<size_t>(generator_dimensions.shape(0)) != num_generators ||
-      static_cast<size_t>(grades_flat.shape(0)) != num_generators) {
-    throw std::runtime_error("Invalid packed input, shape do not coincide.");
-  }
-  validate_packed_indptr<Wrapper, Concrete, Value>(
-      boundary_indptr.data(), boundary_indptr.shape(0), boundary_flat.shape(0), "boundary_indptr");
-  validate_packed_boundaries(boundary_indptr.data(), boundary_flat.data(), generator_dimensions.data(), num_generators);
-
-  std::vector<std::vector<uint32_t>> boundaries(num_generators);
-  const int64_t* boundary_ptr = boundary_indptr.data();
-  const int32_t* boundary_vals = boundary_flat.data();
-  for (size_t i = 0; i < num_generators; ++i) {
-    const int64_t begin = boundary_ptr[i];
-    const int64_t end = boundary_ptr[i + 1];
-    auto& row = boundaries[i];
-    row.reserve(static_cast<size_t>(std::max<int64_t>(end - begin, 0)));
-    for (int64_t idx = begin; idx < end; ++idx) {
-      row.push_back(static_cast<uint32_t>(boundary_vals[idx]));
-    }
-  }
-
-  std::vector<int> dims;
-  dims.reserve(num_generators);
-  for (size_t i = 0; i < num_generators; ++i) {
-    dims.push_back(static_cast<int>(generator_dimensions(i)));
-  }
-
-  std::vector<typename Concrete::Filtration_value> filtrations;
-  filtrations.reserve(num_generators);
-  const size_t num_parameters = grades_flat.shape(1);
-  for (size_t i = 0; i < num_generators; ++i) {
-    std::vector<Value> row(num_parameters);
-    for (size_t p = 0; p < num_parameters; ++p) {
-      row[p] = static_cast<Value>(grades_flat(i, p));
-    }
-    filtrations.emplace_back(std::move(row));
-  }
-
-  Gudhi::multi_persistence::Multi_parameter_filtered_complex<typename Concrete::Filtration_value> cpx(
-      std::move(boundaries), std::move(dims), std::move(filtrations));
-  validate_complex_if_needed<Concrete>(cpx);
-  out.truc = Concrete(std::move(cpx));
-  reset_slicer_python_state(out);
-  return out;
-}
-
-template <typename Desc, typename Class>
-void bind_grid_methods(Class& cls) {
-  if constexpr (Desc::has_grid_methods) {
-    using Wrapper = typename Desc::wrapper;
-    using Concrete = typename Desc::concrete;
-    using Value = typename Desc::value_type;
-    using TargetWrapper = typename Desc::coarsened_wrapper;
-
-    cls.def("coarsen_on_grid_copy",
-            [](Wrapper& self, std::vector<std::vector<Value>> grid) {
-              TargetWrapper out;
-              {
-                nb::gil_scoped_release release;
-                out.truc = build_slicer_coarsen_on_grid(self.truc, grid);
-              }
-              copy_slicer_python_state(out, self);
-              return out;
-            })
-        .def(
-            "compute_kernel_projective_cover",
-            [](Wrapper& self, nb::object dim_obj) {
-              if (!self.generator_basis.is_none()) {
-                throw nb::value_error(
-                    "compute_kernel_projective_cover does not transport `_generator_basis`; "
-                    "discard the basis explicitly before this transformation.");
-              }
-              Wrapper out;
-              if (self.truc.get_number_of_cycle_generators() == 0) {
-                copy_slicer_python_state(out, self);
-                return out;
-              }
-              int dim = dim_obj.is_none() ? self.truc.get_dimension(0) : nb::cast<int>(dim_obj);
-              {
-                nb::gil_scoped_release release;
-                out.truc = build_slicer_from_projective_cover_kernel(self.truc, dim);
-              }
-              copy_slicer_python_state(out, self);
-              return out;
-            },
-            "dim"_a = nb::none());
-  }
-}
-
-template <typename Desc, typename Class>
-void bind_vine_methods(Class& cls) {
-  if constexpr (Desc::is_vine) {
-    using Wrapper = typename Desc::wrapper;
-    using Value = typename Desc::value_type;
-
-    cls.def(
-        "vine_update",
-        [](Wrapper& self, nb::object basepoint, nb::object direction) -> Wrapper& {
-          std::vector<Value> bp = cast_vector<Value>(basepoint);
-          std::vector<Value> dir;
-          bool has_direction = !direction.is_none();
-          if (has_direction) {
-            dir = cast_vector<Value>(direction);
-          }
-          {
-            nb::gil_scoped_release release;
-            if (has_direction) {
-              self.truc.push_to(Gudhi::multi_persistence::Line<Value>(bp, dir));
-            } else {
-              self.truc.push_to(Gudhi::multi_persistence::Line<Value>(bp));
-            }
-            self.truc.update_persistence_computation();
-          }
-          return self;
-        },
-        "basepoint"_a,
-        "direction"_a = nb::none(),
-        nb::rv_policy::reference_internal);
-    using Persistence = typename Desc::concrete::Persistence;
-    if constexpr (Persistence::has_rep_cycles) {
-      cls.def(
-             "get_representative_cycles",
-             [](Wrapper& self, bool update, nb::object idx_obj, nb::object intersect_points_obj) {
-               std::vector<int64_t> requested;
-               bool filter_cycles = !idx_obj.is_none();
-               if (filter_cycles) {
-                 requested = cast_vector<int64_t>(idx_obj);
-               }
-               std::unordered_set<uint32_t> intersect_points;
-               const bool filter_points = !intersect_points_obj.is_none();
-               if (filter_points) {
-                 auto requested_points = cast_vector<uint32_t>(intersect_points_obj);
-                 intersect_points.insert(requested_points.begin(), requested_points.end());
-               }
-               multipers::nanobind_helpers::GeneratorBasisData generator_basis = extract_generator_basis(self);
-               if (filter_points && generator_basis.active && generator_basis.degree != 1) {
-                 throw nb::value_error("intersect_points with keep_generators is only supported in degree 1.");
-               }
-               std::vector<std::vector<std::vector<std::vector<uint32_t>>>> out_cpp;
-               std::vector<std::vector<uint8_t>> keep_mask;
-               {
-                 nb::gil_scoped_release release;
-                 auto cycle_idx = self.truc.get_representative_cycles(update);
-                 std::vector<std::vector<size_t>> selected_indices(cycle_idx.size());
-                 if (!filter_cycles) {
-                   for (size_t i = 0; i < cycle_idx.size(); ++i) {
-                     selected_indices[i].resize(cycle_idx[i].size());
-                     for (size_t j = 0; j < cycle_idx[i].size(); ++j) {
-                       selected_indices[i][j] = j;
-                     }
-                   }
-                 } else {
-                   std::vector<size_t> offsets(cycle_idx.size() + 1, 0);
-                   for (size_t i = 0; i < cycle_idx.size(); ++i) {
-                     offsets[i + 1] = offsets[i] + cycle_idx[i].size();
-                   }
-                   size_t total_cycles = offsets.back();
-                   for (int64_t raw_idx : requested) {
-                     int64_t normalized = raw_idx;
-                     if (normalized < 0) {
-                       normalized += static_cast<int64_t>(total_cycles);
-                     }
-                     if (normalized < 0 || normalized >= static_cast<int64_t>(total_cycles)) {
-                       throw nb::index_error("Representative cycle index out of range.");
-                     }
-                     size_t current = static_cast<size_t>(normalized);
-                     auto it = std::upper_bound(offsets.begin(), offsets.end(), current);
-                     size_t dim = static_cast<size_t>(std::distance(offsets.begin(), it) - 1);
-                     selected_indices[dim].push_back(current - offsets[dim]);
-                   }
-                 }
-                 out_cpp.resize(cycle_idx.size());
-                 keep_mask.resize(cycle_idx.size());
-                 for (size_t i = 0; i < cycle_idx.size(); ++i) {
-                   out_cpp[i].resize(selected_indices[i].size());
-                   keep_mask[i].assign(selected_indices[i].size(), 0);
-                 }
-                 multipers::core::RepresentativeCycleIntersection intersection(
-                     self.truc.get_boundaries(), self.truc.get_dimensions(), intersect_points);
-                 for (size_t i = 0; i < cycle_idx.size(); ++i) {
-                   const bool use_generator_basis =
-                       generator_basis.active && static_cast<int>(i) == generator_basis.degree;
-                   for (size_t j = 0; j < selected_indices[i].size(); ++j) {
-                     const auto& cycle = cycle_idx[i][selected_indices[i][j]];
-                     if (!filter_points) {
-                       keep_mask[i][j] = 1;
-                     } else if (!use_generator_basis && intersection.intersects(cycle)) {
-                       keep_mask[i][j] = 1;
-                     }
-                   }
-                 }
-                 tbb::parallel_for(size_t(0), cycle_idx.size(), [&](size_t i) {
-                   const bool use_generator_basis =
-                       generator_basis.active && static_cast<int>(i) == generator_basis.degree;
-                   for (size_t j = 0; j < selected_indices[i].size(); ++j) {
-                     size_t selected_idx = selected_indices[i][j];
-                     if (filter_points && !use_generator_basis && !keep_mask[i][j]) {
-                       continue;
-                     }
-                     if (!cycle_idx[i][selected_idx].empty()) {
-                       if (use_generator_basis) {
-                         out_cpp[i][j] = expand_cycle_in_generator_basis(cycle_idx[i][selected_idx], generator_basis);
-                       } else if (self.truc.get_boundary(cycle_idx[i][selected_idx][0]).empty()) {
-                         out_cpp[i][j] = {std::vector<uint32_t>{}};
-                       } else {
-                         out_cpp[i][j].resize(cycle_idx[i][selected_idx].size());
-                         for (size_t k = 0; k < cycle_idx[i][selected_idx].size(); ++k) {
-                           out_cpp[i][j][k] = self.truc.get_boundary(cycle_idx[i][selected_idx][k]);
-                         }
-                       }
-                       if (use_generator_basis &&
-                           (!filter_points ||
-                            multipers::core::vertex_boundaries_intersect_points(out_cpp[i][j], intersect_points))) {
-                         keep_mask[i][j] = 1;
-                       }
-                     }
-                   }
-                 });
-               }
-               nb::list out;
-               for (size_t i = 0; i < out_cpp.size(); ++i) {
-                 nb::list dim_cycles;
-                 for (size_t j = 0; j < out_cpp[i].size(); ++j) {
-                   if (!keep_mask[i][j]) {
-                     continue;
-                   }
-                   nb::list cycle;
-                   for (size_t k = 0; k < out_cpp[i][j].size(); ++k) {
-                     auto boundary = std::move(out_cpp[i][j][k]);
-                     cycle.append(owned_array<uint32_t>(std::move(boundary), {boundary.size()}));
-                   }
-                   dim_cycles.append(cycle);
-                 }
-                 out.append(dim_cycles);
-               }
-               return out;
-             },
-             "update"_a = true,
-             "idx"_a = nb::none(),
-             "intersect_points"_a = nb::none())
-          .def(
-              "get_most_persistent_cycle",
-              [](Wrapper& self, int dim, bool update, bool idx) -> nb::object {
-                std::vector<uint32_t> cycle_idx;
-                std::vector<std::vector<uint32_t>> out_cpp;
-                {
-                  nb::gil_scoped_release release;
-                  cycle_idx = self.truc.get_most_persistent_cycle(dim, update);
-                  if (!idx && !cycle_idx.empty()) {
-                    if (self.truc.get_boundary(cycle_idx[0]).empty()) {
-                      out_cpp.push_back(std::vector<uint32_t>{});
-                    } else {
-                      out_cpp.resize(cycle_idx.size());
-                      for (size_t k = 0; k < cycle_idx.size(); ++k) {
-                        out_cpp[k] = self.truc.get_boundary(cycle_idx[k]);
-                      }
-                    }
-                  }
-                }
-                if (idx) {
-                  return nb::cast(owned_array<uint32_t>(std::move(cycle_idx), {cycle_idx.size()}));
-                }
-                nb::list out;
-                for (size_t k = 0; k < out_cpp.size(); ++k) {
-                  auto boundary = std::move(out_cpp[k]);
-                  out.append(owned_array<uint32_t>(std::move(boundary), {boundary.size()}));
-                }
-                return nb::object(out);
-              },
-              "dim"_a = 1,
-              "update"_a = true,
-              "idx"_a = false);
-    }
-    cls.def("get_permutation", [](Wrapper& self) -> nb::ndarray<nb::numpy, uint32_t> {
-      std::vector<uint32_t> order;
-      {
-        nb::gil_scoped_release release;
-        order = self.truc.get_current_order();
-      }
-      return owned_array<uint32_t>(std::move(order), {order.size()});
-    });
-  }
-}
-
-template <typename Desc>
-typename Desc::wrapper construct_from_supported_source(nb::object source) {
-  using Wrapper = typename Desc::wrapper;
-  using Concrete = typename Desc::concrete;
-
-  Wrapper out;
-  if (is_none_or_empty(source)) {
-    return out;
-  }
-  if (try_copy_from_existing<Wrapper, Concrete>(out, source)) {
-    return out;
-  }
-  if (is_simplextree_multi(source)) {
-    if (try_build_from_multipers_simplextree<Wrapper, Concrete>(out, source)) {
-      return out;
-    }
-    throw std::runtime_error("Unsupported SimplexTreeMulti input type.");
-  }
-  throw nb::type_error(
-      "Slicer construction from Python SCC/block iterables has been removed. "
-      "Construct from a SimplexTreeMulti, an existing slicer, an SCC file path, "
-      "or explicit (generator_maps, generator_dimensions, filtration_values) data.");
-}
-
-template <typename Desc>
-void bind_slicer_class(nb::module_& m, nb::list& available_slicers) {
-  using Wrapper = typename Desc::wrapper;
-  using Concrete = typename Desc::concrete;
-  using Value = typename Desc::value_type;
-
-  auto cls =
-      nb::class_<Wrapper>(m, Desc::python_name.data())
-          .def(nb::init<>())
-          .def(nb::new_([](nb::object source) { return construct_from_supported_source<Desc>(source); }),
-               "source"_a = nb::none())
-          .def(nb::new_([](std::string path, int shift_dimension) {
-                 return construct_from_scc_file<Wrapper, Concrete>(path, shift_dimension);
-               }),
-               "path"_a,
-               "shift_dimension"_a = 0)
-          .def(nb::new_([](nb::object generator_maps, nb::object generator_dimensions, nb::object filtration_values) {
-                 return construct_from_generator_data<Wrapper, Concrete, Value, Desc::is_kcritical>(
-                     generator_maps, generator_dimensions, filtration_values);
-               }),
-               "generator_maps"_a,
-               "generator_dimensions"_a,
-               "filtration_values"_a);
-
-  bind_typed_source_constructors<Desc>(cls);
-
-  bind_dense_generator_data_overloads<decltype(cls), Wrapper, Concrete, Value, Desc::is_kcritical, int32_t>(cls);
-  bind_dense_generator_data_overloads<decltype(cls), Wrapper, Concrete, Value, Desc::is_kcritical, int64_t>(cls);
-
-  cls.def_prop_rw(
-         "filtration_grid",
-         [](Wrapper& self) -> nb::object { return self.filtration_grid; },
-         [](Wrapper& self, nb::object value) { self.filtration_grid = value.is_none() ? nb::none() : value; },
-         nb::arg("value").none())
-      .def_prop_rw(
-          "_generator_basis",
-          [](Wrapper& self) -> nb::object { return self.generator_basis; },
-          [](Wrapper& self, nb::object value) {
-            if (value.is_none()) {
-              self.generator_basis = nb::none();
-              return;
-            }
-            self.generator_basis = nb::cast(multipers::nanobind_helpers::generator_basis_from_object(value));
-          },
-          nb::arg("value").none())
-      .def_prop_rw(
-          "minpres_degree",
-          [](const Wrapper& self) { return multipers::nanobind_helpers::slicer_minpres_degree(self); },
-          [](Wrapper& self, int degree) {
-            multipers::nanobind_helpers::mark_slicer_minpres(self, degree, self.is_minres);
-          })
-      .def_prop_ro("is_pres", [](const Wrapper& self) -> bool { return self.pres_degree >= 0; })
-      .def_prop_ro("pres_degree", [](const Wrapper& self) -> int { return self.pres_degree; })
-      .def_prop_ro("is_minpres", [](const Wrapper& self) -> bool { return self.is_minpres; })
-      .def_prop_rw(
-          "is_minres",
-          [](const Wrapper& self) -> bool { return self.is_minres; },
-          [](Wrapper& self, bool value) {
-            if (value && !self.is_minpres) {
-              throw std::invalid_argument("Cannot mark a slicer as `is_minres` without a valid `minpres_degree`.");
-            }
-            self.is_minres = value;
-          })
-      .def(
-          "_mark_minpres",
-          [](Wrapper& self, int degree, bool is_minres) {
-            multipers::nanobind_helpers::mark_slicer_minpres(self, degree, is_minres);
-          },
-          "degree"_a,
-          "is_minres"_a = false)
-      .def(
-          "_mark_pres",
-          [](Wrapper& self, int degree) { multipers::nanobind_helpers::mark_slicer_pres(self, degree); },
-          "degree"_a)
-      .def(
-          "_copy_from_any",
-          [](Wrapper& self, nb::handle other) -> Wrapper& {
-            if (!try_copy_from_existing<Wrapper, Concrete>(self, other)) {
-              throw std::runtime_error("Unsupported slicer input type.");
-            }
-            return self;
-          },
-          "other"_a,
-          nb::rv_policy::reference_internal)
-      .def("__getstate__",
-           [](Wrapper& self) -> nb::tuple {
-             return nb::make_tuple(serialized_state<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(self),
-                                   self.filtration_grid,
-                                   self.generator_basis,
-                                   multipers::nanobind_helpers::slicer_minpres_degree(self),
-                                   self.is_minres,
-                                   self.pres_degree);
-           })
-      .def("__reduce__",
-           [](Wrapper& self) -> nb::tuple {
-             return nb::make_tuple(
-                 nb::borrow<nb::object>(nb::type<Wrapper>()),
-                 nb::make_tuple(),
-                 nb::make_tuple(serialized_state<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(self),
-                                self.filtration_grid,
-                                self.generator_basis,
-                                multipers::nanobind_helpers::slicer_minpres_degree(self),
-                                self.is_minres,
-                                self.pres_degree));
-           })
-      .def("__reduce_ex__",
-           [](Wrapper& self, int) -> nb::tuple {
-             return nb::make_tuple(
-                 nb::borrow<nb::object>(nb::type<Wrapper>()),
-                 nb::make_tuple(),
-                 nb::make_tuple(serialized_state<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(self),
-                                self.filtration_grid,
-                                self.generator_basis,
-                                multipers::nanobind_helpers::slicer_minpres_degree(self),
-                                self.is_minres,
-                                self.pres_degree));
-           })
-      .def("_serialize_state",
-           [](Wrapper& self) -> nb::ndarray<nb::numpy, uint8_t> {
-             return serialized_state<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(self);
-           })
-      .def(
-          "_deserialize_state",
-          [](Wrapper& self, nb::handle state) -> bool {
-            return load_state<Wrapper, Concrete, Value, Desc::is_kcritical, Desc::is_degree_rips>(self, state);
-          },
-          "state"_a)
-      .def("__len__", [](Wrapper& self) -> int { return self.truc.get_number_of_cycle_generators(); })
-      .def_prop_ro("num_generators",
-                   [](const Wrapper& self) -> int { return self.truc.get_number_of_cycle_generators(); })
-      .def_prop_ro("dimension",
-                   [](const Wrapper& self) -> nb::object {
-                     const auto n = self.truc.get_number_of_cycle_generators();
-                     if (n == 0) {
-                       return nb::float_(-std::numeric_limits<double>::infinity());
-                     }
-                     return nb::int_(self.truc.get_dimension(n - 1));
-                   })
-      .def_prop_ro("num_parameters", [](const Wrapper& self) -> int { return self.truc.get_number_of_parameters(); })
-      .def_prop_ro("dtype", [](const Wrapper&) -> nb::object { return numpy_dtype_type(Desc::dtype_name); })
-      .def_prop_ro("_template_id", [](const Wrapper&) -> int { return Desc::template_id; })
-      .def_prop_ro("col_type", [](const Wrapper&) -> std::string { return std::string(Desc::column_type); })
-      .def_prop_ro("filtration_container",
-                   [](const Wrapper&) -> std::string { return std::string(Desc::filtration_container); })
-      .def_prop_ro("is_vine", [](const Wrapper&) -> bool { return Desc::is_vine; })
-      .def_prop_ro("is_kcritical", [](const Wrapper&) -> bool { return Desc::is_kcritical; })
-      .def_prop_ro("pers_backend", [](const Wrapper&) -> std::string { return std::string(Desc::backend_type); })
-      .def_prop_ro("ftype", [](const Wrapper&) -> std::string { return std::string(Desc::filtration_type); })
-      .def("__eq__",
-           [](Wrapper& self, nb::handle other) -> bool {
-             return wrapper_equals<Wrapper, Concrete, Desc::is_kcritical>(self, other);
-           })
-      .def_static("_inf_value",
-                  []() {
-                    if constexpr (std::is_floating_point_v<Value>) {
-                      return nb::cast(std::numeric_limits<Value>::infinity());
-                    }
-                    return nb::cast(std::numeric_limits<Value>::max());
-                  })
-      .def("get_dimensions", [](Wrapper& self) -> nb::ndarray<nb::numpy, int32_t> { return dimensions_array(self); })
-      .def(
-          "get_boundaries",
-          [](Wrapper& self, bool packed) -> nb::object { return boundaries_object(self, packed); },
-          "packed"_a = false)
-      .def(
-          "get_filtration",
-          [](Wrapper& self, int idx, bool raw) {
-            Py_ssize_t n = static_cast<Py_ssize_t>(self.truc.get_number_of_cycle_generators());
-            Py_ssize_t i = idx;
-            if (i < 0) {
-              i += n;
-            }
-            if (i < 0 || i >= n) {
-              throw nb::index_error("Generator index out of range.");
-            }
-            return filtration_value_to_python<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(
-                self, static_cast<size_t>(i), false, raw);
-          },
-          "idx"_a,
-          "raw"_a = false)
-      .def(
-          "_get_filtrations_impl",
-          [](Wrapper& self, bool raw, bool view, bool packed) -> nb::object {
-            if (packed) {
-              return pack_filtrations<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(self, raw);
-            }
-            if (view) {
-              nb::list out;
-              size_t n = self.truc.get_number_of_cycle_generators();
-              for (size_t i = 0; i < n; ++i) {
-                out.append(filtration_value_to_python<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(
-                    self, i, false, raw));
-              }
-              return nb::object(out);
-            }
-            return copy_filtrations<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(self, raw);
-          },
-          "raw"_a = false,
-          "view"_a = false,
-          "packed"_a = false)
-      .def("get_filtrations_values",
-           [](Wrapper& self) -> nb::ndarray<nb::numpy, Value> {
-             return filtration_values_array<Wrapper, Value, Desc::is_kcritical, Desc::is_degree_rips>(self);
-           })
-      .def(
-          "build_from_simplex_tree",
-          [](Wrapper& self, nb::object st) -> Wrapper& {
-            if (try_build_from_multipers_simplextree<Wrapper, Concrete>(self, st)) {
-              return self;
-            }
-            throw std::runtime_error("Unsupported SimplexTreeMulti input type.");
-          },
-          nb::rv_policy::reference_internal)
-      .def(
-          "_build_from_scc_file",
-          [](Wrapper& self, std::string path, bool rivet_compatible, bool reverse, int shift_dimension) -> Wrapper& {
-            {
-              nb::gil_scoped_release release;
-              self.truc = Gudhi::multi_persistence::build_slicer_from_scc_file<Concrete>(
-                  path, rivet_compatible, reverse, shift_dimension);
-            }
-            return self;
-          },
-          "path"_a,
-          "rivet_compatible"_a = false,
-          "reverse"_a = false,
-          "shift_dimension"_a = 0,
-          nb::rv_policy::reference_internal)
-      .def(
-          "_to_scc_raw",
-          [](Wrapper& self,
-             std::string path,
-             int degree,
-             bool rivet_compatible,
-             bool ignore_last_generators,
-             bool strip_comments,
-             bool reverse) -> void {
-            {
-              nb::gil_scoped_release release;
-              write_slicer_to_scc_file(
-                  path, self.truc, degree, rivet_compatible, ignore_last_generators, strip_comments, reverse);
-            }
-          },
-          "path"_a,
-          "degree"_a = -1,
-          "rivet_compatible"_a = false,
-          "ignore_last_generators"_a = false,
-          "strip_comments"_a = false,
-          "reverse"_a = false)
-      .def(
-          "push_to_line",
-          [](Wrapper& self, nb::object basepoint, nb::object direction) -> Wrapper& {
-            std::vector<Value> bp = cast_vector<Value>(basepoint);
-            std::vector<Value> dir;
-            bool has_direction = !direction.is_none();
-            if (has_direction) {
-              dir = cast_vector<Value>(direction);
-            }
-            {
-              nb::gil_scoped_release release;
-              if (has_direction) {
-                self.truc.push_to(Gudhi::multi_persistence::Line<Value>(bp, dir));
-              } else {
-                self.truc.push_to(Gudhi::multi_persistence::Line<Value>(bp));
-              }
-            }
-            return self;
-          },
-          "basepoint"_a,
-          "direction"_a = nb::none(),
-          nb::rv_policy::reference_internal)
-      .def(
-          "set_slice",
-          [](Wrapper& self, nb::object values) -> Wrapper& {
-            auto c_values = cast_vector<Value>(values);
-            {
-              nb::gil_scoped_release release;
-              self.truc.set_slice(c_values);
-            }
-            return self;
-          },
-          nb::rv_policy::reference_internal)
-      .def(
-          "initialize_persistence_computation",
-          [](Wrapper& self, bool ignore_infinite_filtration_values) -> Wrapper& {
-            {
-              nb::gil_scoped_release release;
-              self.truc.initialize_persistence_computation(ignore_infinite_filtration_values);
-            }
-            return self;
-          },
-          "ignore_infinite_filtration_values"_a = true,
-          nb::rv_policy::reference_internal)
-      .def(
-          "_compute_persistence_on_slices",
-          [](Wrapper& self,
-             nb::ndarray<const Value, nb::ndim<2>, nb::c_contig> values,
-             bool ignore_infinite_filtration_values) -> nb::tuple {
-            return compute_persistence_on_slices<Desc>(self, values, ignore_infinite_filtration_values);
-          },
-          "values"_a,
-          "ignore_infinite_filtration_values"_a = true)
-      .def(
-          "_landscapes_on_grid",
-          [](Wrapper& self,
-             nb::ndarray<const Value, nb::ndim<1>, nb::c_contig> xgrid,
-             nb::ndarray<const Value, nb::ndim<1>, nb::c_contig> ygrid,
-             nb::ndarray<const Value, nb::ndim<1>, nb::c_contig> direction,
-             size_t stride_i,
-             size_t stride_j,
-             double dt,
-             int degree,
-             nb::ndarray<const int32_t, nb::ndim<1>, nb::c_contig> ks,
-             int n_jobs,
-             bool ignore_infinite_filtration_values) -> nb::ndarray<nb::numpy, double> {
-            return landscapes_on_grid<Desc>(self,
-                                            xgrid,
-                                            ygrid,
-                                            direction,
-                                            stride_i,
-                                            stride_j,
-                                            dt,
-                                            degree,
-                                            ks,
-                                            n_jobs,
-                                            ignore_infinite_filtration_values);
-          },
-          "xgrid"_a,
-          "ygrid"_a,
-          "direction"_a,
-          "stride_i"_a,
-          "stride_j"_a,
-          "dt"_a,
-          "degree"_a,
-          "ks"_a,
-          "n_jobs"_a = 0,
-          "ignore_infinite_filtration_values"_a = true)
-      .def(
-          "update_persistence_computation",
-          [](Wrapper& self, bool ignore_infinite_filtration_values) -> Wrapper& {
-            {
-              nb::gil_scoped_release release;
-              self.truc.update_persistence_computation(ignore_infinite_filtration_values);
-            }
-            return self;
-          },
-          "ignore_infinite_filtration_values"_a = false,
-          nb::rv_policy::reference_internal)
-      .def("get_barcode",
-           [](Wrapper& self) -> nb::tuple {
-             using Barcode = decltype(self.truc.template get_flat_barcode<true, Value, false>());
-             Barcode barcode;
-             {
-               nb::gil_scoped_release release;
-               barcode = self.truc.template get_flat_barcode<true, Value, false>();
-             }
-             return dim_barcode_to_tuple<Barcode, Value>(barcode);
-           })
-      .def("get_barcode_idx",
-           [](Wrapper& self) -> nb::tuple {
-             using Barcode = decltype(self.truc.template get_flat_barcode<true, int, true>());
-             Barcode barcode;
-             {
-               nb::gil_scoped_release release;
-               barcode = self.truc.template get_flat_barcode<true, int, true>();
-             }
-             return dim_barcode_to_tuple<Barcode, int>(barcode);
-           })
-      .def("get_current_filtration",
-           [](Wrapper& self) -> nb::ndarray<nb::numpy, Value> {
-             std::vector<Value> current;
-             {
-               nb::gil_scoped_release release;
-               current = self.truc.get_slice();
-             }
-             return owned_array<Value>(std::move(current), {current.size()});
-           })
-      .def(
-          "prune_above_dimension",
-          [](Wrapper& self, int max_dimension) -> Wrapper& {
-            {
-              nb::gil_scoped_release release;
-              self.truc.prune_above_dimension(max_dimension);
-            }
-            return self;
-          },
-          nb::rv_policy::reference_internal)
-      .def(
-          "_make_filtration_non_decreasing_raw",
-          [](Wrapper& self, bool safe) -> Wrapper& { return make_filtration_non_decreasing_inplace(self, safe); },
-          "safe"_a = true,
-          nb::rv_policy::reference_internal)
-      .def(
-          "_simplify_filtration_raw",
-          [](Wrapper& self) -> Wrapper& {
-            {
-              nb::gil_scoped_release release;
-              auto& filtrations = self.truc.get_filtration_values();
-              for (auto& filtration : filtrations) {
-                filtration.simplify();
-              }
-            }
-            return self;
-          },
-          nb::rv_policy::reference_internal)
-      .def(
-          "_normalize_filtrations_raw",
-          [](Wrapper& self, nb::object box) -> Wrapper& {
-            return normalize_filtrations_inplace<Wrapper, Value, Desc::is_degree_rips>(self, box);
-          },
-          "box"_a = nb::none(),
-          nb::rv_policy::reference_internal)
-      .def(
-          "_clean_filtration_grid_raw",
-          [](Wrapper& self) -> Wrapper& { return clean_squeezed_filtration_grid_inplace<Wrapper, Value>(self); },
-          nb::rv_policy::reference_internal)
-      .def(
-          "coarsen_on_grid_inplace",
-          [](Wrapper& self, std::vector<std::vector<Value>> grid, bool coordinates) -> Wrapper& {
-            {
-              nb::gil_scoped_release release;
-              self.truc.coarsen_on_grid(grid, coordinates);
-            }
-            return self;
-          },
-          nb::rv_policy::reference_internal)
-      .def(
-          "to_colexical",
-          [](Wrapper& self, bool return_permutation) {
-            if (!return_permutation) {
-              return nb::object(nb::cast(colexical_slicer_copy(self)));
-            }
-            auto [out, perm] = colexical_slicer_copy_with_permutation(self);
-            return nb::object(nb::make_tuple(nb::cast(out), owned_array<uint32_t>(std::move(perm), {perm.size()})));
-          },
-          "return_permutation"_a = false)
-      .def("permute_generators",
-           [](Wrapper& self, std::vector<uint32_t> permutation) { return permuted_slicer_copy(self, permutation); })
-      .def("copy", [](Wrapper& self) -> Wrapper { return Wrapper(self); })
-      .def("_info_string",
-           [](Wrapper& self) -> std::string { return multipers::tmp_interface::slicer_to_str(self.truc); });
-
-  bind_grid_methods<Desc>(cls);
-  bind_vine_methods<Desc>(cls);
-  available_slicers.append(cls);
-}
-
-template <typename... Desc>
-void bind_all_slicers(type_list<Desc...>, nb::module_& m, nb::list& available_slicers) {
-  (bind_slicer_class<Desc>(m, available_slicers), ...);
-}
-
-template <typename... Ds>
-nb::tuple compute_hilbert_signed_measure(type_list<Ds...>,
-                                         nb::handle slicer,
-                                         std::vector<indices_type>& container,
-                                         const std::vector<indices_type>& full_shape,
-                                         const std::vector<indices_type>& degrees,
-                                         size_t width,
-                                         bool zero_pad,
-                                         indices_type n_jobs,
-                                         bool verbose,
-                                         bool ignore_inf) {
-  if (!has_slicer_template_id(slicer)) {
-    throw std::runtime_error("Unsupported slicer type.");
-  }
-  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
-    auto& wrapper = nb::cast<typename D::wrapper&>(slicer);
-    signed_measure_type sm;
-    {
-      nb::gil_scoped_release release;
-      sm = Gudhi::multiparameter::hilbert_function::get_hilbert_signed_measure(
-          wrapper.truc, container.data(), full_shape, degrees, zero_pad, n_jobs, verbose, ignore_inf);
-    }
-    return signed_measure_to_python(sm, width);
-  });
-}
-
-template <typename... Ds>
-nb::tuple compute_hilbert_signed_measure_sparse(type_list<Ds...>,
-                                                nb::handle slicer,
-                                                const std::vector<indices_type>& grid_shape,
-                                                const std::vector<indices_type>& degrees,
-                                                size_t width,
-                                                bool zero_pad,
-                                                indices_type n_jobs,
-                                                bool ignore_inf) {
-  if (!has_slicer_template_id(slicer)) {
-    throw std::runtime_error("Unsupported slicer type.");
-  }
-  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
-    auto& wrapper = nb::cast<typename D::wrapper&>(slicer);
-    signed_measure_type sm;
-    {
-      nb::gil_scoped_release release;
-      sm = Gudhi::multiparameter::hilbert_function::compute_hilbert_signed_measure_sparse_python(
-          wrapper.truc, grid_shape, degrees, zero_pad, n_jobs, ignore_inf);
-    }
-    return signed_measure_to_python(sm, width);
-  });
-}
-
-template <typename... Ds>
-nb::tuple compute_rank_tensor(type_list<Ds...>,
-                              nb::handle slicer,
-                              std::vector<tensor_dtype>& container,
-                              const std::vector<indices_type>& full_shape,
-                              const std::vector<indices_type>& degrees,
-                              size_t total,
-                              indices_type n_jobs,
-                              bool ignore_inf) {
-  if (!has_slicer_template_id(slicer)) {
-    throw std::runtime_error("Unsupported slicer type.");
-  }
-  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
-    auto& wrapper = nb::cast<typename D::wrapper&>(slicer);
-    {
-      nb::gil_scoped_release release;
-      Gudhi::multiparameter::rank_invariant::compute_rank_invariant_python(
-          wrapper.truc, container.data(), full_shape, degrees, n_jobs, ignore_inf);
-    }
-    return nb::make_tuple(nb::cast(owned_array<tensor_dtype>(std::move(container), {total})), nb::cast(full_shape));
-  });
-}
-
-template <typename... Ds>
-nb::tuple compute_rank_signed_measure_sparse(type_list<Ds...>,
-                                             nb::handle slicer,
-                                             const std::vector<indices_type>& grid_shape,
-                                             const std::vector<indices_type>& degrees,
-                                             size_t width,
-                                             bool zero_pad,
-                                             indices_type n_jobs,
-                                             bool ignore_inf) {
-  if (!has_slicer_template_id(slicer)) {
-    throw std::runtime_error("Unsupported slicer type.");
-  }
-  return dispatch_slicer_by_template_id(template_id_of(slicer), [&]<typename D>() -> nb::tuple {
-    auto& wrapper = nb::cast<typename D::wrapper&>(slicer);
-    signed_measure_type sm;
-    {
-      nb::gil_scoped_release release;
-      sm = Gudhi::multiparameter::rank_invariant::compute_rank_signed_measure_sparse_python(
-          wrapper.truc, grid_shape, degrees, zero_pad, n_jobs, ignore_inf);
-    }
-    return signed_measure_to_python(sm, width);
-  });
-}
-
-template <typename Desc>
-Gudhi::multi_persistence::Module_interface<double> module_approximation_from_desc(
-    typename Desc::wrapper& wrapper,
-    const std::vector<double>& direction,
-    double max_error,
-    Gudhi::multi_persistence::Box<double> box,
-    bool threshold,
-    bool complete,
-    bool verbose,
-    int n_jobs) {
-  if constexpr (!Desc::enable_module_approximation) {
-    throw std::runtime_error("Unsupported slicer type for module approximation.");
-  } else {
-    Gudhi::multi_persistence::Module<double> mod;
-    {
-      nb::gil_scoped_release release;
-      mod = Gudhi::multi_persistence::multiparameter_module_approximation(wrapper.truc,
-                                                                          max_error,
-                                                                          box.get_lower_corner(),
-                                                                          box.get_upper_corner(),
-                                                                          direction,
-                                                                          threshold,
-                                                                          complete,
-                                                                          verbose,
-                                                                          n_jobs);
-    }
-    return {std::move(mod), box};
-  }
-}
-
-template <typename... Ds>
-Gudhi::multi_persistence::Module_interface<double> compute_module_approximation_from_slicer(
-    type_list<Ds...>,
-    nb::handle slicer,
-    const std::vector<double>& direction,
-    double max_error,
-    Gudhi::multi_persistence::Box<double> box,
-    bool threshold,
-    bool complete,
-    bool verbose,
-    int n_jobs) {
-  if (!has_slicer_template_id(slicer)) {
-    throw std::runtime_error("Unsupported slicer type for module approximation.");
-  }
-  return dispatch_slicer_by_template_id(template_id_of(slicer),
-                                        [&]<typename D>() -> Gudhi::multi_persistence::Module_interface<double> {
-                                          auto& wrapper = nb::cast<typename D::wrapper&>(slicer);
-                                          return module_approximation_from_desc<D>(
-                                              wrapper, direction, max_error, box, threshold, complete, verbose, n_jobs);
-                                        });
-}
-
-template <typename Desc>
-void bind_bitmap_builder(nb::module_& m) {
-  if constexpr (Desc::enable_bitmap_builder) {
-    using Wrapper = typename Desc::wrapper;
-    using Concrete = typename Desc::concrete;
-    using Value = typename Desc::value_type;
-
-    std::string name = std::string("_build_bitmap_") + std::string(Desc::short_value_type);
-    m.def(
-        name.c_str(),
-        [](nb::ndarray<nb::numpy, const Value, nb::ndim<2>, nb::c_contig> image_handle,
-           nb::ndarray<nb::numpy, const uint32_t, nb::ndim<1>, nb::c_contig> shape_handle) {
-          auto image = matrix_from_array<Value>(image_handle);
-          auto shape = multipers::nanobind_dense_utils::cast_vector_from_array<unsigned int>(shape_handle);
-          if (image.empty()) {
-            return Wrapper();
-          }
-          std::vector<typename Concrete::Filtration_value> vertices;
-          vertices.reserve(image.size());
-          for (const auto& row : image) {
-            vertices.emplace_back(row.begin(), row.end());
-          }
-          Wrapper out;
-          {
-            nb::gil_scoped_release release;
-            out.truc = Gudhi::multi_persistence::build_slicer_from_bitmap<Concrete>(vertices, shape);
-          }
-          reset_slicer_python_state(out);
-          return out;
-        },
-        "image"_a,
-        "shape"_a);
-  }
-}
-
-template <typename... Desc>
-void bind_bitmap_builders(type_list<Desc...>, nb::module_& m) {
-  (bind_bitmap_builder<Desc>(m), ...);
-}
-
 }  // namespace mpnb
 
 NB_MODULE(_slicer_nanobind, m) {
@@ -2415,53 +120,12 @@ NB_MODULE(_slicer_nanobind, m) {
   mpnb::bind_generator_basis(m);
   mpnb::bind_all_slicers(mpnb::SlicerDescriptorList{}, m, available_slicers);
 
-  m.def("_graph_mph0_raw",
-        &mpnb::graph_mph0_raw,
-        "boundary_indptr"_a,
-        "boundary_indices"_a,
-        "dimensions"_a,
-        "grades"_a,
-        "degree"_a);
   m.def("_graph_mph0_minimal_presentation",
         &mpnb::graph_mph0_minimal_presentation,
         "slicer"_a,
         "degree"_a,
         "full_resolution"_a);
 
-  m.def(
-      "build_contiguous_f64_slicer_from_packed_f64",
-      [](nb::ndarray<nb::numpy, const int64_t, nb::ndim<1>, nb::c_contig> boundary_indptr,
-         nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> boundary_flat,
-         nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> generator_dimensions,
-         nb::ndarray<nb::numpy, const double, nb::ndim<2>, nb::c_contig> grades_flat) {
-        return mpnb::construct_contiguous_from_packed<mpnb::ContiguousF64MatrixSlicerDesc::wrapper,
-                                                      mpnb::ContiguousF64MatrixSlicerDesc::concrete,
-                                                      double>(
-            boundary_indptr, boundary_flat, generator_dimensions, grades_flat);
-      },
-      "boundary_indptr"_a,
-      "boundary_flat"_a,
-      "generator_dimensions"_a,
-      "grades_flat"_a);
-
-  m.def(
-      "build_kcritical_contiguous_slicer_from_packed_f64",
-      [](nb::ndarray<nb::numpy, const int64_t, nb::ndim<1>, nb::c_contig> boundary_indptr,
-         nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> boundary_flat,
-         nb::ndarray<nb::numpy, const int32_t, nb::ndim<1>, nb::c_contig> generator_dimensions,
-         nb::ndarray<nb::numpy, const int64_t, nb::ndim<1>, nb::c_contig> grade_indptr,
-         nb::ndarray<nb::numpy, const double, nb::ndim<2>, nb::c_contig> grades_flat) {
-        return mpnb::construct_kcritical_from_packed<mpnb::KcriticalContiguousF64MatrixSlicerDesc::wrapper,
-                                                     mpnb::KcriticalContiguousF64MatrixSlicerDesc::concrete,
-                                                     double>(
-            boundary_indptr, boundary_flat, generator_dimensions, grade_indptr, grades_flat);
-      },
-      "boundary_indptr"_a,
-      "boundary_flat"_a,
-      "generator_dimensions"_a,
-      "grade_indptr"_a,
-      "grades_flat"_a);
-
   m.def(
       "_compute_hilbert_signed_measure",
       [](nb::handle slicer,
@@ -2630,9 +294,9 @@ NB_MODULE(_slicer_nanobind, m) {
       "pers_backend"_a,
       "filtration_container"_a);
 
-  m.def("_get_slicer_class_from_template_id", &mpnb::get_slicer_class_from_template_id, "template_id"_a);
+  // m.def("_get_slicer_class_from_template_id", &mpnb::get_slicer_class_from_template_id, "template_id"_a);
 
-  mpnb::bind_bitmap_builders(mpnb::SlicerDescriptorList{}, m);
+  // mpnb::bind_bitmap_builders(mpnb::SlicerDescriptorList{}, m);
 
   m.attr("available_slicers") = available_slicers;
 }
diff --git a/multipers/_slicer_nanobind.h b/multipers/_slicer_nanobind.h
new file mode 100644
index 00000000..525bf5ce
--- /dev/null
+++ b/multipers/_slicer_nanobind.h
@@ -0,0 +1,443 @@
+#ifndef MP_PY_SLICER_NANOBIND_H_INCLUDED
+#define MP_PY_SLICER_NANOBIND_H_INCLUDED
+
+#include <cstdint>
+#include <utility>
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/operators.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+// #include <nanobind/stl/tuple.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/optional.h>
+
+#include "ext_interface/nanobind_registry_helpers.hpp"
+#include "nanobind_object_utils.hpp"
+#include "gudhi/interface_helper_structs.h"
+
+namespace mpnb {
+
+using namespace nanobind::literals;  // for the "argname"_a
+using multipers::nanobind_helpers::type_list;
+using multipers::nanobind_helpers::simplextree_wrapper_t;
+using multipers::nanobind_helpers::SlicerDescriptorList;
+using multipers::nanobind_helpers::SimplexTreeDescriptorList;
+using multipers::nanobind_helpers::PySimplexTree;
+using multipers::nanobind_utils::numpy_dtype_type;
+
+inline void bind_generator_basis(nanobind::module_& m) {
+  using Generator_basis_data = Gudhi::multi_persistence::detail::Generator_basis_data;
+  using Index = Generator_basis_data::Index;  // std::uint32_t
+  using Grade = Generator_basis_data::Grade;  // double
+
+  nanobind::class_<Generator_basis_data>(m, "_GeneratorBasis")
+      .def(nanobind::init<int,
+                          std::vector<std::vector<Index>>,
+                          std::vector<std::vector<Index>>,
+                          std::vector<std::pair<Grade, Grade>>,
+                          std::vector<std::pair<Grade, Grade>>,
+                          std::vector<Index>>(),
+           "degree"_a,
+           "columns"_a,
+           "row_boundaries"_a,
+           "row_grades"_a = std::vector<std::pair<Grade, Grade>>{},
+           "column_grades"_a = std::vector<std::pair<Grade, Grade>>{},
+           "row_cell_indices"_a = std::vector<Index>{})
+      .def_prop_ro("degree", [](const Generator_basis_data& self) { return self.degree; })
+      .def_prop_ro("columns", [](const Generator_basis_data& self) { return self.columns; })
+      .def_prop_ro("row_boundaries", [](const Generator_basis_data& self) { return self.rowBoundaries; })
+      .def_prop_ro("row_grades", [](const Generator_basis_data& self) { return self.rowGrades; })
+      .def_prop_ro("column_grades", [](const Generator_basis_data& self) { return self.columnGrades; })
+      .def_prop_ro("row_cell_indices", [](const Generator_basis_data& self) { return self.rowCellIndices; })
+      .def("keys", &Generator_basis_data::get_keys)
+      .def("__getitem__",
+           [](const Generator_basis_data& self, const std::string& key) -> nanobind::object { return self[key]; })
+      .def(
+          "__contains__",
+          [](const Generator_basis_data&, const std::string& key) -> bool { return Generator_basis_data::is_key(key); })
+      .def("__repr__", &Generator_basis_data::to_str)
+      .def("__getstate__",
+           [](const Generator_basis_data& self) -> nanobind::ndarray<nanobind::numpy, char> {
+             std::size_t buffer_size;
+             char* buffer;
+             {
+               nanobind::gil_scoped_release release;
+               buffer_size = get_serialization_size_of(self);
+               buffer = new char[buffer_size];
+               serialize_value_to_char_buffer(self, buffer);
+             }
+             return _wrap_as_numpy_array(buffer, buffer_size);
+           })
+      .def("__setstate__",
+           [](Generator_basis_data& self, nanobind::ndarray<const char, nanobind::ndim<1>, nanobind::numpy> state) {
+             new (&self)
+                 Generator_basis_data(Gudhi::multi_persistence::detail::deserialize_gen_basis_from_python(state));
+           });
+}
+
+template <class Target, typename Class, typename... SourceDesc1, typename... SourceDesc2>
+inline void bind_from_slicer_constructors(Class& cls, type_list<SourceDesc1...>, type_list<SourceDesc2...>) {
+  // (cls.def(nanobind::init<const typename SourceDesc1::interface&>()), ...);
+  // (cls.def(nanobind::init<PySimplexTree<typename SourceDesc2::interface_type, typename SourceDesc2::value_type>&>()),
+  //  ...);
+
+  using CtorFn = void (*)(Target*, PyObject*);
+
+  cls.def("__init__", [](Target* self, nanobind::object b) {
+    if (b.is_none()) {
+      new (self) Target();
+      return;
+    }
+
+    // Built once (magic static), reused for the process lifetime.
+    static const std::unordered_map<PyTypeObject*, CtorFn> table = [] {
+      std::unordered_map<PyTypeObject*, CtorFn> t;
+
+      // Pack 1: direct interface types.
+      (t.emplace((PyTypeObject*)nanobind::type<typename SourceDesc1::interface>().ptr(),
+                 +[](Target* self, PyObject* obj) {
+                   using Interface = typename SourceDesc1::interface;
+                   const Interface& b = *nanobind::inst_ptr<Interface>(obj);
+                   new (self) Target(b);
+                 }),
+       ...);
+
+      // Pack 2: PySimplexTree<interface_type, value_type> wrapper types.
+      (t.emplace(
+           (PyTypeObject*)
+               nanobind::type<PySimplexTree<typename SourceDesc2::interface_type, typename SourceDesc2::value_type>>()
+                   .ptr(),
+           +[](Target* self, PyObject* obj) {
+             using Wrapper = PySimplexTree<typename SourceDesc2::interface_type, typename SourceDesc2::value_type>;
+             Wrapper& b = *nanobind::inst_ptr<Wrapper>(obj);
+             new (self) Target(b);
+           }),
+       ...);
+
+      return t;
+    }();
+
+    auto it = table.find(Py_TYPE(b.ptr()));
+    if (it == table.end()) {
+      throw nanobind::type_error("unsupported argument type for constructor");
+    }
+    it->second(self, b.ptr());
+  });
+}
+
+// template <typename Class, typename... SourceDesc>
+// inline void bind_from_simplex_tree_constructors(Class& cls, type_list<SourceDesc...>) {
+//   (cls.def(nanobind::init<PySimplexTree<typename SourceDesc::interface_type, typename SourceDesc::value_type>&>()),
+//    ...);
+// }
+
+template <class Target, typename Class, typename... SourceDesc>
+inline void bind_slicer_eq(Class& cls, type_list<SourceDesc...>) {
+  // (cls.def(
+  //      "__eq__",
+  //      [](const Target& a, const typename SourceDesc::interface& b) { return a == b; },
+  //      nanobind::is_operator()),
+  //  ...);
+  using CmpFn = bool (*)(const Target&, PyObject*);
+
+  cls.def("__eq__", [](const Target& a, nanobind::object b) -> nanobind::object {
+    // Built once (magic static), reused for the process lifetime.
+    static const std::unordered_map<PyTypeObject*, CmpFn> table = [] {
+      std::unordered_map<PyTypeObject*, CmpFn> t;
+      (t.emplace((PyTypeObject*)nanobind::type<typename SourceDesc::interface>().ptr(),
+                 +[](const Target& a, PyObject* obj) -> bool {
+                   // Exact type already confirmed by the table lookup,
+                   // so an unchecked pointer cast is safe here.
+                   using Interface = typename SourceDesc::interface;
+                   const Interface& b = *nanobind::inst_ptr<Interface>(obj);
+                   return a == b;
+                 }),
+       ...);
+      return t;
+    }();
+
+    auto it = table.find(Py_TYPE(b.ptr()));
+    if (it == table.end()) return nanobind::borrow(Py_NotImplemented);
+
+    return nanobind::cast(it->second(a, b.ptr()));
+  });
+}
+
+// template <class Target, typename Class, typename... SourceDesc>
+// inline void bind_from_slicer_copy(Class& cls, type_list<SourceDesc...>) {
+//   (cls.def("_copy_from_any",
+//            nanobind::overload_cast<const typename SourceDesc::interface&>(
+//                &Target::template copy<typename SourceDesc::concrete::Filtration_value,
+//                                       typename SourceDesc::concrete::Persistence>)),
+//    ...);
+// }
+
+// template <class Target, typename Class, typename... SourceDesc>
+// inline void bind_from_simplex_tree_copy(Class& cls, type_list<SourceDesc...>) {
+//   (cls.def(
+//        "_copy_from_any",
+//        nanobind::overload_cast<PySimplexTree<typename SourceDesc::interface_type, typename SourceDesc::value_type>&>(
+//            &Target::template copy<typename SourceDesc::filtration_type>)),
+//    ...);
+// }
+
+template <class Slicer, typename Desc, typename Class>
+inline void bind_slicer_constructors(Class& cls) {
+  using T = typename Slicer::value_type;
+  using Tensor2D = nanobind::ndarray<const T, nanobind::ndim<2>>;
+
+  // default constructor
+  cls.def(nanobind::init<>());
+
+  // from cubical image
+  cls.def(nanobind::init<Tensor2D, const std::vector<unsigned int>&>());
+
+  // from file
+  cls.def(nanobind::init<const std::string&, int, bool, bool>(),
+          "path"_a,
+          "shift_dimension"_a,
+          "is_rivet_compatible"_a = false,
+          "is_reversed"_a = false);
+
+  // from containers
+  cls.def(nanobind::init<const std::vector<std::vector<typename Slicer::Index>>&,
+                         nanobind::ndarray<const std::int32_t, nanobind::ndim<1>, nanobind::any_contig>,
+                         nanobind::iterable>(),
+          "generator_maps"_a,
+          "generator_dimensions"_a.noconvert(),
+          "filtration_values"_a)
+      .def(nanobind::init<const std::vector<std::vector<typename Slicer::Index>>&,
+                          nanobind::ndarray<const std::int64_t, nanobind::ndim<1>, nanobind::any_contig>,
+                          nanobind::iterable>());
+  if constexpr (Desc::is_kcritical) {
+    cls.def(nanobind::init<const std::vector<std::vector<typename Slicer::Index>>&,
+                           const std::vector<typename Slicer::Index>&,
+                           const std::vector<std::vector<std::vector<typename Slicer::value_type>>>&>());
+  } else {
+    cls.def(nanobind::init<const std::vector<std::vector<typename Slicer::Index>>&,
+                           const std::vector<typename Slicer::Index>&,
+                           const std::vector<std::vector<typename Slicer::value_type>>&>());
+  }
+
+  // flat containers
+  cls.def(nanobind::init<nanobind::ndarray<const std::int64_t, nanobind::ndim<1>, nanobind::any_contig>,
+                         nanobind::ndarray<const std::int32_t, nanobind::ndim<1>, nanobind::any_contig>,
+                         nanobind::ndarray<const std::int32_t, nanobind::ndim<1>, nanobind::any_contig>,
+                         nanobind::ndarray<const double, nanobind::ndim<2>>>());
+
+  // constructors from all available slicers and simplex trees
+  // to make no problems with other possible single argument constructors, it always has to be last!
+  bind_from_slicer_constructors<Slicer>(cls, SlicerDescriptorList{}, SimplexTreeDescriptorList{});
+  // // constructors from all available simplex trees
+  // bind_from_simplex_tree_constructors(cls, SimplexTreeDescriptorList{});
+
+  // // handles None case, has to be bind last
+  // cls.def("__init__", [](Slicer* self, nanobind::handle arg) {
+  //   if (!arg.is_none()) throw nanobind::next_overload();
+  //   new (self) Slicer();
+  // });
+}
+
+template <class Slicer, typename Class>
+inline void bind_slicer_dunders(Class& cls) {
+  cls.def("__len__", &Slicer::size)
+      .def("__getstate__",
+           [](const Slicer& self) -> nanobind::tuple {
+             std::size_t buffer_size;
+             char* buffer;
+             {
+               nanobind::gil_scoped_release release;
+               buffer_size = get_serialization_size_of(self);
+               buffer = new char[buffer_size];
+               serialize_value_to_char_buffer(self, buffer);
+             }
+             return nanobind::make_tuple(Slicer::SERIALIZATION_VERSION,
+                                         self.get_filtration_grid(),
+                                         _wrap_as_numpy_array(buffer, buffer_size));
+           })
+      .def("__setstate__", [](Slicer& self, nanobind::tuple state) {
+        new (&self) Slicer(Gudhi::multi_persistence::deserialize_slicer_from_python<Slicer>(state));
+      });
+
+  //__eq__
+  bind_slicer_eq<Slicer>(cls, SlicerDescriptorList{});
+}
+
+template <class Slicer, typename Desc, typename Class>
+inline void bind_slicer_properties(Class& cls) {
+  cls.def_prop_rw("filtration_grid", &Slicer::get_filtration_grid, &Slicer::set_filtration_grid, "value"_a.none())
+      .def_prop_rw("minpres_degree",
+                   &Slicer::get_min_pres_degree,
+                   [](Slicer& self, int degree) { self.set_min_pres_degree(degree, self.is_min_res()); })
+      .def_prop_rw("is_minres", &Slicer::is_min_res, &Slicer::set_is_min_res)
+      .def_prop_rw(
+          "_generator_basis",
+          &Slicer::get_generator_basis,
+          [](Slicer& self, nanobind::object value) -> void {
+            if (nanobind::isinstance<nanobind::dict>(value)) {
+              self.set_generator_basis(nanobind::cast<nanobind::dict>(value));
+              return;
+            }
+            self.set_generator_basis(
+                nanobind::cast<std::optional<Gudhi::multi_persistence::detail::Generator_basis_data>>(value));
+          },
+          "value"_a.none())
+      .def_prop_ro("is_pres", &Slicer::is_pres)
+      .def_prop_ro("pres_degree", &Slicer::get_pres_degree)
+      .def_prop_ro("is_minpres", &Slicer::is_min_pres)
+      .def_prop_ro("num_generators", &Slicer::size)
+      .def_prop_ro("dimension", &Slicer::get_max_dimension)
+      .def_prop_ro("num_parameters", &Slicer::get_number_of_parameters)
+      .def_prop_ro("dtype", [](const Slicer&) -> nanobind::object { return numpy_dtype_type(Desc::dtype_name); })
+      .def_prop_ro("col_type", [](const Slicer&) -> std::string { return std::string(Desc::column_type); })
+      .def_prop_ro("filtration_container",
+                   [](const Slicer&) -> std::string { return std::string(Desc::filtration_container); })
+      .def_prop_ro("is_vine", [](const Slicer&) -> bool { return Desc::is_vine; })
+      .def_prop_ro("is_kcritical", [](const Slicer&) -> bool { return Desc::is_kcritical; })
+      .def_prop_ro("pers_backend", [](const Slicer&) -> std::string { return std::string(Desc::backend_type); })
+      .def_prop_ro("ftype", [](const Slicer&) -> std::string { return std::string(Desc::filtration_type); })
+      .def_prop_ro("_template_id", [](const Slicer&) -> int { return Desc::template_id; })
+      .def_ro_static("_inf_value", &Slicer::T_inf)
+      .def_ro_static("_minus_inf_value", &Slicer::T_m_inf);
+
+  cls.def("get_dimensions", &Slicer::get_dimensions)
+      .def(
+          "get_boundaries",
+          [](const Slicer& self, bool packed) -> nanobind::tuple {
+            if (packed) return self.get_flat_boundaries();
+            return self.get_boundaries();
+          },
+          "packed"_a = false)
+      .def("get_filtration",
+           &Slicer::get_filtration_value,
+           "idx"_a,
+           "copy_only_when_necessary"_a = true,
+           "raw"_a = false)
+      .def("get_filtrations_values",
+           [](Slicer& self) -> nanobind::ndarray<nanobind::numpy, typename Slicer::value_type> {
+             return nanobind::cast<nanobind::ndarray<nanobind::numpy, typename Slicer::value_type>>(
+                 self.get_all_filtration_values(true, false, false)[1]);
+           })
+      .def("_get_filtrations_impl",
+           &Slicer::get_all_filtration_values,
+           "packed"_a = false,
+           "view"_a = false,
+           "raw"_a = false)
+      .def("_mark_minpres", &Slicer::set_min_pres_degree, "degree"_a, "is_minres"_a = false)
+      .def("_mark_pres", [](Slicer& self, int degree) { self.set_is_pres(degree, false); });
+}
+
+template <class Slicer, typename Desc, typename Class>
+inline void bind_slicer_modifiers(Class& cls) {
+  using T = typename Slicer::value_type;
+  using Tensor1D = nanobind::ndarray<const T, nanobind::ndim<1>, nanobind::any_contig>;
+
+  cls.def("prune_above_dimension", &Slicer::prune_above_dimension)
+      .def("coarsen_on_grid_inplace",
+           nanobind::overload_cast<const std::vector<Tensor1D>&, bool>(&Slicer::template coarsen_on_grid<T>))
+      .def("coarsen_on_grid_inplace",
+           nanobind::overload_cast<const std::vector<std::vector<T>>&, bool>(&Slicer::template coarsen_on_grid<T>))
+      .def("to_colexical", &Slicer::build_colexical_permuted_slicer, "return_permutation"_a = false)
+      .def("permute_generators", &Slicer::build_slicer_as_permutation)
+      .def("push_to_line", &Slicer::template push_to_line<T>, "basepoint"_a, "direction"_a = nanobind::none())
+      .def("initialize_persistence_computation",
+           &Slicer::initialize_persistence_computation,
+           "ignore_infinite_filtration_values"_a = true)
+      .def("update_persistence_computation",
+           &Slicer::update_persistence_computation,
+           "ignore_infinite_filtration_values"_a = false)
+      .def("get_barcode", &Slicer::get_barcode)
+      .def("get_barcode_idx", &Slicer::get_barcode_as_indices)
+      .def("_compute_persistence_on_slices",
+           &Slicer::compute_persistence_on_slices,
+           "values"_a,
+           "ignore_infinite_filtration_values"_a = true)
+      .def("_landscapes_on_grid",
+           &Slicer::template compute_landscapes_on_grid<T>,
+           "xgrid"_a,
+           "ygrid"_a,
+           "direction"_a,
+           "stride_i"_a,
+           "stride_j"_a,
+           "dt"_a,
+           "degree"_a,
+           "ks"_a,
+           "n_jobs"_a = 0,
+           "ignore_infinite_filtration_values"_a = true)
+      .def("_make_filtration_non_decreasing_raw", &Slicer::make_filtration_non_decreasing)
+      .def("_simplify_filtration_raw", &Slicer::simplify_all_filtration_values)
+      .def("_normalize_filtrations_raw",
+           &Slicer::template normalize_filtration_values<double>,
+           "box"_a = nanobind::none())
+      .def("_clean_filtration_grid_raw", &Slicer::clean_filtration_grid);
+
+  // bind_from_slicer_copy<Slicer>(cls, SlicerDescriptorList{});
+  // bind_from_simplex_tree_copy<Slicer>(cls, SimplexTreeDescriptorList{});
+  cls.def("copy", [](const Slicer& self) -> Slicer { return Slicer(self); });
+
+  if constexpr (Desc::has_grid_methods) {
+    cls.def("coarsen_on_grid_copy", &Slicer::template build_coarsen_on_grid<T>)
+        .def(
+            "compute_kernel_projective_cover", &Slicer::build_from_projective_cover_kernel, "dim"_a = nanobind::none());
+  }
+
+  if constexpr (Desc::is_vine) {
+    using Persistence = typename Desc::concrete::Persistence;
+    if constexpr (Persistence::has_rep_cycles) {
+      cls.def("get_representative_cycles",
+              &Slicer::get_representative_cycles,
+              "update"_a = true,
+              "dim"_a = nanobind::none(),
+              "idx"_a = nanobind::none(),
+              "intersect_points"_a = nanobind::none())
+          .def("get_most_persistent_cycles",
+               &Slicer::get_most_persistent_cycles,
+               "dim"_a = 1,
+               "n"_a = 1,
+               "update"_a = true,
+               "idx"_a = false);
+    }
+  }
+}
+
+template <class Slicer, typename Class>
+inline void bind_slicer_io(Class& cls) {
+  cls.def("_info_string", &Slicer::to_string)
+      .def("_to_scc_raw",
+           &Slicer::write_to_scc_file,
+           "path"_a,
+           "degree"_a = -1,
+           "rivet_compatible"_a = false,
+           "ignore_last_generators"_a = false,
+           "strip_comments"_a = false,
+           "reverse"_a = false);
+}
+
+template <typename Desc>
+inline void bind_slicer_class(nanobind::module_& m, nanobind::list& available_slicers) {
+  using Slicer = typename Desc::interface;
+
+  auto cls = nanobind::class_<Slicer>(m, Desc::python_name.data());
+
+  bind_slicer_constructors<Slicer, Desc>(cls);
+  bind_slicer_dunders<Slicer>(cls);
+  bind_slicer_properties<Slicer, Desc>(cls);
+  bind_slicer_modifiers<Slicer, Desc>(cls);
+  bind_slicer_io<Slicer>(cls);
+
+  available_slicers.append(cls);
+}
+
+template <typename... Desc>
+inline void bind_all_slicers(type_list<Desc...>, nanobind::module_& m, nanobind::list& available_slicers) {
+  (bind_slicer_class<Desc>(m, available_slicers), ...);
+}
+
+}  // namespace mpnb
+
+#endif  // MP_PY_SLICER_NANOBIND_H_INCLUDED
diff --git a/multipers/ext_interface/nanobind_generator_basis.hpp b/multipers/ext_interface/nanobind_generator_basis.hpp
index cf149ae0..f6fd384f 100644
--- a/multipers/ext_interface/nanobind_generator_basis.hpp
+++ b/multipers/ext_interface/nanobind_generator_basis.hpp
@@ -4,196 +4,22 @@
 #include <nanobind/stl/pair.h>
 #include <nanobind/stl/vector.h>
 
-#include <algorithm>
-#include <cstdint>
-#include <limits>
 #include <stdexcept>
 #include <string>
-#include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "contiguous_slicer_bridge.hpp"
 
 namespace multipers::nanobind_helpers {
 
-struct GeneratorBasisData {
-  bool active = false;
-  int degree = -1;
-  std::vector<std::vector<uint32_t>> columns;
-  std::vector<std::vector<uint32_t>> row_boundaries;
-  std::vector<std::pair<double, double>> row_grades;
-  std::vector<std::pair<double, double>> column_grades;
-  std::vector<uint32_t> row_cell_indices;
-
-  GeneratorBasisData() = default;
-
-  GeneratorBasisData(int degree_,
-                     std::vector<std::vector<uint32_t>> columns_,
-                     std::vector<std::vector<uint32_t>> row_boundaries_,
-                     std::vector<std::pair<double, double>> row_grades_ = {},
-                     std::vector<std::pair<double, double>> column_grades_ = {},
-                     std::vector<uint32_t> row_cell_indices_ = {})
-      : active(true),
-        degree(degree_),
-        columns(std::move(columns_)),
-        row_boundaries(std::move(row_boundaries_)),
-        row_grades(std::move(row_grades_)),
-        column_grades(std::move(column_grades_)),
-        row_cell_indices(std::move(row_cell_indices_)) {}
-};
-
-template <typename Index>
-inline uint32_t checked_uint32_index(Index raw_idx, const std::string& error_prefix, const char* label) {
-  if constexpr (std::is_signed_v<Index>) {
-    if (raw_idx < 0) {
-      throw std::runtime_error(error_prefix + label + " index is negative.");
-    }
-  }
-
-  const auto wide = static_cast<uint64_t>(raw_idx);
-  if (wide > std::numeric_limits<uint32_t>::max()) {
-    throw std::runtime_error(error_prefix + label + " index exceeds uint32 range.");
-  }
-  return static_cast<uint32_t>(wide);
-}
-
-template <typename Columns>
-inline std::vector<std::vector<uint32_t>> convert_generator_columns(const Columns& columns,
-                                                                    const std::string& error_prefix,
-                                                                    const char* label) {
-  std::vector<std::vector<uint32_t>> out;
-  out.reserve(columns.size());
-  for (const auto& column : columns) {
-    std::vector<uint32_t> support;
-    support.reserve(column.size());
-    for (const auto row_idx : column) {
-      support.push_back(checked_uint32_index(row_idx, error_prefix, label));
-    }
-    out.push_back(std::move(support));
-  }
-  return out;
-}
-
-inline GeneratorBasisData generator_basis_from_legacy_dict(const nanobind::dict& basis) {
-  if (!basis.contains("degree") || !basis.contains("columns") || !basis.contains("row_boundaries")) {
-    throw std::runtime_error("Invalid `_generator_basis`: expected keys `degree`, `columns`, and `row_boundaries`.");
-  }
-
-  GeneratorBasisData out;
-  out.active = true;
-  out.degree = nanobind::cast<int>(basis["degree"]);
-  out.columns = nanobind::cast<std::vector<std::vector<uint32_t>>>(basis["columns"]);
-  out.row_boundaries = nanobind::cast<std::vector<std::vector<uint32_t>>>(basis["row_boundaries"]);
-  if (basis.contains("row_grades")) {
-    out.row_grades = nanobind::cast<std::vector<std::pair<double, double>>>(basis["row_grades"]);
-  }
-  if (basis.contains("column_grades")) {
-    out.column_grades = nanobind::cast<std::vector<std::pair<double, double>>>(basis["column_grades"]);
-  }
-  if (basis.contains("row_cell_indices")) {
-    out.row_cell_indices = nanobind::cast<std::vector<uint32_t>>(basis["row_cell_indices"]);
-  }
-  return out;
-}
-
-inline GeneratorBasisData generator_basis_from_object(const nanobind::handle& basis_handle) {
-  if (!basis_handle.is_valid() || basis_handle.is_none()) {
-    return GeneratorBasisData{};
-  }
-
-  if (nanobind::isinstance<nanobind::dict>(basis_handle)) {
-    return generator_basis_from_legacy_dict(nanobind::borrow<nanobind::dict>(basis_handle));
-  }
-
-  GeneratorBasisData out = nanobind::cast<GeneratorBasisData>(basis_handle);
-  out.active = true;
-  return out;
-}
-
-inline nanobind::object generator_basis_to_python_object(GeneratorBasisData basis) {
-  nanobind::module_::import_("multipers._slicer_nanobind");
-  basis.active = true;
-  return nanobind::cast(std::move(basis));
-}
-
-template <typename Wrapper, typename GeneratorMatrix>
-GeneratorBasisData generator_basis_from_degree_rows(const Wrapper& input_wrapper,
-                                                    int degree,
-                                                    GeneratorMatrix& generator_matrix,
-                                                    const char* backend_name) {
-  const std::string error_prefix = std::string(backend_name) + " generator-basis extraction failed: ";
-  const auto dimensions = input_wrapper.truc.get_dimensions();
-  const auto& boundaries = input_wrapper.truc.get_boundaries();
-  const auto& filtrations = input_wrapper.truc.get_filtration_values();
-  std::vector<size_t> degree_indices;
-  degree_indices.reserve(dimensions.size());
-  for (size_t i = 0; i < dimensions.size(); ++i) {
-    if (dimensions[i] == degree) {
-      degree_indices.push_back(i);
-    }
-  }
-  std::stable_sort(degree_indices.begin(), degree_indices.end(), [&](size_t a, size_t b) {
-    const auto& fa = filtrations[a];
-    const auto& fb = filtrations[b];
-    return fa(0, 1) < fb(0, 1) || (fa(0, 1) == fb(0, 1) && fa(0, 0) < fb(0, 0));
-  });
-
-  if (generator_matrix.row_indices.size() != generator_matrix.row_grades.size()) {
-    throw std::runtime_error(error_prefix + "row count mismatch.");
-  }
-  for (size_t i = 0; i < generator_matrix.row_indices.size(); ++i) {
-    const auto row_idx = static_cast<size_t>(generator_matrix.row_indices[i]);
-    if (row_idx >= degree_indices.size()) {
-      throw std::runtime_error(error_prefix + "row index out of range.");
-    }
-    const auto& filtration = filtrations[degree_indices[row_idx]];
-    const auto& grade = generator_matrix.row_grades[i];
-    if (filtration(0, 0) != grade.first || filtration(0, 1) != grade.second) {
-      throw std::runtime_error(error_prefix + "row grades do not match the original degree block.");
-    }
-  }
-
-  GeneratorBasisData basis;
-  basis.active = true;
-  basis.degree = degree;
-  basis.row_grades = generator_matrix.row_grades;
-  basis.column_grades = generator_matrix.column_grades;
-  basis.columns = convert_generator_columns(generator_matrix.columns, error_prefix, "column support");
-  basis.row_boundaries.reserve(generator_matrix.row_indices.size());
-  basis.row_cell_indices.reserve(generator_matrix.row_indices.size());
-  for (auto raw_row_idx : generator_matrix.row_indices) {
-    const auto row_idx = static_cast<size_t>(raw_row_idx);
-    const auto idx = degree_indices[row_idx];
-    std::vector<uint32_t> boundary;
-    boundary.reserve(boundaries[idx].size());
-    for (auto value : boundaries[idx]) {
-      boundary.push_back(checked_uint32_index(value, error_prefix, "row boundary"));
-    }
-    basis.row_boundaries.push_back(std::move(boundary));
-    basis.row_cell_indices.push_back(checked_uint32_index(idx, error_prefix, "row cell"));
-  }
-
-  return basis;
-}
-
-template <typename Wrapper, typename GeneratorMatrix>
-nanobind::object generator_basis_object_from_degree_rows(const Wrapper& input_wrapper,
-                                                         int degree,
-                                                         GeneratorMatrix& generator_matrix,
-                                                         const char* backend_name) {
-  return generator_basis_to_python_object(
-      generator_basis_from_degree_rows(input_wrapper, degree, generator_matrix, backend_name));
-}
-
 template <typename Wrapper, typename ComplexFactory, typename ResultFactory>
 nanobind::object build_minpres_slicer_output_for_target(nanobind::object target,
-                                                         const Wrapper& input_wrapper,
-                                                         int degree,
-                                                         bool keep_generators,
-                                                         const char* backend_name,
-                                                         ComplexFactory&& compute_complex,
-                                                         ResultFactory&& compute_with_generators) {
+                                                        const Wrapper& input_wrapper,
+                                                        int degree,
+                                                        bool keep_generators,
+                                                        const char* backend_name,
+                                                        ComplexFactory&& compute_complex,
+                                                        ResultFactory&& compute_with_generators) {
   nanobind::object out = target.type()();
   auto& out_wrapper = nanobind::cast<Wrapper&>(out);
 
@@ -201,18 +27,21 @@ nanobind::object build_minpres_slicer_output_for_target(nanobind::object target,
     {
       nanobind::gil_scoped_release release;
       auto complex = std::forward<ComplexFactory>(compute_complex)();
-      build_slicer_from_complex(out_wrapper.truc, complex);
+      build_slicer_from_complex(out_wrapper.get_slicer(), complex);
     }
     return out;
   }
 
-  auto basis = [&]() {
+  auto result = [&]() {
     nanobind::gil_scoped_release release;
     auto result = std::forward<ResultFactory>(compute_with_generators)();
-    build_slicer_from_complex(out_wrapper.truc, result.first);
-    return generator_basis_from_degree_rows(input_wrapper, degree, result.second, backend_name);
+    build_slicer_from_complex(out_wrapper.get_slicer(), result.first);
+    if (result.second.row_indices.size() != result.second.row_grades.size()) {
+      throw std::runtime_error(std::string(backend_name) + " generator-basis extraction failed: row count mismatch.");
+    }
+    return result.second;
   }();
-  out_wrapper.generator_basis = generator_basis_to_python_object(std::move(basis));
+  out_wrapper.set_generator_basis(input_wrapper.get_slicer().get_filtered_complex(), degree, result);
   return out;
 }
 
diff --git a/multipers/ext_interface/nanobind_registry_helpers.hpp b/multipers/ext_interface/nanobind_registry_helpers.hpp
index b1dad84b..4021fb25 100644
--- a/multipers/ext_interface/nanobind_registry_helpers.hpp
+++ b/multipers/ext_interface/nanobind_registry_helpers.hpp
@@ -3,18 +3,20 @@
 #include <nanobind/nanobind.h>
 
 #include <optional>
-#include <type_traits>
 #include <utility>
 
-#include "Persistence_slices_interface.h"
-#include "Simplex_tree_multi_interface.h"
 #include "nanobind_wrapper_types.hpp"
 #include "nanobind_object_utils.hpp"
+#include "../gudhi/Slicer_interface.h"
 
 namespace nb = nanobind;
 
 namespace multipers::nanobind_helpers {
 
+template <typename Slicer>
+using PySlicer =
+    Gudhi::multi_persistence::Slicer_interface<typename Slicer::Filtration_value, typename Slicer::Persistence>;
+
 template <typename... Types>
 struct type_list {};
 
@@ -80,7 +82,7 @@ inline bool is_known_simplextree_template_id(int template_id) {
 template <typename Func>
 decltype(auto) visit_slicer_wrapper(const nb::handle& input, Func&& func) {
   return dispatch_slicer_by_template_id(template_id_of(input), [&]<typename Desc>() -> decltype(auto) {
-    auto& wrapper = nb::cast<typename Desc::wrapper&>(input);
+    auto& wrapper = nb::cast<typename Desc::interface&>(input);
     return std::forward<Func>(func).template operator()<Desc>(wrapper);
   });
 }
@@ -88,7 +90,7 @@ decltype(auto) visit_slicer_wrapper(const nb::handle& input, Func&& func) {
 template <typename Func>
 decltype(auto) visit_const_slicer_wrapper(const nb::handle& input, Func&& func) {
   return dispatch_slicer_by_template_id(template_id_of(input), [&]<typename Desc>() -> decltype(auto) {
-    const auto& wrapper = nb::cast<const typename Desc::wrapper&>(input);
+    const auto& wrapper = nb::cast<const typename Desc::interface&>(input);
     return std::forward<Func>(func).template operator()<Desc>(wrapper);
   });
 }
@@ -156,7 +158,7 @@ bool has_slicer_filtration_container(type_list<Ds...>, std::string filtration_co
 }
 
 inline int related_slicer_template_id(const nb::handle& source, bool is_kcritical, const std::string& filtration_container) {
-  return visit_const_slicer_wrapper(source, [&]<typename Desc>(const typename Desc::wrapper&) -> int {
+  return visit_const_slicer_wrapper(source, [&]<typename Desc>(const typename Desc::interface&) -> int {
     return select_slicer_template_id(SlicerDescriptorList{},
                                      Desc::is_vine,
                                      is_kcritical,
@@ -173,7 +175,7 @@ inline bool is_slicer_object(const nb::handle& input) {
     return false;
   }
   return dispatch_slicer_by_template_id(
-      *template_id, [&]<typename Desc>() -> bool { return nb::isinstance<typename Desc::wrapper>(input); });
+      *template_id, [&]<typename Desc>() -> bool { return nb::isinstance<typename Desc::interface>(input); });
 }
 
 inline bool is_simplextree_object(const nb::handle& input) {
diff --git a/multipers/ext_interface/nanobind_registry_runtime.cpp b/multipers/ext_interface/nanobind_registry_runtime.cpp
index a32d76bd..6507f73c 100644
--- a/multipers/ext_interface/nanobind_registry_runtime.cpp
+++ b/multipers/ext_interface/nanobind_registry_runtime.cpp
@@ -23,7 +23,7 @@ inline bool is_canonical_kcontiguous_f64_slicer_object(const nb::handle& input)
 
 inline nb::object slicer_class_from_template_id(int template_id) {
   return dispatch_slicer_by_template_id(template_id, [&]<typename Desc>() -> nb::object {
-    return nb::borrow<nb::object>(nb::type<typename Desc::wrapper>());
+    return nb::borrow<nb::object>(nb::type<typename Desc::interface>());
   });
 }
 
@@ -35,9 +35,9 @@ inline nb::object simplextree_class_from_template_id(int template_id) {
 
 template <typename CanonicalSlicer>
 void copy_into_canonical_slicer_impl(const nb::handle& input, CanonicalSlicer& output) {
-  visit_const_slicer_wrapper(input, [&]<typename Desc>(const typename Desc::wrapper& source) {
+  visit_const_slicer_wrapper(input, [&]<typename Desc>(const typename Desc::interface& source) {
     nb::gil_scoped_release release;
-    output = CanonicalSlicer(source.truc);
+    output = CanonicalSlicer(source.get_slicer());
   });
 }
 
@@ -49,9 +49,8 @@ nb::object ensure_canonical_slicer_object_impl(const nb::object& input, IsCanoni
 
   nb::object out = nb::borrow<nb::object>(nb::type<CanonicalWrapper>())();
   auto& out_wrapper = nb::cast<CanonicalWrapper&>(out);
-  copy_into_canonical_slicer_impl(input, out_wrapper.truc);
-  visit_const_slicer_wrapper(input, [&]<typename Desc>(const typename Desc::wrapper& source) {
-    copy_slicer_python_state(out_wrapper, source);
+  visit_const_slicer_wrapper(input, [&]<typename Desc>(const typename Desc::interface& source) {
+    out_wrapper = typename Desc::interface(source);
   });
   return out;
 }
diff --git a/multipers/ext_interface/nanobind_registry_runtime.hpp b/multipers/ext_interface/nanobind_registry_runtime.hpp
index 0dd0257c..330c69f1 100644
--- a/multipers/ext_interface/nanobind_registry_runtime.hpp
+++ b/multipers/ext_interface/nanobind_registry_runtime.hpp
@@ -10,6 +10,7 @@
 
 #include "contiguous_slicer_bridge.hpp"
 #include "nanobind_wrapper_types.hpp"
+#include "nanobind_registry_helpers.hpp"
 
 namespace multipers::nanobind_helpers {
 
@@ -37,18 +38,18 @@ BifiltrationMinpresDegreeBlock extract_bifiltration_minpres_degree_block(const W
   if (degree < 0) {
     throw std::runtime_error("Expected a minimal-presentation slicer.");
   }
-  if (wrapper.truc.get_number_of_parameters() != 2) {
+  if (wrapper.get_slicer().get_number_of_parameters() != 2) {
     throw std::runtime_error("Only 2-parameter minimal-presentation slicers are supported.");
   }
 
   BifiltrationMinpresDegreeBlock out;
   out.degree = degree;
-  out.filtration_grid = wrapper.filtration_grid;
-  out.is_squeezed = has_nonempty_filtration_grid(wrapper.filtration_grid);
+  out.filtration_grid = wrapper.get_filtration_grid();
+  out.is_squeezed = has_nonempty_filtration_grid(wrapper.get_filtration_grid());
 
-  const auto& dimensions = wrapper.truc.get_dimensions();
-  const auto& filtrations = wrapper.truc.get_filtration_values();
-  const auto& boundaries = wrapper.truc.get_boundaries();
+  const auto& dimensions = wrapper.get_slicer().get_dimensions();
+  const auto& filtrations = wrapper.get_slicer().get_filtration_values();
+  const auto& boundaries = wrapper.get_slicer().get_boundaries();
 
   out.row_begin = std::lower_bound(dimensions.begin(), dimensions.end(), degree) - dimensions.begin();
   out.row_end = std::lower_bound(dimensions.begin(), dimensions.end(), degree + 1) - dimensions.begin();
@@ -98,48 +99,11 @@ nanobind::object build_canonical_contiguous_f64_slicer_object_from_complex(const
   auto& out_wrapper = nanobind::cast<canonical_contiguous_f64_slicer_wrapper&>(out);
   {
     nanobind::gil_scoped_release release;
-    build_slicer_from_complex(out_wrapper.truc, complex);
+    build_slicer_from_complex(out_wrapper.get_slicer(), complex);
   }
   return out;
 }
 
-template <typename Wrapper>
-Wrapper colexical_slicer_copy(const Wrapper& source) {
-  decltype(build_permuted_slicer(source.truc)) stuff;
-  {
-    nanobind::gil_scoped_release release;
-    stuff = build_permuted_slicer(source.truc);
-  }
-  Wrapper out;
-  out.truc = std::move(stuff.first);
-  copy_slicer_python_state(out, source);
-  return out;
-}
-
-template <typename Wrapper>
-std::pair<Wrapper, std::vector<uint32_t>> colexical_slicer_copy_with_permutation(const Wrapper& source) {
-  decltype(build_permuted_slicer(source.truc)) stuff;
-  {
-    nanobind::gil_scoped_release release;
-    stuff = build_permuted_slicer(source.truc);
-  }
-  Wrapper out;
-  out.truc = std::move(stuff.first);
-  copy_slicer_python_state(out, source);
-  return {std::move(out), std::vector<uint32_t>(stuff.second.begin(), stuff.second.end())};
-}
-
-template <typename Wrapper>
-Wrapper permuted_slicer_copy(const Wrapper& source, const std::vector<uint32_t>& permutation) {
-  Wrapper out;
-  {
-    nanobind::gil_scoped_release release;
-    out.truc = build_permuted_slicer(source.truc, permutation);
-  }
-  copy_slicer_python_state(out, source);
-  return out;
-}
-
 nanobind::object astype_slicer_to_template_id(const nanobind::object& source, int template_id);
 nanobind::object astype_simplextree_to_template_id(const nanobind::object& source, int template_id);
 nanobind::object astype_slicer_to_original_type(const nanobind::object& original, const nanobind::object& source);
diff --git a/multipers/ext_interface/nanobind_wrapper_types.hpp b/multipers/ext_interface/nanobind_wrapper_types.hpp
index 1eb778e8..65d551d4 100644
--- a/multipers/ext_interface/nanobind_wrapper_types.hpp
+++ b/multipers/ext_interface/nanobind_wrapper_types.hpp
@@ -2,26 +2,11 @@
 
 #include <nanobind/nanobind.h>
 
-#include <algorithm>
-#include <cmath>
 #include <cstdint>
-#include <stdexcept>
-#include <string>
-#include <unordered_map>
 #include <vector>
 
 namespace multipers::nanobind_helpers {
 
-using squeezed_coordinate_remap = std::vector<std::unordered_map<int64_t, int64_t>>;
-
-struct CompactedSqueezedFiltrationGrid {
-  nanobind::object filtration_grid;
-  std::vector<std::vector<int64_t>> coordinates;
-  squeezed_coordinate_remap remap;
-
-  CompactedSqueezedFiltrationGrid() : filtration_grid(nanobind::none()) {}
-};
-
 inline bool has_nonempty_filtration_grid(const nanobind::handle& grid) {
   if (!grid.is_valid() || grid.is_none() || !nanobind::hasattr(grid, "__len__") || nanobind::len(grid) == 0) {
     return false;
@@ -33,86 +18,6 @@ inline bool has_nonempty_filtration_grid(const nanobind::handle& grid) {
   return false;
 }
 
-inline int64_t squeezed_raw_index_from_value(double value, size_t parameter) {
-  if (!std::isfinite(value)) {
-    throw std::runtime_error("Expected finite squeezed filtration coordinates for parameter " +
-                             std::to_string(parameter) + ".");
-  }
-  const double rounded = std::round(value);
-  if (std::fabs(value - rounded) > 1e-9) {
-    throw std::runtime_error("Expected integer squeezed filtration coordinates for parameter " +
-                             std::to_string(parameter) + ".");
-  }
-  return static_cast<int64_t>(rounded);
-}
-
-inline int64_t normalized_squeezed_index(int64_t raw_index, int64_t row_size, size_t parameter) {
-  int64_t normalized = raw_index;
-  if (normalized < 0) {
-    normalized += row_size;
-  }
-  if (normalized < 0 || normalized >= row_size) {
-    throw std::runtime_error("Squeezed filtration coordinate is outside the filtration grid for parameter " +
-                             std::to_string(parameter) + ".");
-  }
-  return normalized;
-}
-
-inline int64_t normalized_squeezed_index_or_sentinel(int64_t raw_index, int64_t row_size, size_t parameter) {
-  int64_t normalized = raw_index;
-  if (normalized < 0) {
-    normalized += row_size;
-  }
-  if (normalized == row_size) {
-    return normalized;
-  }
-  return normalized_squeezed_index(raw_index, row_size, parameter);
-}
-
-inline CompactedSqueezedFiltrationGrid compact_squeezed_filtration_grid(
-    const nanobind::object& filtration_grid,
-    std::vector<std::vector<int64_t>> used_coordinates) {
-  const size_t num_parameters = used_coordinates.size();
-  auto compact_grid = nanobind::steal<nanobind::tuple>(PyTuple_New(static_cast<Py_ssize_t>(num_parameters)));
-  if (!compact_grid.is_valid()) {
-    throw nanobind::python_error();
-  }
-
-  CompactedSqueezedFiltrationGrid out;
-  out.coordinates = std::move(used_coordinates);
-  out.remap.resize(num_parameters);
-
-  for (size_t parameter = 0; parameter < num_parameters; ++parameter) {
-    auto& current_coordinates = out.coordinates[parameter];
-    std::sort(current_coordinates.begin(), current_coordinates.end());
-    current_coordinates.erase(std::unique(current_coordinates.begin(), current_coordinates.end()),
-                              current_coordinates.end());
-
-    nanobind::object row = filtration_grid[parameter];
-    const int64_t row_size = static_cast<int64_t>(nanobind::len(row));
-    nanobind::list selection;
-    auto& remap = out.remap[parameter];
-    for (size_t i = 0; i < current_coordinates.size(); ++i) {
-      const int64_t raw_index = current_coordinates[i];
-      const int64_t normalized = normalized_squeezed_index_or_sentinel(raw_index, row_size, parameter);
-      remap.emplace(raw_index, static_cast<int64_t>(i));
-      if (normalized != row_size) {
-        selection.append(nanobind::int_(raw_index));
-      }
-    }
-
-    nanobind::object compact_row = row.attr("__getitem__")(selection);
-    PyTuple_SET_ITEM(compact_grid.ptr(), static_cast<Py_ssize_t>(parameter), compact_row.release().ptr());
-  }
-
-  out.filtration_grid = compact_grid;
-  return out;
-}
-
-inline double remap_squeezed_coordinate(double value, size_t parameter, const squeezed_coordinate_remap& remap) {
-  return static_cast<double>(remap.at(parameter).at(squeezed_raw_index_from_value(value, parameter)));
-}
-
 template <typename Value>
 inline std::vector<std::vector<Value>> cast_squeezed_coordinate_grid(
     const std::vector<std::vector<int64_t>>& coordinates) {
@@ -128,76 +33,6 @@ inline std::vector<std::vector<Value>> cast_squeezed_coordinate_grid(
   return out;
 }
 
-struct PySlicerPythonState {
-  nanobind::object filtration_grid;
-  nanobind::object generator_basis;
-  std::vector<double> current_line_basepoint;
-  std::vector<double> current_line_direction;
-  int pres_degree;
-  bool is_minpres;
-  bool is_minres;
-  bool has_current_line;
-
-  PySlicerPythonState()
-      : filtration_grid(nanobind::none()),
-        generator_basis(nanobind::none()),
-        pres_degree(-1),
-        is_minpres(false),
-        is_minres(false),
-        has_current_line(false) {}
-};
-
-template <typename State>
-inline void clear_slicer_current_line(State& state) {
-  state.current_line_basepoint.clear();
-  state.current_line_direction.clear();
-  state.has_current_line = false;
-}
-
-template <typename State>
-inline int slicer_minpres_degree(const State& state) {
-  return state.is_minpres ? state.pres_degree : -1;
-}
-
-template <typename State>
-inline void mark_slicer_minpres(State& state, int degree, bool is_minres = false) {
-  state.is_minpres = degree >= 0;
-  if (state.is_minpres) state.pres_degree = degree;
-  state.is_minres = state.is_minpres && is_minres;
-}
-
-template <typename State>
-inline void mark_slicer_pres(State& state, int degree) {
-  state.pres_degree = degree;
-  state.is_minpres = false;
-  state.is_minres = false;
-}
-
-template <typename TargetState, typename SourceState>
-inline void copy_slicer_python_state(TargetState& target, const SourceState& source) {
-  target.filtration_grid = source.filtration_grid;
-  target.generator_basis = source.generator_basis;
-  target.current_line_basepoint = source.current_line_basepoint;
-  target.current_line_direction = source.current_line_direction;
-  target.pres_degree = source.pres_degree;
-  target.is_minpres = source.is_minpres;
-  target.is_minres = source.is_minres;
-  target.has_current_line = source.has_current_line;
-}
-
-template <typename State>
-inline void reset_slicer_python_state(State& state) {
-  state.filtration_grid = nanobind::none();
-  state.generator_basis = nanobind::none();
-  clear_slicer_current_line(state);
-  mark_slicer_pres(state, -1);
-}
-
-template <typename Slicer>
-struct PySlicer : PySlicerPythonState {
-  Slicer truc;
-};
-
 struct PySimplexTreePythonState {
   nanobind::object filtration_grid;
 
diff --git a/multipers/filtrations/filtrations.py b/multipers/filtrations/filtrations.py
index d79c735b..c745ead2 100644
--- a/multipers/filtrations/filtrations.py
+++ b/multipers/filtrations/filtrations.py
@@ -704,17 +704,18 @@ def Cubical(image: ArrayLike, **slicer_kwargs):
 
         _Slicer = Slicer(return_type_only=True, **slicer_kwargs)
         builder_name = f"_build_bitmap_{np.dtype(dtype).name.replace('float64', 'f64').replace('int32', 'i32')}"
-        if not hasattr(mps, builder_name):
-            raise ValueError(
-                f"Invalid dtype. Got {bitmap.dtype=}, was expecting {available_dtype=}."
-            )
+        # if not hasattr(mps, builder_name):
+        #     raise ValueError(
+        #         f"Invalid dtype. Got {bitmap.dtype=}, was expecting {available_dtype=}."
+        #     )
         timing.substep("resolved_builder")
 
         flattened = np.ascontiguousarray(bitmap.reshape(-1, bitmap.shape[-1]))
         shape = np.ascontiguousarray(bitmap.shape[:-1], dtype=np.uint32)
         timing.substep("prepared_bitmap")
-        base = getattr(mps, builder_name)(flattened, shape)
-        slicer = base if type(base) is _Slicer else _Slicer(base)
+        # base = getattr(mps, builder_name)(flattened, shape)
+        # slicer = base if type(base) is _Slicer else _Slicer(flattened, shape)
+        slicer = _Slicer(flattened, shape)
         timing.substep("built_bitmap")
 
         if grid is not None:
diff --git a/multipers/graph_mph0/nanobind_interface.cpp b/multipers/graph_mph0/nanobind_interface.cpp
index d0fa4d09..bfcae313 100644
--- a/multipers/graph_mph0/nanobind_interface.cpp
+++ b/multipers/graph_mph0/nanobind_interface.cpp
@@ -158,9 +158,9 @@ nb::object graph_mph0_slicer_output(Complex&& complex, std::int32_t degree, bool
   auto& wrapper = nb::cast<Wrapper&>(out);
   {
     nb::gil_scoped_release release;
-    multipers::build_slicer_from_complex(wrapper.truc, complex);
+    multipers::build_slicer_from_complex(wrapper.get_slicer(), complex);
   }
-  multipers::nanobind_helpers::mark_slicer_minpres(wrapper, degree, is_minres);
+  wrapper.set_min_pres_degree(degree, is_minres);
   return out;
 }
 
@@ -237,7 +237,7 @@ nb::object graph_mph0_minimal_presentation(const nb::handle& slicer, std::int32_
     if constexpr (Desc::is_kcritical) {
       throw std::invalid_argument("graph requires a one-critical filtration");
     } else {
-      if (wrapper.truc.get_number_of_parameters() != 2) {
+      if (wrapper.get_slicer().get_number_of_parameters() != 2) {
         throw std::invalid_argument("graph requires exactly two filtration parameters");
       }
 
@@ -245,9 +245,9 @@ nb::object graph_mph0_minimal_presentation(const nb::handle& slicer, std::int32_
           std::conditional_t<std::is_same_v<typename Desc::value_type, std::int32_t>, std::int32_t, double>;
       auto complex = [&] {
         nb::gil_scoped_release release;
-        const auto& dimensions = wrapper.truc.get_dimensions();
-        const auto& boundaries = wrapper.truc.get_boundaries();
-        const auto& filtrations = wrapper.truc.get_filtration_values();
+        const auto& dimensions = wrapper.get_slicer().get_dimensions();
+        const auto& boundaries = wrapper.get_slicer().get_boundaries();
+        const auto& filtrations = wrapper.get_slicer().get_filtration_values();
         auto input = build_graph_mph0_input(
             dimensions.size(),
             degree,
@@ -313,13 +313,13 @@ nb::object graph_mph0_minimal_presentation(const nb::handle& slicer, std::int32_
         if (full_resolution) {
           return graph_mph0_slicer_output<ContiguousI32MatrixSlicerWrapper>(std::move(complex), degree, true);
         }
-        return graph_mph0_slicer_output<typename ContiguousI32GraphSlicerDesc::wrapper>(
+        return graph_mph0_slicer_output<typename ContiguousI32GraphSlicerDesc::interface>(
             std::move(complex), degree, false);
       } else {
         if (full_resolution) {
           return graph_mph0_slicer_output<ContiguousF64MatrixSlicerWrapper>(std::move(complex), degree, true);
         }
-        return graph_mph0_slicer_output<typename ContiguousF64GraphSlicerDesc::wrapper>(
+        return graph_mph0_slicer_output<typename ContiguousF64GraphSlicerDesc::interface>(
             std::move(complex), degree, false);
       }
     }
diff --git a/multipers/gudhi/Module_interface.h b/multipers/gudhi/Module_interface.h
index 3101071e..4dd5b34a 100644
--- a/multipers/gudhi/Module_interface.h
+++ b/multipers/gudhi/Module_interface.h
@@ -38,6 +38,7 @@
 
 #include <gudhi/Debug_utils.h>
 #include <gudhi/simple_mdspan.h>
+#include <gudhi/multi_persistence_landscapes.h>
 #include <gudhi/Multi_persistence/Module.h>
 #include <gudhi/Multi_persistence/module_helpers.h>
 #include <gudhi/Multi_persistence/Line.h>
@@ -46,23 +47,9 @@
 #include <python_interfaces/numpy_utils.h>
 #include <python_interfaces/construction_utils.h>
 
-#include "gudhi/module_landscapes.hpp"
-
 namespace Gudhi {
 namespace multi_persistence {
 
-template <typename T, typename... Args>
-Numpy_span<T> contiguous_numpy_span(const nanobind::ndarray<const T, Args...> &array) {
-  return {array.data(), array.data() + array.shape(0)};
-}
-
-template <typename T>
-Numpy_2d_span<T> contiguous_numpy_2d_span(
-    const nanobind::ndarray<const T, nanobind::ndim<2>, nanobind::c_contig> &array) {
-  typename Numpy_2d_span<T>::Array gudhi_array(array);
-  return Numpy_2d_span<T>(gudhi_array);
-}
-
 /**
  * @private
  */
@@ -124,24 +111,28 @@ class Module_interface {
   }
 
   auto get_box_lower_corner_view() const {
-    // no transfer of ownership, dies together with the box
-    return nanobind::ndarray<const T, nanobind::numpy>(box_.data(), {box_.size() / 2});
+    // no transfer of ownership, dies together with the module
+    // careful: can invalidate if box_ gets reallocated by some modifications
+    return _wrap_view_as_numpy_array(nanobind::find(this), box_.data(), box_.size() / 2);
   }
 
   auto get_box_upper_corner_view() const {
     auto shift = box_.size() / 2;
-    // no transfer of ownership, dies together with the box
-    return nanobind::ndarray<const T, nanobind::numpy>(box_.data() + shift, {shift});
+    // no transfer of ownership, dies together with the module
+    // careful: can invalidate if box_ gets reallocated by some modifications
+    return _wrap_view_as_numpy_array(nanobind::find(this), box_.data() + shift, shift);
   }
 
   auto get_box_view_ro() const {
-    // no transfer of ownership, dies together with the box
-    return nanobind::ndarray<const T, nanobind::numpy>(box_.data(), {2, box_.size() / 2});
+    // no transfer of ownership, dies together with the module
+    // careful: can invalidate if box_ gets reallocated by some modifications
+    return _wrap_view_as_numpy_array(nanobind::find(this), box_.data(), 2, box_.size() / 2);
   }
 
   auto get_box_view() {
-    // no transfer of ownership, dies together with the box
-    return nanobind::ndarray<T, nanobind::numpy>(box_.data(), {2, box_.size() / 2});
+    // no transfer of ownership, dies together with the module
+    // careful: can invalidate if box_ gets reallocated by some modifications
+    return _wrap_view_as_numpy_array<false>(nanobind::find(this), box_.data(), 2, box_.size() / 2);
   }
 
   Module_interface &set_box(const Box<value_type> &box) {
@@ -280,10 +271,10 @@ class Module_interface {
     {
       nanobind::gil_scoped_release release;
       Dimension dim = degree < 0 ? get_null_value<Dimension>() : static_cast<Dimension>(degree);
-      auto baseView = contiguous_numpy_span(basepoint);
+      auto baseView = Numpy_span(basepoint);
       Line<T> line;
       if (direction.has_value()) {
-        auto dirView = contiguous_numpy_span(*direction);
+        auto dirView = Numpy_span(*direction);
         line = Line<T>(baseView.begin(), baseView.end(), dirView.begin(), dirView.end());
       } else {
         line = Line<T>(baseView.begin(), baseView.end());
@@ -304,11 +295,11 @@ class Module_interface {
     {
       nanobind::gil_scoped_release release;
       Dimension dim = degree < 0 ? get_null_value<Dimension>() : static_cast<Dimension>(degree);
-      auto basesView = contiguous_numpy_2d_span(basepoints);
+      auto basesView = Numpy_2d_span(basepoints);
       numberOfLines = basesView.size();
       std::vector<Line<T>> lines(numberOfLines);
       if (directions.has_value()) {
-        auto dirsView = contiguous_numpy_2d_span(*directions);
+        auto dirsView = Numpy_2d_span(*directions);
         if (numberOfLines != dirsView.size())
           throw std::invalid_argument("If directions are specified, there need to be as many as base points.");
         for (std::size_t i = 0; i < lines.size(); ++i) {
@@ -340,7 +331,7 @@ class Module_interface {
     {
       nanobind::gil_scoped_release release;
       Dimension dim = degree < 0 ? get_null_value<Dimension>() : static_cast<Dimension>(degree);
-      module_.rescale(contiguous_numpy_span(rescaleFactors), dim);
+      module_.rescale(Numpy_span(rescaleFactors), dim);
     }
     return *this;
   }
@@ -358,7 +349,7 @@ class Module_interface {
     {
       nanobind::gil_scoped_release release;
       Dimension dim = degree < 0 ? get_null_value<Dimension>() : static_cast<Dimension>(degree);
-      module_.translate(contiguous_numpy_span(translation), dim);
+      module_.translate(Numpy_span(translation), dim);
     }
     return *this;
   }
@@ -376,7 +367,7 @@ class Module_interface {
       nanobind::gil_scoped_release release;
       std::vector<Numpy_span<T>> views;
       views.reserve(grid.size());
-      for (const auto &axis : grid) views.push_back(contiguous_numpy_span(axis));
+      for (const auto &axis : grid) views.push_back(Numpy_span(axis));
       module_.evaluate_in_grid(views);
     }
     return *this;
@@ -385,7 +376,7 @@ class Module_interface {
   Module_interface &evaluate_in_grid(Tensor2D grid) {
     {
       nanobind::gil_scoped_release release;
-      module_.evaluate_in_grid(contiguous_numpy_2d_span(grid));
+      module_.evaluate_in_grid(Numpy_2d_span(grid));
     }
     return *this;
   }
@@ -394,7 +385,7 @@ class Module_interface {
     Module_interface out(box_);
     {
       nanobind::gil_scoped_release release;
-      out.module_ = Gudhi::multi_persistence::build_permuted_module(module_, contiguous_numpy_span(permutation));
+      out.module_ = Gudhi::multi_persistence::build_permuted_module(module_, Numpy_span(permutation));
     }
     return out;
   }
@@ -413,7 +404,7 @@ class Module_interface {
     Module_interface out(box_);
     {
       nanobind::gil_scoped_release release;
-      out.module_ = Gudhi::multi_persistence::build_module_of_dimension(module_, contiguous_numpy_span(degrees));
+      out.module_ = Gudhi::multi_persistence::build_module_of_dimension(module_, Numpy_span(degrees));
     }
     return out;
   }
@@ -438,13 +429,20 @@ class Module_interface {
         static_cast<std::size_t>(module_.get_number_of_parameters()) != box.shape(1))
       throw std::invalid_argument(
           "The given box has not the same number of coordinates than parameters in the stored module");
+    auto ksView = Numpy_span(ks);
+    for (auto k : ksView) {
+      if (k < 0) throw std::invalid_argument("Landscape indices must be positive.");
+      if (static_cast<std::size_t>(k) == std::numeric_limits<std::size_t>::max())
+        throw std::invalid_argument("Landscape index is too large.");
+    }
 
     std::vector<maybe_make_signed_t<T>> out;
-    auto resolutionView = contiguous_numpy_span(resolution);
+    auto resolutionView = Numpy_span(resolution);
+    if (resolutionView.size() < 2) throw std::invalid_argument("Not enough resolution values.");
     {
       nanobind::gil_scoped_release release;
-      out = multipers::detail::compute_module_landscapes(
-          module_, degree, contiguous_numpy_span(ks), get_box_from_tensor(box), resolutionView, n_jobs);
+      out = Gudhi::multi_persistence::compute_set_of_module_landscapes(
+          module_, degree, ksView, get_box_from_tensor(box), resolutionView, n_jobs);
     }
     return _wrap_as_numpy_array(std::move(out), ks.shape(0), resolutionView[0], resolutionView[1]);
   }
@@ -455,14 +453,21 @@ class Module_interface {
                                     const std::vector<Tensor1D> &grid,
                                     int n_jobs) {
     if (degree < 0) throw std::invalid_argument("Landscape dimension has to be positive.");
+    auto ksView = Numpy_span(ks);
+    for (auto k : ksView) {
+      if (k < 0) throw std::invalid_argument("Landscape indices must be positive.");
+      if (static_cast<std::size_t>(k) == std::numeric_limits<std::size_t>::max())
+        throw std::invalid_argument("Landscape index is too large.");
+    }
+    if (grid.size() < 2) throw std::invalid_argument("First axis of the grid has not enough values.");
 
     std::vector<maybe_make_signed_t<T>> out;
     {
       nanobind::gil_scoped_release release;
       std::vector<Numpy_span<T>> views;
       views.reserve(grid.size());
-      for (const auto &axis : grid) views.push_back(contiguous_numpy_span(axis));
-      out = multipers::detail::compute_module_landscapes(module_, degree, contiguous_numpy_span(ks), views, n_jobs);
+      for (const auto &axis : grid) views.push_back(Numpy_span(axis));
+      out = Gudhi::multi_persistence::compute_set_of_module_landscapes(module_, degree, ksView, views, n_jobs);
     }
     return _wrap_as_numpy_array(std::move(out), ks.shape(0), grid[0].shape(0), grid[1].shape(0));
   }
@@ -485,8 +490,8 @@ class Module_interface {
     {
       nanobind::gil_scoped_release release;
       out = Gudhi::multi_persistence::compute_module_pixels(module_,
-                                                            contiguous_numpy_2d_span(coordinates),
-                                                            contiguous_numpy_span(degrees),
+                                                            Numpy_2d_span(coordinates),
+                                                            Numpy_span(degrees),
                                                             get_box_from_tensor(box),
                                                             delta,
                                                             p,
@@ -511,7 +516,7 @@ class Module_interface {
     {
       nanobind::gil_scoped_release release;
       out = Gudhi::multi_persistence::compute_module_distances_to(
-          module_, contiguous_numpy_2d_span(pts), signed_distance, n_jobs);
+          module_, Numpy_2d_span(pts), signed_distance, n_jobs);
     }
     return _wrap_as_numpy_array(std::move(out), pts.shape(0), module_.size());
   }
@@ -542,7 +547,7 @@ class Module_interface {
   nanobind::tuple get_flat_indices_in_grid(const std::vector<Tensor1D> &grid) {
     std::vector<Numpy_span<T>> views;
     views.reserve(grid.size());
-    for (const auto &axis : grid) views.push_back(contiguous_numpy_span(axis));
+    for (const auto &axis : grid) views.push_back(Numpy_span(axis));
     return _get_flat_indices_in_grid(views);
   }
 
@@ -562,33 +567,22 @@ class Module_interface {
 
   friend char *serialize_value_to_char_buffer(const Module_interface &value, char *start) {
     char *curr = start;
-    const std::size_t length = value.box_.size();
-    const std::size_t argSize = sizeof(T) * length;
-    const std::size_t typeSize = sizeof(std::size_t);
-    memcpy(curr, &length, typeSize);
-    curr += typeSize;
-    memcpy(curr, value.box_.data(), argSize);
-    curr += argSize;
     curr = serialize_value_to_char_buffer(value.module_, curr);
+    curr = serialize_value_to_char_buffer(value.box_, curr);
     return curr;
   }
 
   friend const char *deserialize_value_from_char_buffer(Module_interface &value, const char *start) {
     const char *curr = start;
-    const std::size_t typeSize = sizeof(std::size_t);
-    std::size_t length;
-    memcpy(&length, curr, typeSize);
-    curr += typeSize;
-    std::size_t argSize = sizeof(T) * length;
-    value.box_.resize(length);
-    memcpy(value.box_.data(), curr, argSize);
-    curr += argSize;
     curr = deserialize_value_from_char_buffer(value.module_, curr);
+    curr = deserialize_value_from_char_buffer(value.box_, curr);
     return curr;
   }
 
   friend std::size_t get_serialization_size_of(const Module_interface &value) {
-    return sizeof(std::size_t) + (sizeof(T) * value.box_.size()) + get_serialization_size_of(value.module_);
+    std::size_t size = get_serialization_size_of(value.module_);
+    size += get_serialization_size_of(value.box_);
+    return size;
   }
 
   friend void swap(Module_interface &mod1, Module_interface &mod2) noexcept {
@@ -608,7 +602,7 @@ class Module_interface {
   static Box<T> get_box_from_tensor(Tensor2D box) {
     if (box.shape(0) != 2) throw std::invalid_argument("Box has to be represented by two corners.");
 
-    auto boxView = contiguous_numpy_2d_span(box);
+    auto boxView = Numpy_2d_span(box);
     auto lowerView = boxView[0];
     auto upperView = boxView[1];
     return {lowerView.begin(), lowerView.end(), upperView.begin(), upperView.end()};
@@ -622,7 +616,7 @@ class Module_interface {
   static Box_t get_flat_box_from_tensor(Tensor2D box) {
     if (box.shape(0) != 2) throw std::invalid_argument("Box has to be represented by two corners.");
 
-    auto boxView = contiguous_numpy_2d_span(box);
+    auto boxView = Numpy_2d_span(box);
     auto lowerView = boxView[0];
     auto upperView = boxView[1];
     Box_t fb(lowerView.begin(), lowerView.end());
@@ -770,7 +764,7 @@ class Module_interface {
 };
 
 template <typename T>
-Module_interface<T> deserialize_module_from_python(
+inline Module_interface<T> deserialize_module_from_python(
     const nanobind::ndarray<const char, nanobind::ndim<1>, nanobind::numpy> &state) {
   Module_interface<T> mod;
   {
diff --git a/multipers/gudhi/Slicer_interface.h b/multipers/gudhi/Slicer_interface.h
new file mode 100644
index 00000000..7dff43ad
--- /dev/null
+++ b/multipers/gudhi/Slicer_interface.h
@@ -0,0 +1,1277 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       David Loiseaux, Hannah Schreiber
+ *
+ *    Copyright (C) 2026 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file Slicer_interface.h
+ * @author David Loiseaux, Hannah Schreiber
+ * @brief Contains the @ref Gudhi::multi_persistence::Slicer_interface class for python bindings.
+ */
+
+#ifndef MP_PY_SLICER_H_INCLUDED
+#define MP_PY_SLICER_H_INCLUDED
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <numeric>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+
+#include <oneapi/tbb/parallel_for.h>
+
+#include <gudhi/simple_mdspan.h>
+#include <gudhi/slicer_helpers.h>
+#include <gudhi/Slicer.h>
+#include <gudhi/multi_persistence_landscapes.h>
+#include <gudhi/Degree_rips_bifiltration.h>
+#include <gudhi/Multi_persistence/Line.h>
+#include <gudhi/Multi_persistence/utils.h>
+#include <python_interfaces/numpy_utils.h>
+
+#include "Simplex_tree_multi_interface.h"
+#include "python_interfaces/construction_utils.h"
+#include "slicer_interface_helpers.h"
+#include "interface_helper_structs.h"
+#include "ext_interface/nanobind_wrapper_types.hpp"
+
+namespace Gudhi {
+namespace multi_persistence {
+
+/**
+ * @private
+ */
+template <class MultiFiltrationValue, class PersistenceAlgorithm>
+class Slicer_interface {
+ public:
+  using value_type = typename MultiFiltrationValue::value_type;
+  using Slicer_t = Slicer<MultiFiltrationValue, PersistenceAlgorithm>;
+  using Complex = typename Slicer_t::Complex;
+  using Dimension = typename Slicer_t::Dimension;
+  using Index = typename Slicer_t::Index;
+  template <typename U>
+  using Tensor1D = nanobind::ndarray<const U, nanobind::ndim<1>, nanobind::any_contig>;
+  template <typename U>
+  using Tensor2D = nanobind::ndarray<const U, nanobind::ndim<2>>;
+
+  // as this needs to be updated only when the serialization strategy changes, 255 updates should be enough?
+  static constexpr std::uint8_t SERIALIZATION_VERSION = 0;
+
+  static constexpr value_type T_inf = MultiFiltrationValue::T_inf;     /**< Infinity. */
+  static constexpr value_type T_m_inf = MultiFiltrationValue::T_m_inf; /**< Minus infinity. */
+
+  Slicer_interface()
+      : slicer_(), filtrationGrid_(nanobind::none()), presDegree_(-1), isMinPres_(false), isMinRes_(false) {};
+
+  template <class OtherMultiFiltrationValue, class OtherPersistenceAlgorithm>
+  Slicer_interface(const Slicer_interface<OtherMultiFiltrationValue, OtherPersistenceAlgorithm> &other)
+      : slicer_(other.get_slicer()),
+        filtrationGrid_(other.get_filtration_grid()),
+        generatorBasis_(other.get_generator_basis()),
+        presDegree_(other.get_pres_degree()),
+        isMinPres_(other.is_min_pres()),
+        isMinRes_(other.is_min_res()) {}
+
+  template <class OtherMultiFiltrationValue, class OtherPersistenceAlgorithm>
+  Slicer_interface(const Slicer_interface<OtherMultiFiltrationValue, OtherPersistenceAlgorithm> &other,
+                   Slicer_t &&slicer)
+      : slicer_(std::move(slicer)),
+        filtrationGrid_(other.get_filtration_grid()),
+        generatorBasis_(other.get_generator_basis()),
+        presDegree_(other.get_pres_degree()),
+        isMinPres_(other.is_min_pres()),
+        isMinRes_(other.is_min_res()) {}
+
+  // use Simplex_tree_multi_interface<OtherMultiFiltrationValue> instead once the weird wrapper thing is removed
+  template <class OtherMultiFiltrationValue>
+  Slicer_interface(multipers::nanobind_helpers::PySimplexTree<
+                   Gudhi::multiparameter::python_interface::Simplex_tree_multi_interface<OtherMultiFiltrationValue>,
+                   typename OtherMultiFiltrationValue::value_type> &simplexTree)
+      : slicer_(), filtrationGrid_(simplexTree.filtration_grid), presDegree_(-1), isMinPres_(false), isMinRes_(false) {
+    {
+      nanobind::gil_scoped_release release;
+      slicer_ = Gudhi::multi_persistence::build_slicer_from_simplex_tree<Slicer_t>(simplexTree.tree);
+    }
+  }
+
+  Slicer_interface(const std::string &path, int shiftDimension, bool isRivetCompatible = false, bool isReversed = false)
+      : slicer_(), filtrationGrid_(nanobind::none()), presDegree_(-1), isMinPres_(false), isMinRes_(false) {
+    {
+      nanobind::gil_scoped_release release;
+      slicer_ = Gudhi::multi_persistence::build_slicer_from_scc_file<Slicer_t>(
+          path, isRivetCompatible, isReversed, shiftDimension);
+    }
+  }
+
+  Slicer_interface(const std::vector<std::vector<Index>> &generator_maps,
+                   const std::vector<Index> &generator_dimensions,
+                   const std::vector<std::vector<value_type>> &filtration_values)
+      : slicer_(), filtrationGrid_(nanobind::none()), presDegree_(-1), isMinPres_(false), isMinRes_(false) {
+    static_assert(MultiFiltrationValue::ensures_1_criticality(),
+                  "Slicer constructor only available for 1-critical filtration values. Use sequence[sequence[U]] for "
+                  "filtration value type.");
+    _build_slicer(generator_maps, generator_dimensions, filtration_values);
+  }
+
+  Slicer_interface(const std::vector<std::vector<Index>> &generator_maps,
+                   const std::vector<Index> &generator_dimensions,
+                   const std::vector<std::vector<std::vector<value_type>>> &filtration_values)
+      : slicer_(), filtrationGrid_(nanobind::none()), presDegree_(-1), isMinPres_(false), isMinRes_(false) {
+    static_assert(!MultiFiltrationValue::ensures_1_criticality(),
+                  "Slicer constructor only available for k-critical filtration values. Use "
+                  "sequence[sequence[sequence[U]]] for filtration value type.");
+    _build_slicer(generator_maps, generator_dimensions, filtration_values);
+  }
+
+  template <typename I>
+  Slicer_interface(const std::vector<std::vector<Index>> &generator_maps,
+                   Tensor1D<I> generator_dimensions,
+                   nanobind::object filtration_values)
+      : slicer_(), filtrationGrid_(nanobind::none()), presDegree_(-1), isMinPres_(false), isMinRes_(false) {
+    if constexpr (MultiFiltrationValue::ensures_1_criticality()) {
+      auto cast_as_vector = [&]() -> void {
+        std::vector<std::vector<value_type>> val;
+        if (!nanobind::try_cast<std::vector<std::vector<value_type>>>(filtration_values, val))
+          throw std::invalid_argument("Filtration values must be either iterable[iterable[U]] or ndarray[U, ndim=2].");
+        _build_slicer(generator_maps, Numpy_span(generator_dimensions), val);
+      };
+      auto cast_first_as_tensor_then_as_vector = [&]<typename U>() -> void {
+        if (Tensor2D<U> val; nanobind::try_cast<Tensor2D<U>>(filtration_values, val, false)) {
+          _build_slicer(generator_maps, Numpy_span(generator_dimensions), Numpy_2d_span(val));
+          return;
+        }
+        cast_as_vector();
+      };
+      detail::_dispatch_dtype(filtration_values, cast_first_as_tensor_then_as_vector, []() -> void {}, cast_as_vector);
+    } else {
+      auto cast_as_vector = [&]() -> void {
+        std::vector<std::vector<std::vector<value_type>>> val;
+        if (!nanobind::try_cast<std::vector<std::vector<std::vector<value_type>>>>(filtration_values, val))
+          throw std::invalid_argument(
+              "Filtration values must be either iterable[iterable[iterable[U]]] or iterable[ndarray[U, ndim=2]].");
+        _build_slicer(generator_maps, Numpy_span(generator_dimensions), val);
+      };
+      auto cast_first_as_tensor_then_as_vector = [&]<typename U>() -> void {
+        if (std::vector<Tensor2D<U>> val; nanobind::try_cast<std::vector<Tensor2D<U>>>(filtration_values, val, false)) {
+          // Tensors have to stay alive to use Numpy_2d_span, so val is necessary
+          std::vector<Numpy_2d_span<U>> fils(val.begin(), val.end());
+          _build_slicer(generator_maps, Numpy_span(generator_dimensions), fils);
+          return;
+        }
+        cast_as_vector();
+      };
+      detail::_dispatch_dtype(filtration_values, cast_first_as_tensor_then_as_vector, []() -> void {}, cast_as_vector);
+    }
+  }
+
+  template <typename I1, typename I2, typename F>
+  Slicer_interface(Tensor1D<I1> boundary_indptr,
+                   Tensor1D<I2> boundary_flat,
+                   Tensor1D<I2> generator_dimensions,
+                   Tensor2D<F> grades_flat)
+      : slicer_(), filtrationGrid_(nanobind::none()), presDegree_(-1), isMinPres_(false), isMinRes_(false) {
+    auto boundaryDelimitersView = boundary_indptr.view();
+    auto boundariesView = boundary_flat.view();
+    auto dimensionsView = generator_dimensions.view();
+    auto filValuesView = grades_flat.view();
+
+    if (boundaryDelimitersView.shape(0) == 0) {
+      if (boundariesView.shape(0) != 0 || dimensionsView.shape(0) != 0 || filValuesView.shape(0) != 0)
+        throw std::invalid_argument("Invalid packed input, shapes do not coincide.");
+      return;
+    }
+    std::size_t numGen = boundaryDelimitersView.shape(0) - 1;
+    if (boundaryDelimitersView(numGen) > boundariesView.shape(0))
+      throw std::invalid_argument("Boundary index ptr and flat boundaries are not coherent.");
+    if (dimensionsView.shape(0) != numGen || filValuesView.shape(0) != numGen)
+      throw std::invalid_argument("Invalid packed input, shapes do not coincide.");
+
+    // do we really want to test here if the values of boundary_indptr are positive and increasing integers,
+    // and the values of boundary_flat and generator_dimensions positive integers ?
+    // those testes are not that cheap anymore and do not guarantee no crashes as there still will be some
+    // if the boundaries are not valid boundaries or the filtration values do not yield a valid filtration order etc.
+    // At some point, the user has to take responsibilities...
+
+    detail::Flat_2D_array_span boundaries(boundary_indptr, boundary_flat);
+    Numpy_span dimensions(generator_dimensions);
+    Numpy_2d_span filValues(grades_flat);
+
+    _build_slicer(boundaries, dimensions, filValues);
+  }
+
+  // std::vector<unsigned int> imposed by Gudhi::cubical_complex::Bitmap_cubical_complex
+  Slicer_interface(Tensor2D<value_type> image, const std::vector<unsigned int> &shape)
+      : slicer_(), filtrationGrid_(nanobind::none()), presDegree_(-1), isMinPres_(false), isMinRes_(false) {
+    Numpy_2d_span imageView(image);
+    if (imageView.size() == 0 || shape.size() == 0 || shape[0] == 0) return;
+    {
+      nanobind::gil_scoped_release release;
+      std::vector<MultiFiltrationValue> vertices;
+      vertices.reserve(imageView.size());
+      for (std::size_t i = 0; i < imageView.size(); ++i) {
+        auto rowView = imageView[i];
+        vertices.emplace_back(rowView.begin(), rowView.end());
+      }
+      slicer_ = Gudhi::multi_persistence::build_slicer_from_bitmap<Slicer_t>(vertices, shape);
+    }
+  }
+
+  template <class OtherMultiFiltrationValue, class OtherPersistenceAlgorithm>
+  Slicer_interface &copy(const Slicer_interface<OtherMultiFiltrationValue, OtherPersistenceAlgorithm> &other) {
+    *this = Slicer_interface(other);
+    return *this;
+  }
+
+  // use Simplex_tree_multi_interface<OtherMultiFiltrationValue> instead once the weird wrapper thing is removed
+  template <class OtherMultiFiltrationValue>
+  Slicer_interface &copy(
+      multipers::nanobind_helpers::PySimplexTree<
+          Gudhi::multiparameter::python_interface::Simplex_tree_multi_interface<OtherMultiFiltrationValue>,
+          typename OtherMultiFiltrationValue::value_type> &other) {
+    *this = Slicer_interface(other);
+    return *this;
+  }
+
+  Slicer_t &get_slicer() { return slicer_; }
+
+  const Slicer_t &get_slicer() const { return slicer_; }
+
+  [[nodiscard]] nanobind::object get_filtration_grid() const { return filtrationGrid_; }
+
+  void set_filtration_grid(nanobind::object grid) {
+    if (grid.is_none()) {
+      filtrationGrid_ = nanobind::none();
+      return;
+    }
+
+    // throws if it does not pass the check
+    // returns false if valid but empty
+    if (_verify_grid_validity(grid)) {
+      filtrationGrid_ = grid;
+      return;
+    }
+
+    filtrationGrid_ = nanobind::none();
+  }
+
+  [[nodiscard]] std::optional<detail::Generator_basis_data> get_generator_basis() const { return generatorBasis_; }
+
+  void set_generator_basis(const std::optional<detail::Generator_basis_data> &basis) {
+    if (basis.has_value()) {
+      generatorBasis_ = basis;
+      return;
+    }
+    generatorBasis_.reset();
+  }
+
+  void set_generator_basis(nanobind::dict basis) {
+    if (basis.empty() || basis.is_none()) {
+      generatorBasis_.reset();
+      return;
+    }
+    generatorBasis_ = detail::Generator_basis_data(basis);
+  }
+
+  template <class Complex, class GeneratorMatrix>
+  void set_generator_basis(const Complex &complex, int degree, GeneratorMatrix &generatorMatrix) {
+    generatorBasis_ = detail::Generator_basis_data(complex, degree, generatorMatrix);
+  }
+
+  [[nodiscard]] int get_min_pres_degree() const { return isMinPres_ ? presDegree_ : -1; }
+
+  void set_min_pres_degree(int degree, bool isMinRes = false) {
+    isMinPres_ = degree >= 0;
+    if (isMinPres_) presDegree_ = degree;
+    isMinRes_ = isMinPres_ && isMinRes;
+  }
+
+  [[nodiscard]] int get_pres_degree() const { return presDegree_; }
+
+  [[nodiscard]] bool is_pres() const { return presDegree_ >= 0; }
+
+  void set_is_pres(int degree, bool isMinPres = false) {
+    presDegree_ = degree;
+    isMinPres_ = degree >= 0 ? isMinPres : false;
+    isMinRes_ = isMinPres_;
+  }
+
+  [[nodiscard]] bool is_min_pres() const { return isMinPres_; }
+
+  [[nodiscard]] bool is_min_res() const { return isMinRes_; }
+
+  void set_is_min_res(bool isMinRes) {
+    if (isMinRes && !isMinPres_)
+      throw std::invalid_argument("Cannot mark a slicer as `is_minres` without a valid `minpres_degree`.");
+    isMinRes_ = isMinRes;
+  }
+
+  [[nodiscard]] int size() const { return slicer_.get_number_of_cycle_generators(); }
+
+  [[nodiscard]] int get_number_of_cycle_generators() const { return slicer_.get_number_of_cycle_generators(); }
+
+  [[nodiscard]] int get_number_of_parameters() const { return slicer_.get_number_of_parameters(); }
+
+  [[nodiscard]] nanobind::object get_max_dimension() const {
+    auto dim = slicer_.get_max_dimension();
+    if (dim == Complex::nullDimension) return nanobind::float_(-std::numeric_limits<double>::infinity());
+    return nanobind::int_(dim);
+  }
+
+  [[nodiscard]] auto get_dimensions() const {
+    const auto &dims = slicer_.get_dimensions();
+    // no transfer of ownership, dies together with the slicer
+    return _wrap_view_as_numpy_array(nanobind::find(this), dims.data(), dims.size());
+  }
+
+  [[nodiscard]] nanobind::tuple get_boundaries() const {
+    const auto &boundaries = slicer_.get_boundaries();
+    return Gudhi::python::_build_tuple(boundaries.size(), [&](std::size_t b) {
+      // no transfer of ownership, dies together with the slicer
+      return _wrap_view_as_numpy_array(nanobind::find(this), boundaries[b].data(), boundaries[b].size());
+    });
+  }
+
+  [[nodiscard]] nanobind::tuple get_flat_boundaries() const {
+    std::vector<std::uint64_t> startIndices;
+    std::vector<std::uint32_t> boundaries;
+
+    {
+      nanobind::gil_scoped_release release;
+      const auto &b = slicer_.get_boundaries();
+      startIndices.resize(b.size() + 1, 0);
+      for (std::size_t i = 0; i < b.size(); ++i) {
+        startIndices[i + 1] = startIndices[i] + b[i].size();
+      }
+      boundaries.reserve(startIndices.back());
+      for (const auto &bi : b) {
+        boundaries.insert(boundaries.end(), bi.begin(), bi.end());
+      }
+    }
+
+    return nanobind::make_tuple(_wrap_as_numpy_array(std::move(startIndices), startIndices.size()),
+                                _wrap_as_numpy_array(std::move(boundaries), boundaries.size()));
+  }
+
+  [[nodiscard]] nanobind::object get_filtration_value(int index, bool viewIfPossible = true, bool raw = false) {
+    int size = slicer_.get_number_of_cycle_generators();
+    if (index < 0) index += size;
+    if (index < 0 || index >= size) throw std::out_of_range("Generator index out of range.");
+
+    auto &f = slicer_.get_filtration_value(index);
+
+    if (raw) return detail::_get_raw_filtration_data(f, !viewIfPossible);
+
+    // view not possible for Degree_rips_bifiltration
+    if constexpr (!detail::_is_degree_rips<MultiFiltrationValue>()) {
+      if (viewIfPossible) return detail::_get_raw_filtration_data(f, false);
+    }
+    return nanobind::cast(_get_filtration_array(f));
+  }
+
+  [[nodiscard]] nanobind::object get_all_filtration_values(bool compact,
+                                                           bool viewIfPossible = true,
+                                                           bool raw = false) {
+    auto &filts = slicer_.get_filtration_values();
+
+    // view not possible for compact
+    if (compact) {
+      // raw makes only a difference for Degree_rips
+      if constexpr (detail::_is_degree_rips<MultiFiltrationValue>()) {
+        if (raw) return detail::_get_compact_filtration_data(filts);
+      }
+      return _get_compact_filtration_array(filts, slicer_.get_number_of_parameters());
+    }
+
+    if (raw) {
+      return Gudhi::python::_build_tuple(
+          filts.size(), [&](std::size_t i) { return detail::_get_raw_filtration_data(filts[i], !viewIfPossible); });
+    }
+
+    // view not possible for Degree_rips_bifiltration
+    if constexpr (!detail::_is_degree_rips<MultiFiltrationValue>()) {
+      if (viewIfPossible) {
+        return Gudhi::python::_build_tuple(
+            filts.size(), [&](std::size_t i) { return detail::_get_raw_filtration_data(filts[i], false); });
+      }
+    }
+    return _get_filtration_array(filts, slicer_.get_number_of_parameters());
+  }
+
+  [[nodiscard]] auto get_current_slice() const {
+    const auto &slice = slicer_.get_slice();
+    // no transfer of ownership, dies together with the slicer
+    return _wrap_view_as_numpy_array(nanobind::find(this), slice.data(), slice.size());
+  }
+
+  template <typename U>
+  Slicer_interface &push_to_line(Tensor1D<U> basepoint, std::optional<Tensor1D<U>> direction) {
+    {
+      nanobind::gil_scoped_release release;
+      Numpy_span baseView(basepoint);
+      Line<U> line;
+      if (direction.has_value()) {
+        Numpy_span dirView(*direction);
+        line = Line<U>(baseView.begin(), baseView.end(), dirView.begin(), dirView.end());
+      } else {
+        line = Line<U>(baseView.begin(), baseView.end());
+      }
+      slicer_.push_to(line);
+    }
+    return *this;
+  }
+
+  Slicer_interface &make_filtration_non_decreasing() {
+    {
+      nanobind::gil_scoped_release release;
+      // validity of grid was already tested when set
+      slicer_.make_filtration_non_decreasing();
+    }
+    return *this;
+  }
+
+  Slicer_interface &simplify_all_filtration_values() {
+    {
+      nanobind::gil_scoped_release release;
+      for (auto &f : slicer_.get_filtration_values()) f.simplify();
+    }
+    return *this;
+  }
+
+  Slicer_interface &prune_above_dimension(int max_dimension) {
+    {
+      nanobind::gil_scoped_release release;
+      slicer_.prune_above_dimension(max_dimension);
+    }
+    return *this;
+  }
+
+  template <typename U>
+  Slicer_interface &coarsen_on_grid(const std::vector<std::vector<U>> &grid, bool coordinates) {
+    {
+      nanobind::gil_scoped_release release;
+      slicer_.coarsen_on_grid(grid, coordinates);
+    }
+    return *this;
+  }
+
+  template <typename U>
+  Slicer_interface &coarsen_on_grid(const std::vector<Tensor1D<U>> &grid, bool coordinates) {
+    std::vector<Numpy_span<U>> views(grid.begin(), grid.end());
+    {
+      nanobind::gil_scoped_release release;
+      slicer_.coarsen_on_grid(views, coordinates);
+    }
+    return *this;
+  }
+
+  template <typename U>
+  Slicer_interface &normalize_filtration_values(const std::optional<Tensor2D<U>> &box) {
+    if constexpr (std::is_same_v<MultiFiltrationValue,
+                                 Gudhi::multi_filtration::Degree_rips_bifiltration<
+                                     value_type,
+                                     MultiFiltrationValue::has_negative_cones(),
+                                     MultiFiltrationValue::ensures_1_criticality()>>) {
+      throw nanobind::type_error("Degree-Rips slicers cannot be affinely normalized.");
+    } else if constexpr (!std::is_floating_point_v<value_type>) {
+      throw nanobind::type_error("Normalize filtration requires a floating-point dtype for slicers.");
+    } else {
+      {
+        nanobind::gil_scoped_release release;
+        if (box.has_value()) {
+          if (box->shape(0) != 2 || box->shape(1) != slicer_.get_number_of_parameters())
+            throw std::invalid_argument("Box must have shape (2, num_parameters).");
+          auto boxView = Numpy_2d_span(*box);
+          auto lowerView = boxView[0];
+          auto upperView = boxView[1];
+          slicer_.normalize_filtration_values({lowerView.begin(), lowerView.end(), upperView.begin(), upperView.end()});
+        } else {
+          slicer_.normalize_filtration_values();
+        }
+      }
+      return *this;
+    }
+  }
+
+  Slicer_interface &clean_filtration_grid() {
+    if (filtrationGrid_.is_none()) throw std::runtime_error("No grid to clean.");
+    auto usedCoordinates = detail::Compacted_squeezed_filtration_grid::collect_used_squeezed_coordinates(slicer_);
+    detail::Compacted_squeezed_filtration_grid compact(filtrationGrid_, usedCoordinates);
+    filtrationGrid_ = compact.filtrationGrid;
+    return coarsen_on_grid(compact.coordinates, true);
+  }
+
+  Slicer_interface &initialize_persistence_computation(bool ignoreInf) {
+    {
+      nanobind::gil_scoped_release release;
+      slicer_.initialize_persistence_computation(ignoreInf);
+    }
+    return *this;
+  }
+
+  Slicer_interface &update_persistence_computation(bool ignoreInf) {
+    {
+      nanobind::gil_scoped_release release;
+      slicer_.update_persistence_computation(ignoreInf);
+    }
+    return *this;
+  }
+
+  nanobind::tuple compute_persistence_on_slices(Tensor2D<value_type> slices, bool ignoreInf) {
+    std::vector<typename Slicer_t::template Multi_dimensional_flat_barcode<value_type>> barcodes;
+    {
+      nanobind::gil_scoped_release release;
+      barcodes = persistence_on_slices<value_type>(slicer_, Numpy_2d_span(slices), ignoreInf);
+    }
+
+    return Gudhi::python::_build_tuple(barcodes.size(), [&](std::size_t i) {
+      return Gudhi::python::_build_tuple(barcodes[i].size(), [&](std::size_t j) {
+        return _wrap_as_numpy_array(std::move(barcodes[i][j]), barcodes[i][j].size(), 2);
+      });
+    });
+  }
+
+  [[nodiscard]] nanobind::tuple get_barcode() {
+    typename Slicer_t::template Multi_dimensional_flat_barcode<value_type> barcode;
+    {
+      nanobind::gil_scoped_release release;
+      barcode = slicer_.template get_flat_barcode<true>();
+    }
+
+    return Gudhi::python::_build_tuple(barcode.size(), [&](std::size_t i) {
+      return _wrap_as_numpy_array(std::move(barcode[i]), barcode[i].size(), 2);
+    });
+  }
+
+  [[nodiscard]] nanobind::tuple get_barcode_as_indices() {
+    typename Slicer_t::template Multi_dimensional_flat_barcode<int> barcode;
+    {
+      nanobind::gil_scoped_release release;
+      barcode = slicer_.template get_flat_barcode<true, int, true>();
+    }
+
+    return Gudhi::python::_build_tuple(barcode.size(), [&](std::size_t i) {
+      return _wrap_as_numpy_array(std::move(barcode[i]), barcode[i].size(), 2);
+    });
+  }
+
+  template <typename U>
+  auto compute_landscapes_on_grid(Tensor1D<U> xGrid,
+                                  Tensor1D<U> yGrid,
+                                  Tensor1D<U> direction,
+                                  std::size_t xStride,
+                                  std::size_t yStride,
+                                  double dt,
+                                  int degree,
+                                  Tensor1D<std::int32_t> ks,
+                                  int n_jobs,
+                                  bool ignoreInf = true) {
+    auto xView = xGrid.view();
+    auto yView = yGrid.view();
+    auto dirView = direction.view();
+    auto kView = ks.view();
+
+    const std::size_t nx = xView.shape(0);
+    const std::size_t ny = yView.shape(0);
+
+    if (get_number_of_parameters() != 2)
+      throw nanobind::value_error("Landscapes can only be computed for bi-filtrations.");
+    if (nx == 0 || ny == 0) throw nanobind::value_error("Landscape grid axes must be non-empty.");
+    if (direction.shape(0) != 2) throw nanobind::value_error("Landscape direction must be two-dimensional.");
+    if (xStride == 0 || yStride == 0) throw nanobind::value_error("Landscape grid strides must be strictly positive.");
+    if (!std::isfinite(dt) || dt <= 0.0)
+      throw nanobind::value_error("Landscape grid step must be finite and strictly positive.");
+    if (nx > std::numeric_limits<std::size_t>::max() / ny)
+      throw nanobind::value_error("Landscape output grid is too large.");
+    if (degree < 0) throw nanobind::value_error("Degree has to be positive.");
+
+    for (std::size_t i = 0; i < nx; ++i) {
+      if (!std::isfinite(xView(i))) throw nanobind::value_error("Landscape x-grid must be finite.");
+    }
+    for (std::size_t i = 0; i < ny; ++i) {
+      if (!std::isfinite(yView(i))) throw nanobind::value_error("Landscape y-grid must be finite.");
+    }
+    for (std::size_t i = 0; i < dirView.shape(0); ++i) {
+      if (!std::isfinite(dirView(i))) throw nanobind::value_error("Landscape direction must be finite.");
+      if (dirView(i) <= 0.0) throw nanobind::value_error("Landscape direction must be strictly positive.");
+    }
+    for (std::size_t i = 0; i < kView.shape(0); ++i) {
+      if (kView(i) < 0) throw nanobind::value_error("Landscape ks must be strictly positive.");
+    }
+
+    std::vector<double> out;
+
+    {
+      nanobind::gil_scoped_release release;
+      out = Gudhi::multi_persistence::compute_slicer_landscapes_on_grid(slicer_,
+                                                                        Numpy_span(xGrid),
+                                                                        Numpy_span(yGrid),
+                                                                        Numpy_span(direction),
+                                                                        xStride,
+                                                                        yStride,
+                                                                        dt,
+                                                                        degree,
+                                                                        Numpy_span(ks),
+                                                                        ignoreInf,
+                                                                        n_jobs);
+    }
+
+    return _wrap_as_numpy_array(std::move(out), kView.shape(0), nx, ny);
+  }
+
+  [[nodiscard]] nanobind::object get_representative_cycles(
+      bool update,
+      const std::optional<Dimension> &dimension,
+      nanobind::object barcodeIndices,
+      const std::optional<Tensor1D<Index>> &pointsToIntersect) {
+    auto get_cycle_list = [](auto &cycles) {
+      nanobind::list outCycles;
+      for (auto &c : cycles) {
+        if (!c.empty()) {
+          outCycles.append(Gudhi::python::_build_tuple(
+              c.size(), [&](std::size_t b) { return _wrap_as_numpy_array(std::move(c[b]), c[b].size()); }));
+        }
+      }
+      return outCycles;
+    };
+
+    if (dimension.has_value()) {
+      std::optional<Tensor1D<std::int64_t>> indices;
+      if (!barcodeIndices.is_none()) {
+        Tensor1D<std::int64_t> tmp;
+        if (!nanobind::try_cast<Tensor1D<std::int64_t>>(barcodeIndices, tmp, false))
+          throw std::invalid_argument(
+              "When dimension is specified, barcode_indices has to be either None or a 1D numpy array.");
+        indices = std::move(tmp);
+      }
+      auto cycles = _get_cycle_boundaries(update, *dimension, indices, pointsToIntersect);
+      return get_cycle_list(cycles);
+    }
+
+    std::optional<Tensor2D<std::int64_t>> indices;
+    if (!barcodeIndices.is_none()) {
+      Tensor2D<std::int64_t> tmp;
+      if (!nanobind::try_cast<Tensor2D<std::int64_t>>(barcodeIndices, tmp, false))
+        throw std::invalid_argument(
+            "When dimension is not specified, barcode_indices has to be either None or a 2D numpy array.");
+      indices = std::move(tmp);
+    }
+    auto cycles = _get_cycle_boundaries(update, indices, pointsToIntersect);
+    return Gudhi::python::_build_tuple(cycles.size(), [&](std::size_t dim) { return get_cycle_list(cycles[dim]); });
+  }
+
+  [[nodiscard]] nanobind::object get_most_persistent_cycles(int dim, int n, bool update, bool idx) {
+    if (dim < 0 || n < 0) throw std::invalid_argument("Dimension and number of cycles have to be positive.");
+
+    std::vector<std::vector<Index>> cycleIdx;
+    std::vector<std::vector<std::vector<Index>>> out;
+    {
+      nanobind::gil_scoped_release release;
+      cycleIdx = slicer_.get_n_most_persistent_cycles(dim, n, update);
+
+      if (!idx && !cycleIdx.empty()) {
+        out.resize(cycleIdx.size());
+        tbb::parallel_for(std::size_t(0), cycleIdx.size(), [&](std::size_t idx) {
+          _get_cycle_boundary(out[idx], cycleIdx[idx], dim);
+        });
+      }
+    }
+
+    if (cycleIdx.empty()) return nanobind::make_tuple();
+
+    if (n == 1) {
+      if (idx) return nanobind::cast(_wrap_as_numpy_array(std::move(cycleIdx[0]), cycleIdx[0].size()));
+      return Gudhi::python::_build_tuple(
+          out[0].size(), [&](std::size_t i) { return _wrap_as_numpy_array(std::move(out[0][i]), out[0][i].size()); });
+    }
+
+    if (idx) {
+      return Gudhi::python::_build_tuple(cycleIdx.size(), [&](std::size_t i) {
+        return _wrap_as_numpy_array(std::move(cycleIdx[i]), cycleIdx[i].size());
+      });
+    }
+    return Gudhi::python::_build_tuple(out.size(), [&](std::size_t i) {
+      return Gudhi::python::_build_tuple(
+          out[i].size(), [&](std::size_t b) { return _wrap_as_numpy_array(std::move(out[i][b]), out[i][b].size()); });
+    });
+  }
+
+  Slicer_interface &write_to_scc_file(const std::string &outFilePath,
+                                      int degree,
+                                      bool rivetCompatible,
+                                      bool ignoreLastGenerators,
+                                      bool stripComments,
+                                      bool reverse) {
+    {
+      nanobind::gil_scoped_release release;
+      write_slicer_to_scc_file(
+          outFilePath, slicer_, degree, rivetCompatible, ignoreLastGenerators, stripComments, reverse);
+    }
+    return *this;
+  }
+
+  Slicer_interface &sort_slicer_co_lexically() {
+    std::pair<Slicer_t, std::vector<Index>> outSlicer;
+    {
+      nanobind::gil_scoped_release release;
+      outSlicer = build_permuted_slicer(slicer_);
+    }
+    // TODO: complex has an internal sort, could be worth interfacing to avoid copy?
+    slicer_ = outSlicer.first;
+    return *this;
+  }
+
+  [[nodiscard]] nanobind::object build_colexical_permuted_slicer(bool returnPermutation) const {
+    std::pair<Slicer_t, std::vector<Index>> outSlicer;
+    {
+      nanobind::gil_scoped_release release;
+      outSlicer = build_permuted_slicer(slicer_);
+    }
+
+    Slicer_interface out(*this, std::move(outSlicer.first));
+
+    if (returnPermutation)
+      return nanobind::make_tuple(out, _wrap_as_numpy_array(std::move(outSlicer.second), outSlicer.second.size()));
+
+    return nanobind::cast(out);
+  }
+
+  [[nodiscard]] Slicer_interface build_slicer_as_permutation(const std::vector<Index> &permutation) const {
+    Slicer_t outSlicer;
+    {
+      nanobind::gil_scoped_release release;
+      outSlicer = build_permuted_slicer(slicer_, permutation);
+    }
+    return {*this, std::move(outSlicer)};
+  }
+
+  template <typename U>
+  auto build_coarsen_on_grid(const std::vector<std::vector<U>> &grid) const {
+    using S = decltype(build_slicer_coarsen_on_grid(slicer_, grid));
+
+    S outSlicer;
+    {
+      nanobind::gil_scoped_release release;
+      outSlicer = build_slicer_coarsen_on_grid(slicer_, grid);
+    }
+
+    return Slicer_interface<typename S::Filtration_value, typename S::Persistence>(*this, std::move(outSlicer));
+  }
+
+  [[nodiscard]] Slicer_interface build_from_projective_cover_kernel(std::optional<int> dimension) const {
+    if (generatorBasis_.has_value()) {
+      throw nanobind::value_error(
+          "compute_kernel_projective_cover does not transport `_generator_basis`;"
+          " discard the basis explicitly before this transformation.");
+    }
+
+    Slicer_t outSlicer;
+
+    if (slicer_.get_number_of_cycle_generators() == 0) return {*this, std::move(outSlicer)};
+
+    int dim = dimension.has_value() ? *dimension : static_cast<int>(slicer_.get_max_dimension());
+    {
+      nanobind::gil_scoped_release release;
+      outSlicer = build_slicer_from_projective_cover_kernel(slicer_, dim);
+    }
+    return {*this, std::move(outSlicer)};
+  }
+
+  [[nodiscard]] std::string to_string() const {
+    std::stringstream stream;
+    stream << slicer_;
+    return stream.str();
+  }
+
+  template <class OtherMultiFiltrationValue, class OtherPersistenceAlgorithm>
+  bool operator==(const Slicer_interface<OtherMultiFiltrationValue, OtherPersistenceAlgorithm> &other) const {
+    bool res;
+    {
+      nanobind::gil_scoped_release release;
+      // the boundaries in the two slicers have to be ordered the same for them to be equal
+      // can potentially be generalized by ordering them the same before comparing
+      // but that adds even more annoying complexity
+      res = (slicer_.get_dimensions() == other.get_slicer().get_dimensions() &&
+             slicer_.get_boundaries() == other.get_slicer().get_boundaries());
+    }
+    return res && _has_same_filtration_values(other);
+  }
+
+  friend char *serialize_value_to_char_buffer(const Slicer_interface &value, char *start) {
+    char *curr = start;
+    curr = serialize_value_to_char_buffer(value.slicer_, curr);
+    bool hasBasis = value.generatorBasis_.has_value();
+    curr = serialize_value_to_char_buffer(hasBasis, curr);
+    if (hasBasis) curr = serialize_value_to_char_buffer(*value.generatorBasis_, curr);
+    curr = serialize_value_to_char_buffer(value.presDegree_, curr);
+    curr = serialize_value_to_char_buffer(value.isMinPres_, curr);
+    curr = serialize_value_to_char_buffer(value.isMinRes_, curr);
+    return curr;
+  }
+
+  friend const char *deserialize_value_from_char_buffer(Slicer_interface &value, const char *start) {
+    const char *curr = start;
+    curr = deserialize_value_from_char_buffer(value.slicer_, curr);
+    bool hasBasis;
+    curr = deserialize_value_from_char_buffer(hasBasis, curr);
+    if (hasBasis) {
+      value.generatorBasis_.emplace();
+      curr = deserialize_value_from_char_buffer(*value.generatorBasis_, curr);
+    }
+    curr = deserialize_value_from_char_buffer(value.presDegree_, curr);
+    curr = deserialize_value_from_char_buffer(value.isMinPres_, curr);
+    curr = deserialize_value_from_char_buffer(value.isMinRes_, curr);
+    return curr;
+  }
+
+  friend std::size_t get_serialization_size_of(const Slicer_interface &value) {
+    std::size_t size = get_serialization_size_of(value.slicer_);
+    bool hasBasis = value.generatorBasis_.has_value();
+    size += get_serialization_size_of(hasBasis);
+    if (hasBasis) size += get_serialization_size_of(*value.generatorBasis_);
+    size += get_serialization_size_of(value.presDegree_);
+    size += get_serialization_size_of(value.isMinPres_);
+    size += get_serialization_size_of(value.isMinRes_);
+    return size;
+  }
+
+ private:
+  Slicer_t slicer_;
+  nanobind::object filtrationGrid_;
+  std::optional<detail::Generator_basis_data> generatorBasis_;
+  int presDegree_;
+  bool isMinPres_;
+  bool isMinRes_;
+
+  static auto _get_filtration_array(const MultiFiltrationValue &f) {
+    std::vector<value_type> values(f.num_generators() * f.num_parameters());
+    Gudhi::Simple_mdspan view(values.data(), f.num_generators(), f.num_parameters());
+    {
+      nanobind::gil_scoped_release release;
+      for (std::size_t g = 0; g < f.num_generators(); ++g) {
+        for (std::size_t p = 0; p < f.num_parameters(); ++p) {
+          view(g, p) = f(g, p);
+        }
+      }
+    }
+    if constexpr (MultiFiltrationValue::ensures_1_criticality()) {
+      return _wrap_as_numpy_array(std::move(values), f.num_parameters());
+    } else {
+      return _wrap_as_numpy_array(std::move(values), f.num_generators(), f.num_parameters());
+    }
+  }
+
+  static nanobind::tuple _get_compact_filtration_array(const typename Complex::Filtration_value_container &filts,
+                                                       int numParam) {
+    std::vector<value_type> values;
+    std::vector<std::int64_t> startIndices(filts.size() + 1, 0);
+
+    {
+      nanobind::gil_scoped_release release;
+      for (std::size_t i = 0; i < filts.size(); ++i) {
+        startIndices[i + 1] = startIndices[i] + filts[i].num_generators();
+      }
+      values.resize(startIndices.back() * numParam);
+      for (std::size_t i = 0; i < filts.size(); ++i) {
+        const auto &f = filts[i];
+        if (numParam != f.num_parameters())
+          throw std::runtime_error("Inconsistent number of parameters in stored filtration values");
+        Gudhi::Simple_mdspan view(&values[startIndices[i] * numParam], f.num_generators(), numParam);
+        for (std::size_t g = 0; g < f.num_generators(); ++g) {
+          for (std::size_t p = 0; p < numParam; ++p) {
+            view(g, p) = f(g, p);
+          }
+        }
+      }
+    }
+
+    return nanobind::make_tuple(_wrap_as_numpy_array(std::move(startIndices), startIndices.size()),
+                                _wrap_as_numpy_array(std::move(values), startIndices.back(), numParam));
+  }
+
+  static nanobind::object _get_filtration_array(const typename Complex::Filtration_value_container &filts,
+                                                int numParam) {
+    if constexpr (MultiFiltrationValue::ensures_1_criticality()) {
+      std::vector<value_type> values(filts.size() * numParam);
+      {
+        nanobind::gil_scoped_release release;
+        Gudhi::Simple_mdspan view(values.data(), filts.size(), numParam);
+        for (std::size_t i = 0; i < filts.size(); ++i) {
+          const auto &f = filts[i];
+          if (numParam != f.num_parameters())
+            throw std::runtime_error("Inconsistent number of parameters in stored filtration values");
+          for (int p = 0; p < numParam; ++p) {
+            view(i, p) = f(0, p);
+          }
+        }
+      }
+
+      return nanobind::cast(_wrap_as_numpy_array(std::move(values), filts.size(), numParam));
+    } else {
+      std::vector<std::vector<value_type>> values(filts.size());
+      {
+        nanobind::gil_scoped_release release;
+        for (std::size_t i = 0; i < filts.size(); ++i) {
+          const auto &f = filts[i];
+          if (numParam != f.num_parameters())
+            throw std::runtime_error("Inconsistent number of parameters in stored filtration values");
+          values[i].resize(f.num_generators() * numParam);
+          Gudhi::Simple_mdspan view(values[i].data(), f.num_generators(), numParam);
+          for (std::size_t g = 0; g < f.num_generators(); ++g) {
+            for (int p = 0; p < numParam; ++p) {
+              view(g, p) = f(g, p);
+            }
+          }
+        }
+      }
+
+      // Storing the items in values and releasing the gil only once is probably faster than
+      // storing the items directly in the tuple and releasing the gil at each construction ?
+      return Gudhi::python::_build_tuple(filts.size(), [&](std::size_t i) {
+        return _wrap_as_numpy_array(std::move(values[i]), filts[i].num_generators(), numParam);
+      });
+    }
+  }
+
+  template <typename U>
+  static bool _check_has_sorted_rows(Tensor2D<U> grid) {
+    auto view = grid.view();
+    std::size_t rows = view.shape(0), cols = view.shape(1);
+
+    for (std::size_t i = 0; i < rows; ++i)
+      for (std::size_t j = 1; j < cols; ++j)
+        if (view(i, j - 1) > view(i, j))
+          throw nanobind::type_error("Expected grid rows to be sorted by increasing values.");
+
+    return rows != 0 && cols != 0;  // returns false if the grid is valid but empty
+  }
+
+  template <typename U>
+  static bool _check_has_sorted_rows(nanobind::iterable grid) {
+    bool hasNonEmptyRows = false;
+    for (nanobind::handle row : grid) {
+      if (!nanobind::isinstance<nanobind::iterable>(row))
+        throw nanobind::type_error("Expected each row to be iterable.");
+
+      bool hasPrev = false;
+      U prev = 0;
+
+      for (nanobind::handle elem : nanobind::cast<nanobind::iterable>(row)) {
+        U val;
+        if (!nanobind::try_cast<U>(elem, val)) throw nanobind::type_error("Expected arithmetic elements in the grid.");
+
+        if (hasPrev && val < prev)
+          throw nanobind::type_error("Expected rows of the grid to be ordered by increasing value.");
+
+        prev = val;
+        hasPrev = true;
+      }
+      hasNonEmptyRows |= hasPrev;
+    }
+
+    return hasNonEmptyRows;  // returns false if the grid is valid but empty
+  }
+
+  template <class B, class D, class F>
+  void _build_slicer(const B &boundaries, const D &dimensions, const F &filValues) {
+    {
+      nanobind::gil_scoped_release release;
+      Complex cpx(boundaries, dimensions, filValues);
+      slicer_ = Slicer_t(std::move(cpx));
+    }
+  }
+
+  template <class OtherMultiFiltrationValue, class OtherPersistenceAlgorithm>
+  bool _has_same_filtration_values(
+      const Slicer_interface<OtherMultiFiltrationValue, OtherPersistenceAlgorithm> &other) const {
+    using F1_double = decltype(std::declval<MultiFiltrationValue>().template as_type<double>());
+    using F2_double = decltype(std::declval<OtherMultiFiltrationValue>().template as_type<double>());
+
+    auto are_equal = [](const auto &a, const auto &b) {
+      // we already know they have the same size
+      return std::equal(a.begin(), a.end(), b.begin(), [](auto f1, auto f2) {
+        return Gudhi::multi_filtration::are_equal_filtration_values(f1, f2);
+      });
+    };
+
+    const auto &filtsA = slicer_.get_filtration_values();
+    const auto &filtsB = other.get_slicer().get_filtration_values();
+
+    if (filtsA.size() != filtsB.size()) return false;
+
+    nanobind::object otherGrid = other.get_filtration_grid();
+
+    if (filtrationGrid_.is_none() && otherGrid.is_none()) {
+      nanobind::gil_scoped_release release;
+      return are_equal(filtsA, filtsB);
+    }
+
+    // if filtrationGrid_ is not None for one of them, the filtration values to compare are in the grid
+    // as two different grids can still yield the same filtration values, it is not sufficient to compare the grids
+    // also, once translated, the filtration values could be not minimal, i.e. the values have to
+    // be explicitly constructed
+
+    std::vector<F1_double> transA;
+    std::vector<F2_double> transB;
+
+    if (filtrationGrid_.is_none()) {
+      std::vector<std::vector<double>> grid;
+      if (!nanobind::try_cast<std::vector<std::vector<double>>>(otherGrid, grid))
+        throw std::runtime_error("Stored filtration grid in other did not have a valid format.");
+      nanobind::gil_scoped_release release;
+      transB.reserve(filtsB.size());
+      for (const auto &f : filtsB) {
+        transB.push_back(evaluate_coordinates_in_grid(f, grid));
+      }
+      return are_equal(filtsA, transB);
+    }
+
+    if (otherGrid.is_none()) {
+      std::vector<std::vector<double>> grid;
+      if (!nanobind::try_cast<std::vector<std::vector<double>>>(filtrationGrid_, grid))
+        throw std::runtime_error("Stored filtration grid did not have a valid format.");
+      nanobind::gil_scoped_release release;
+      transA.reserve(filtsA.size());
+      for (const auto &f : filtsA) {
+        transA.push_back(evaluate_coordinates_in_grid(f, grid));
+      }
+      return are_equal(transA, filtsB);
+    }
+
+    std::vector<std::vector<double>> gridA;
+    std::vector<std::vector<double>> gridB;
+    if (!nanobind::try_cast<std::vector<std::vector<double>>>(filtrationGrid_, gridA))
+      throw std::runtime_error("Stored filtration grid did not have a valid format.");
+    if (!nanobind::try_cast<std::vector<std::vector<double>>>(otherGrid, gridB))
+      throw std::runtime_error("Stored filtration grid in other did not have a valid format.");
+    nanobind::gil_scoped_release release;
+    for (std::size_t i = 0; i < filtsA.size(); ++i) {
+      transA.push_back(evaluate_coordinates_in_grid(filtsA[i], gridA));
+      transB.push_back(evaluate_coordinates_in_grid(filtsB[i], gridB));
+    }
+    return are_equal(transA, transB);
+  }
+
+  [[nodiscard]] bool _verify_grid_validity(nanobind::object grid) const {
+    // special case of ndarray is more efficient then general nanobind::iterable
+    if (nanobind::ndarray<> arr; nanobind::try_cast<nanobind::ndarray<>>(grid, arr, false)) {
+      if (arr.ndim() != 2) throw nanobind::type_error("Expected a 2D grid.");
+      return detail::_dispatch_dtype(
+          grid,
+          [&]<typename U>() { return _check_has_sorted_rows<U>(Tensor2D<U>(arr)); },
+          []() { return true; },
+          []() -> bool { throw nanobind::type_error("Unsupported element type."); });
+    }
+
+    if (!nanobind::isinstance<nanobind::iterable>(grid))
+      throw nanobind::type_error("Expected a grid as a 2D array or an iterable of iterables.");
+
+    return detail::_dispatch_dtype(
+        grid,
+        [&]<typename U>() { return _check_has_sorted_rows<U>(nanobind::cast<nanobind::iterable>(grid)); },
+        []() { return true; },
+        []() -> bool { throw nanobind::type_error("Unsupported element type."); });
+  }
+
+  void _get_cycle_boundary(std::vector<std::vector<Index>> &outCycle, const std::vector<Index> &cycle, int dim) const {
+    if (cycle.size() == 0) throw std::runtime_error("A cycle should not be empty");
+    if (generatorBasis_.has_value() && dim == generatorBasis_->degree) {
+      outCycle = generatorBasis_->expand_cycle(cycle);
+    } else if (slicer_.get_boundary(cycle[0]).empty()) {
+      outCycle = {std::vector<Index>{}};
+    } else {
+      outCycle.resize(cycle.size());
+      for (std::size_t i = 0; i < cycle.size(); ++i) {
+        outCycle[i] = slicer_.get_boundary(cycle[i]);
+      }
+    }
+  }
+
+  std::vector<std::vector<std::vector<std::vector<Index>>>> _get_cycle_boundaries(
+      bool update,
+      const std::optional<Tensor2D<std::int64_t>> &barcodeIndices,
+      const std::optional<Tensor1D<Index>> &pointsToIntersect) {
+    std::unordered_set<Index> points;
+    if (pointsToIntersect.has_value()) {
+      if (generatorBasis_.has_value())
+        PyErr_WarnEx(PyExc_UserWarning,
+                     " When there is a generator basis, points to intersect are ignored for dimensions different of 1 "
+                     "for now: to be implemented.",
+                     1);
+      Numpy_span view(*pointsToIntersect);
+      points.reserve(view.size());
+      points.insert(view.begin(), view.end());
+    }
+
+    std::vector<std::vector<std::vector<std::vector<Index>>>> out;
+
+    {
+      nanobind::gil_scoped_release release;
+      auto cycleIdx = slicer_.get_representative_cycles(update);
+      out.resize(cycleIdx.size());
+      std::vector<std::array<std::int64_t, 3>> blocks;
+
+      if (barcodeIndices.has_value()) {
+        Numpy_2d_span view(*barcodeIndices);
+        std::vector<std::int64_t> sizeByDim(cycleIdx.size(), 0);
+        for (Index i = 0; i < view.size(); ++i) {
+          auto bar = view[i];
+          if (bar.size() != 2) throw std::invalid_argument("`barcode_indices` has to be of shape (*, 2).");
+          auto barDim = bar[0];
+          auto barIdx = bar[1];
+          if (barDim < 0 || barDim >= sizeByDim.size())
+            throw std::invalid_argument("Given dimension in `idx` is not valid or out of bound.");
+          if (barIdx < 0 || barIdx >= cycleIdx[barDim].size())
+            throw std::invalid_argument("Given bar index in `idx` is not valid or out of bound.");
+          ++sizeByDim[barDim];
+        }
+        for (std::size_t dim = 0; dim < cycleIdx.size(); ++dim) {
+          out[dim].resize(sizeByDim[dim]);
+          sizeByDim[dim] = 0;
+        }
+        for (Index i = 0; i < view.size(); ++i) {
+          auto barIdx = view[i];
+          blocks.push_back({barIdx[0], barIdx[1], sizeByDim[barIdx[0]]});
+          ++sizeByDim[barIdx[0]];
+        }
+      } else {
+        for (std::int64_t dim = 0; dim < static_cast<std::int64_t>(cycleIdx.size()); ++dim) {
+          out[dim].resize(cycleIdx[dim].size());
+          for (std::int64_t c = 0; c < static_cast<std::int64_t>(cycleIdx[dim].size()); ++c) {
+            blocks.push_back({dim, c, c});
+          }
+        }
+      }
+      detail::Representative_cycle_intersection inter(slicer_.get_boundaries(), slicer_.get_dimensions(), points);
+      if (pointsToIntersect.has_value() && !generatorBasis_.has_value()) {
+        // pre-initialize cache in sequential loop to avoid problems in parallelization
+        inter.initialize_cache(blocks.size(), [&](std::size_t i) -> const auto & {
+          auto [dim, cIdx, cOut] = blocks[i];
+          return cycleIdx[dim][cIdx];
+        });
+      }
+      tbb::parallel_for(std::size_t(0), blocks.size(), [&](std::size_t blockIdx) {
+        auto [dim, cIdx, cOut] = blocks[blockIdx];
+        const auto &cycle = cycleIdx[dim][cIdx];
+        if (!pointsToIntersect.has_value() || generatorBasis_.has_value() || inter.intersects(cycle)) {
+          auto &outCycle = out[dim][cOut];
+          _get_cycle_boundary(outCycle, cycle, dim);
+          // TODO: intersects version for generatorBasis_ and remove this if
+          if (dim == 1 && generatorBasis_.has_value() && pointsToIntersect.has_value() &&
+              !inter.dim_1_boundaries_intersects(outCycle)) {
+            outCycle.clear();  // to mark as to be ignored
+          }
+        }
+      });
+    }
+
+    return out;
+  }
+
+  std::vector<std::vector<std::vector<Index>>> _get_cycle_boundaries(
+      bool update,
+      Dimension dimension,
+      const std::optional<Tensor1D<std::int64_t>> &barcodeIndices,
+      const std::optional<Tensor1D<Index>> &pointsToIntersect) {
+    std::unordered_set<Index> points;
+    if (pointsToIntersect.has_value()) {
+      if (dimension != 1 && generatorBasis_.has_value()) {
+        PyErr_WarnEx(PyExc_UserWarning,
+                     "When there is a generator basis, points to intersect are ignored for dimensions different of 1 "
+                     "for now: to be implemented.",
+                     1);
+      } else {
+        Numpy_span view(*pointsToIntersect);
+        points.reserve(view.size());
+        points.insert(view.begin(), view.end());
+      }
+    }
+
+    std::vector<std::vector<std::vector<Index>>> out;
+
+    {
+      nanobind::gil_scoped_release release;
+      auto cycleIdx = slicer_.get_representative_cycles_in_dim(dimension, update);
+
+      detail::Representative_cycle_intersection inter(slicer_.get_boundaries(), slicer_.get_dimensions(), points);
+      auto compute_boundaries = [&](const auto &range) {
+        if (pointsToIntersect.has_value() && !generatorBasis_.has_value()) {
+          // pre-initialize cache in sequential loop to avoid problems in parallelization
+          inter.initialize_cache(range.size(), [&](std::size_t i) -> const auto & { return cycleIdx[range[i]]; });
+        }
+        tbb::parallel_for(std::size_t(0), range.size(), [&](std::size_t idx) {
+          const auto &cycle = cycleIdx[range[idx]];
+          if (!pointsToIntersect.has_value() || generatorBasis_.has_value() || inter.intersects(cycle)) {
+            auto &outCycle = out[idx];
+            _get_cycle_boundary(outCycle, cycle, dimension);
+            // TODO: intersects version for generatorBasis_ and remove this if
+            if (dimension == 1 && generatorBasis_.has_value() && pointsToIntersect.has_value() &&
+                !inter.dim_1_boundaries_intersects(outCycle)) {
+              outCycle.clear();  // to mark as to be ignored
+            }
+          }
+        });
+      };
+
+      if (barcodeIndices.has_value()) {
+        Numpy_span view(*barcodeIndices);
+        out.resize(view.size());
+        compute_boundaries(view);
+      } else {
+        out.resize(cycleIdx.size());
+        std::vector<std::int64_t> id(cycleIdx.size());
+        std::iota(id.begin(), id.end(), 0);
+        compute_boundaries(id);
+      }
+    }
+
+    return out;
+  }
+};
+
+template <class SlicerInterface>
+inline SlicerInterface deserialize_slicer_from_python(nanobind::tuple state) {
+  if (nanobind::len(state) != 3)
+    throw std::invalid_argument("Given state to deserialize is not compatible with current multipers version.");
+  std::uint8_t version;
+  if (!nanobind::try_cast<std::uint8_t>(state[0], version, false))
+    throw std::invalid_argument("Given state to deserialize is not compatible with current multipers version.");
+  if (version < SlicerInterface::SERIALIZATION_VERSION)
+    throw std::invalid_argument(
+        "Given state to deserialize is not compatible with current multipers version: try an older release");
+  if (version > SlicerInterface::SERIALIZATION_VERSION)
+    throw std::invalid_argument(
+        "Given state to deserialize is not compatible with current multipers version: try an newer release");
+
+  nanobind::ndarray<const char, nanobind::ndim<1>, nanobind::numpy> data;
+  if (!nanobind::try_cast<nanobind::ndarray<const char, nanobind::ndim<1>, nanobind::numpy>>(state[2], data, false))
+    throw std::invalid_argument("Given state to deserialize is not compatible with current multipers version.");
+  SlicerInterface slicer;
+  {
+    nanobind::gil_scoped_release release;
+    deserialize_value_from_char_buffer(slicer, data.data());
+  }
+  slicer.set_filtration_grid(state[1]);
+  return slicer;
+}
+
+}  // namespace multi_persistence
+}  // namespace Gudhi
+
+#endif  // MP_PY_SLICER_H_INCLUDED
diff --git a/multipers/gudhi/interface_helper_structs.h b/multipers/gudhi/interface_helper_structs.h
new file mode 100644
index 00000000..b24291ba
--- /dev/null
+++ b/multipers/gudhi/interface_helper_structs.h
@@ -0,0 +1,575 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       David Loiseaux, Hannah Schreiber
+ *
+ *    Copyright (C) 2026 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file interface_helper_structs.h
+ * @author David Loiseaux, Hannah Schreiber
+ * @brief Contains helper structs for python bindings.
+ */
+
+#ifndef MP_PY_INTER_HELPER_STRUCTS_H_INCLUDED
+#define MP_PY_INTER_HELPER_STRUCTS_H_INCLUDED
+
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+#include <cstdint>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/vector.h>
+
+#include <gudhi/Slicer.h>
+#include <gudhi/Multi_persistence/utils.h>
+#include <python_interfaces/construction_utils.h>
+
+#include "ext_interface/nanobind_wrapper_types.hpp"
+#include "slicer_interface_helpers.h"
+
+namespace Gudhi {
+namespace multi_persistence {
+namespace detail {
+
+struct Generator_basis_data {
+  using Index = std::uint32_t;
+  using Grade = double;
+
+  int degree = -1;
+  std::vector<std::vector<Index>> columns;
+  std::vector<std::vector<Index>> rowBoundaries;
+  std::vector<std::pair<Grade, Grade>> rowGrades;  // change pair to array<Grade, 2>?
+  std::vector<std::pair<Grade, Grade>> columnGrades;
+  std::vector<Index> rowCellIndices;
+
+  Generator_basis_data() = default;
+
+  Generator_basis_data(int degree_,
+                       std::vector<std::vector<Index>> columns_,
+                       std::vector<std::vector<Index>> rowBoundaries_,
+                       std::vector<std::pair<Grade, Grade>> rowGrades_ = {},
+                       std::vector<std::pair<Grade, Grade>> columnGrades_ = {},
+                       std::vector<Index> rowCellIndices_ = {})
+      : degree(degree_),
+        columns(std::move(columns_)),
+        rowBoundaries(std::move(rowBoundaries_)),
+        rowGrades(std::move(rowGrades_)),
+        columnGrades(std::move(columnGrades_)),
+        rowCellIndices(std::move(rowCellIndices_)) {}
+
+  template <class Complex, class GeneratorMatrix>
+  Generator_basis_data(const Complex& complex, int degree_, GeneratorMatrix& generatorMatrix)
+      : degree(degree_),
+        columns(generatorMatrix.columns.size()),
+        rowBoundaries(generatorMatrix.row_indices.size()),
+        rowGrades(generatorMatrix.row_grades),
+        columnGrades(generatorMatrix.column_grades),
+        rowCellIndices(generatorMatrix.row_indices.size()) {
+    nanobind::gil_scoped_release release;
+    const auto& dimensions = complex.get_dimensions();
+    const auto& boundaries = complex.get_boundaries();
+    const auto& filtrations = complex.get_filtration_values();
+    std::vector<std::size_t> degreeIndices;
+    degreeIndices.reserve(dimensions.size());
+    for (std::size_t i = 0; i < dimensions.size(); ++i) {
+      if (dimensions[i] == degree) {
+        degreeIndices.push_back(i);
+      }
+    }
+    std::stable_sort(degreeIndices.begin(), degreeIndices.end(), [&](std::size_t a, std::size_t b) {
+      const auto& fa = filtrations[a];
+      const auto& fb = filtrations[b];
+      return fa(0, 1) < fb(0, 1) || (fa(0, 1) == fb(0, 1) && fa(0, 0) < fb(0, 0));
+    });
+
+    for (std::size_t i = 0; i < generatorMatrix.row_indices.size(); ++i) {
+      const auto row_idx = static_cast<std::size_t>(generatorMatrix.row_indices[i]);
+      if (row_idx >= degreeIndices.size()) {
+        throw std::runtime_error("generator-basis extraction failed: row index out of range.");
+      }
+      const auto& filtration = filtrations[degreeIndices[row_idx]];
+      const auto& grade = generatorMatrix.row_grades[i];
+      if (filtration(0, 0) != grade.first || filtration(0, 1) != grade.second) {
+        throw std::runtime_error(
+            "generator-basis extraction failed: row grades do not match the original degree block.");
+      }
+    }
+
+    for (std::size_t i = 0; i < generatorMatrix.columns.size(); ++i) {
+      columns[i].reserve(generatorMatrix.columns[i].size());
+      for (const auto row_idx : generatorMatrix.columns[i]) {
+        columns[i].push_back(Gudhi::python::_cast_to_int<Index>(
+            row_idx, "generator-basis extraction failed: column support index does not fit into uint32."));
+      }
+    }
+
+    for (std::size_t i = 0; i < generatorMatrix.row_indices.size(); ++i) {
+      const auto rowIdx = static_cast<std::size_t>(generatorMatrix.row_indices[i]);
+      const auto idx = degreeIndices[rowIdx];
+      rowBoundaries[i].reserve(boundaries[idx].size());
+      for (auto value : boundaries[idx]) {
+        rowBoundaries[i].push_back(Gudhi::python::_cast_to_int<Index>(
+            value, "generator-basis extraction failed: row boundary index does not fit into uint32."));
+      }
+      rowCellIndices[i] = Gudhi::python::_cast_to_int<Index>(
+          idx, "generator-basis extraction failed: row cell index does not fit into uint32.");
+    }
+  }
+
+  Generator_basis_data(nanobind::dict basis) {
+    if (basis.is_none()) return;
+
+    if (!basis.contains("degree") || !basis.contains("columns") || !basis.contains("row_boundaries")) {
+      throw std::invalid_argument(
+          "Invalid generator basis dictionary: expected keys `degree`, `columns`, and `row_boundaries`.");
+    }
+
+    bool success = nanobind::try_cast<int>(basis["degree"], degree);
+    if (!success) {
+      throw std::invalid_argument("_generator_basis['degree'] has to be of type int.");
+    }
+    success = nanobind::try_cast<std::vector<std::vector<Index>>>(basis["columns"], columns);
+    if (!success) {
+      throw std::invalid_argument("_generator_basis['columns'] has to be of an iterable of iterable of uint32.");
+    }
+    success = nanobind::try_cast<std::vector<std::vector<Index>>>(basis["row_boundaries"], rowBoundaries);
+    if (!success) {
+      throw std::invalid_argument("_generator_basis['row_boundaries'] has to be of an iterable of iterable of uint32.");
+    }
+    if (basis.contains("row_grades")) {
+      success = nanobind::try_cast<std::vector<std::pair<Grade, Grade>>>(basis["row_grades"], rowGrades);
+      if (!success) {
+        throw std::invalid_argument("_generator_basis['row_grades'] has to be an iterable of pairs of float.");
+      }
+    }
+    if (basis.contains("column_grades")) {
+      success = nanobind::try_cast<std::vector<std::pair<Grade, Grade>>>(basis["column_grades"], columnGrades);
+      if (!success) {
+        throw std::invalid_argument("_generator_basis['column_grades'] has to be an iterable of pairs of float.");
+      }
+    }
+    if (basis.contains("row_cell_indices")) {
+      success = nanobind::try_cast<std::vector<std::uint32_t>>(basis["row_cell_indices"], rowCellIndices);
+      if (!success) {
+        throw std::invalid_argument("_generator_basis['row_cell_indices'] has to be an iterable of int.");
+      }
+    }
+  }
+
+  nanobind::object operator[](std::string_view key) const {
+    if (key == "degree") return nanobind::cast(degree);
+    if (key == "columns") return nanobind::cast(columns);
+    if (key == "row_boundaries") return nanobind::cast(rowBoundaries);
+    if (key == "row_grades") return nanobind::cast(rowGrades);
+    if (key == "column_grades") return nanobind::cast(columnGrades);
+    if (key == "row_cell_indices") return nanobind::cast(rowCellIndices);
+
+    throw nanobind::key_error("Invalid `_GeneratorBasis` key.");
+  }
+
+  static bool is_key(std::string_view key) {
+    return key == "degree" || key == "columns" || key == "row_boundaries" || key == "row_grades" ||
+           key == "column_grades" || key == "row_cell_indices";
+  }
+
+  static nanobind::tuple get_keys() {
+    return nanobind::make_tuple(
+        "degree", "columns", "row_boundaries", "row_grades", "column_grades", "row_cell_indices");
+  }
+
+  std::vector<std::vector<Index>> expand_cycle(const std::vector<Index>& cycle) const {
+    std::unordered_set<Index> activeRows;
+    for (Index genIdx : cycle) {
+      if (genIdx >= columns.size()) {
+        throw std::runtime_error("Representative cycle refers to a generator outside `_generator_basis`.");
+      }
+      for (Index rowIdx : columns[genIdx]) {
+        if (rowIdx >= rowBoundaries.size()) {
+          throw std::runtime_error("`_generator_basis` column support refers to a row outside `row_boundaries`.");
+        }
+        auto [it, inserted] = activeRows.insert(rowIdx);
+        if (!inserted) {
+          activeRows.erase(it);
+        }
+      }
+    }
+
+    std::vector<std::vector<Index>> out;
+    out.reserve(activeRows.size());
+    for (Index rowIdx : activeRows) {
+      out.push_back(rowBoundaries[rowIdx]);
+    }
+    return out;
+  }
+
+  std::vector<Index> expand_cycle_cell_ids(const std::vector<Index>& cycle) {
+    if (rowCellIndices.size() != rowBoundaries.size()) {
+      throw std::runtime_error(
+          "`_generator_basis` does not contain complete `row_cell_indices`; "
+          "use `expand_generator_basis=False` or rebuild it with the current Multipers version.");
+    }
+
+    std::unordered_set<Index> activeRows;
+    for (Index genIdx : cycle) {
+      if (genIdx >= columns.size()) {
+        throw std::runtime_error("Representative cycle refers to a generator outside `_generator_basis`.");
+      }
+      for (Index rowIdx : columns[genIdx]) {
+        if (rowIdx >= rowCellIndices.size()) {
+          throw std::runtime_error("`_generator_basis` column support refers to a row outside `row_cell_indices`.");
+        }
+        auto [it, inserted] = activeRows.insert(rowIdx);
+        if (!inserted) {
+          activeRows.erase(it);
+        }
+      }
+    }
+
+    std::vector<Index> out;
+    out.reserve(activeRows.size());
+    for (Index row_idx : activeRows) {
+      out.push_back(rowCellIndices[row_idx]);
+    }
+    std::sort(out.begin(), out.end());
+    if (std::adjacent_find(out.begin(), out.end()) != out.end()) {
+      throw std::runtime_error("`_generator_basis.row_cell_indices` must identify distinct source cells.");
+    }
+    return out;
+  }
+
+  [[nodiscard]] std::string to_str() const {
+    return "_GeneratorBasis(degree=" + std::to_string(degree) + ", columns=" + std::to_string(columns.size()) +
+           ", row_boundaries=" + std::to_string(rowBoundaries.size()) +
+           ", row_cell_indices=" + std::to_string(rowCellIndices.size()) + ")";
+  }
+
+  /**
+   * @brief Serialize given value into the buffer at given pointer.
+   *
+   * @param value Value to serialize.
+   * @param start Pointer to the start of the space in the buffer where to store the serialization.
+   * @return End position of the serialization in the buffer.
+   */
+  friend char* serialize_value_to_char_buffer(const Generator_basis_data& value, char* start) {
+    char* curr = start;
+    curr = serialize_value_to_char_buffer(value.degree, curr);
+    curr = serialize_value_to_char_buffer(value.columns, curr);
+    curr = serialize_value_to_char_buffer(value.rowBoundaries, curr);
+    curr = serialize_value_to_char_buffer(value.rowGrades, curr);
+    curr = serialize_value_to_char_buffer(value.columnGrades, curr);
+    curr = serialize_value_to_char_buffer(value.rowCellIndices, curr);
+    return curr;
+  }
+
+  /**
+   * @brief Deserialize the value from a buffer at given pointer and stores it in given value.
+   *
+   * @param value Value to fill with the deserialized summand.
+   * @param start Pointer to the start of the space in the buffer where the serialization is stored.
+   * @return End position of the serialization in the buffer.
+   */
+  friend const char* deserialize_value_from_char_buffer(Generator_basis_data& value, const char* start) {
+    const char* curr = start;
+    curr = deserialize_value_from_char_buffer(value.degree, curr);
+    curr = deserialize_value_from_char_buffer(value.columns, curr);
+    curr = deserialize_value_from_char_buffer(value.rowBoundaries, curr);
+    curr = deserialize_value_from_char_buffer(value.rowGrades, curr);
+    curr = deserialize_value_from_char_buffer(value.columnGrades, curr);
+    curr = deserialize_value_from_char_buffer(value.rowCellIndices, curr);
+    return curr;
+  }
+
+  /**
+   * @brief Returns the serialization size of the given summand.
+   */
+  friend std::size_t get_serialization_size_of(const Generator_basis_data& value) {
+    std::size_t size = get_serialization_size_of(value.degree);
+    size += get_serialization_size_of(value.columns);
+    size += get_serialization_size_of(value.rowBoundaries);
+    size += get_serialization_size_of(value.rowGrades);
+    size += get_serialization_size_of(value.columnGrades);
+    size += get_serialization_size_of(value.rowCellIndices);
+    return size;
+  }
+};
+
+inline Generator_basis_data deserialize_gen_basis_from_python(
+    nanobind::ndarray<const char, nanobind::ndim<1>, nanobind::numpy> state) {
+  Generator_basis_data basis;
+  {
+    nanobind::gil_scoped_release release;
+    deserialize_value_from_char_buffer(basis, state.data());
+  }
+  return basis;
+}
+
+struct Compacted_squeezed_filtration_grid {
+  using Index = std::int64_t;
+  using squeezed_coordinate_remap = std::vector<std::unordered_map<Index, Index>>;
+
+  nanobind::tuple filtrationGrid;
+  std::vector<std::vector<Index>> coordinates;
+  squeezed_coordinate_remap remap;
+
+  Compacted_squeezed_filtration_grid() = default;
+
+  Compacted_squeezed_filtration_grid(const nanobind::object& grid,
+                                     const std::vector<std::vector<Index>>& usedCoordinates)
+      : coordinates(usedCoordinates), remap(usedCoordinates.size()) {
+    // special case of ndarray should be more efficient then general nanobind::iterable
+    if (nanobind::ndarray<> arr; nanobind::try_cast<nanobind::ndarray<>>(grid, arr, false)) {
+      if (arr.ndim() != 2) throw nanobind::type_error("Expected a 2D grid.");
+      _dispatch_dtype(
+          grid,
+          [&]<typename U>() -> void { _get_compact_grid<U>(nanobind::ndarray<const U, nanobind::ndim<2>>(arr)); },
+          []() -> void {},
+          []() -> void { throw nanobind::type_error("Unsupported element type."); });
+      return;
+    }
+
+    if (!nanobind::isinstance<nanobind::iterable>(grid))
+      throw nanobind::type_error("Expected a grid as a 2D array or an iterable of iterables.");
+
+    _get_compact_grid(nanobind::cast<nanobind::iterable>(grid));
+  }
+
+  template <typename T>
+  T remap_squeezed_coordinate(T coordinate, std::size_t parameter) {
+    if (parameter >= remap.size()) throw std::out_of_range("Parameter is out of range");
+    // careful: just assumes that it will fit into T
+    return static_cast<T>(remap[parameter].at(python::_cast_to_int<Index>(
+        coordinate,
+        "Expected integer squeezed filtration coordinates for parameter " + std::to_string(parameter) + ".")));
+  }
+
+  template <class MultiFiltrationValue, class PersistenceAlgorithm>
+  static std::vector<std::vector<Index>> collect_used_squeezed_coordinates(
+      const Gudhi::multi_persistence::Slicer<MultiFiltrationValue, PersistenceAlgorithm>& slicer) {
+    const auto numParam = slicer.get_number_of_parameters();
+    std::vector<std::vector<Index>> usedCoordinates(numParam);
+    {
+      nanobind::gil_scoped_release release;
+      for (const auto& f : slicer.get_filtration_values()) {
+        for (std::size_t g = 0; g < f.num_generators(); ++g) {
+          for (std::size_t p = 0; p < numParam; ++p) {
+            usedCoordinates[p].push_back(python::_cast_to_int<Index>(
+                f(g, p),
+                "Expected slicer integer squeezed filtration coordinates for parameter " + std::to_string(p) + "."));
+          }
+        }
+      }
+    }
+    return usedCoordinates;
+  }
+
+  template <typename Interface, typename T>
+  static std::vector<std::vector<Index>> collect_used_squeezed_coordinates(
+      multipers::nanobind_helpers::PySimplexTree<Interface, T>& simplexTree) {
+    const auto numParam = simplexTree.tree.num_parameters();
+    std::vector<std::vector<Index>> usedCoordinates(numParam);
+    {
+      nanobind::gil_scoped_release release;
+      for (auto simplex_handle : simplexTree.tree.complex_simplex_range()) {
+        auto pair = simplexTree.tree.get_simplex_and_filtration(simplex_handle);
+        const auto& f = *pair.second;
+        for (std::size_t g = 0; g < f.num_generators(); ++g) {
+          for (std::size_t p = 0; p < numParam; ++p) {
+            usedCoordinates[p].push_back(python::_cast_to_int<Index>(
+                f(g, p),
+                "Expected simplex tree integer squeezed filtration coordinates for parameter " + std::to_string(p) +
+                    "."));
+          }
+        }
+      }
+    }
+    return usedCoordinates;
+  }
+
+  template <typename T>
+  static std::vector<std::vector<Index>> collect_used_squeezed_coordinates(
+      const std::vector<std::pair<T, T>>& biFiltrationValues) {
+    std::vector<std::vector<Index>> usedCoordinates(2);
+    {
+      nanobind::gil_scoped_release release;
+      usedCoordinates[0].reserve(biFiltrationValues.size());
+      usedCoordinates[1].reserve(biFiltrationValues.size());
+      for (const auto& degree : biFiltrationValues) {
+        usedCoordinates[0].push_back(python::_cast_to_int<Index>(
+            degree.first, "Expected integer squeezed filtration coordinates for parameter 0."));
+        usedCoordinates[1].push_back(python::_cast_to_int<Index>(
+            degree.second, "Expected integer squeezed filtration coordinates for parameter 1."));
+      }
+    }
+    return usedCoordinates;
+  }
+
+ private:
+  static Index normalize_squeezed_index_or_sentinel(Index rawIndex, Index rowSize, std::size_t parameter) {
+    if (rawIndex < 0) {
+      rawIndex += rowSize;
+    }
+    if (rawIndex == rowSize) {
+      return rawIndex;  // sentinel
+    }
+    if (rawIndex < 0 || rawIndex > rowSize) {
+      throw std::runtime_error("Squeezed filtration coordinate is outside the filtration grid for parameter " +
+                               std::to_string(parameter) + ".");
+    }
+    return rawIndex;
+  }
+
+  template <typename U>
+  void _get_compact_grid(nanobind::ndarray<const U, nanobind::ndim<2>> grid) {
+    auto view = grid.view();
+    const Index rowSize = view.shape(1);
+
+    if (view.shape(0) < coordinates.size())
+      throw std::invalid_argument("Grid size and number of coordinates do not match.");
+
+    filtrationGrid = Gudhi::python::_build_tuple(coordinates.size(), [&](std::size_t p) {
+      auto& currentCoordinates = coordinates[p];
+      std::ranges::sort(currentCoordinates);
+      const auto uniq = std::ranges::unique(currentCoordinates);
+      currentCoordinates.erase(uniq.begin(), uniq.end());
+
+      nanobind::list selection;
+      auto& m = remap[p];
+      for (size_t i = 0; i < currentCoordinates.size(); ++i) {
+        const Index rawIdx = currentCoordinates[i];
+        const Index normalized = normalize_squeezed_index_or_sentinel(rawIdx, rowSize, p);
+        m.emplace(rawIdx, i);
+        if (normalized != rowSize) {
+          selection.append(normalized);
+        }
+      }
+
+      nanobind::object gridTmp = nanobind::cast(grid);
+      auto rowTmp = gridTmp.attr("__getitem__")(p);
+      return rowTmp.attr("__getitem__")(selection);
+    });
+  }
+
+  void _get_compact_grid(nanobind::iterable grid) {
+    if (!nanobind::hasattr(grid, "__getitem__")) throw nanobind::type_error("Grid has to support subscripting.");
+    Index gridSize = 0;
+    if (nanobind::hasattr(grid, "__len__")) {
+      gridSize = static_cast<Index>(nanobind::len(grid));
+    } else {
+      for (auto it = grid.begin(); it != grid.end(); ++it) ++gridSize;
+    }
+    if (gridSize < coordinates.size()) throw std::invalid_argument("Grid size and number of coordinates do not match.");
+
+    filtrationGrid = Gudhi::python::_build_tuple(coordinates.size(), [&](std::size_t p) {
+      auto& currentCoordinates = coordinates[p];
+      std::ranges::sort(currentCoordinates);
+      const auto uniq = std::ranges::unique(currentCoordinates);
+      currentCoordinates.erase(uniq.begin(), uniq.end());
+
+      nanobind::list selection;
+      auto& m = remap[p];
+      if (!nanobind::hasattr(grid[p], "__getitem__"))
+        throw nanobind::type_error("Grid rows have to support subscripting.");
+      nanobind::object row = nanobind::cast(grid[p]);
+      Index rowSize;
+      if (nanobind::hasattr(row, "__len__"))
+        rowSize = static_cast<Index>(nanobind::len(row));
+      else
+        rowSize = static_cast<Index>(nanobind::list(row).size());
+      for (std::size_t i = 0; i < currentCoordinates.size(); ++i) {
+        const Index rawIdx = currentCoordinates[i];
+        const Index normalized = normalize_squeezed_index_or_sentinel(rawIdx, rowSize, p);
+        m.emplace(rawIdx, i);
+        if (normalized != rowSize) {
+          selection.append(normalized);
+        }
+      }
+
+      return row.attr("__getitem__")(selection);
+    });
+  }
+};
+
+template <class Boundaries, class Dimensions, typename Index>
+class Representative_cycle_intersection {
+ public:
+  Representative_cycle_intersection(const Boundaries& boundaries,
+                                    const Dimensions& dimensions,
+                                    const std::unordered_set<Index>& points)
+      : boundaries_(&boundaries), dimensions_(&dimensions), points_(&points), cache_(boundaries.size(), -1) {}
+
+  bool intersects(const std::vector<Index>& cycle) {
+    if (points_->empty()) {
+      return false;
+    }
+    for (Index cell : cycle) {
+      if (_cell_intersects(cell)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // for Generator_basis_data case, temporary
+  bool dim_1_boundaries_intersects(const std::vector<std::vector<Index>>& cycle) {
+    if (points_->empty()) {
+      return false;
+    }
+    for (const auto& boundary : cycle) {
+      for (Index vertex : boundary) {
+        if (points_->contains(vertex)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  template <class F>
+  void initialize_cache(std::size_t n, F&& get_cycle) {
+    for (std::size_t i = 0; i < n; ++i) {
+      intersects(std::forward<F>(get_cycle)(i));
+    }
+  }
+
+ private:
+  Boundaries const* boundaries_;
+  Dimensions const* dimensions_;
+  std::unordered_set<Index> const* points_;
+  std::vector<std::int8_t> cache_;
+
+  bool _cell_intersects(Index cell) {
+    auto& cached = cache_[static_cast<std::size_t>(cell)];
+    if (cached >= 0) {
+      return cached != 0;
+    }
+
+    bool intersects = false;
+    if ((*dimensions_)[cell] == 0) {
+      intersects = points_->find(cell) != points_->end();
+    } else {
+      for (auto face : (*boundaries_)[cell]) {
+        if (_cell_intersects(face)) {
+          intersects = true;
+          break;
+        }
+      }
+    }
+    cached = static_cast<std::int8_t>(intersects);
+    return intersects;
+  }
+};
+
+}  // namespace detail
+}  // namespace multi_persistence
+}  // namespace Gudhi
+
+#endif  // MP_PY_INTER_HELPER_STRUCTS_H_INCLUDED
diff --git a/multipers/gudhi/module_landscapes.hpp b/multipers/gudhi/module_landscapes.hpp
deleted file mode 100644
index 562bc273..00000000
--- a/multipers/gudhi/module_landscapes.hpp
+++ /dev/null
@@ -1,228 +0,0 @@
-#ifndef MULTIPERS_GUDHI_MODULE_LANDSCAPES_HPP
-#define MULTIPERS_GUDHI_MODULE_LANDSCAPES_HPP
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <limits>
-#include <stdexcept>
-#include <type_traits>
-#include <vector>
-
-#ifdef GUDHI_USE_TBB
-#include <oneapi/tbb/enumerable_thread_specific.h>
-#include <oneapi/tbb/parallel_for.h>
-#include <oneapi/tbb/task_arena.h>
-#endif
-
-#include <gudhi/Multi_persistence/Box.h>
-#include <gudhi/Multi_persistence/Module.h>
-#include <gudhi/Multi_persistence/summand_helpers.h>
-#include <gudhi/Multi_persistence/utils.h>
-
-namespace multipers::detail {
-
-template <typename T>
-struct ModuleLandscapeSummandCache {
-  const typename Gudhi::multi_persistence::Module<T>::Summand_t* summand;
-  std::vector<T> lower;
-  std::vector<T> upper;
-};
-
-template <typename T>
-inline std::vector<ModuleLandscapeSummandCache<T>> build_module_landscape_summand_cache(
-    const Gudhi::multi_persistence::Module<T>& module,
-    typename Gudhi::multi_persistence::Module<T>::Dimension dimension) {
-  using Module = Gudhi::multi_persistence::Module<T>;
-  using Summand = typename Module::Summand_t;
-
-  std::vector<ModuleLandscapeSummandCache<T>> summands;
-  summands.reserve(module.size());
-  for (const auto& summand : module) {
-    if (summand.get_dimension() != dimension) continue;
-    const auto& births = summand.get_upset();
-    const auto& deaths = summand.get_downset();
-    if (births.num_generators() == 0 || deaths.num_generators() == 0) continue;
-
-    const auto num_parameters = static_cast<std::size_t>(summand.get_number_of_parameters());
-    ModuleLandscapeSummandCache<T> entry{
-        &summand,
-        std::vector<T>(num_parameters, Summand::T_inf),
-        std::vector<T>(num_parameters, Summand::T_m_inf),
-    };
-    for (std::size_t generator = 0; generator < static_cast<std::size_t>(births.num_generators()); ++generator) {
-      for (std::size_t parameter = 0; parameter < num_parameters; ++parameter) {
-        entry.lower[parameter] = std::min(entry.lower[parameter], births(generator, parameter));
-      }
-    }
-    for (std::size_t generator = 0; generator < static_cast<std::size_t>(deaths.num_generators()); ++generator) {
-      for (std::size_t parameter = 0; parameter < num_parameters; ++parameter) {
-        const T death = deaths(generator, parameter);
-        if (death == Summand::T_inf) {
-          entry.upper[parameter] = Summand::T_inf;
-        } else if (entry.upper[parameter] != Summand::T_inf) {
-          entry.upper[parameter] = std::max(entry.upper[parameter], death);
-        }
-      }
-    }
-    summands.push_back(std::move(entry));
-  }
-  return summands;
-}
-
-template <typename T, class RandomAccessValueRange>
-inline bool could_have_positive_module_landscape(const ModuleLandscapeSummandCache<T>& summand,
-                                                 const RandomAccessValueRange& x) {
-  if (x.size() != summand.lower.size()) return true;
-  for (std::size_t parameter = 0; parameter < summand.lower.size(); ++parameter) {
-    if (x[parameter] <= summand.lower[parameter] || x[parameter] >= summand.upper[parameter]) return false;
-  }
-  return true;
-}
-
-template <class RandomAccessValueRange>
-inline std::size_t module_landscape_top_size(const RandomAccessValueRange& ks) {
-  std::size_t top_size = 0;
-  for (std::size_t index = 0; index < ks.size(); ++index) {
-    const auto k = ks[index];
-    if constexpr (std::is_signed_v<std::decay_t<decltype(k)>>) {
-      if (k < 0) throw std::invalid_argument("Landscape indices must be non-negative.");
-    }
-    const auto k_value = static_cast<std::size_t>(k);
-    if (k_value == std::numeric_limits<std::size_t>::max()) {
-      throw std::length_error("Landscape index is too large.");
-    }
-    top_size = std::max(top_size, k_value + 1);
-  }
-  return top_size;
-}
-
-template <typename T>
-inline void insert_module_landscape_value(T value, std::vector<T>& top) {
-  if (top.empty() || !(value > top.back())) return;
-  for (std::size_t position = 0; position < top.size(); ++position) {
-    if (value > top[position]) {
-      for (std::size_t shift = top.size() - 1; shift > position; --shift) {
-        top[shift] = top[shift - 1];
-      }
-      top[position] = value;
-      return;
-    }
-  }
-}
-
-template <typename T, class RandomAccessValueRange1, class RandomAccessValueRange2>
-inline void set_module_landscape_pixel(std::vector<Gudhi::multi_persistence::maybe_make_signed_t<T>>& images,
-                                       std::size_t pixel,
-                                       std::size_t plane_size,
-                                       const std::vector<ModuleLandscapeSummandCache<T>>& summands,
-                                       const RandomAccessValueRange1& x,
-                                       const RandomAccessValueRange2& ks,
-                                       std::vector<Gudhi::multi_persistence::maybe_make_signed_t<T>>& top) {
-  using SignedT = Gudhi::multi_persistence::maybe_make_signed_t<T>;
-
-  std::fill(top.begin(), top.end(), SignedT(0));
-  for (const auto& summand : summands) {
-    if (!could_have_positive_module_landscape(summand, x)) continue;
-    insert_module_landscape_value(Gudhi::multi_persistence::compute_summand_landscape_value(*summand.summand, x), top);
-  }
-  for (std::size_t index = 0; index < ks.size(); ++index) {
-    const auto k = static_cast<std::size_t>(ks[index]);
-    images[index * plane_size + pixel] = k < top.size() ? top[k] : SignedT(0);
-  }
-}
-
-template <typename T, typename U, class RandomAccessValueRange1, class RandomAccessValueRange2>
-inline std::vector<Gudhi::multi_persistence::maybe_make_signed_t<T>> compute_module_landscapes(
-    const Gudhi::multi_persistence::Module<T>& module,
-    typename Gudhi::multi_persistence::Module<T>::Dimension dimension,
-    const RandomAccessValueRange1& ks,
-    const Gudhi::multi_persistence::Box<U>& box,
-    const RandomAccessValueRange2& resolution,
-    int n_jobs = 0) {
-  static_assert(std::is_same_v<U, T> || std::is_same_v<U, Gudhi::multi_persistence::maybe_make_signed_t<T>>,
-                "Box template parameter is not compatible with Summand value type.");
-  if (resolution.size() < 2) throw std::invalid_argument("Not enough resolution values.");
-
-  using SignedT = Gudhi::multi_persistence::maybe_make_signed_t<T>;
-  const auto nx = static_cast<std::size_t>(resolution[0]);
-  const auto ny = static_cast<std::size_t>(resolution[1]);
-  const auto plane_size = nx * ny;
-  std::vector<SignedT> images(ks.size() * plane_size);
-  if (ks.size() == 0 || plane_size == 0) return images;
-
-  const auto summands = build_module_landscape_summand_cache(module, dimension);
-  const auto top_size = std::min(module_landscape_top_size(ks), summands.size());
-  if (top_size == 0) return images;
-
-  const U step_x = (box.get_upper_corner()[0] - box.get_lower_corner()[0]) / static_cast<U>(nx);
-  const U step_y = (box.get_upper_corner()[1] - box.get_lower_corner()[1]) / static_cast<U>(ny);
-  auto set_pixel = [&](std::size_t pixel, std::vector<SignedT>& top) {
-    const auto row = pixel / ny;
-    const auto column = pixel - row * ny;
-    const std::array<U, 2> x{
-        box.get_lower_corner()[0] + step_x * static_cast<U>(row),
-        box.get_lower_corner()[1] + step_y * static_cast<U>(column),
-    };
-    set_module_landscape_pixel(images, pixel, plane_size, summands, x, ks, top);
-  };
-
-#ifdef GUDHI_USE_TBB
-  tbb::enumerable_thread_specific<std::vector<SignedT>> top([&] { return std::vector<SignedT>(top_size); });
-  oneapi::tbb::task_arena arena(n_jobs);
-  arena.execute([&] {
-    tbb::parallel_for(std::size_t(0), plane_size, [&](std::size_t pixel) { set_pixel(pixel, top.local()); });
-  });
-#else
-  std::vector<SignedT> top(top_size);
-  for (std::size_t pixel = 0; pixel < plane_size; ++pixel) set_pixel(pixel, top);
-#endif
-
-  return images;
-}
-
-template <typename T, class RandomAccessValueRange, class RandomAccessArray>
-inline std::vector<Gudhi::multi_persistence::maybe_make_signed_t<T>> compute_module_landscapes(
-    const Gudhi::multi_persistence::Module<T>& module,
-    typename Gudhi::multi_persistence::Module<T>::Dimension dimension,
-    const RandomAccessValueRange& ks,
-    const std::vector<RandomAccessArray>& grid,
-    int n_jobs = 0) {
-  if (grid.size() < 2) throw std::invalid_argument("First axis of the grid has not enough values.");
-
-  using SignedT = Gudhi::multi_persistence::maybe_make_signed_t<T>;
-  using GridT = std::decay_t<decltype(grid[0][0])>;
-  const auto nx = grid[0].size();
-  const auto ny = grid[1].size();
-  const auto plane_size = nx * ny;
-  std::vector<SignedT> images(ks.size() * plane_size);
-  if (ks.size() == 0 || plane_size == 0) return images;
-
-  const auto summands = build_module_landscape_summand_cache(module, dimension);
-  const auto top_size = std::min(module_landscape_top_size(ks), summands.size());
-  if (top_size == 0) return images;
-
-  auto set_pixel = [&](std::size_t pixel, std::vector<SignedT>& top) {
-    const auto row = pixel / ny;
-    const auto column = pixel - row * ny;
-    const std::array<GridT, 2> x{grid[0][row], grid[1][column]};
-    set_module_landscape_pixel(images, pixel, plane_size, summands, x, ks, top);
-  };
-
-#ifdef GUDHI_USE_TBB
-  tbb::enumerable_thread_specific<std::vector<SignedT>> top([&] { return std::vector<SignedT>(top_size); });
-  oneapi::tbb::task_arena arena(n_jobs);
-  arena.execute([&] {
-    tbb::parallel_for(std::size_t(0), plane_size, [&](std::size_t pixel) { set_pixel(pixel, top.local()); });
-  });
-#else
-  std::vector<SignedT> top(top_size);
-  for (std::size_t pixel = 0; pixel < plane_size; ++pixel) set_pixel(pixel, top);
-#endif
-
-  return images;
-}
-
-}  // namespace multipers::detail
-
-#endif
diff --git a/multipers/gudhi/slicer_conversion_core.hpp b/multipers/gudhi/slicer_conversion_core.hpp
deleted file mode 100644
index ef63ffe6..00000000
--- a/multipers/gudhi/slicer_conversion_core.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include "Persistence_slices_interface.h"
-
-namespace multipers::core {
-
-template <class TargetSlicer, class SourceSlicer>
-struct SlicerConversion {
-  static TargetSlicer run(const SourceSlicer& source) { return TargetSlicer(source); }
-};
-
-}  // namespace multipers::core
-
-#if !defined(MULTIPERS_BUILD_CORE_TEMPLATES) && __has_include(<slicer_conversion_extern_templates.h>)
-#include <slicer_conversion_extern_templates.h>
-#endif
diff --git a/multipers/gudhi/slicer_interface_helpers.h b/multipers/gudhi/slicer_interface_helpers.h
new file mode 100644
index 00000000..7ec69492
--- /dev/null
+++ b/multipers/gudhi/slicer_interface_helpers.h
@@ -0,0 +1,370 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       Hannah Schreiber
+ *
+ *    Copyright (C) 2026 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file slicer_interface_helpers.h
+ * @author Hannah Schreiber
+ * @brief Contains helpers for the @ref Gudhi::multi_persistence::Slicer_interface class for python bindings.
+ */
+
+#ifndef MP_PY_SLICER_HELPERS_H_INCLUDED
+#define MP_PY_SLICER_HELPERS_H_INCLUDED
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+// #include <sstream>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+
+#include <gudhi/Slicer.h>
+#include <gudhi/Degree_rips_bifiltration.h>
+#include <gudhi/Dynamic_multi_parameter_filtration.h>
+#include <gudhi/Multi_parameter_filtration.h>
+#include <python_interfaces/numpy_utils.h>
+#include <python_interfaces/construction_utils.h>
+
+namespace Gudhi {
+namespace multi_persistence {
+namespace detail {
+
+template <typename T, typename... Ts>
+inline constexpr bool _all_same_v = (std::is_same_v<T, Ts> && ...);
+
+enum class Array_dtype : std::uint8_t { INT32, INT64, UINT32, UINT64, FLOAT32, FLOAT64, EMPTY, UNKNOWN };
+
+template <typename U>
+inline bool _is_dtype(const nanobind::dlpack::dtype &dt) {
+  auto expected = nanobind::dtype<U>();
+  return dt.code == expected.code && dt.bits == expected.bits && dt.lanes == expected.lanes;
+}
+
+inline Array_dtype _get_dtype(const nanobind::dlpack::dtype &dt) {
+  if (_is_dtype<std::uint64_t>(dt)) return Array_dtype::UINT64;
+  if (_is_dtype<std::uint32_t>(dt)) return Array_dtype::UINT32;
+  if (_is_dtype<std::int64_t>(dt)) return Array_dtype::INT64;
+  if (_is_dtype<std::int32_t>(dt)) return Array_dtype::INT32;
+  if (_is_dtype<double>(dt)) return Array_dtype::FLOAT64;
+  if (_is_dtype<float>(dt)) return Array_dtype::FLOAT32;
+  return Array_dtype::UNKNOWN;
+}
+
+inline Array_dtype _get_dtype(nanobind::handle obj) {
+  // special case of ndarray
+  if (nanobind::ndarray<> arr; nanobind::try_cast<nanobind::ndarray<>>(obj, arr)) {
+    return _get_dtype(arr.dtype());
+  }
+
+  // terminal case of recursion
+  if (nanobind::isinstance<nanobind::int_>(obj)) return Array_dtype::INT64;
+  if (nanobind::isinstance<nanobind::float_>(obj)) return Array_dtype::FLOAT64;
+
+  // recursion on first element
+  if (nanobind::isinstance<nanobind::iterable>(obj)) {
+    if (!nanobind::hasattr(obj, "__getitem__")) throw nanobind::type_error("Container has to support subscripting.");
+    if (!nanobind::hasattr(obj, "__len__")) throw nanobind::type_error("Container has to support __len__.");
+    if (nanobind::len(obj) != 0) return _get_dtype(obj[0]);
+    return Array_dtype::EMPTY;
+  }
+
+  return Array_dtype::UNKNOWN;
+}
+
+// template <typename F>
+// inline auto _dispatch_int_dtype(nanobind::handle data, F &&func) {
+//   using R_int32 = decltype(func.template operator()<std::int32_t>());
+//   using R_int64 = decltype(func.template operator()<std::int64_t>());
+//   using R_uint32 = decltype(func.template operator()<std::uint32_t>());
+//   using R_uint64 = decltype(func.template operator()<std::uint64_t>());
+
+//   using Union = std::conditional_t<_all_same_v<R_int32, R_int64, R_uint32, R_uint64>,
+//                                    R_uint32,
+//                                    std::variant<R_int32, R_int64, R_uint32, R_uint64>>;
+
+//   Array_dtype dtype = _get_dtype(data);
+//   switch (dtype) {
+//     case Array_dtype::INT32:
+//       return Union(std::forward<F>(func).template operator()<std::int32_t>());
+//     case Array_dtype::UINT32:
+//       return Union(std::forward<F>(func).template operator()<std::uint32_t>());
+//     case Array_dtype::INT64:
+//       return Union(std::forward<F>(func).template operator()<std::int64_t>());
+//     case Array_dtype::UINT64:
+//       return Union(std::forward<F>(func).template operator()<std::uint64_t>());
+//     case Array_dtype::EMPTY:
+//       // type does not matter for now then
+//       return Union(std::forward<F>(func).template operator()<std::uint32_t>());
+//     default:
+//       std::stringstream errMsg;
+//       errMsg << "Unsupported integer type: ";
+//       if (dtype == Array_dtype::FLOAT32)
+//         errMsg << "FLOAT32";
+//       else if (dtype == Array_dtype::FLOAT64)
+//         errMsg << "FLOAT64";
+//       else
+//         errMsg << "UNKNOWN";
+//       errMsg << ".";
+//       throw nanobind::type_error(errMsg.str().c_str());
+//   }
+// }
+
+// template <typename F>
+// inline auto _dispatch_float_dtype(nanobind::handle data, F &&func) {
+//   using R_float32 = decltype(func.template operator()<float>());
+//   using R_float64 = decltype(func.template operator()<double>());
+
+//   using Union = std::conditional_t<std::is_same_v<R_float32, R_float64>, R_float32, std::variant<R_float32, R_float64>>;
+
+//   Array_dtype dtype = _get_dtype(data);
+//   switch (dtype) {
+//     case Array_dtype::FLOAT32:
+//       return Union(std::forward<F>(func).template operator()<float>());
+//     case Array_dtype::FLOAT64:
+//       return Union(std::forward<F>(func).template operator()<double>());
+//     case Array_dtype::EMPTY:
+//       // type does not matter for now then
+//       return Union(std::forward<F>(func).template operator()<float>());
+//     default:
+//       std::stringstream errMsg;
+//       errMsg << "Unsupported floating point type: ";
+//       if (dtype == Array_dtype::INT32)
+//         errMsg << "INT32";
+//       else if (dtype == Array_dtype::INT64)
+//         errMsg << "INT64";
+//       else if (dtype == Array_dtype::UINT32)
+//         errMsg << "UINT32";
+//       else if (dtype == Array_dtype::UINT64)
+//         errMsg << "UINT64";
+//       else
+//         errMsg << "UNKNOWN";
+//       errMsg << ".";
+//       throw nanobind::type_error(errMsg.str().c_str());
+//   }
+// }
+
+template <typename F, typename F_empty, typename F_unknown>
+inline auto _dispatch_dtype(nanobind::handle data, F &&func, F_empty &&funcEmpty, F_unknown &&funcUnkown) {
+  using R_int32 = decltype(func.template operator()<std::int32_t>());
+  using R_int64 = decltype(func.template operator()<std::int64_t>());
+  using R_uint32 = decltype(func.template operator()<std::uint32_t>());
+  using R_uint64 = decltype(func.template operator()<std::uint64_t>());
+  using R_float32 = decltype(func.template operator()<float>());
+  using R_float64 = decltype(func.template operator()<double>());
+
+  using Union = std::conditional_t<_all_same_v<R_int32, R_int64, R_uint32, R_uint64, R_float32, R_float64>,
+                                   R_uint32,
+                                   std::variant<R_int32, R_int64, R_uint32, R_uint64, R_float32, R_float64>>;
+
+  Array_dtype dtype = _get_dtype(data);
+  switch (dtype) {
+    case Array_dtype::INT32:
+      return Union(std::forward<F>(func).template operator()<std::int32_t>());
+    case Array_dtype::UINT32:
+      return Union(std::forward<F>(func).template operator()<std::uint32_t>());
+    case Array_dtype::INT64:
+      return Union(std::forward<F>(func).template operator()<std::int64_t>());
+    case Array_dtype::UINT64:
+      return Union(std::forward<F>(func).template operator()<std::uint64_t>());
+    case Array_dtype::FLOAT32:
+      return Union(std::forward<F>(func).template operator()<float>());
+    case Array_dtype::FLOAT64:
+      return Union(std::forward<F>(func).template operator()<double>());
+    case Array_dtype::EMPTY:
+      return Union(std::forward<F_empty>(funcEmpty)());
+    default:
+      Union(std::forward<F_unknown>(funcUnkown)());
+  }
+}
+
+// uncommenting in the _get_compatible_* methods gives much more possibilities, but it also takes much more
+// compile time (and binary size). I had to split the _dispatch_dtype method into a int and a float version
+// for the same reason
+
+// inline auto _get_compatible_generator_maps(nanobind::iterable maps) {
+//   return _dispatch_int_dtype(maps, [&]<typename U>() {
+//     // return Gudhi::python::_convert_iterable_to_cpp_type_and_wrap_ndarrays<
+//     //     std::vector<nanobind::ndarray<const U, nanobind::ndim<1>, nanobind::any_contig>>,
+//     //     std::vector<std::vector<U>>>(
+//     //     maps, "Generator maps must be either iterable[iterable[U]] or iterable[ndarray[U, ndim=1]]
+//     (contiguous)."); std::vector<std::vector<U>> res; if (nanobind::try_cast(maps, res, false)) return res; throw
+//     std::invalid_argument("Generator maps must be iterable[iterable[U]].");
+//   });
+// }
+
+// inline auto _get_compatible_generator_dimensions(nanobind::iterable dimensions) {
+//   return _dispatch_int_dtype(dimensions, [&]<typename U>() {
+//     // return Gudhi::python::_convert_iterable_to_cpp_type_and_wrap_ndarrays<
+//     //     nanobind::ndarray<const U, nanobind::ndim<1>, nanobind::any_contig>,
+//     //     std::vector<U>>(dimensions,
+//     //                     "Generator dimensions must be either iterable[U] or ndarray[U, ndim=1] (contiguous).");
+//     nanobind::ndarray<const U, nanobind::ndim<1>, nanobind::any_contig> res;
+//     if (nanobind::try_cast(dimensions, res, false)) return Numpy_span(res);
+//     throw std::invalid_argument("Generator dimensions must be ndarray[U, ndim=1] (contiguous).");
+//   });
+// }
+
+// template <typename T, bool is_kcritical>
+// inline auto _get_compatible_filtration_values(nanobind::iterable filts) {
+//   auto convert = [&]<typename U>() {
+//     if constexpr (is_kcritical) {
+//       using Seq2_t = std::vector<std::vector<std::vector<U>>>;
+//       using Ten2_t = std::vector<nanobind::ndarray<const U, nanobind::ndim<2>>>;
+//       return Gudhi::python::_convert_iterable_to_cpp_type_and_wrap_ndarrays<Ten2_t, Seq2_t>(
+//             filts,
+//             "Filtration values must be one of: iterable[iterable[U]], iterable[iterable[iterable[U]]], "
+//             "iterable[ndarray[U, ndim=1]] (contiguous), or iterable[ndarray[U, ndim=2]]."
+//             /* "Filtration values must be either iterable[ndarray[U, ndim=1]] (contiguous) or iterable[ndarray[U, "
+//             "ndim=2]]." */);
+//     } else {
+//       using Seq1_t = std::vector<std::vector<U>>;
+//       using Ten1_t = nanobind::ndarray<const U, nanobind::ndim<2>>;
+//       return Gudhi::python::_convert_iterable_to_cpp_type_and_wrap_ndarrays<Ten1_t, Seq1_t>(
+//             filts,
+//             "Filtration values must be one of: iterable[iterable[U]], iterable[iterable[iterable[U]]], "
+//             "iterable[ndarray[U, ndim=1]] (contiguous), or iterable[ndarray[U, ndim=2]]."
+//             /* "Filtration values must be either iterable[ndarray[U, ndim=1]] (contiguous) or iterable[ndarray[U, "
+//             "ndim=2]]." */);
+//     }
+//   };
+//   if constexpr (std::is_floating_point_v<T>) {
+//     return _dispatch_float_dtype(filts, convert);
+//   } else {
+//     return _dispatch_int_dtype(filts, convert);
+//   }
+// }
+
+template <class MultiFiltrationValue>
+constexpr bool _is_degree_rips() {
+  using T = typename MultiFiltrationValue::value_type;
+  constexpr bool co = MultiFiltrationValue::has_negative_cones();
+  constexpr bool oneCrit = MultiFiltrationValue::ensures_1_criticality();
+
+  return std::is_same_v<MultiFiltrationValue, multi_filtration::Degree_rips_bifiltration<T, co, oneCrit>>;
+}
+
+template <class MultiFiltrationValue>
+constexpr bool _is_dynamic() {
+  using T = typename MultiFiltrationValue::value_type;
+  constexpr bool co = MultiFiltrationValue::has_negative_cones();
+  constexpr bool oneCrit = MultiFiltrationValue::ensures_1_criticality();
+
+  return std::is_same_v<MultiFiltrationValue, multi_filtration::Dynamic_multi_parameter_filtration<T, co, oneCrit>>;
+}
+
+template <class MultiFiltrationValue>
+constexpr bool _is_flat() {
+  using T = typename MultiFiltrationValue::value_type;
+  constexpr bool co = MultiFiltrationValue::has_negative_cones();
+  constexpr bool oneCrit = MultiFiltrationValue::ensures_1_criticality();
+
+  return std::is_same_v<MultiFiltrationValue, multi_filtration::Multi_parameter_filtration<T, co, oneCrit>>;
+}
+
+template <typename T, bool Co, bool OneCritical>
+inline nanobind::object _get_raw_filtration_data(
+    multi_filtration::Dynamic_multi_parameter_filtration<T, Co, OneCritical> &f,
+    bool copy) {
+  if constexpr (OneCritical) {
+    if (copy) {
+      std::vector<T> copy(f[0].begin(), f[0].end());
+      return nanobind::cast(_wrap_as_numpy_array(std::move(copy), f.num_parameters()));
+    }
+    return nanobind::cast(_wrap_view_as_numpy_array<false>(&f(0, 0), f.num_parameters()));
+  } else {
+    return Gudhi::python::_build_tuple(f.num_generators(), [&](std::size_t g) -> nanobind::object {
+      if (copy) {
+        std::vector<T> copy(f[g].begin(), f[g].end());
+        return nanobind::cast(_wrap_as_numpy_array(std::move(copy), f.num_parameters()));
+      }
+      return nanobind::cast(_wrap_view_as_numpy_array<false>(&f(g, 0), f.num_parameters()));
+    });
+  }
+}
+
+template <typename T, bool Co, bool OneCritical>
+inline nanobind::object _get_raw_filtration_data(multi_filtration::Multi_parameter_filtration<T, Co, OneCritical> &f,
+                                                 bool copy) {
+  if constexpr (OneCritical) {
+    if (copy) {
+      std::vector<T> copy(f.begin(), f.end());
+      return nanobind::cast(_wrap_as_numpy_array(std::move(copy), f.num_parameters()));
+    }
+    return nanobind::cast(_wrap_view_as_numpy_array<false>(&f(0, 0), f.num_parameters()));
+  } else {
+    if (copy) {
+      std::vector<T> copy(f.begin(), f.end());
+      return nanobind::cast(_wrap_as_numpy_array(std::move(copy), f.num_generators(), f.num_parameters()));
+    }
+    return nanobind::cast(_wrap_view_as_numpy_array<false>(&f(0, 0), f.num_generators(), f.num_parameters()));
+  }
+}
+
+template <typename T, bool Co, bool OneCritical>
+inline nanobind::object _get_raw_filtration_data(multi_filtration::Degree_rips_bifiltration<T, Co, OneCritical> &f,
+                                                 bool copy) {
+  if (copy) {
+    std::vector<T> copy(f.begin(), f.end());
+    return nanobind::cast(_wrap_as_numpy_array(std::move(copy), f.num_generators()));
+  }
+  return nanobind::cast(_wrap_view_as_numpy_array<false>(&f(0, 0), f.num_generators()));
+}
+
+template <typename T, bool Co, bool OneCritical>
+inline nanobind::tuple _get_compact_filtration_data(
+    const std::vector<multi_filtration::Degree_rips_bifiltration<T, Co, OneCritical>> &filts) {
+  std::vector<T> values;
+  std::vector<std::int64_t> startIndices(filts.size() + 1, 0);
+
+  {
+    nanobind::gil_scoped_release release;
+    for (std::size_t i = 0; i < filts.size(); ++i) {
+      startIndices[i + 1] = startIndices[i] + filts[i].num_generators();
+    }
+    values.resize(startIndices.back());
+    for (std::size_t i = 0; i < filts.size(); ++i) {
+      const auto &f = filts[i];
+      std::copy(f.begin(), f.end(), values.begin() + startIndices[i]);
+    }
+  }
+
+  return nanobind::make_tuple(_wrap_as_numpy_array(std::move(startIndices), startIndices.size()),
+                              _wrap_as_numpy_array(std::move(values), values.size()));
+}
+
+template <typename T, typename U>
+struct Flat_2D_array_span {
+  using Del_array = nanobind::ndarray<const T, nanobind::ndim<1>, nanobind::any_contig>;
+  using Data_array = nanobind::ndarray<const U, nanobind::ndim<1>, nanobind::any_contig>;
+  using Del_view = decltype(std::declval<Del_array>().view());
+  using Data_view = decltype(std::declval<Data_array>().view());
+
+  Flat_2D_array_span(Del_array delimiters, Data_array flatData)
+      : delimiters_(delimiters.view()), flatData_(flatData.view()) {}
+
+  std::size_t size() const { return delimiters_.shape(0) - 1; }
+
+  auto operator[](std::size_t i) const {
+    if (i >= size()) throw std::out_of_range("Index is out of range for flat 2D range.");
+    return Numpy_span(&flatData_(delimiters_(i)), &flatData_(delimiters_(i + 1)));
+  }
+
+  Del_view delimiters_;
+  Data_view flatData_;
+};
+
+}  // namespace detail
+}  // namespace multi_persistence
+}  // namespace Gudhi
+
+#endif  // MP_PY_SLICER_HELPERS_H_INCLUDED
diff --git a/multipers/gudhi/summand_interface.h b/multipers/gudhi/summand_interface.h
index 74eee71a..82b3cef1 100644
--- a/multipers/gudhi/summand_interface.h
+++ b/multipers/gudhi/summand_interface.h
@@ -33,7 +33,7 @@ namespace multi_persistence {
  * @private
  */
 template <typename T, class Corners>
-auto compute_flat_corners(const Corners& corners) {
+inline auto compute_flat_corners(const Corners& corners) {
   std::vector<T> res(corners.num_generators() * corners.num_parameters());
   {
     nanobind::gil_scoped_release release;
@@ -51,7 +51,7 @@ auto compute_flat_corners(const Corners& corners) {
  * @private
  */
 template <typename T>
-Summand<T> deserialize_summand_from_python(
+inline Summand<T> deserialize_summand_from_python(
     const nanobind::ndarray<const char, nanobind::ndim<1>, nanobind::numpy>& state) {
   Summand<T> sum;
   {
diff --git a/multipers/invariants/end_curves.py b/multipers/invariants/end_curves.py
index a6f9c894..e6a7c1cf 100644
--- a/multipers/invariants/end_curves.py
+++ b/multipers/invariants/end_curves.py
@@ -118,9 +118,16 @@ def _birth_curve_presentation(presentation, inf_indices: np.ndarray):
             filtrations[relations]
         )
 
-    from multipers._slicer_nanobind import build_contiguous_f64_slicer_from_packed_f64
-
-    return build_contiguous_f64_slicer_from_packed_f64(
+    from multipers.slicer import get_matrix_slicer
+
+    return get_matrix_slicer(
+        is_vineyard=False,
+        is_k_critical=False,
+        dtype=np.double,
+        col="UNORDERED_SET",
+        pers_backend="Matrix",
+        filtration_container="Contiguous",
+    )(
         new_boundary_indptr,
         new_boundary_flat,
         new_dimensions,
diff --git a/multipers/nanobind_slicer_serialization.hpp b/multipers/nanobind_slicer_serialization.hpp
deleted file mode 100644
index 66d09aca..00000000
--- a/multipers/nanobind_slicer_serialization.hpp
+++ /dev/null
@@ -1,388 +0,0 @@
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <nanobind/ndarray.h>
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <stdexcept>
-#include <type_traits>
-#include <vector>
-
-#include "ext_interface/nanobind_wrapper_types.hpp"
-#include "gudhi/Multi_parameter_filtered_complex.h"
-#include "nanobind_array_utils.hpp"
-
-namespace mpnb {
-
-namespace nb = nanobind;
-
-inline constexpr uint32_t kSlicerSerializationMagic = 0x4d50534c;
-inline constexpr uint32_t kSlicerSerializationVersion = 2;
-
-enum class SlicerSerializationMode : uint32_t {
-  OneCritical = 0,
-  KCritical = 1,
-  DegreeRips = 2,
-};
-
-struct SlicerSerializationHeaderV1 {
-  uint32_t magic;
-  uint32_t version;
-  uint32_t mode;
-  uint32_t is_minres;
-  uint64_t num_generators;
-  uint64_t boundary_flat_size;
-  uint64_t num_parameters;
-  uint64_t filtration_rows;
-  uint64_t boundary_indptr_offset;
-  uint64_t boundary_flat_offset;
-  uint64_t dimensions_offset;
-  uint64_t grade_indptr_offset;
-  uint64_t grades_offset;
-  uint64_t total_size;
-};
-
-static_assert(std::is_trivially_copyable_v<SlicerSerializationHeaderV1>);
-
-struct SlicerSerializationLayout {
-  size_t boundary_indptr_offset;
-  size_t boundary_flat_offset;
-  size_t dimensions_offset;
-  size_t grade_indptr_offset;
-  size_t grades_offset;
-  size_t total_size;
-};
-
-template <typename T>
-size_t serialized_array_bytes(size_t count) {
-  return count * sizeof(T);
-}
-
-inline size_t align_serialized_offset(size_t offset, size_t alignment) {
-  size_t remainder = offset % alignment;
-  if (remainder == 0) {
-    return offset;
-  }
-  return offset + alignment - remainder;
-}
-
-template <bool IsKCritical, bool IsDegreeRips>
-constexpr uint32_t expected_slicer_serialization_mode() {
-  return static_cast<uint32_t>(
-      IsDegreeRips ? SlicerSerializationMode::DegreeRips
-                   : (IsKCritical ? SlicerSerializationMode::KCritical : SlicerSerializationMode::OneCritical));
-}
-
-template <typename Value>
-SlicerSerializationLayout make_slicer_serialization_layout(size_t num_generators,
-                                                           size_t boundary_flat_size,
-                                                           size_t num_parameters,
-                                                           size_t filtration_rows,
-                                                           bool include_grade_indptr) {
-  SlicerSerializationLayout layout{};
-  size_t offset = sizeof(SlicerSerializationHeaderV1);
-  offset = align_serialized_offset(offset, alignof(uint64_t));
-  layout.boundary_indptr_offset = offset;
-  offset += serialized_array_bytes<uint64_t>(num_generators + 1);
-  offset = align_serialized_offset(offset, alignof(uint32_t));
-  layout.boundary_flat_offset = offset;
-  offset += serialized_array_bytes<uint32_t>(boundary_flat_size);
-  offset = align_serialized_offset(offset, alignof(int32_t));
-  layout.dimensions_offset = offset;
-  offset += serialized_array_bytes<int32_t>(num_generators);
-  if (include_grade_indptr) {
-    offset = align_serialized_offset(offset, alignof(int64_t));
-    layout.grade_indptr_offset = offset;
-    offset += serialized_array_bytes<int64_t>(num_generators + 1);
-  } else {
-    layout.grade_indptr_offset = 0;
-  }
-  offset = align_serialized_offset(offset, alignof(Value));
-  layout.grades_offset = offset;
-  offset += serialized_array_bytes<Value>(filtration_rows * num_parameters);
-  layout.total_size = offset;
-  return layout;
-}
-
-template <typename T>
-T* mutable_serialized_block(std::vector<uint8_t>& buffer, size_t offset, size_t count) {
-  if (offset % alignof(T) != 0) {
-    throw std::runtime_error("Invalid serialized slicer state.");
-  }
-  size_t num_bytes = serialized_array_bytes<T>(count);
-  if (offset > buffer.size() || buffer.size() - offset < num_bytes) {
-    throw std::runtime_error("Invalid serialized slicer state.");
-  }
-  return reinterpret_cast<T*>(buffer.data() + offset);
-}
-
-template <typename T>
-const T* serialized_block_view(const uint8_t* data, size_t buffer_size, uint64_t offset_value, uint64_t count_value) {
-  size_t offset = static_cast<size_t>(offset_value);
-  size_t count = static_cast<size_t>(count_value);
-  if (offset % alignof(T) != 0) {
-    throw std::runtime_error("Invalid serialized slicer state.");
-  }
-  size_t num_bytes = serialized_array_bytes<T>(count);
-  if (offset > buffer_size || buffer_size - offset < num_bytes) {
-    throw std::runtime_error("Invalid serialized slicer state.");
-  }
-  return reinterpret_cast<const T*>(data + offset);
-}
-
-template <typename Wrapper, typename Concrete>
-void load_slicer_from_generator_data(Wrapper& self,
-                                     std::vector<std::vector<uint32_t>>&& boundaries,
-                                     std::vector<int>&& dimensions,
-                                     std::vector<typename Concrete::Filtration_value>&& filtrations) {
-  if (boundaries.empty()) {
-    self.truc = Concrete();
-    return;
-  }
-  Gudhi::multi_persistence::Multi_parameter_filtered_complex<typename Concrete::Filtration_value> cpx(
-      std::move(boundaries), std::move(dimensions), std::move(filtrations));
-  self.truc = Concrete(std::move(cpx));
-}
-
-template <typename FiltrationValue, typename Value, bool IsDegreeRips>
-FiltrationValue filtration_from_serialized_rows(const Value* grades_flat,
-                                                size_t row_begin,
-                                                size_t row_end,
-                                                size_t num_parameters) {
-  using Underlying_container = typename FiltrationValue::Underlying_container;
-  if constexpr (IsDegreeRips) {
-    Underlying_container generators(row_end - row_begin);
-    for (size_t row = row_begin; row < row_end; ++row) {
-      generators[row - row_begin] = grades_flat[2 * row];
-    }
-    return FiltrationValue(std::move(generators), static_cast<int>(num_parameters));
-  } else if constexpr (std::is_same_v<typename Underlying_container::value_type, Value>) {
-    Underlying_container generators((row_end - row_begin) * num_parameters);
-    if (!generators.empty()) {
-      size_t offset = row_begin * num_parameters;
-      std::memcpy(generators.data(), grades_flat + offset, generators.size() * sizeof(Value));
-    }
-    return FiltrationValue(std::move(generators), static_cast<int>(num_parameters));
-  } else {
-    Underlying_container generators;
-    generators.reserve(row_end - row_begin);
-    for (size_t row = row_begin; row < row_end; ++row) {
-      size_t offset = row * num_parameters;
-      generators.emplace_back(grades_flat + offset, grades_flat + offset + num_parameters);
-    }
-    return FiltrationValue(std::move(generators), static_cast<int>(num_parameters));
-  }
-}
-
-template <typename Wrapper, typename Concrete, typename Value, bool IsKCritical, bool IsDegreeRips>
-bool load_state_v1(Wrapper& self, const uint8_t* data, size_t buffer_size) {
-  if (buffer_size < sizeof(SlicerSerializationHeaderV1)) {
-    throw std::runtime_error("Invalid serialized slicer state.");
-  }
-  SlicerSerializationHeaderV1 header;
-  std::memcpy(&header, data, sizeof(header));
-  if (header.magic != kSlicerSerializationMagic || header.version < 1 || header.version > kSlicerSerializationVersion ||
-      header.total_size != buffer_size) {
-    throw std::runtime_error("Invalid serialized slicer state.");
-  }
-  constexpr uint32_t expected_mode = expected_slicer_serialization_mode<IsKCritical, IsDegreeRips>();
-  if (header.mode != expected_mode) {
-    throw std::runtime_error("Serialized slicer state does not match target type.");
-  }
-
-  size_t num_generators = static_cast<size_t>(header.num_generators);
-  size_t boundary_flat_size = static_cast<size_t>(header.boundary_flat_size);
-  size_t num_parameters = static_cast<size_t>(header.num_parameters);
-  size_t filtration_rows = static_cast<size_t>(header.filtration_rows);
-  if constexpr (IsDegreeRips) {
-    if (num_parameters != 2) {
-      throw std::runtime_error("Invalid serialized slicer filtrations.");
-    }
-  }
-  if constexpr (!IsKCritical) {
-    if (filtration_rows != num_generators) {
-      throw std::runtime_error("Invalid serialized slicer filtrations.");
-    }
-  }
-
-  const uint64_t* boundary_indptr =
-      serialized_block_view<uint64_t>(data, buffer_size, header.boundary_indptr_offset, header.num_generators + 1);
-  const uint32_t* boundary_flat =
-      serialized_block_view<uint32_t>(data, buffer_size, header.boundary_flat_offset, header.boundary_flat_size);
-  const int32_t* dimensions32 =
-      serialized_block_view<int32_t>(data, buffer_size, header.dimensions_offset, header.num_generators);
-  if (boundary_indptr[num_generators] != header.boundary_flat_size) {
-    throw std::runtime_error("Invalid serialized slicer boundaries.");
-  }
-
-  std::vector<std::vector<uint32_t>> boundaries(num_generators);
-  for (size_t i = 0; i < num_generators; ++i) {
-    uint64_t begin = boundary_indptr[i];
-    uint64_t finish = boundary_indptr[i + 1];
-    if (begin > finish || finish > boundary_flat_size) {
-      throw std::runtime_error("Invalid serialized slicer boundaries.");
-    }
-    boundaries[i].assign(boundary_flat + begin, boundary_flat + finish);
-  }
-
-  std::vector<int> dimensions(num_generators);
-  for (size_t i = 0; i < num_generators; ++i) {
-    dimensions[i] = static_cast<int>(dimensions32[i]);
-  }
-
-  std::vector<typename Concrete::Filtration_value> c_filtrations;
-  c_filtrations.reserve(num_generators);
-
-  if constexpr (IsKCritical) {
-    const int64_t* grade_indptr =
-        serialized_block_view<int64_t>(data, buffer_size, header.grade_indptr_offset, header.num_generators + 1);
-    const Value* grades_flat =
-        serialized_block_view<Value>(data, buffer_size, header.grades_offset, filtration_rows * num_parameters);
-    if (grade_indptr[num_generators] != static_cast<int64_t>(header.filtration_rows)) {
-      throw std::runtime_error("Invalid serialized slicer filtrations.");
-    }
-    for (size_t i = 0; i < num_generators; ++i) {
-      int64_t begin = grade_indptr[i];
-      int64_t finish = grade_indptr[i + 1];
-      if (begin > finish || finish > static_cast<int64_t>(filtration_rows)) {
-        throw std::runtime_error("Invalid serialized slicer filtrations.");
-      }
-      c_filtrations.push_back(filtration_from_serialized_rows<typename Concrete::Filtration_value, Value, IsDegreeRips>(
-          grades_flat, static_cast<size_t>(begin), static_cast<size_t>(finish), num_parameters));
-    }
-  } else {
-    const Value* grades_flat =
-        serialized_block_view<Value>(data, buffer_size, header.grades_offset, num_generators * num_parameters);
-    for (size_t i = 0; i < num_generators; ++i) {
-      size_t offset = i * num_parameters;
-      if (num_parameters == 0) {
-        c_filtrations.emplace_back(std::vector<Value>());
-      } else {
-        c_filtrations.emplace_back(grades_flat + offset, grades_flat + offset + num_parameters);
-      }
-    }
-  }
-
-  load_slicer_from_generator_data<Wrapper, Concrete>(
-      self, std::move(boundaries), std::move(dimensions), std::move(c_filtrations));
-  return header.version >= 2 && header.is_minres != 0;
-}
-
-template <typename Wrapper, typename Value, bool IsKCritical, bool IsDegreeRips>
-nb::ndarray<nb::numpy, uint8_t> serialized_state(Wrapper& self) {
-  std::vector<uint8_t> buffer;
-  {
-    nb::gil_scoped_release release;
-    const auto& boundaries = self.truc.get_boundaries();
-    const auto& dims = self.truc.get_dimensions();
-    const auto& filtrations = self.truc.get_filtration_values();
-
-    size_t num_generators = boundaries.size();
-    size_t total_boundary_size = 0;
-    size_t total_rows = 0;
-    for (size_t i = 0; i < num_generators; ++i) {
-      total_boundary_size += boundaries[i].size();
-      if constexpr (IsKCritical) {
-        total_rows += filtrations[i].num_generators();
-      }
-    }
-
-    size_t num_parameters = 0;
-    size_t filtration_rows = 0;
-
-    if constexpr (IsKCritical) {
-      num_parameters = IsDegreeRips ? size_t(2) : static_cast<size_t>(self.truc.get_number_of_parameters());
-      filtration_rows = total_rows;
-    } else {
-      num_parameters = static_cast<size_t>(self.truc.get_number_of_parameters());
-      filtration_rows = num_generators;
-    }
-
-    SlicerSerializationLayout layout = make_slicer_serialization_layout<Value>(
-        num_generators, total_boundary_size, num_parameters, filtration_rows, IsKCritical);
-    buffer.resize(layout.total_size);
-
-    SlicerSerializationHeaderV1 header{kSlicerSerializationMagic,
-                                       kSlicerSerializationVersion,
-                                       expected_slicer_serialization_mode<IsKCritical, IsDegreeRips>(),
-                                        self.is_minres ? 1u : 0u,
-                                       static_cast<uint64_t>(num_generators),
-                                       static_cast<uint64_t>(total_boundary_size),
-                                       static_cast<uint64_t>(num_parameters),
-                                       static_cast<uint64_t>(filtration_rows),
-                                       static_cast<uint64_t>(layout.boundary_indptr_offset),
-                                       static_cast<uint64_t>(layout.boundary_flat_offset),
-                                       static_cast<uint64_t>(layout.dimensions_offset),
-                                       static_cast<uint64_t>(layout.grade_indptr_offset),
-                                       static_cast<uint64_t>(layout.grades_offset),
-                                       static_cast<uint64_t>(layout.total_size)};
-    std::memcpy(buffer.data(), &header, sizeof(header));
-
-    auto* boundary_indptr =
-        mutable_serialized_block<uint64_t>(buffer, layout.boundary_indptr_offset, num_generators + 1);
-    auto* boundary_flat = mutable_serialized_block<uint32_t>(buffer, layout.boundary_flat_offset, total_boundary_size);
-    auto* dimensions = mutable_serialized_block<int32_t>(buffer, layout.dimensions_offset, num_generators);
-    auto* grades_flat = mutable_serialized_block<Value>(buffer, layout.grades_offset, filtration_rows * num_parameters);
-    boundary_indptr[0] = 0;
-
-    size_t boundary_offset = 0;
-    for (size_t i = 0; i < num_generators; ++i) {
-      const auto& row = boundaries[i];
-      dimensions[i] = static_cast<int32_t>(dims[i]);
-      if (!row.empty()) {
-        std::memcpy(boundary_flat + boundary_offset, row.data(), serialized_array_bytes<uint32_t>(row.size()));
-      }
-      boundary_offset += row.size();
-      boundary_indptr[i + 1] = static_cast<uint64_t>(boundary_offset);
-    }
-
-    if constexpr (IsKCritical) {
-      auto* grade_indptr = mutable_serialized_block<int64_t>(buffer, layout.grade_indptr_offset, num_generators + 1);
-      grade_indptr[0] = 0;
-      size_t offset = 0;
-      for (size_t i = 0; i < num_generators; ++i) {
-        size_t k = filtrations[i].num_generators();
-        for (size_t g = 0; g < k; ++g) {
-          if constexpr (IsDegreeRips) {
-            grades_flat[2 * (offset + g)] = filtrations[i](g, 0);
-            grades_flat[2 * (offset + g) + 1] = static_cast<Value>(g);
-          } else {
-            Value* out_row = grades_flat + (offset + g) * num_parameters;
-            for (size_t p = 0; p < num_parameters; ++p) {
-              out_row[p] = filtrations[i](g, p);
-            }
-          }
-        }
-        offset += k;
-        grade_indptr[i + 1] = static_cast<int64_t>(offset);
-      }
-    } else {
-      for (size_t i = 0; i < num_generators; ++i) {
-        Value* out_row = grades_flat + i * num_parameters;
-        if (!filtrations[i].is_finite()) {
-          std::fill_n(out_row, num_parameters, filtrations[i](0, 0));
-        } else if (num_parameters > 0) {
-          std::memcpy(out_row, &filtrations[i](0, 0), num_parameters * sizeof(Value));
-        }
-      }
-    }
-  }
-  return multipers::nanobind_utils::owned_array<uint8_t>(std::move(buffer), {buffer.size()});
-}
-
-template <typename Wrapper, typename Concrete, typename Value, bool IsKCritical, bool IsDegreeRips>
-bool load_state(Wrapper& self, nb::handle state) {
-  auto buffer = nb::cast<nb::ndarray<nb::numpy, const uint8_t, nb::ndim<1>, nb::c_contig>>(state);
-  bool is_minres = false;
-  {
-    nb::gil_scoped_release release;
-    is_minres = load_state_v1<Wrapper, Concrete, Value, IsKCritical, IsDegreeRips>(self, buffer.data(), buffer.size());
-  }
-  multipers::nanobind_helpers::reset_slicer_python_state(self);
-  return is_minres;
-}
-
-}  // namespace mpnb
diff --git a/multipers/slicer.py b/multipers/slicer.py
index f83aee88..987db981 100644
--- a/multipers/slicer.py
+++ b/multipers/slicer.py
@@ -213,7 +213,7 @@ def _current_bc(
 ):
     bcs = tuple(np.asarray(stuff, dtype=self.dtype) for stuff in self.get_barcode())
     if not keep_inf:
-        inf_value = type(self)._inf_value()
+        inf_value = type(self)._inf_value
         bcs = tuple(
             np.asarray(
                 [a for a in stuff if a[0] < inf_value],
@@ -247,7 +247,7 @@ def _barcode_coordinates_to_values(
     self, barcode, line_values, line_coordinates, api, keep_inf
 ):
     coord_values = api.set_at(line_values * 0, line_coordinates, line_values)
-    inf_coord = type(self)._inf_value()
+    inf_coord = type(self)._inf_value
     out = []
     for dim_barcode in barcode:
         coords = np.asarray(dim_barcode, dtype=np.int64)
@@ -470,35 +470,35 @@ def _looks_like_serialized_state(state) -> bool:
     return arr.ndim == 1 and arr.dtype == np.uint8
 
 
-def _setstate(self, dump):
-    explicit_is_minres = None
-    pres_degree = -1
-    if isinstance(dump, tuple) and len(dump) == 6 and _looks_like_serialized_state(dump[0]):
-        serialized, filtration_grid, generator_basis, minpres_degree, explicit_is_minres, pres_degree = dump
-        serialized_is_minres = bool(self._deserialize_state(serialized))
-    elif isinstance(dump, tuple) and len(dump) == 5 and _looks_like_serialized_state(dump[0]):
-        serialized, filtration_grid, generator_basis, minpres_degree, explicit_is_minres = dump
-        serialized_is_minres = bool(self._deserialize_state(serialized))
-    elif isinstance(dump, tuple) and len(dump) == 4:
-        serialized, filtration_grid, generator_basis, minpres_degree = dump
-        serialized_is_minres = bool(self._deserialize_state(serialized))
-    elif isinstance(dump, tuple) and len(dump) == 3:
-        serialized, filtration_grid, minpres_degree = dump
-        generator_basis = None
-        serialized_is_minres = bool(self._deserialize_state(serialized))
-    else:
-        generator_basis = None
-        boundaries, dimensions, filtrations, filtration_grid, minpres_degree = dump
-        self._copy_from_any(type(self)(boundaries, dimensions, filtrations))
-        serialized_is_minres = False
-    if explicit_is_minres is not None:
-        serialized_is_minres = serialized_is_minres or bool(explicit_is_minres)
-    if pres_degree < 0 and minpres_degree >= 0:
-        pres_degree = minpres_degree
-    self._mark_pres(pres_degree)
-    self._mark_minpres(minpres_degree, is_minres=serialized_is_minres)
-    self.filtration_grid = filtration_grid
-    self._generator_basis = generator_basis
+# def _setstate(self, dump):
+#     explicit_is_minres = None
+#     pres_degree = -1
+#     if isinstance(dump, tuple) and len(dump) == 6 and _looks_like_serialized_state(dump[0]):
+#         serialized, filtration_grid, generator_basis, minpres_degree, explicit_is_minres, pres_degree = dump
+#         serialized_is_minres = bool(self._deserialize_state(serialized))
+#     elif isinstance(dump, tuple) and len(dump) == 5 and _looks_like_serialized_state(dump[0]):
+#         serialized, filtration_grid, generator_basis, minpres_degree, explicit_is_minres = dump
+#         serialized_is_minres = bool(self._deserialize_state(serialized))
+#     elif isinstance(dump, tuple) and len(dump) == 4:
+#         serialized, filtration_grid, generator_basis, minpres_degree = dump
+#         serialized_is_minres = bool(self._deserialize_state(serialized))
+#     elif isinstance(dump, tuple) and len(dump) == 3:
+#         serialized, filtration_grid, minpres_degree = dump
+#         generator_basis = None
+#         serialized_is_minres = bool(self._deserialize_state(serialized))
+#     else:
+#         generator_basis = None
+#         boundaries, dimensions, filtrations, filtration_grid, minpres_degree = dump
+#         self._copy_from_any(type(self)(boundaries, dimensions, filtrations))
+#         serialized_is_minres = False
+#     if explicit_is_minres is not None:
+#         serialized_is_minres = serialized_is_minres or bool(explicit_is_minres)
+#     if pres_degree < 0 and minpres_degree >= 0:
+#         pres_degree = minpres_degree
+#     self._mark_pres(pres_degree)
+#     self._mark_minpres(minpres_degree, is_minres=serialized_is_minres)
+#     self.filtration_grid = filtration_grid
+#     self._generator_basis = generator_basis
 
 
 def _bc_to_full(bcs, basepoint, direction=None):
@@ -683,10 +683,38 @@ def _unsqueeze(self, grid=None, inf_overflow=True):
         )
         new_filtrations = evaluate_in_grid(filtrations, grid)
 
+    # is len(grid) == 0 even possible here? I had the impression that evaluate_in_grid just assumes len(grid) > 0
+    # and will throw an out-of-bound exception if not (i.e. this part is never reached in that case)
     real_dtype = np.asarray(grid[0]).dtype.type if len(grid) else self.dtype
     if not np.dtype(real_dtype) in {np.dtype(dtype) for dtype in available_dtype}:
-        float_dtypes = [np.dtype(d) for d in available_dtype if np.issubdtype(np.dtype(d), np.floating)]
-        real_dtype = float_dtypes[0] if float_dtypes else self.dtype
+        if np.issubdtype(real_dtype, np.floating):
+            float_dtypes = [
+                np.dtype(d) for d in available_dtype if np.issubdtype(np.dtype(d), np.floating)
+            ]
+            if float_dtypes:
+                real_dtype = float_dtypes[0]
+            else:
+                warn(
+                    "Grid has floating point dtype, but no floating point dtype is available for this build."
+                    " Casting into integer type instead.",
+                    UserWarning,
+                )
+                real_dtype = self.dtype
+                new_filtrations = np.asarray(new_filtrations, dtype=real_type)
+        else:
+            int_dtypes = [
+                np.dtype(d) for d in available_dtype if np.issubdtype(np.dtype(d), np.integer)
+            ]
+            if int_dtypes:
+                real_dtype = int_dtypes[0]
+            else:
+                warn(
+                    "Grid has integer dtype, but no integer dtype is available for this build."
+                    " Casting into floating point type instead.",
+                    UserWarning,
+                )
+                real_dtype = self.dtype
+                new_filtrations = np.asarray(new_filtrations, dtype=real_type)
 
     new_slicer = get_matrix_slicer(
         self.is_vine,
@@ -779,7 +807,7 @@ def get_matrix_slicer(
 def _install_python_api():
     for cls in available_slicers:
         cls.__repr__ = _repr
-        cls.__setstate__ = _setstate
+        # cls.__setstate__ = _setstate
         cls.astype = _astype
         cls.get_filtrations = _get_filtrations
         cls.compute_persistence = _compute_persistence
diff --git a/multipers/slicer_landscapes.hpp b/multipers/slicer_landscapes.hpp
deleted file mode 100644
index 44298a81..00000000
--- a/multipers/slicer_landscapes.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <nanobind/ndarray.h>
-
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <limits>
-#include <stdexcept>
-#include <vector>
-
-#if defined(GUDHI_USE_TBB)
-#include <tbb/blocked_range.h>
-#include <tbb/parallel_for.h>
-#include <tbb/task_arena.h>
-#endif
-
-#include <gudhi/Multi_persistence/Line.h>
-#include <python_interfaces/numpy_utils.h>
-
-#include "nanobind_array_utils.hpp"
-
-namespace nb = nanobind;
-
-namespace mpnb {
-
-using multipers::nanobind_utils::owned_array;
-
-template <typename Bars>
-inline void insert_landscape_barcode_values(std::vector<double>& out,
-                                            std::size_t base,
-                                            std::size_t plane_size,
-                                            const Bars& bars,
-                                            double t,
-                                            const std::vector<std::int32_t>& ks,
-                                            std::vector<double>& top) {
-  std::fill(top.begin(), top.end(), 0.0);
-  auto* data = bars.data();
-  for (std::size_t b = 0; b < bars.size(); ++b) {
-    const double value =
-        std::max(0.0, std::min(t - static_cast<double>(data[b][0]), static_cast<double>(data[b][1]) - t));
-    if (value <= top.back()) continue;
-    auto it = std::upper_bound(top.begin(), top.end(), value, std::greater<double>{});
-    top.insert(it, value);
-    top.pop_back();
-  }
-  for (std::size_t k = 0; k < ks.size(); ++k) {
-    out[k * plane_size + base] = top[static_cast<std::size_t>(ks[k])];
-  }
-}
-
-struct Landscape_grid_line_start {
-  std::size_t i;
-  std::size_t j;
-};
-
-inline std::vector<Landscape_grid_line_start> landscape_grid_line_starts(std::size_t nx,
-                                                                         std::size_t ny,
-                                                                         std::size_t stride_i,
-                                                                         std::size_t stride_j) {
-  std::vector<Landscape_grid_line_start> starts;
-  starts.reserve(std::min(stride_i, nx) * ny + (stride_i < nx ? (nx - stride_i) * std::min(stride_j, ny) : 0));
-  for (std::size_t i = 0; i < std::min(stride_i, nx); ++i) {
-    for (std::size_t j = 0; j < ny; ++j) starts.push_back({i, j});
-  }
-  for (std::size_t i = stride_i; i < nx; ++i) {
-    for (std::size_t j = 0; j < std::min(stride_j, ny); ++j) starts.push_back({i, j});
-  }
-  return starts;
-}
-
-template <typename Desc, typename Wrapper, typename Value>
-nb::ndarray<nb::numpy, double> landscapes_on_grid(Wrapper& self,
-                                                  nb::ndarray<const Value, nb::ndim<1>, nb::c_contig> xgrid,
-                                                  nb::ndarray<const Value, nb::ndim<1>, nb::c_contig> ygrid,
-                                                  nb::ndarray<const Value, nb::ndim<1>, nb::c_contig> direction,
-                                                  std::size_t stride_i,
-                                                  std::size_t stride_j,
-                                                  double dt,
-                                                  int degree,
-                                                  nb::ndarray<const std::int32_t, nb::ndim<1>, nb::c_contig> ks_array,
-                                                  int n_jobs,
-                                                  bool ignore_infinite_filtration_values) {
-  const std::size_t nx = xgrid.shape(0);
-  const std::size_t ny = ygrid.shape(0);
-  if (nx == 0 || ny == 0) throw nb::value_error("Landscape grid axes must be non-empty.");
-  if (direction.shape(0) != 2) throw nb::value_error("Landscape direction must be two-dimensional.");
-  if (stride_i == 0 || stride_j == 0) throw nb::value_error("Landscape grid strides must be positive.");
-  if (!std::isfinite(dt) || dt <= 0.0) throw nb::value_error("Landscape grid step must be finite and positive.");
-  if (nx > std::numeric_limits<std::size_t>::max() / ny) throw nb::value_error("Landscape output grid is too large.");
-
-  auto x_range = make_element_range(xgrid.data(), xgrid.view(), false);
-  auto y_range = make_element_range(ygrid.data(), ygrid.view(), false);
-  auto direction_range = make_element_range(direction.data(), direction.view(), false);
-  std::vector<Value> x_values(x_range.begin(), x_range.end());
-  std::vector<Value> y_values(y_range.begin(), y_range.end());
-  std::vector<Value> direction_vec(direction_range.begin(), direction_range.end());
-
-  for (Value value : x_values) {
-    if (!std::isfinite(static_cast<double>(value))) throw nb::value_error("Landscape x-grid must be finite.");
-  }
-  for (Value value : y_values) {
-    if (!std::isfinite(static_cast<double>(value))) throw nb::value_error("Landscape y-grid must be finite.");
-  }
-  for (Value value : direction_vec) {
-    const double direction_value = static_cast<double>(value);
-    if (!std::isfinite(direction_value)) throw nb::value_error("Landscape direction must be finite.");
-    if (direction_value <= 0.0) throw nb::value_error("Landscape direction must be strictly positive.");
-  }
-
-  std::vector<std::int32_t> ks(ks_array.data(), ks_array.data() + ks_array.shape(0));
-  std::int32_t need = 0;
-  for (std::int32_t k : ks) {
-    if (k < 0) throw nb::value_error("Landscape ks must be nonnegative.");
-    need = std::max(need, k + 1);
-  }
-  const std::size_t plane_size = nx * ny;
-  std::vector<double> out(ks.size() * plane_size, 0.0);
-  if (ks.empty()) return owned_array<double>(std::move(out), {ks.size(), nx, ny});
-
-  const std::vector<Landscape_grid_line_start> starts = landscape_grid_line_starts(nx, ny, stride_i, stride_j);
-  auto compute_line = [&](auto& slicer, std::size_t line, bool& initialized, std::vector<double>& top) {
-    const auto [i0, j0] = starts[line];
-    const std::size_t length = std::min((nx - 1 - i0) / stride_i + 1, (ny - 1 - j0) / stride_j + 1);
-    std::vector<Value> basepoint{x_values[i0], y_values[j0]};
-    slicer.push_to(Gudhi::multi_persistence::Line<Value>(basepoint, direction_vec));
-    if constexpr (Desc::is_vine) {
-      if (initialized) {
-        slicer.update_persistence_computation(ignore_infinite_filtration_values);
-      } else {
-        slicer.initialize_persistence_computation(ignore_infinite_filtration_values);
-        initialized = true;
-      }
-    } else {
-      slicer.initialize_persistence_computation(ignore_infinite_filtration_values);
-    }
-    auto barcode = slicer.template get_flat_barcode<true, Value, false>();
-    if (degree < 0 || static_cast<std::size_t>(degree) >= barcode.size()) {
-      throw std::out_of_range("Landscape degree is outside barcode degree range.");
-    }
-    const auto& bars = barcode[static_cast<std::size_t>(degree)];
-    for (std::size_t step = 0; step < length; ++step) {
-      const std::size_t i = i0 + step * stride_i;
-      const std::size_t j = j0 + step * stride_j;
-      insert_landscape_barcode_values(out, i * ny + j, plane_size, bars, dt * static_cast<double>(step), ks, top);
-    }
-  };
-
-  {
-    nb::gil_scoped_release release;
-#if defined(GUDHI_USE_TBB)
-    auto compute_range = [&](std::size_t begin, std::size_t end) {
-      auto slicer = self.truc.weak_copy();
-      bool initialized = false;
-      std::vector<double> top(static_cast<std::size_t>(need), 0.0);
-      for (std::size_t line = begin; line < end; ++line) compute_line(slicer, line, initialized, top);
-    };
-    if (n_jobs == 1) {
-      compute_range(0, starts.size());
-    } else {
-      const std::size_t target_chunks = n_jobs > 0 ? static_cast<std::size_t>(n_jobs) * 4 : std::size_t(64);
-      const std::size_t grain_size = std::max<std::size_t>(1, (starts.size() + target_chunks - 1) / target_chunks);
-      auto run = [&] {
-        tbb::parallel_for(tbb::blocked_range<std::size_t>(0, starts.size(), grain_size), [&](const auto& range) {
-          tbb::this_task_arena::isolate([&] { compute_range(range.begin(), range.end()); });
-        });
-      };
-      if (n_jobs > 0) {
-        tbb::task_arena arena(n_jobs);
-        arena.execute(run);
-      } else {
-        run();
-      }
-    }
-#else
-    auto slicer = self.truc.weak_copy();
-    bool initialized = false;
-    std::vector<double> top(static_cast<std::size_t>(need), 0.0);
-    for (std::size_t line = 0; line < starts.size(); ++line) compute_line(slicer, line, initialized, top);
-#endif
-  }
-  return owned_array<double>(std::move(out), {ks.size(), nx, ny});
-}
-
-}  // namespace mpnb
diff --git a/pyproject.toml b/pyproject.toml
index e01e3aa9..ef3eac61 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -348,25 +348,26 @@ include = [
   "ext/gudhi-devel/src/Multi_filtration/include/gudhi/Multi_filtration/multi_filtration_products.h",
   "ext/gudhi-devel/src/Multi_filtration/include/gudhi/Multi_filtration/multi_filtration_utils.h",
   "ext/gudhi-devel/src/Multi_filtration/include/gudhi/Multi_parameter_filtration.h",
-  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_parameter_filtered_complex.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Box.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Line.h",
+  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/module_helpers.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Module.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Multi_parameter_filtered_complex_pcoh_interface.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Persistence_interface_cohomology.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Persistence_interface_homology.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Persistence_interface_vineyard.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Point.h",
-  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Summand.h",
-  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/module_helpers.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/summand_helpers.h",
+  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/Summand.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_persistence/utils.h",
+  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Multi_parameter_filtered_complex.h",
+  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/multi_persistence_landscapes.h",
+  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/multi_simplex_tree_helpers.h",
+  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/multiparameter_module_approximation.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Projective_cover_kernel.h",
+  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/slicer_helpers.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Slicer.h",
   "ext/gudhi-devel/src/Multi_persistence/include/gudhi/Thread_safe_slicer.h",
-  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/multi_simplex_tree_helpers.h",
-  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/slicer_helpers.h",
-  "ext/gudhi-devel/src/Multi_persistence/include/gudhi/multiparameter_module_approximation.h",
   "ext/gudhi-devel/src/Persistence_matrix/include/gudhi/Fields/Z2_field_operators.h",
   "ext/gudhi-devel/src/Persistence_matrix/include/gudhi/Fields/Zp_field_operators.h",
   "ext/gudhi-devel/src/Persistence_matrix/include/gudhi/Matrix.h",
diff --git a/tests/test_slicer.py b/tests/test_slicer.py
index 7a14c715..1e856fd9 100644
--- a/tests/test_slicer.py
+++ b/tests/test_slicer.py
@@ -116,8 +116,8 @@ def test_make_filtration_non_decreasing_propagates_transitively():
 
 def test_rank_custom():
     B = [[], [0], [0], [0], [0]]
-    F = [[0, 0], [2, 1], [1, 2], [3, 0], [0, 3]]
-    D = [0, 1, 1, 1, 1]
+    F = np.asarray([[0, 0], [2, 1], [1, 2], [3, 0], [0, 3]], dtype=np.uint32)
+    D = np.asarray([0, 1, 1, 1, 1])
     s = mp.Slicer(return_type_only=True, dtype=np.int32)(B, D, F)
     ((pts, w),) = mp.signed_measure(s, invariant="rank", degree=0)
     assert np.array_equal(
@@ -132,8 +132,8 @@ def test_rank_custom():
     )
     assert np.array_equal(w, [-1, 1, -1, 1, 1])
     B = [[]]
-    D = [0]
-    F = [[0, 0]]
+    D = np.asarray([0])
+    F = np.asarray([[0, 0]], dtype=float)
     s = mp.Slicer(return_type_only=True)(B, D, F)
     ((a, b),) = mp.signed_measure(
         s,
@@ -171,7 +171,7 @@ def test_representative_cycles():
     slicer = mp.slicer._ContiguousSlicer_Matrix0_vine_f64(
         truc,
         np.array([max(len(x) - 1, 0) for x in truc]),
-        np.array([list(range(len(truc))), list(range(len(truc)))]).T,
+        np.array([list(range(len(truc))), list(range(len(truc)))], dtype=np.double).T,
     )
     slicer.compute_persistence(one_filtration=list(range(len(truc))))
     cycles = slicer.get_representative_cycles()
@@ -214,16 +214,16 @@ def test_representative_cycles_intersect_points_descends_boundaries():
     )
     slicer.compute_persistence(one_filtration=filtration)
 
-    assert len(slicer.get_representative_cycles(intersect_points=[4])[0]) == 1
-    assert slicer.get_representative_cycles(intersect_points=[100])[0] == []
+    assert len(slicer.get_representative_cycles(intersect_points=np.asarray([4], dtype=np.uint32))[0]) == 1
+    assert slicer.get_representative_cycles(intersect_points=np.asarray([100], dtype=np.uint32))[0] == []
 
     cycles = slicer.get_representative_cycles()[2]
     assert len(cycles) == 1
-    filtered = slicer.get_representative_cycles(intersect_points=[0])[2]
+    filtered = slicer.get_representative_cycles(intersect_points=np.asarray([0], dtype=np.uint32))[2]
     assert len(filtered) == 1
     assert [boundary.tolist() for boundary in filtered[0]] == [boundary.tolist() for boundary in cycles[0]]
-    assert slicer.get_representative_cycles(intersect_points=[4])[2] == []
-    assert slicer.get_representative_cycles(intersect_points=[100])[2] == []
+    assert slicer.get_representative_cycles(intersect_points=np.asarray([4], dtype=np.uint32))[2] == []
+    assert slicer.get_representative_cycles(intersect_points=np.asarray([100], dtype=np.uint32))[2] == []
 
 
 # def test_pruning():
@@ -319,7 +319,7 @@ def test_get_filtrations_view_flag_one_critical():
     copied_alias = s.get_filtrations(copy=True)
     viewed_alias = s.get_filtrations(copy=False)
     assert isinstance(copied_alias, np.ndarray)
-    assert isinstance(viewed_alias, list)
+    assert isinstance(viewed_alias, tuple)
 
 
 def test_get_filtration_single_view_one_critical():
diff --git a/tools/core/slicer_core.cc b/tools/core/slicer_core1.cc
similarity index 55%
rename from tools/core/slicer_core.cc
rename to tools/core/slicer_core1.cc
index 5feebd7f..9dbe4150 100644
--- a/tools/core/slicer_core.cc
+++ b/tools/core/slicer_core1.cc
@@ -2,13 +2,11 @@
 
 #include <Persistence_slices_interface.h>
 #include <filtrations_extern_templates.h>
-#include <slicer_conversion_core.hpp>
 
-#include <slicer_instantiations.inc>
-#include <slicer_conversion_instantiations.inc>
+#include <slicer_instantiations1.inc>
 
 namespace multipers::core {
 
-void slicer_core_anchor() {}
+void slicer_core1_anchor() {}
 
 }  // namespace multipers::core
diff --git a/tools/core/slicer_core2.cc b/tools/core/slicer_core2.cc
new file mode 100644
index 00000000..02ded829
--- /dev/null
+++ b/tools/core/slicer_core2.cc
@@ -0,0 +1,12 @@
+#define MULTIPERS_BUILD_CORE_TEMPLATES 1
+
+#include <Persistence_slices_interface.h>
+#include <filtrations_extern_templates.h>
+
+#include <slicer_instantiations2.inc>
+
+namespace multipers::core {
+
+void slicer_core2_anchor() {}
+
+}  // namespace multipers::core
diff --git a/tools/core/slicer_core3.cc b/tools/core/slicer_core3.cc
new file mode 100644
index 00000000..932c53c4
--- /dev/null
+++ b/tools/core/slicer_core3.cc
@@ -0,0 +1,12 @@
+#define MULTIPERS_BUILD_CORE_TEMPLATES 1
+
+#include <Persistence_slices_interface.h>
+#include <filtrations_extern_templates.h>
+
+#include <slicer_instantiations3.inc>
+
+namespace multipers::core {
+
+void slicer_core3_anchor() {}
+
+}  // namespace multipers::core
diff --git a/tools/tempita_grid_gen.py b/tools/tempita_grid_gen.py
index a4956182..3eed30a1 100644
--- a/tools/tempita_grid_gen.py
+++ b/tools/tempita_grid_gen.py
@@ -286,17 +286,17 @@ def _render_instantiations_include_slicer(type_names: list[str]) -> str:
         if "GudhiCohomology" in type_name or "BackendsEnum::Graph" in type_name
     )
     lines.extend(
-        f"template<> std::vector<std::vector<{type_name}::Cycle>> {type_name}::get_representative_cycles(bool) = delete;"
+        f"template<> std::vector<{type_name}::Cycle> {type_name}::get_n_most_persistent_cycles({type_name}::Dimension, {type_name}::Index, bool) = delete;"
         for type_name in type_names
         if "GudhiCohomology" in type_name or "BackendsEnum::Graph" in type_name
     )
     lines.extend(
-        f"template<> std::vector<{type_name}::Cycle> {type_name}::get_representative_cycles_in_dim({type_name}::Dimension, bool) = delete;"
+        f"template<> std::vector<std::vector<{type_name}::Cycle>> {type_name}::get_representative_cycles(bool) = delete;"
         for type_name in type_names
         if "GudhiCohomology" in type_name or "BackendsEnum::Graph" in type_name
     )
     lines.extend(
-        f"template<> std::vector<{type_name}::Cycle> {type_name}::get_n_most_persistent_cycles({type_name}::Dimension, {type_name}::Index, bool) = delete;"
+        f"template<> std::vector<{type_name}::Cycle> {type_name}::get_representative_cycles_in_dim({type_name}::Dimension, bool) = delete;"
         for type_name in type_names
         if "GudhiCohomology" in type_name or "BackendsEnum::Graph" in type_name
     )
@@ -378,7 +378,7 @@ def _render_slicer_nanobind_registry(
             [
                 f"struct SlicerDesc_{index} {{",
                 f"  using concrete = {slicer['TRUC_TYPE']};",
-                "  using wrapper = PySlicer<concrete>;",
+                "  using interface = PySlicer<concrete>;",
                 f"  using value_type = {slicer['C_VALUE_TYPE']};",
                 f"  using coarsened_concrete = {coarsened['TRUC_TYPE']};",
                 "  using coarsened_wrapper = PySlicer<coarsened_concrete>;",
@@ -942,12 +942,6 @@ def _slicer_type_for_instantiation(slicer: dict[str, Any]) -> str:
     OUTPUT_ROOT / "multipers/gudhi/slicer_extern_templates.h",
     _render_extern_templates_header(slicer_instantiation_types),
 )
-_write_text_if_changed(
-    OUTPUT_ROOT / "multipers/gudhi/slicer_conversion_extern_templates.h",
-    _render_pairwise_template_header(
-        "SlicerConversion", slicer_instantiation_types, slicer_instantiation_types
-    ),
-)
 _write_text_if_changed(
     OUTPUT_ROOT / "multipers/gudhi/simplextree_conversion_extern_templates.h",
     _render_pairwise_template_header(
@@ -964,15 +958,20 @@ def _slicer_type_for_instantiation(slicer: dict[str, Any]) -> str:
     OUTPUT_ROOT / "tools/core/simplextree_instantiations.inc",
     _render_instantiations_include_simplextree(simplextree_instantiation_types),
 )
+slicer_instantiation_types1 = [slicer for slicer in slicer_instantiation_types if "Multi_parameter_filtration" in slicer]
+slicer_instantiation_types2 = [slicer for slicer in slicer_instantiation_types if "Dynamic_multi_parameter_filtration" in slicer]
+slicer_instantiation_types3 = [slicer for slicer in slicer_instantiation_types if "Degree_rips_bifiltration" in slicer]
 _write_text_if_changed(
-    OUTPUT_ROOT / "tools/core/slicer_instantiations.inc",
-    _render_instantiations_include_slicer(slicer_instantiation_types),
+    OUTPUT_ROOT / "tools/core/slicer_instantiations1.inc",
+    _render_instantiations_include_slicer(slicer_instantiation_types1),
 )
 _write_text_if_changed(
-    OUTPUT_ROOT / "tools/core/slicer_conversion_instantiations.inc",
-    _render_pairwise_instantiations_include(
-        "SlicerConversion", slicer_instantiation_types, slicer_instantiation_types
-    ),
+    OUTPUT_ROOT / "tools/core/slicer_instantiations2.inc",
+    _render_instantiations_include_slicer(slicer_instantiation_types2),
+)
+_write_text_if_changed(
+    OUTPUT_ROOT / "tools/core/slicer_instantiations3.inc",
+    _render_instantiations_include_slicer(slicer_instantiation_types3),
 )
 _write_text_if_changed(
     OUTPUT_ROOT / "tools/core/simplextree_conversion_instantiations.inc",
@@ -1000,6 +999,5 @@ def _slicer_type_for_instantiation(slicer: dict[str, Any]) -> str:
     f"filtration_instantiations={len(filtration_instantiation_types)} "
     f"slicer_instantiations={len(slicer_instantiation_types)} "
     f"simplextree_instantiations={len(simplextree_instantiation_types)} "
-    f"slicer_conversion_instantiations={slicer_conversion_instantiation_count} "
     f"simplextree_conversion_instantiations={simplextree_conversion_instantiation_count}"
 )