From 4f3d868f2d737e5279a8511a4644b277c9a7c06b Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Thu, 12 Feb 2026 11:34:24 +0100
Subject: [PATCH 1/8] add: unwarper.py

---
 pyproject.toml         |   2 +-
 pywarper/unwarper.py   | 100 +++++++++++++++++++++++++++++++++++++++++
 pywarper/utils.py      |  87 ++++++++++++++++++++++++++++++++++-
 pywarper/warpers.py    |  93 ++++----------------------------------
 tests/test_unwarper.py |  87 +++++++++++++++++++++++++++++++++++
 5 files changed, 282 insertions(+), 87 deletions(-)
 create mode 100644 pywarper/unwarper.py
 create mode 100644 tests/test_unwarper.py

diff --git a/pyproject.toml b/pyproject.toml
index e5ba6f8..9d302ea 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pywarper"
-version = "0.2.4"
+version = "0.2.5"
 description = "Conformal mapping-based warping of retinal morphologies."
 authors = []
 requires-python = ">=3.10.0"
diff --git a/pywarper/unwarper.py b/pywarper/unwarper.py
new file mode 100644
index 0000000..c339c8e
--- /dev/null
+++ b/pywarper/unwarper.py
@@ -0,0 +1,100 @@
+"""Inverse mapping helpers for pywarper."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .utils import build_surface_correspondences, resolve_conformal_jump
+from .warpers import local_ls_registration
+
+
+def denormalize_nodes(
+    nodes: np.ndarray,
+    med_z_on: float,
+    med_z_off: float,
+    on_sac_pos: float = 0.0,
+    off_sac_pos: float = 12.0,
+) -> np.ndarray:
+    """
+    Undo `normalize_nodes` and map z back to the pre-normalized warped frame.
+
+    Parameters
+    ----------
+    nodes : np.ndarray
+        (N, 3) normalized [x, y, z] coordinates.
+    med_z_on : float
+        Median z-value of the ON SAC surface used during warping.
+    med_z_off : float
+        Median z-value of the OFF SAC surface used during warping.
+    on_sac_pos : float, default=0.0
+        ON surface position used in normalized space.
+    off_sac_pos : float, default=12.0
+        OFF surface position used in normalized space.
+
+    Returns
+    -------
+    np.ndarray
+        (N, 3) coordinates in the pre-normalized warped frame.
+    """
+    nodes = np.asarray(nodes, dtype=float)
+    if nodes.ndim != 2 or nodes.shape[1] != 3:
+        raise ValueError("nodes must be an (N, 3) array.")
+    if np.isclose(off_sac_pos, on_sac_pos):
+        raise ValueError("off_sac_pos and on_sac_pos must be different values.")
+
+    denormalized_nodes = nodes.copy()
+    rel_depth = (nodes[:, 2] - on_sac_pos) / (off_sac_pos - on_sac_pos)
+    denormalized_nodes[:, 2] = med_z_on + rel_depth * (med_z_off - med_z_on)
+    return denormalized_nodes
+
+
+def unwarp_nodes(
+    nodes: np.ndarray,
+    surface_mapping: dict,
+    med_z_on: float,
+    med_z_off: float,
+    *,
+    on_sac_pos: float = 0.0,
+    off_sac_pos: float = 12.0,
+    conformal_jump: int | None = None,
+    prenormalized: bool = False,
+    backward_compatible: bool = False,
+) -> np.ndarray:
+    """
+    Approximate inverse of `warp_nodes` for point coordinates.
+
+    The inverse is computed with the same local least-squares model used by
+    forward warping, but with input/output correspondences swapped.
+    """
+    points = np.asarray(nodes, dtype=float)
+    if points.ndim != 2 or points.shape[1] != 3:
+        raise ValueError("nodes must be an (N, 3) array.")
+
+    if prenormalized:
+        prenormed_nodes = points
+    else:
+        prenormed_nodes = denormalize_nodes(
+            points,
+            med_z_on=med_z_on,
+            med_z_off=med_z_off,
+            on_sac_pos=on_sac_pos,
+            off_sac_pos=off_sac_pos,
+        )
+
+    resolved_jump = resolve_conformal_jump(surface_mapping, conformal_jump)
+    on_input_pts, off_input_pts, on_output_pts, off_output_pts, _, _ = (
+        build_surface_correspondences(
+            surface_mapping,
+            conformal_jump=resolved_jump,
+            backward_compatible=backward_compatible,
+        )
+    )
+
+    # Inverse pass: swap forward correspondences (flattened -> curved frame).
+    return local_ls_registration(
+        prenormed_nodes,
+        on_output_pts,
+        off_output_pts,
+        on_input_pts,
+        off_input_pts,
+    )
diff --git a/pywarper/utils.py b/pywarper/utils.py
index c3a8ca0..0ded224 100644
--- a/pywarper/utils.py
+++ b/pywarper/utils.py
@@ -2,6 +2,91 @@
 import numpy as np
 
 
+def resolve_conformal_jump(
+    surface_mapping: dict,
+    conformal_jump: int | None,
+) -> int:
+    """Resolve `conformal_jump` from argument or surface mapping metadata."""
+    if conformal_jump is None:
+        try:
+            conformal_jump = int(surface_mapping["conformal_jump"])
+        except KeyError as exc:
+            raise ValueError(
+                "conformal_jump must be provided or found in surface_mapping."
+            ) from exc
+    if conformal_jump <= 0:
+        raise ValueError("conformal_jump must be a positive integer.")
+    return int(conformal_jump)
+
+
+def build_surface_correspondences(
+    surface_mapping: dict,
+    *,
+    conformal_jump: int,
+    backward_compatible: bool = False,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, float, float]:
+    """
+    Build paired control points for local LS registration.
+
+    Returns
+    -------
+    on_input_pts, off_input_pts, on_output_pts, off_output_pts, med_z_on, med_z_off
+    """
+    mapped_on = np.asarray(surface_mapping["mapped_on"], dtype=float)
+    mapped_off = np.asarray(surface_mapping["mapped_off"], dtype=float)
+    on_sac_surface = np.asarray(surface_mapping["on_sac_surface"], dtype=float)
+    off_sac_surface = np.asarray(surface_mapping["off_sac_surface"], dtype=float)
+
+    if backward_compatible:
+        sampled_x_idx = np.asarray(surface_mapping["sampled_x_idx"], dtype=int) + 1
+        sampled_y_idx = np.asarray(surface_mapping["sampled_y_idx"], dtype=int) + 1
+    else:
+        sampled_x_idx = np.asarray(surface_mapping["sampled_x_idx"], dtype=int)
+        sampled_y_idx = np.asarray(surface_mapping["sampled_y_idx"], dtype=int)
+
+    x_vals = np.arange(sampled_x_idx[0], sampled_x_idx[-1] + 1, conformal_jump)
+    y_vals = np.arange(sampled_y_idx[0], sampled_y_idx[-1] + 1, conformal_jump)
+    xmesh, ymesh = np.meshgrid(x_vals, y_vals, indexing="ij")
+
+    if backward_compatible:
+        on_subsampled_depths = on_sac_surface[x_vals[:, None] - 1, y_vals - 1]
+        off_subsampled_depths = off_sac_surface[x_vals[:, None] - 1, y_vals - 1]
+    else:
+        on_subsampled_depths = on_sac_surface[x_vals[:, None], y_vals]
+        off_subsampled_depths = off_sac_surface[x_vals[:, None], y_vals]
+
+    expected = xmesh.size
+    if mapped_on.shape[0] != expected or mapped_off.shape[0] != expected:
+        raise ValueError(
+            "Surface mapping size mismatch: mapped_on/mapped_off do not match sampled grid."
+        )
+
+    med_z_on = float(np.median(on_subsampled_depths))
+    med_z_off = float(np.median(off_subsampled_depths))
+
+    on_input_pts = np.column_stack(
+        [
+            xmesh.ravel(order="F"),
+            ymesh.ravel(order="F"),
+            on_subsampled_depths.ravel(order="F"),
+        ]
+    )
+    off_input_pts = np.column_stack(
+        [
+            xmesh.ravel(order="F"),
+            ymesh.ravel(order="F"),
+            off_subsampled_depths.ravel(order="F"),
+        ]
+    )
+    on_output_pts = np.column_stack(
+        [mapped_on[:, 0], mapped_on[:, 1], np.full(mapped_on.shape[0], med_z_on)]
+    )
+    off_output_pts = np.column_stack(
+        [mapped_off[:, 0], mapped_off[:, 1], np.full(mapped_off.shape[0], med_z_off)]
+    )
+    return on_input_pts, off_input_pts, on_output_pts, off_output_pts, med_z_on, med_z_off
+
+
 def read_sumbul_et_al_chat_bands(fname: str, unit="voxel") -> dict[str, np.ndarray]:
     """
     Read a ChAT-band point cloud exported by KNOSSOS/FiJi.
@@ -42,4 +127,4 @@ def read_sumbul_et_al_chat_bands(fname: str, unit="voxel") -> dict[str, np.ndarr
             "z": z * voxel_resolution[2],
         }
     else:
-        raise ValueError(f"Unknown unit: {unit}. Use 'voxel' or 'physical'.")
\ No newline at end of file
+        raise ValueError(f"Unknown unit: {unit}. Use 'voxel' or 'physical'.")
diff --git a/pywarper/warpers.py b/pywarper/warpers.py
index fc4bec3..75233d3 100644
--- a/pywarper/warpers.py
+++ b/pywarper/warpers.py
@@ -46,6 +46,7 @@
 from skeliner.dx import _ellipsoid_aabb, _voxelize_union
 
 from .surface import build_mapping, fit_sac_surface
+from .utils import build_surface_correspondences, resolve_conformal_jump
 
 _PYWARPER_VERSION = _metadata.version("pywarper")
 
@@ -187,87 +188,13 @@ def warp_nodes(
     conformal_jump: int | None = None,
     backward_compatible: bool = False,
 ) -> tuple[np.ndarray, float, float]:
-    # Unpack mappings and surfaces
-    mapped_on = surface_mapping["mapped_on"]
-    mapped_off = surface_mapping["mapped_off"]
-    on_sac_surface = surface_mapping["on_sac_surface"]
-    off_sac_surface = surface_mapping["off_sac_surface"]
-
-    if backward_compatible:
-        sampled_x_idx = surface_mapping["sampled_x_idx"] + 1
-        sampled_y_idx = surface_mapping["sampled_y_idx"] + 1
-        # this is one ugly hack: thisx and thisy are 1-based in MATLAB
-        # but 0-based in Python; the rest of the code is to produce exact
-        # same results as MATLAB given the SAME input, that means thisx and
-        # thisy needs to be 1-based, but we need to shift it back to 0-based
-        # when slicing
-    else:
-        sampled_x_idx = surface_mapping["sampled_x_idx"]
-        sampled_y_idx = surface_mapping["sampled_y_idx"]
-
-    # Convert MATLAB 1-based inclusive ranges to Python slices
-    # If thisx/thisy are consecutive integer indices:
-    # x_vals = np.arange(thisx[0], thisx[-1] + 1)  # matches [thisx(1):thisx(end)] in MATLAB
-    # y_vals = np.arange(thisy[0], thisy[-1] + 1)  # matches [thisy(1):thisy(end)] in MATLAB
-    if conformal_jump is None:
-        try:
-            conformal_jump = surface_mapping["conformal_jump"]
-        except KeyError:
-            raise ValueError(
-                "conformal_jump must be provided or found in surface_mapping."
-            )
-    x_vals = np.arange(sampled_x_idx[0], sampled_x_idx[-1] + 1, conformal_jump)
-    y_vals = np.arange(sampled_y_idx[0], sampled_y_idx[-1] + 1, conformal_jump)
-
-    # Create a meshgrid shaped like MATLAB's [tmpymesh, tmpxmesh] = meshgrid(yRange, xRange).
-    # This means we want shape (len(x_vals), len(y_vals)) for each array, with row=“x”, col=“y”:
-    xmesh, ymesh = np.meshgrid(x_vals, y_vals, indexing="ij")
-    # xmesh.shape == ymesh.shape == (len(x_vals), len(y_vals))
-
-    # Extract the corresponding subregion of the surfaces so it also has shape (len(x_vals), len(y_vals)).
-    # In MATLAB: tmpminmesh = thisVZminmesh(xRange, yRange)
-    if backward_compatible:
-        on_subsampled_depths = on_sac_surface[
-            x_vals[:, None] - 1, y_vals - 1
-        ]  # shape (len(x_vals), len(y_vals))
-        off_subsampled_depths = off_sac_surface[
-            x_vals[:, None] - 1, y_vals - 1
-        ]  # shape (len(x_vals), len(y_vals))
-    else:
-        on_subsampled_depths = on_sac_surface[x_vals[:, None], y_vals]
-        off_subsampled_depths = off_sac_surface[x_vals[:, None], y_vals]
-
-    # Now flatten in column-major order (like MATLAB’s A(:)) to line up with tmpxmesh(:), etc.
-    on_input_pts = np.column_stack(
-        [
-            xmesh.ravel(order="F"),
-            ymesh.ravel(order="F"),
-            on_subsampled_depths.ravel(order="F"),
-        ]
-    )  # old topInputPos
-
-    off_input_pts = np.column_stack(
-        [
-            xmesh.ravel(order="F"),
-            ymesh.ravel(order="F"),
-            off_subsampled_depths.ravel(order="F"),
-        ]
-    )  # old botInputPos
-
-    on_output_pts = np.column_stack(
-        [
-            mapped_on[:, 0],
-            mapped_on[:, 1],
-            np.median(on_subsampled_depths) * np.ones(mapped_on.shape[0]),
-        ]
-    )
-
-    off_output_pts = np.column_stack(
-        [
-            mapped_off[:, 0],
-            mapped_off[:, 1],
-            np.median(off_subsampled_depths) * np.ones(mapped_off.shape[0]),
-        ]
+    resolved_jump = resolve_conformal_jump(surface_mapping, conformal_jump)
+    on_input_pts, off_input_pts, on_output_pts, off_output_pts, med_z_on, med_z_off = (
+        build_surface_correspondences(
+            surface_mapping,
+            conformal_jump=resolved_jump,
+            backward_compatible=backward_compatible,
+        )
     )
 
     # Apply local least-squares registration to each node
@@ -275,10 +202,6 @@ def warp_nodes(
         nodes, on_input_pts, off_input_pts, on_output_pts, off_output_pts
     )
 
-    # Compute median Z-planes
-    med_z_on = np.median(on_subsampled_depths)
-    med_z_off = np.median(off_subsampled_depths)
-
     return warped, med_z_on, med_z_off
 
 
diff --git a/tests/test_unwarper.py b/tests/test_unwarper.py
new file mode 100644
index 0000000..c35813a
--- /dev/null
+++ b/tests/test_unwarper.py
@@ -0,0 +1,87 @@
+import numpy as np
+
+from pywarper.unwarper import denormalize_nodes, unwarp_nodes
+from pywarper.warpers import normalize_nodes, warp_nodes
+
+
+def _identity_surface_mapping(nx: int = 25, ny: int = 25) -> dict:
+    on_sac_surface = np.zeros((nx, ny), dtype=float)
+    off_sac_surface = np.full((nx, ny), 10.0, dtype=float)
+
+    sampled_x_idx = np.arange(nx, dtype=int)
+    sampled_y_idx = np.arange(ny, dtype=int)
+    xmesh, ymesh = np.meshgrid(sampled_x_idx, sampled_y_idx, indexing="ij")
+
+    mapped_xy = np.column_stack([xmesh.ravel(order="F"), ymesh.ravel(order="F")])
+    return {
+        "mapped_on": mapped_xy.copy(),
+        "mapped_off": mapped_xy.copy(),
+        "on_sac_surface": on_sac_surface,
+        "off_sac_surface": off_sac_surface,
+        "sampled_x_idx": sampled_x_idx,
+        "sampled_y_idx": sampled_y_idx,
+        "conformal_jump": 1,
+    }
+
+
+def test_denormalize_nodes_inverts_normalize_nodes():
+    rng = np.random.default_rng(0)
+    nodes = rng.uniform(-10.0, 10.0, size=(100, 3))
+    med_z_on, med_z_off = -2.5, 21.0
+    on_sac_pos, off_sac_pos = 0.0, 12.0
+
+    normalized = normalize_nodes(
+        nodes,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+    )
+    restored = denormalize_nodes(
+        normalized,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+    )
+
+    assert np.allclose(restored, nodes, rtol=1e-12, atol=1e-12)
+
+
+def test_unwarp_nodes_roundtrip_with_identity_surface_mapping():
+    rng = np.random.default_rng(1)
+    mapping = _identity_surface_mapping()
+
+    nodes = np.empty((200, 3), dtype=float)
+    nodes[:, 0] = rng.uniform(6.0, 18.0, size=200)
+    nodes[:, 1] = rng.uniform(6.0, 18.0, size=200)
+    nodes[:, 2] = rng.uniform(0.0, 10.0, size=200)
+
+    warped, med_z_on, med_z_off = warp_nodes(nodes, mapping)
+    normalized = normalize_nodes(
+        warped,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        on_sac_pos=0.0,
+        off_sac_pos=12.0,
+    )
+
+    recovered = unwarp_nodes(
+        normalized,
+        mapping,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        on_sac_pos=0.0,
+        off_sac_pos=12.0,
+    )
+    recovered_from_prenormed = unwarp_nodes(
+        warped,
+        mapping,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        prenormalized=True,
+    )
+
+    assert np.allclose(recovered, nodes, rtol=1e-6, atol=1e-6)
+    assert np.allclose(recovered_from_prenormed, nodes, rtol=1e-6, atol=1e-6)
+

From e9fa89985a93c99eb305adc82fa18e285fa245f8 Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Thu, 12 Feb 2026 13:27:10 +0100
Subject: [PATCH 2/8] add: `mode=optimize` to unwarper

---
 pywarper/unwarper.py   |  89 ++++++++++++++++++++++++++++---
 pywarper/warpers.py    | 116 ++++++++++++++++++++++++++---------------
 tests/test_unwarper.py |  92 ++++++++++++++++++++++++++++++++
 uv.lock                |   8 +--
 4 files changed, 249 insertions(+), 56 deletions(-)

diff --git a/pywarper/unwarper.py b/pywarper/unwarper.py
index c339c8e..f9d8c1c 100644
--- a/pywarper/unwarper.py
+++ b/pywarper/unwarper.py
@@ -3,9 +3,14 @@
 from __future__ import annotations
 
 import numpy as np
+from scipy.optimize import least_squares
 
 from .utils import build_surface_correspondences, resolve_conformal_jump
-from .warpers import local_ls_registration
+from .warpers import (
+    _apply_local_ls_state,
+    _build_local_ls_state,
+    local_ls_registration,
+)
 
 
 def denormalize_nodes(
@@ -59,12 +64,18 @@ def unwarp_nodes(
     conformal_jump: int | None = None,
     prenormalized: bool = False,
     backward_compatible: bool = False,
+    method: str = "local_ls",
+    optimize_max_evals_per_point: int = 80,
+    optimize_convergence_tol: float = 1e-9,
+    optimize_bound_xy_to_map: bool = True,
 ) -> np.ndarray:
     """
-    Approximate inverse of `warp_nodes` for point coordinates.
+    Inverse of `warp_nodes` for point coordinates.
 
-    The inverse is computed with the same local least-squares model used by
-    forward warping, but with input/output correspondences swapped.
+    `method="local_ls"` uses the original approximate inverse by swapping
+    local LS correspondences.
+    `method="optimize"` refines per-point coordinates by minimizing forward
+    warp residuals, i.e. solving `warp_nodes(x) ~= target`.
     """
     points = np.asarray(nodes, dtype=float)
     if points.ndim != 2 or points.shape[1] != 3:
@@ -90,11 +101,75 @@ def unwarp_nodes(
         )
     )
 
-    # Inverse pass: swap forward correspondences (flattened -> curved frame).
-    return local_ls_registration(
-        prenormed_nodes,
+    if method == "local_ls":
+        # Inverse pass: swap forward correspondences (flattened -> curved frame).
+        return local_ls_registration(
+            prenormed_nodes,
+            on_output_pts,
+            off_output_pts,
+            on_input_pts,
+            off_input_pts,
+        )
+
+    if method != "optimize":
+        raise ValueError("method must be one of {'local_ls', 'optimize'}")
+
+    if optimize_max_evals_per_point <= 0:
+        raise ValueError("optimize_max_evals_per_point must be a positive integer.")
+    if optimize_convergence_tol <= 0:
+        raise ValueError("optimize_convergence_tol must be a positive float.")
+
+    # Start from the fast approximate inverse and refine against the forward model.
+    inverse_state = _build_local_ls_state(
         on_output_pts,
         off_output_pts,
         on_input_pts,
         off_input_pts,
+        window=5.0,
+        max_order=2,
     )
+    initial = _apply_local_ls_state(prenormed_nodes, inverse_state, warn=False)
+
+    forward_state = _build_local_ls_state(
+        on_input_pts,
+        off_input_pts,
+        on_output_pts,
+        off_output_pts,
+        window=5.0,
+        max_order=2,
+    )
+
+    if optimize_bound_xy_to_map:
+        x_min = float(min(on_input_pts[:, 0].min(), off_input_pts[:, 0].min()))
+        x_max = float(max(on_input_pts[:, 0].max(), off_input_pts[:, 0].max()))
+        y_min = float(min(on_input_pts[:, 1].min(), off_input_pts[:, 1].min()))
+        y_max = float(max(on_input_pts[:, 1].max(), off_input_pts[:, 1].max()))
+        lower_bounds = np.array([x_min, y_min, -np.inf], dtype=float)
+        upper_bounds = np.array([x_max, y_max, np.inf], dtype=float)
+    else:
+        lower_bounds = np.array([-np.inf, -np.inf, -np.inf], dtype=float)
+        upper_bounds = np.array([np.inf, np.inf, np.inf], dtype=float)
+
+    recovered = np.empty_like(prenormed_nodes)
+    for i, target in enumerate(prenormed_nodes):
+        x0 = initial[i].astype(float, copy=True)
+        if optimize_bound_xy_to_map:
+            x0[:2] = np.clip(x0[:2], lower_bounds[:2], upper_bounds[:2])
+
+        def _residual(x: np.ndarray) -> np.ndarray:
+            warped = _apply_local_ls_state(x[None, :], forward_state, warn=False)[0]
+            return warped - target
+
+        sol = least_squares(
+            _residual,
+            x0=x0,
+            bounds=(lower_bounds, upper_bounds),
+            method="trf",
+            max_nfev=int(optimize_max_evals_per_point),
+            ftol=float(optimize_convergence_tol),
+            xtol=float(optimize_convergence_tol),
+            gtol=float(optimize_convergence_tol),
+        )
+        recovered[i] = sol.x
+
+    return recovered
diff --git a/pywarper/warpers.py b/pywarper/warpers.py
index 75233d3..93953c7 100644
--- a/pywarper/warpers.py
+++ b/pywarper/warpers.py
@@ -70,24 +70,15 @@ def poly_basis_2d(x: np.ndarray, y: np.ndarray, max_order: int) -> np.ndarray:
     return np.stack(cols, axis=1)  # (N, n_terms)
 
 
-def local_ls_registration(
-    nodes: np.ndarray,
+def _build_local_ls_state(
     top_input_pos: np.ndarray,
     bot_input_pos: np.ndarray,
     top_output_pos: np.ndarray,
     bot_output_pos: np.ndarray,
-    window: float = 5.0,
-    max_order: int = 2,
-) -> np.ndarray:
-    """
-    Same algorithm as before, but a **single KDTree** stores both
-    surfaces.  The neighbour search is therefore performed once.
-    """
-    transformed_nodes = np.zeros_like(nodes)
-
-    # ------------------------------------------------------------------
-    # 0.  merge the two bands  -----------------------------------------
-    # ------------------------------------------------------------------
+    *,
+    window: float,
+    max_order: int,
+) -> dict[str, np.ndarray | KDTree | float | int]:
     in_all = np.vstack((top_input_pos, bot_input_pos))
     out_all = np.vstack((top_output_pos, bot_output_pos))
     is_top = np.concatenate(
@@ -96,23 +87,44 @@ def local_ls_registration(
             np.zeros(len(bot_input_pos), dtype=bool),
         )
     )
+    all_xy = in_all[:, :2]
+    query_r = window * np.sqrt(2.0)
+    tree = KDTree(all_xy)
+    return {
+        "in_all": in_all,
+        "out_all": out_all,
+        "is_top": is_top,
+        "all_xy": all_xy,
+        "query_r": query_r,
+        "tree": tree,
+        "window": float(window),
+        "max_order": int(max_order),
+    }
 
-    all_xy = in_all[:, :2]  # (Mtot, 2)
 
-    # ------------------------------------------------------------------
-    # 1.  one KD-tree and a *batched* query
-    # ------------------------------------------------------------------
-    query_r = window * np.sqrt(2.0)  # circumscribes rectangle
-    tree = KDTree(all_xy)
-    idx_lists = tree.query_ball_point(nodes[:, :2], r=query_r, workers=-1)
+def _apply_local_ls_state(
+    nodes: np.ndarray,
+    state: dict[str, np.ndarray | KDTree | float | int],
+    *,
+    warn: bool = True,
+) -> np.ndarray:
+    transformed_nodes = np.zeros_like(nodes)
+
+    in_all = state["in_all"]
+    out_all = state["out_all"]
+    is_top = state["is_top"]
+    all_xy = state["all_xy"]
+    query_r = state["query_r"]
+    tree = state["tree"]
+    window = state["window"]
+    max_order = state["max_order"]
+
+    workers = -1 if nodes.shape[0] >= 512 else 1
+    idx_lists = tree.query_ball_point(nodes[:, :2], r=query_r, workers=workers)
 
-    # ------------------------------------------------------------------
-    # 2.  per-node loop (same math as before)
-    # ------------------------------------------------------------------
     for k, (x, y, z) in enumerate(nodes):
-        idx = np.array(idx_lists[k], dtype=int)  # neighbour indices
+        idx = np.array(idx_lists[k], dtype=int)
 
-        # rectangular mask (identical criterion)
         lx, ux = x - window, x + window
         ly, uy = y - window, y + window
         mask_rect = (
@@ -122,15 +134,15 @@ def local_ls_registration(
             & (all_xy[idx, 1] <= uy)
         )
 
-        idx = idx[mask_rect]  # inside the rectangle
+        idx = idx[mask_rect]
         if idx.size == 0:
-            print(
-                f"[pywarper] Warning: no neighbours for node {k} at ({x:.2f}, {y:.2f}, {z:.2f})"
-            )
+            if warn:
+                print(
+                    f"[pywarper] Warning: no neighbours for node {k} at ({x:.2f}, {y:.2f}, {z:.2f})"
+                )
             transformed_nodes[k] = nodes[k]
             continue
 
-        # split back into top / bottom — order preserved
         idx_top = idx[is_top[idx]]
         idx_bot = idx[~is_top[idx]]
 
@@ -141,13 +153,13 @@ def local_ls_registration(
         this_out = np.vstack((out_top, out_bot))
 
         if this_in.shape[0] < 12:
-            print(
-                f"[pywarper] Warning: not enough neighbours for node {k} at ({x:.2f}, {y:.2f}, {z:.2f})"
-            )
+            if warn:
+                print(
+                    f"[pywarper] Warning: not enough neighbours for node {k} at ({x:.2f}, {y:.2f}, {z:.2f})"
+                )
             transformed_nodes[k] = nodes[k]
             continue
 
-        # centre the neighbourhood
         shift_xy = this_in[:, :2].mean(axis=0)
         xin, yin, zin = (
             this_in[:, 0] - shift_xy[0],
@@ -161,27 +173,47 @@ def local_ls_registration(
             this_out[:, 2],
         )
 
-        # polynomial basis
-        base_terms = poly_basis_2d(xin, yin, max_order)  # (n_pts, n_terms)
-        X = np.hstack((base_terms, base_terms * zin[:, None]))  # z-modulated
+        base_terms = poly_basis_2d(xin, yin, max_order)
+        X = np.hstack((base_terms, base_terms * zin[:, None]))
 
-        # least-squares solve
         T, _, _, _ = lstsq(X, np.column_stack((xout, yout, zout)), rcond=None)
 
-        # evaluate at the node
         nx, ny = nodes[k, 0] - shift_xy[0], nodes[k, 1] - shift_xy[1]
         basis_eval = poly_basis_2d(np.array([nx]), np.array([ny]), max_order).ravel()
-
         vec = np.concatenate((basis_eval, z * basis_eval))
         new_pos = vec @ T
 
-        # undo shift
         new_pos[:2] += shift_xy
         transformed_nodes[k] = new_pos
 
     return transformed_nodes
 
 
+def local_ls_registration(
+    nodes: np.ndarray,
+    top_input_pos: np.ndarray,
+    bot_input_pos: np.ndarray,
+    top_output_pos: np.ndarray,
+    bot_output_pos: np.ndarray,
+    window: float = 5.0,
+    max_order: int = 2,
+    warn: bool = True,
+) -> np.ndarray:
+    """
+    Same algorithm as before, but a **single KDTree** stores both
+    surfaces.  The neighbour search is therefore performed once.
+    """
+    state = _build_local_ls_state(
+        top_input_pos,
+        bot_input_pos,
+        top_output_pos,
+        bot_output_pos,
+        window=window,
+        max_order=max_order,
+    )
+    return _apply_local_ls_state(nodes, state, warn=warn)
+
+
 def warp_nodes(
     nodes: np.ndarray,
     surface_mapping: dict,
diff --git a/tests/test_unwarper.py b/tests/test_unwarper.py
index c35813a..8fa2a98 100644
--- a/tests/test_unwarper.py
+++ b/tests/test_unwarper.py
@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 from pywarper.unwarper import denormalize_nodes, unwarp_nodes
 from pywarper.warpers import normalize_nodes, warp_nodes
@@ -24,6 +25,40 @@ def _identity_surface_mapping(nx: int = 25, ny: int = 25) -> dict:
     }
 
 
+def _nontrivial_surface_mapping(nx: int = 35, ny: int = 35) -> dict:
+    on_sac_surface = np.zeros((nx, ny), dtype=float)
+    off_sac_surface = np.full((nx, ny), 10.0, dtype=float)
+
+    sampled_x_idx = np.arange(nx, dtype=int)
+    sampled_y_idx = np.arange(ny, dtype=int)
+    xmesh, ymesh = np.meshgrid(sampled_x_idx, sampled_y_idx, indexing="ij")
+
+    x = xmesh.ravel(order="F").astype(float)
+    y = ymesh.ravel(order="F").astype(float)
+
+    mapped_on = np.column_stack(
+        [
+            x + 0.15 * np.sin(y / 7.0),
+            y + 0.15 * np.sin(x / 8.0),
+        ]
+    )
+    mapped_off = np.column_stack(
+        [
+            x + 0.35 * np.sin(y / 7.0 + 0.1),
+            y + 0.35 * np.sin(x / 8.0 - 0.1),
+        ]
+    )
+    return {
+        "mapped_on": mapped_on,
+        "mapped_off": mapped_off,
+        "on_sac_surface": on_sac_surface,
+        "off_sac_surface": off_sac_surface,
+        "sampled_x_idx": sampled_x_idx,
+        "sampled_y_idx": sampled_y_idx,
+        "conformal_jump": 1,
+    }
+
+
 def test_denormalize_nodes_inverts_normalize_nodes():
     rng = np.random.default_rng(0)
     nodes = rng.uniform(-10.0, 10.0, size=(100, 3))
@@ -85,3 +120,60 @@ def test_unwarp_nodes_roundtrip_with_identity_surface_mapping():
     assert np.allclose(recovered, nodes, rtol=1e-6, atol=1e-6)
     assert np.allclose(recovered_from_prenormed, nodes, rtol=1e-6, atol=1e-6)
 
+
+def test_unwarp_nodes_optimize_refines_nontrivial_mapping():
+    rng = np.random.default_rng(42)
+    mapping = _nontrivial_surface_mapping()
+
+    nodes = np.empty((80, 3), dtype=float)
+    nodes[:, 0] = rng.uniform(8.0, 27.0, size=80)
+    nodes[:, 1] = rng.uniform(8.0, 27.0, size=80)
+    # allow points far beyond ON/OFF layer z to match annotation use-cases
+    nodes[:, 2] = rng.uniform(-120.0, 180.0, size=80)
+
+    warped, med_z_on, med_z_off = warp_nodes(nodes, mapping)
+
+    recovered_local = unwarp_nodes(
+        warped,
+        mapping,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        prenormalized=True,
+        method="local_ls",
+    )
+    recovered_opt = unwarp_nodes(
+        warped,
+        mapping,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        prenormalized=True,
+        method="optimize",
+        optimize_max_evals_per_point=80,
+        optimize_convergence_tol=1e-9,
+        optimize_bound_xy_to_map=True,
+    )
+
+    local_err = np.linalg.norm(recovered_local - nodes, axis=1)
+    opt_err = np.linalg.norm(recovered_opt - nodes, axis=1)
+
+    assert opt_err.mean() < local_err.mean() * 1e-3
+    assert np.quantile(opt_err, 0.95) < 1e-6
+
+    rewarped_opt, _, _ = warp_nodes(recovered_opt, mapping)
+    assert np.allclose(rewarped_opt, warped, rtol=1e-8, atol=1e-8)
+
+
+def test_unwarp_nodes_invalid_method_raises():
+    mapping = _identity_surface_mapping()
+    nodes = np.array([[10.0, 10.0, 5.0]], dtype=float)
+    warped, med_z_on, med_z_off = warp_nodes(nodes, mapping)
+
+    with pytest.raises(ValueError, match="method"):
+        unwarp_nodes(
+            warped,
+            mapping,
+            med_z_on=med_z_on,
+            med_z_off=med_z_off,
+            prenormalized=True,
+            method="unknown",
+        )
diff --git a/uv.lock b/uv.lock
index 1e15abd..fd116c2 100644
--- a/uv.lock
+++ b/uv.lock
@@ -446,10 +446,8 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
     { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
     { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
     { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
     { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
     { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
     { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
     { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
@@ -457,10 +455,8 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
     { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
     { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
     { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
     { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
-    { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
     { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
     { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
     { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
@@ -468,10 +464,8 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
     { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
     { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
     { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
     { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
-    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
     { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
     { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
     { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
@@ -1621,7 +1615,7 @@ wheels = [
 
 [[package]]
 name = "pywarper"
-version = "0.2.4"
+version = "0.2.5"
 source = { editable = "." }
 dependencies = [
     { name = "alphashape" },

From b227af5eae06067875249a3f02f195b2ff45ef5f Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Thu, 12 Feb 2026 13:46:02 +0100
Subject: [PATCH 3/8] update: notebooks and deps

---
 notebooks/example.api.high.ipynb |   48 +-
 notebooks/example.api.low.ipynb  |   32 +-
 uv.lock                          | 2507 ++++++++++++++++++++++--------
 3 files changed, 1905 insertions(+), 682 deletions(-)

diff --git a/notebooks/example.api.high.ipynb b/notebooks/example.api.high.ipynb
index a884994..f8d4307 100644
--- a/notebooks/example.api.high.ipynb
+++ b/notebooks/example.api.high.ipynb
@@ -75,21 +75,15 @@
      "text": [
       "[pywarper] Fitting SAC surfaces …\n",
       "↳ fitting OFF (max) surface\n",
-      "    done in 0.13 seconds.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "    done in 0.02 seconds.\n",
       "↳ fitting ON (min) surface\n",
-      "    done in 0.14 seconds.\n"
+      "    done in 0.02 seconds.\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "<pywarper.warpers.Warper at 0x11bc382f0>"
+       "<pywarper.warpers.Warper at 0x117b80ad0>"
       ]
      },
      "execution_count": 4,
@@ -121,15 +115,15 @@
      "text": [
       "[pywarper] Building mapping …\n",
       "↳ mapping ON (min) surface …\n",
-      "    done in 0.47 seconds.\n",
+      "    done in 0.06 seconds.\n",
       "↳ mapping OFF (max) surface …\n",
-      "    done in 0.50 seconds.\n"
+      "    done in 0.05 seconds.\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "<pywarper.warpers.Warper at 0x11bc382f0>"
+       "<pywarper.warpers.Warper at 0x117b80ad0>"
       ]
      },
      "execution_count": 5,
@@ -158,14 +152,14 @@
      "output_type": "stream",
      "text": [
       "[pywarper] Warping skeleton...\n",
-      "    done in 2.65 seconds.\n",
+      "    done in 0.32 seconds.\n",
       "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "<pywarper.warpers.Warper at 0x11bc382f0>"
+       "<pywarper.warpers.Warper at 0x117b80ad0>"
       ]
      },
      "execution_count": 6,
@@ -198,7 +192,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2114.21x400 with 2 Axes>"
       ]
@@ -341,7 +335,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x11c56bb10>"
+       "<matplotlib.legend.Legend at 0x117c191d0>"
       ]
      },
      "execution_count": 9,
@@ -350,7 +344,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 600x600 with 1 Axes>"
       ]
@@ -411,18 +405,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Last updated: 2025-11-14 14:32:08CET\n",
+      "Last updated: 2026-02-12 13:43:42 CET\n",
       "\n",
       "Python implementation: CPython\n",
-      "Python version       : 3.13.9\n",
-      "IPython version      : 9.7.0\n",
+      "Python version       : 3.13.11\n",
+      "IPython version      : 9.10.0\n",
       "\n",
-      "pywarper  : 0.2.4\n",
-      "matplotlib: 3.10.7\n",
-      "numpy     : 2.3.4\n",
-      "skeliner  : 0.2.3\n",
+      "matplotlib: 3.10.8\n",
+      "numpy     : 2.4.2\n",
+      "pywarper  : 0.2.5\n",
+      "skeliner  : 0.2.6\n",
       "\n",
-      "Watermark: 2.5.0\n",
+      "Watermark: 2.6.0\n",
       "\n"
      ]
     }
@@ -435,7 +429,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv (3.11.11)",
+   "display_name": "pywarper",
    "language": "python",
    "name": "python3"
   },
@@ -449,7 +443,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.9"
+   "version": "3.13.11"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/example.api.low.ipynb b/notebooks/example.api.low.ipynb
index fb63ce6..16ce521 100644
--- a/notebooks/example.api.low.ipynb
+++ b/notebooks/example.api.low.ipynb
@@ -68,9 +68,9 @@
      "output_type": "stream",
      "text": [
       "↳ mapping ON (min) surface …\n",
-      "    done in 0.16 seconds.\n",
+      "    done in 0.01 seconds.\n",
       "↳ mapping OFF (max) surface …\n",
-      "    done in 0.14 seconds.\n"
+      "    done in 0.01 seconds.\n"
      ]
     }
    ],
@@ -91,7 +91,7 @@
      "output_type": "stream",
      "text": [
       "[pywarper] Warping skeleton...\n",
-      "    done in 4.33 seconds.\n",
+      "    done in 0.34 seconds.\n",
       "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
      ]
     }
@@ -122,7 +122,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2136.59x400 with 2 Axes>"
       ]
@@ -267,7 +267,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x118777c50>"
+       "<matplotlib.legend.Legend at 0x1169c91d0>"
       ]
      },
      "execution_count": 8,
@@ -276,7 +276,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAJHCAYAAAC5GKMiAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/QdwZOl1H3z/7+2ccyPnjMk5z2zicpdZgUESLcqUHGW6JH2SSJYl2VTJoq2SFV7JZbssKpKiXtmiKL7kkpt3cs4BOefQOffte+9Xz9ODiQgNoBFm9/ymugB0vN0YoA/Oc55zBFVVVRBCCCGEkFURV3dzQgghhBBCQRUhhBBCSJFQpooQQgghpAgoqCKEEEIIKQIKqgghhBBCioCCKkIIIYSQIqCgihBCCCGkCCioIoQQQggpAgqqCCGEEEKe1aAqGo3i8OHDeO6557B//368/fbbYI3dv/SlL+HYsWP42Mc+hmAwyK/LPrKv2fnscmoATwghhJDNaEOCKqvVilOnTuG9997D3/3d3+ErX/kKXn/9dSSTSZw+fRqf+cxn8Hu/93v8uuzjZz/7WX5+IpHg1yOEEEII2Wy0G/Ggoijy01zWavv27Th58iTPSDEf//jH8T/+x//gn7Pzv/zlLz84n339yiuvzHu/mUyGn+YoisIzXR6PB4IgrMMzI4QQQsizgq1+xWIxlJeXP4hLnrmgihkbG+MZqO7ubvz5n/85vve978HlcvHLnE4nQqEQ/5wFRezrufPnlgXn8/Wvfx1f+9rX1ukZEEIIIeT9YGRkBJWVlc9uUFVRUYEzZ85gcHCQ11Z97nOfQzgc5pdFIpEHARb7yL5mARX76Ha7F7zPr371q/iVX/mVB1+z61dXV/MXy263r8OzIoQQQsizgq2WVVVVwWazFeX+NiSoYkt0BoOBf86CHfZkTpw4gX/8x3/Epz71Kbz22mv8a4Z9ZF//9E//NP/44z/+4wveL7vPuft9FHsMCqoIIYQQMp9ilQhtSFB1584d/PIv/zI0Gg1yuRz+6I/+CM8//zy+//3v811+LAD667/+a37dX//1X8fP/uzP8horVnv18ssvb8QhE0IIIYQsSlDfxz0KWFrP4XDwZUDKVBFCCCFkLeOEDaupIoQQQsjKsHRIIADE46xNEeDxsCUsejU3GnVUJ4QQQp4RbD/XH/8x0NQE+HxAXV3+I/uanX9/vxfZIBRUEUIIIc8A1vua7fr/5V8G+vsfv4x9zc5nl1OP7I1DQRUhhBCyybFA6aMfBVKp/NLfk9XQc+exy9n1KLDaGBRUEUIIIZsYW9L7iZ/IB02Ksvh12eXseuz6tBS4/iioIoQQQjaxv/orIJlcOqCaw67Hrn+/MxFZR9RSgRBCCNmkWNaJFaGzmqnlNEBiOwHr64GenqV3Bd69exe/8Au/AKPRyE9//Md/jH/5L/8ln4tXWlqKv/zLv4TJZOITStjs3cuXL+Mzn/kMpqamcP78eezduxf//b//d9y7dw//7t/9O8iyDK1Wi7/7u7+Dj1XRf4BaKlBQRQghhGxSs7P53X2ruT1rt7CYP/iDP4DVauWBlKIofHIJG/l2/Phx/PZv/zYfE/fv//2/54HV0NAQD0JKSkrwzjvvYPfu3di1axfefvttfjmbasIGE7OG3TMzM/it3/otbGbUp4oQQgj5gGB9qFYjFls6qPrn//yf4z//5/+Mn/mZn+GTS7q7u3H48GF+Gfv4ne98h39eXl4Ov9/PP/d6vTyYmpvlGwqFEAgEeDDGAhWW+dm3bx8+aKimihBCCNmkWGPP1ShkTjDLLv3+7/8+vvWtb+HNN99EWVkZzp07xy9jH1taWuadj/fo12yp8E//9E/5nN6TJ08+WD78oKGO6oQQQsgmxbJMDQ0rr6lyu5e+7re//W1eN8WCJFZD9Ru/8Rv40pe+xIMilpn6m7/5m4Ie81Of+hSvqWL3x7JXH0RUU0UIIYRsYqxTOmvsudyg6o/+CPj3/34tj+zZFy1yoTot/xFCCCGb2Be+AJjNgFjgOza7Hrv+z/7sWh8ZeRIFVYQQQsgm5nQC//AP+ezTw8BKhcc6ixrvIP/IvmbY5ex6rLac3Y6sL6qpIoQQQja5D38Y+MEPgC9+PoxP7/0r/LuX/wSNJX0PLu+dasCfvvEl/J8rX8BffMuJl1/e0MP9wKKaKkIIIeRZMP461NM/AeSSvL5KFB8WWSmKkG/yqTVDOPYPQPmHN/RQnxVUU0UIIYR80Iy/Dpz8KAQ5BUFQHwuoGPY1O59dzq7Hr0/WHdVUEUIIIZtZNgycuT9RGUsNALw/UZldn91uCYODg3jppZcKPpSf+7mfw5kzZ/jnjY2NKLZwOIy/XubQQtYOgvXXehJ7Xuz5rScKqgghhJDNrP+v+JLf0gHVHCV//YFnb6JyeJGgis0UXCjQ+9CHPoTNgIIqQgghZLNiWafuP1nZbbv+n4KaW7ERM5///Of5HL8/Ys2tAPyn//Sf8M1vfpN/zjJTLHApxPDwMB+6fOLECZ4pYrMER0ZG8NGPfhQvvPAC/8hmAs5lur785S/z637uc597MIfw6tWreO655/CDH/yAHwd77E984hP4+7//e3zta1/DoUOHcODAAX75k8fKhkGzAc+f/exnEQwGsd5o9x8hhBCyWWUCQPzhLr/CqfnbZYOAYfHhfxMTEzh9+jQfhNzW1oZf+qVfWvHh/uqv/ip++Zd/GR/+8Id5QMXu89d+7dfwm7/5mzh48CD+6Z/+Cf/1v/5XPhYnl8vhp37qp/jXL7/8Mu7cucNnB967dw9vvfUWv7/Lly/zMTrf+973cOPGDXzjG9/go3NYs879+/fj1VdfffDY09PTfCmQ3SaZTKKetZRfZxRUEUIIIZtVbpUTlaXYkkEVC6TMrFsoAI1GM+9cv0LdvXuXZ6QYFlAxt2/fxle+8hX+OQuk5mqxtFotdu7cyT+vrq7mA5mt8ww7nBvu3NXVxQMzdmxOp5OP0JmdZT268gYGBrB161Z+v6w7emtrK9YbBVWEEELIZqVd5URl3dITlZ8clMy43W6Mjo7yz9lyXKG2bNmC9957j9c4zWWq2Hlf/epXsWvXLn6dbDY7721Z8KbX63ng9ai5QK+5uRn/+3//b349lqlimSmv1/vgenV1dTyoY7dPpVLo7OzEeqOgihBCCNmsWJbJ2gDE+x90TS+MAFjrAX0BE5Xn8ZnPfIbXMbFlQRasFOr3f//38S/+xb/A7/zO70Cn0+GNN97Af/tv/w2/+Iu/iHg8n3X74he/yGu45sMGOptMJvzET/wE/u2//bePXcaCMpa1YjVVLGBj9zuXDWNY5ordL6u3YgHYco67WKj5JyGEELKZdf4xcO2Xlx9U7fkjoIUmKi+Gmn8SQgghHyT1X+Cd0gvfsC/mr19HE5XXG7VUIIQQQjYzvRM4en+i8pJv2/cnKh/7Tv52ZF1RUEUIIYRsdmyW34kfAFpTfmmPnUQHoCnLf5w7j13+3GtAGU1U3ghUqE4IIYQ8K4HVx4aAzneAsAnQlD68TJ4EnCmg9UXAvLLidLJ6FFQRQgghz4JgBLg7BCh1QL7LwEMswIqx/geDwBYN4GbZK7LeaPmPEEIIeRYCqts9gLLE/D92Obseuz5ZdxRUEUIIIZsZa4Z5d5mjatj1n2iiuRpzXdA32ne/+10+X3CzoqCKEEII2cwmA0tnqJ7Ers9uVwSyLG/IbYsRVBX78ZdCQRUhhBCyWbG5e2PTK7stu90Sc/vY7LwXX3wRzz33HI4cOYLu7m5+/s/93M/hX//rf42PfexjvKs6wwYlnzhxgnctZx3N2biYf/Wv/hWOHj3KO51funRpwdvO+eM//mPe8fz555/HX/3VX/Hz/uRP/gTHjh3jndL/7M/+jJ/HBiN/6lOfwo//+I/zeX7sftig5R/96Ef40pe+hE9/+tOL3pZdzm7PHm89UaE6IYQQslmxJbx0ZmW3ZbfLyYBu4bd6h8OBH/7wh3zmHvv4X/7Lf8Gf//mf88tqamrwP//n/7x/GDk+uuYP//AP+Ria733ve/x8SZJw5swZ9Pf343Of+9yDwOrR2865c+cOvvOd7+Ds2bN86DHLInV0dPBA6dSpUzxQYwHSj/3Yjz24Dbv+uXPn8Ad/8Af4v//3/+KVV17BL/zCL/BAbrHbspE4r7322rxzDdcSBVWEEELIZiUrq7z94kFVOBzmc/kmJyf5oGOb7eEAZpZ9msOCk/379/PPWaapq6vrsevU19cjFArNe9s5LNPEgiEWUM0NSmaBFjufZa7mxsaMjIzwz/fs2cM/VldXIxB4eilzsdsePHhw3QMqhpb/CCGEkM1Ks8q3ac2TvRce981vfpMPKmbZnt/6rd/iS3oPb/rwtuz8K1eu8M8vX77MBxa3tLTwLBLDMlVOp3Pe287ZsmULv/5cnRPLLrW1tfHHf/fdd/Hee+/h+vXr2LlzJ7/80aBo7rhYRo1lzZjFbjvf468HylQRQgghmxXL6hgNK1sCZLfTLh5cvPzyy/jpn/5pHlSxoGfhw9DiH/7hH/Drv/7rqKiowCc+8Qke9PzgBz/g2ScWKP3Jn/zJoo/F7v+Tn/wkz2JZLBZ84Qtf4KeXXnqJ12qxQMhkMj1YWpwPq9NiwR8LqP7X//pfy7rtehDUR8PS95liT58mhBBC1t3oFNCXX9ZaloYqoLJkLY7ofSNa5DiBlv8IIYSQzazUA4jLfLtm12e3I+uKgipCCCFksy8BbmlY3m3Y9e8XhJP1Q0EVIYQQstmxWX7bmpbOWLHL2fVo9t+GoDCWEEIIeRawQOnQ9nyndNbY89HidVaUXuHPL/lRhmrDUFBFCCGEPCtYwMSKz1kAxRp7svYErH0A2+W3AX2ZyOMoqCKEEEKeNSyAYk09F2nsSdYf1VQRQgghhBQBBVWEEEIIIUVAQRUhhBBCSBFQUEUIIYQQUgQUVBFCCCGEFAEFVYQQQgghRUBBFSGEEEJIEVBQRQghhBBSBBRUEUIIIYQUAQVVhBBCCCFFQEEVIYQQQkgRUFBFCCGEEFIEFFQRQgghhBQBBVWEEEIIIUVAQRUhhBBCSBFQUEUIIYQQUgQUVBFCCCGEFAEFVYQQQgghRUBBFSGEEEJIEVBQRQghhBBSBBRUEUIIIYQUAQVVhBBCCCFFQEEVIYQQQkgRUFBFCCGEEFIEFFQRQgghhBQBBVWEEEIIIUVAQRUhhBBCSBFQUEUIIYQQUgQUVBFCCCGEFAEFVYQQQgghRUBBFSGEEEJIEVBQRQghhBBSBBRUEUIIIYRQUEUIIYQQ8gHOVF2/fh1HjhzB8ePH8cILL6C/vx9/+Zd/ibq6Ojz33HP8NDY2xq87ODjIr8Ou/7u/+7sbcbiEEEIIIUsSVFVVsc4mJydhsVhgs9nw2muv4dvf/jZefPFFjI6O4jd+4zceu+7nPvc5/OIv/iKOHTuGl156CX/6p3+K1tbWgh4nGo3C4XAgEonAbrev0bMhhBBCyLOo2HHChmSqSktLeUDFGAwGaLVa/vlf//Vf4+jRo/jN3/xNKIrCz7tx4wYPqJiPfvSjOHny5IL3m8lk+Av06IkQQggh5H1fqJ5IJHhm6td+7dfwyU9+Eh0dHTxoGhoawre+9S1+nbnginE6nQgGgwve39e//nUecc6dqqqq1uV5EEIIIYRsWFAlSRI++9nP4stf/jLa29vhcrmg0Wj4iS35XblyhV9PFB8eIkvPud3uBe/zq1/9Kr/O3GlkZGRdngshhBBCyIYEVSz79PnPfx6f+tSn+IkJh8MPLn/nnXfQ0tLCP9+xYwfOnTvHP//hD3/Ii9sXwpYS2ZrooydCCCGEkPWQL2ZaZ9/5znfwgx/8AFNTU/jmN7+Jbdu28QDorbfe4vVVLKBiS3kM+/jzP//zyGazePXVV9HW1rYRh0wIIYQQsvl2/60X2v1HCCGEkPf17j9CCCGEkPcbCqoIIYQQQoqAgipCCCGEkCKgoIoQQgghpAgoqCKEEEIIKQIKqgghhBBCioCCKkIIIYSQIqCgihBCCCGkCCioIoQQQggpAgqqCCGEEEKKgIIqQgghhJAioKCKEEIIIaQItMW4E0LeD7LZLDYLSZKwWSSTSWwW6XQam4HBYMBmYbPZsFlsptdFFClnQNYf/a8jhBBCCCkCCqoIIYQQQoqAgipCCCGEkCKgoIoQQgghpAgoqCKEEEIIKQIKqgghhBBCioCCKkIIIYSQIqCgihBCCCGkCCioIoQQQggpAgqqCCGEEEKKgIIqQgghhJAioKCKEEIIIaQIKKgihBBCCCkCCqoIIYQQQoqAgipCCCGEkCKgoIoQQgghpAgoqCKEEEIIKQIKqgghZAVyiopwKouMlKPXjxDCafMfCCGEPCqTUxDPyEhkZcSzj34uIy0LSGYkqLkkDBoRL7RXoNptoReQkA84CqoIIR84qqoiKc0FSvmPLFjiQRP/XIEkKwveXqPRQlUkTE9MwKgX8EMZONpcji1l1nV9HoSQzYWCKkLI+3JpjgVIifsB0lzQNBdEscsUVV3x/Vv0Gpi1RhidIi53DqNFr8XpXj0i6RwO1jogCkJRnw8h5NlAQRUh5JnGAqSZuISZWBYzoVlE0jJSggUQVlYyygIiq14Di0HkH60GDQ+i2EerXoSZXWYy8mxXriyAsc6r6BsQ0LrVgzsTOkTTMl5ockGvpZJVQj5oKKgihDwz2JLcbCKXD6ISEv+YlOT7F6aQjEyCrdrZXCKgm7/GSa8RYTFoYNOLPFjKf/4wiDLpRAgFZJrYdQSTC9udaYykZyGqEj9/OJTG9+7M4sOtbtiM9CuWkA8S+oknhGxKbHkulMxhOp7FdCzLP85G01CxwLKdnMLI2CRaakrgtxlhMRvvZ5fygZP1fhBlKFIGiWWqoGQhyTLKtDHsaTTinUmRF7gHkxK+e3sGL7d6UGLTF+XxCCGbHwVVhJBNgdU7scBpZi6ASkhPFYs/GVDpNCJ8Fh28Fi38uWm4R0bxqb2tgKucpZLW9HhVKY6x4QEIECCpAsqsAj651YvXu4KIpHJISTK+f3sCJxqcaCxxrOmxEEI2BwqqCCHrLptT8st39wModkpm7y/jLbLc5jHr4LXq4GeBlFUHp1HzcKkuCNyBAojaNQ+oGCUbQ0dnN44e2IXz17sxPj6CypZyfHKrD291BzEeiiGdSeCNW2GIO2pR76fAipD3OwqqCCFrvozHlsNY/dPcMl44mVt4Ge8+q0ELv1UPn1XHl9C8Fh1yUnbhG6iAKihsXQ5rTZGzyCXCiMWSMDv9aKxPIRScRYWcg9Eo4tU2D073yLjWM4OxsXG8qRHwyT2NKHWY1/zYCCEbh4IqQkjRsDojthtv+v5uvCm2jBeXkFMW7vk0t4w3F0D5bXr+Odtl96RcvhZ8fqxwnO34W+sslSpDCo/jh2++gx07t0Nv8ULKDUCn1QJivl5LIwo40exHTkohEQtjYmISb9yz4sd2VVPxOiHvYxRUEUI2ZBnv0QDKadIWtONuUXMJqrUOqrIJDPZ3w+20oqFlK1TRgKwkwWQ0QMXDx2bP51iDB4MDwEhY5q8Lq7f6xBYvtVsg5H2KgipCyLos4/ltOv6RLeNpNWvQw0nUQcrJUHNpCKqy4j5Vi8qlkQyP4OadTrz80vMQDG4ISgY6gwnRaBzIxqHqLA8CRK0gY4cljETGAQgaBBMS3ukJ4eVWNzUIJeR9iIIqQsi8y3hsN95ULIPhmWh+N14Rl/HWhM4Gt9OBwaFh1FkqAaOruPefSyEVGMA7757BscMHYffXQ9QZoSpatLRtwZtvvAFP/11Ut1og6G3526g5yNk0nqs04aoqIqfm+1hdHIriUC0VrhPyfkNBFSGEL+NNxzI8iJqKZngmKpHN8VdGkqT1XcZbKaMbu3btwo/efAclJaUw+9sBnak4951LIx0exJvvvIeD+/bAX7sFoiEfFAmiFjpHDY7u346zF2+isq4F4v2gShD1cLqcGJ8Yx4sHduHNQZbxA26Px/lr1VZCQ5gJeT+hoIqQD+AyXiCRb6jJAigWSIUS0uZZxlsprQlWbz2eOxzFe6fP4SOvugF77eprrFQVanIab7zxDvbt3g5/VSs09wOqOSyw0pjsyEpZ3r9KVRVeNC/orWisq8Wdu104YcriSH0JTveF+W3O9odhN2hQ4TSu7vgIIZsGBVWEfECW8fIZqHwWaqllPDbKxW8zoMRugF2nrO8y3moYnPCW1kCRb2J2chhekxeYW4pbKVVBKjYDvQ4oq6gC9PanriKIGphtXthsFowOD6PaUg6NgV1PgKoo0Os1vNMDy0yFUzmeqWIZq7e6Q/jkNi+cJt3qjpEQsilQUEXIfclkctO8FuFwPpuxEoF4GmMRCTMphReVp6TFAyhRAFxm7YPO5Oyj40FTzRzGxsYwOotNIRaLLXkdnZBBc1Mt3j59DkdkIKY6oazqV50MhzwNKZPByOgEokoCfr//qWuJShb1tTW4cPEyrHYPMvoSQFEgRqYh5xSEwhFkEqOo0KgYUNMYj+WXV//f81G8VG+GQbuyjFpNTQ02Cy1rK7FJbNgy9CY/FrK2Ns9PACFk1W6NR3BtKAhFlvjSE4Snf8TZPDyf5WEQxeqitJr3zy99SdXDYitDQ10C5y9exsH9e5GAC/KKf90JUBSVL+mxzxeiCHrYXSUQNTokQhMwuQ3IqSKSqQTMJuODwE4UBByqNOLtgSTCaQWxrIKzIymcqDHx/laEkGcXBVWEvE/cHE/g2mgCUjqBwaEhNDc1Q2dy8tonn1XLP7IgyqwrcBlPzgJqFiKk+wHBs/KGLyChWOAtb4Ko1eHMuYs4enAfkqILOaxkuLEKjSjyYEhd7CUQBEhaJw7s24mzZ8+juW4COp0B93qGsaW9DYrG8OCqOo2AY9UmvNmfRDqnYjoh4+pEBvvKDZTVIOQZRkEVIe8DN8YTuD6W4JkpvU6Lam0IP96Yhc3vXdmbtJxCNjyKidF+6PQGGOxlyMDyjAVWZjj9ddgqanD24mUc2rcXGa0HEpZbvyTwIn5Wxi8sMQFHEQ0wOqvxwnEVQ4NDkJQsdu3aDk9pPbLC4zsRLXoRR6tNeHcwCTY3uj8kwW4Q0epdSeBHCNkMNtHWHULISgrRWTDFA6r79lYYUa2NwqwmISjSSu8YspxDLBbH6fOXMT3aDSNYPdPaz9UrHgEpxQSLpxrbtzTj9PmL0OemoRMWmR+4AFlhu/kKe/Y5jRWqrR41Ww+jbutROMrbkdWw5p9PB6Reswb7Kx7u/rs5lcFYNF9rRQh59lBQRcgzHFDdGE/yLNWc/VVWbK3wYNfWJpy9dAtCNrSyO9eYYHLXYuue5/HSC8+ht28I40NdMCD+7AVWqhkGZw327d6GcxeuQpuegl7ILOMeWD0Vq4ViS4CLF/3PUTQmyFonZI0VimhctK1DjUOHrf58doo9zvnRNEKpxUf9EEI2JwqqCHlGA6prY4nHA6pqK7aUmgGdFRUVpUilkrxp5YqwIEBrAkxuZHR+HD5yCP2DY5gangus5GcquEorBojWCuzbwxp0XoOQnIBJSLAS9CVvq0KExmDDTCiORCQI4zICskJt8elR48xXY+QUFaeHU0vu2iSEbD4UVBHyDAZUV8cSuDXxsAXEARZQlZgfBkQaE7KSjFwmtvLAau7xoEVW68WxIwfQ0z+C8f5bsMujMKsBaJHkhezPQoCVVQ2AuQxHDu7G5au3MDl0D1Y1CC0//qWyXTYcO3oQV2/eRiY2ClFOFfXYWN3bvnIjPOb8JoKkpOLMcJoHWISQZwcFVYQ8awHVaAK3HwmoDlZb0T4XUN2nGNzYuX0bfvT2GUiRYUDOrDqwSmt9OH7sMGaDUbxz6iLeefstBIZvQo0PwYIgjIhABxbAqZs6sJIMJTh0aD9yUg7nL1yAkQeHiwdWEvSQdF4cP7gDt+/cg055mCEsFq0o4GiVERZdfqkwkJJxaSzNv+eEkGcD7f4j5BnB3lwvjyZwd/JhQHWoxoZW/zzz7fQuVDfv4p2+3377Hbz03CHorD6oGlt+A5+oBTSL1/rMG1hpvNi+9wj7DJHQLGYmp3C38wLsVgsMeh1KSktRXlmDFKyQUaS5e0WWU/VQND7UNFrg8U7g1JlLOHF4NxSdC0nFyBooLHA7HQx6Iw9+VHVtislNOhHHakx4qz/Fs1TDkRxshiy2+R+2YyCEbF4UVBHyjARUl0biuDf1cNnpcK0NLb4FAhcWLBlcqGraxht7/vCt07BbDaipLOfV0BaHC/6KBqhGP5uxUvhxQIMM7MjABr3LgRpXJRpa2pCMhXjD0TsdfbjX2cd7NRkd5cjCvGCQspEUaBBXbTC6tNi7U4uTZy7B43Zh+44diCn2BTqwq8gpOd6zSljDJL/TqMHhKiOvq2JJqrvTWdj0ImqdNMqGkM2OgipCnrGAisVLh2tsaF4ooHossPKgrGE3PlFZjdGhPkTCYb441zN4G/6xCezctROq3g3ozICoX0aAxUq8Dciyk2iD4PBCCwX7j1RCSQbw7ulLqK+tQmNDPW+Imd2kPa7SigkGewVeetGB0eFBnL9wCYcO7EdMnT+wku8Xj6trPHak3KbFzhIDrk/ml23ZMqBVL/IWDISQzYuCKkI2eUB1cTiOjumHAdWRWhuavMtYWtPboOosqGjxo4L1rVIVbJEiuHLpEr77T99HS2MVPN4S+PzlgM4CiLr8EGL2seCmA1oerKXhhtZsxgvPG9HX3YkfvfkumprqUNe4BSk4NmUZZ0Y1IJPTwVdpgirocPHSJezbvwdZWJGDDrLKAhkh31pBUaDTatalbKzZo0M0q6AvKPHhy2eGU/hQvZk3DSWEbE4UVBGyiQOqC8NxdK4moJrDMlAsYJqjt2PfYRu2x8fR1dmLjs4uXLl2Ay6bFXqjGTu2tkBrsgKiCSIy97M27M186QxNDkbI+jI0bnWgrT2GC5euQZJuo7WtHWnYIa9oVMwctpioQC7wWAonIqGY4K+oh6gRcfrUWTTXVcLl8cJq8yAus+BKhKzk8h3ql7FkulLscXaXGhDPKpiKy3yczanhFF6qM/MxN4SQzUdQ38dbS6LRKBwOByKRCOx2+0YfDtnkwuEwNotQKITzQ3F0zTwMqI7W2tHofdh9uyhY5kpKQJDiSMRmkEpEEAiEYDaaYTRqcfVWF9qaa2CyOqEx2nnAlIOh4DopATmY1CDOn78AjaBiy5Y26OxV7NyVHCyQnEIuJ0HVmHnvqeJTYRaTkKJTCIUC6Bschd6gw/E9zTAadOgZmkIoJmHv4ZcgaVnmbe1lcireGkgilskvPZbZtDhWbeSzCJmamhpsFpvp96xWu3lyBisaFUWeyTiBgipCNllQxf7Oee3mCLpn8v2l2O/jY3V2NHiMa/mggMJ2tClALonuO9fQPzgAj8OKSCyCWCwGh90Gl9OJqroG3rdKLXCGnsD2AaphRAKjuHazAwf27YbWXs0DtMIpMKkhXL9yGaJGi/qWHUgpa/V6qNAIMm+zYBTSyMancPX6bfQOjGL3tha079gLk68VqrB+b9osoGLDl7Oy+mBpcHdZ/vlTUDU/CqrIRgRVmyeUJ4TwgOq9nuBjAdXxOjvq1zKgmnsgzf0gSWNA854X0byHreWlEJgagEZJIjAzhUAggDNnz+HYkYPIav1QCgisWFYrKbhh8JpwYL8Fp89exvEjGmhsFZALCKzyQVkIV69c4YfZ2tqGqLyWQ4cFyKoWLKzKqEZoLUa88JwbjXUDGJkI8HE1PL+/jskHm4ENXzbivcEUr6/qDkj8vCY3DV8mZDOhikdCNglFVfFuTxCdU/nGkiILqOrXIaBajNaENBxIiCWwlLShvn0PWhrrcfLUORikSRgR4icdkkuMfGGXmqG1VeLo4b04d+kqkJzgDRqwxK2MSgCXLl2EzWJCa/t2RGQrHx2zPgTkVBMmJR88lVvgL6vAuQtXoMtOQuCZvaWJSgZaOQpRXeFw6/v8Fi32lD/8v3B9IoPJOA1fJmQzoaCKkE0SUL3XHUTXkwGVewMDqseIkGFABg54KxrR1lKPt989hRsXT+PmpTMY7roEuzoOM4LQ8K7q82NLfqym6sDenTh15gKE5PiigZUecfT1dMJq0qGxfTtisnWDfm0JiCkWlFY2orqyFOfOnoc2O5WvSVuCXolgqOc2dLlQfpl1FRpcOrR689kplrE6N5JGKLm6YI0QUjwUVBGyGTJULKCafhhQnai3o27TBFSPEnirAW9FC547fhTtbU1oa62HnMvh9bdO4+Q7b0KOjfKO64sFVgZHFQ7u343T5y5BSE9Cg+xT19MhgXhwDL19Q2hpa+cNRze215WAhGJGaXUTykr9OH36DPQ8sFoiW6QCfb09iAXHIaqrH8a8vUSPSnu+coPVWP2wYxYpiQ24JoRsNAqqCNnggOqdrgC6HwmoPtTqRe2mDKgeD6yyxkoo9mao9mbUb9mPD33oBezbux2nz12GEmcZqIUDKwkmGJ1V2LtrG86cvQRNevL+YOY8FpTFZgZw7fotPP/cMcg6Vhi/GUpABcRlE+qat6G6uhynz5yHPju96FJgVjCjtakWExNTfClwtdiuvwMVRriM+V/fsXQOb3YGaPgyIZsABVWEbGBA9XZXAD0z+Vl+GlHAy21e1HsfH468oVhfJiyUBWFtFTR8F2AWdsRQAq29DocP7sbZi1eAJMtALRxESDDD7KnBzu1teO/0eeiy0w8CKwMSuH37Ll48thequXyZOwXXmghJ60JNwxZUlPlx+uwZ6KTJBZcCVVEHt8uLwZFxXvC/2iVAhvWpOlptglGbz9xNRDM43Rei4cuEbDAKqgjZALKi4q2uAHofDahaPajzbJKAimVeUtOQIoM8wFk4sJpvaa8a+/fs4DVTYmrxmikJFth9ddi5rRWnz7LAaooHVqy/lSgCWr0Ryqqaha4RQYAkOlHXsg1V5X5eY6VXovNeVRX0sDld0GlEQIoXJahiWGf1Y9Um/n+HYdnOG2Oxotw3IWRlKKgiZIMCqr5HAqoPt3lRuxkCqkwUQnwQavAurpx7Gz/4wWuQMyyoKjwQYI09jc5qHNy7kw8q1mTY0t7TNVNz2FxAV2k92lsaeMbKnJuACRGIarbgYG5DiCIkjQuN9fXIpBPQKg+HXT9GEKCqIn8Fee8kFi0WiceswfNN7gdfXxqKYCCwwHEQQtbcZihSIOQDFlDNon82/8anZQFVuxfVrpV0GC8ilj2RwpgeuotLl6/xflBNDbX4xEf2YDYlzjtceDG8Zspdhf27FZw6cwnHjx5EzlCyYNYpAys85Y3YquTw+tunYNYrGJ+chZoJw2SwIwX75vwbkAVMEPMds9VFWkoIClR+efGfQ4PXjEgqh8vDEf71O91BfGKbDz7rJszwEfI+R0EVIesYUL3ZOfsgk7BpAiomE8TE4D1cuXYLL794DEarG6rOBugckFKTK7pLtrRn8tRg1zYZ75w6jxdPHIakZw1D53+zZ1kpn8+Pj324hGe2Zqan8frpW3B7JrFj114k4cRGyGfp5Mf3HebSEESRD2Bml7P6OHWheYCqAlFlGTdh4eus0q5KG8KpHHpmEsgpCn7UMYsf2+6H1UC/4glZT5vwTz9C3n9yiorXOx4PqF7ZLAFVNoKx/tu4cesuPvzhF2DwtkK11gAGNyAWNuNvscDK5q/Hrm0tOHP2AvTS9LxLgWy338xoL65ev4UUnAigEXr/Hrz40ss8aLlz6xosCEHEejW7VKETsjALSdjFIPTJIegSAxCjfRCjvUiM3UBmphMGaQIaJQqdIAPy/EuVWiWJnr5+2Cw2SCLrs1V8LFN2vNGFElt+HmIyK+P1jgAkebGGrISQYqM/YwhZY7Ki4PXbYxgKZSBodNBqRLza7kOlc3PsaBOkCG7dvouXnzsMjbOej6kpJlYz5S6tRxtrcHrqPJ47cQQZrf+xFgkaSDwz1d5UiSzyj88GN8fhxfade3Dz+lVcv3weDQ2NUAwepNds7t/Docqp8ASmZqbQPzIBn9sBHauHElRoRA30OgPC0RjvQWU1KZiaDUKrJvIF/uLjv1ZFJYXpyUns2tHGg8y1wjOfrR78461pxDI5zCayvEP/h1o8NNCXkHVCQRUha2xgOoL+qSBi0TA8Xj8+sq0OFZskoOJkCayMWmswQi1yQPVYzVRZI9plBWfPXcCRw4eQ0foeBFasX7uUk6DRaKE8lkAXkRRc2LZrLyaGunHq7AXs2bkdJlcl0upaZPlUWMUkJsb6MNA/gK3NdTh+tBZagw2yytpHqDyQcjpd0CgpJONBiLk47GYz3jl3HYePOiDpS54IrERkZRmKIkMj8HtYMya9Bq+0efHd29M8S8Uyo5eHo9hf41jDRyWEzKHlP0LW2FRChqpkMTo6igOuCEqtG9kVfAHqWvcqF5CBBb7KJtTXVuPMmXMw5yb5zED+4CwzlVOg0Wjm2WmoQVpwwV+7Hc8dO4Tb97qQjo7BIC7cXHSljEIaMxP9mBibxNGjx2DwtSCtLUFUtiOhWJBUrEiqVuR0LmT0ZdC4WiG4dqFh61GUl5Xj8uWL0MuPt1bIiRZsa23E1Ztd0Cr5Jq9ryW3R4aUWN4T739Hro9EHzWUJIWuLgipC1lgwqUBjsKPE58XAHdZtfGrzveZs8xrbwbbGD8IyVmXVzWior8Zb757G9NBtmBCGDC1KS3y41z0A/bx9rVj3KgvSGh8OHdyH69fvQoqMwyAUN7AyazLo6e3HsYPbEVOdkGBYeOcje71YRkpvQNbgR2NTM8KhMKTEFIRHGoEqogFejxuSJEGzyqHKhWK1eofqHmanTvaGMBFZfTd3QsjiKKgiZI0FklmIWiMqy3zIJOMITPZBkTZR5kAQkZPl/KiVxdoCFOfBkIYNpdWtOH50P0ZHx9F56zKEbAjNDeWIROPQLtIsNMe6t4tuHD68H9du3oESnyhaYKURckgnojy/k4GRt0oo/GkJkAQbWhuq0d83CI36SK8oRUFOVqDVsKL/9eu7tbXMivbSfGE82534RmeAt14ghLzPgqrr16/jyJEjOH78OF544QX09/cjnU7jZ37mZ3Ds2DH+kX3NDA4O8uuw6//u7/7uRhwuISvGdmGlsixQEeBxunFw7w5cuXYbcmQUylKDeNeL1oYSnxt3OnsAaT06cuczVrKpGvsPHYFWb8Abb72HWHgWGkHO1y0tQoIOks6DIwf34vL121Dik9ALq83CKLyW6l5XD7a2NSIpL7/mTRb1MJhMEEUVgvJI8MRaL2hNiMYSyCZjj2Wx1hLbEXik3vlgQ0Q6x3YEziKTox2BhLyvgqqysjL86Ec/wqlTp/Crv/qr+I//8T/iL//yL9Ha2orTp0+jpaWFf8185Stfwde+9jWcPXsW77zzDjo7OzfikAlZkWDy4Ruoz2FHeU0LdDotLl6+yIOBzYD1o2pprMfsbBDIzj9qpfgEKNAhLXpR37oLzx8/hJPnb0HOZfglS8mpemR1PhzcvxsXr96EmpxYUWDF2prqxQwcmhgGBnqRkWQ4fJXIqiso2Bc0sDtc6BuagPjojD+2TKizoaGuHNPTUxDWaQlwbvjySy0eOE06/nUoJfFu/ixzRQh5nwRVpaWlsNls/HODwcBHN5w8eRIf+9jH+Hkf//jH+dfMjRs3ePaK+ehHP/rg/PlkMhlEo9HHToRspEDiYU8mj0UPraMaJ44dxsjICHLJWWwKGh0sTh9mZkNIRQNAbv1qb9gSWwZ2iNZy7NlSj4GhSWjvD1VeiqTqIBv8fIDz5au3gNQkDMsKrFRYNCmEx7tw++YVhINBHN6/+367huXXl6mCFha7CxazEXI6ypf95ijQQBTmOq9jXRm0It8RaNTme46NhtM4NxBe34Mg5ANiQ1sqJBIJ/MZv/Aa+8Y1v4Jd+6Zfgcrn4+U6nE8FgkH+uPPKLiZ0/ObnwX/df//rXeVaLkJWY+z9XTENTMaRS+aVsUUogHMlCyKp8az2r30kGAvlMxhPGxsawnnSQ0dhQjYuXL2PrbgEpsJ/F/HFduHBhzR9fLwJtfhmZdAaByVFc6R+eN181PDz81HlOiw41Xiv+6f97HVtaGzERySEYkx6NaebFXvb6Ugt0SEEQRLgcNpy/dAUWixl3BuPIyQtHP+Xl5fOe77OJkLJpXL95E1rTGEaCbDkTcFtFIDGDVCqJuyOnkSpisoqVRxSi2STj1HCGZ6lOB4OIz06i0Z3PYBULW2XYLCyWtesJtlw6XXFfZ7J5bVihOtsJ89nPfhZf/vKX0d7eDrfbjXA4/9dTJBLhX/MDfGT46KPnz+erX/0qv87ciWUDCNlIoWTuwRu405T/G4ZtdWf14DlJerhEtMFyMKOyton/XI4OdPNAYz0pfPehFm6nDTfu9KKpVESFU4TbIkCzxG+pcELCcCCHrW1N6OkbRIlVQXuVHXrt4tkm9tIPTScxERExFlIxNJNCOpFAMhaG176yuXnxtIL2ljpcu9UNOTGNLZVasPwQOymKyn+fbdR33GfWYE/pw+d1fUrCZHwTD6wm5Bm0IUEVyz59/vOfx6c+9Sl+Yk6cOIHXXnuNf84+sq+ZHTt24Ny5c/zzH/7wh7y4fSFsKdFutz92ImSjsIxAOJ1/07IbNLzjNcPeVLVa1khS2TRBFVuGSwkOPk5mfHxygbYGa4e9MolUDjXVZdDrtLh56w4mhruRCo2gyiVCs8RqXCguYTSYRVNjHWYCEQwPD6K5wgqzYfFfcSwbFUnmEE3JmApl0NpYhbGJWXgdhdVU6bWA1y6izCmi1qtBuVPF9PQMju9rxsDQMMaH+rGtRsc2WEK+P1B5I7/ltU4tWjxzWRMV58cyiGSocJ2QZ3r57zvf+Q5+8IMfYGpqCt/85jexbds2/N7v/R6++MUv8vqpyspK/MVf/MWDJb2f//mfRzabxauvvoq2traNOGRCli2alvkQZcZlfvijJog63sYgmUjA5mbrQKubr1csKjS89keRc7zDeT78W59GpSzeZJkc1mG9uroaJeUS9IKCkbEpdHV1orW1BUOBxaORYCyHVFZFvb8MiXgIw0MDaK+vQSCpYnAquWgwYzVqodUISEsyHyNk1C38vFnWkQV5PpsGbouK/qERqEoOqqJgJhhDY20ZMqKAbW11GBqd4UuWVVXV6A+pYJNu1A3u/brNp0M8q2IsluMzKc+MZPBirRHGJTJ7hJBNGlT95E/+JD896dvf/vZT59XX1+Pdd99dpyMjpHhCqYdLK677S3+Mordjx5ZmXL7egZdKGqFo56/PWX8C9GYHpJyMRHQWot3O9satW1AlyTke+EzHVIQSrLO6Bn5fNaAZw9DAILwVtRhc4n5SGRl3R2KoK7WjtESHez19KPX7sLPejYHJJF8qfJJOI6Dab4CqyMhk84GwRs3B79AjlZX55SUuI1xWHQ+mFCiwWRV09AyjJxxFe0MVTGYzL0KvqtUjklLBVn2TWaC+0Y2u3iFIAwPQawSoLKLa4OQkO8795Xq8O6QgnFaQlBScG83gRLUBmvvZVELIylDzT0LWSOiRRosu0yPZKK0FXp8PuVwOkDdTl2tWoG7B1vZW3Lh1DyaVNcIsztKQVgT8NgE+2/w1Ujp2HgtmtBqwNkqsRjynAhNhBVWVlQhHwnCbZOjZHRWAZaYCKS1aW1oQDEfR2dmFao8Ir+PxIJHFEH6XDiaNhFgsjHRWxY7WavT296GlXIN6r4BqNzA80I97nd3o6OlHR/cgbncMwG41Y//e3YjCif6gDr2zWvTPKJiNqYimVEQTKjonFVTV1ECWFfQPjcFlEXlR/kZjS9FHKg0PslOBlIwrE1mom2Q5mpBn1Sb48SbkgxBUPZ4UZrvNODkJITML5BKbor4qByNcpTVwuj24dvUqTGpoyXqmxbCbltoFNJcKmB7rw+z4AKrdAg+y5ug0gMcK3OkZgcXiQJZFU/exz2aiCqoryzAyNoEyd2G1TuylDEQl3B6IwltSiV3bW9DRO4CtVUa8sNOLXQ0O7Gq042CLGy59Dv2DI2is8MBsFOF22jE9G0UsGkcqlUIskUJDXSXq6pvgK6uGv6wKVTUtUAw+dI5lEUmqDwLBJ7+FbPV3eFZBbV09nHYr3jp7HU3lm2MnmFkn8sBqLjs1HM2hM7BJGtIS8oyioIqQNV7+Y8s+1ifSE2pOhipnMTbQgytn3sBU72UI6Wkgl12HUTFLZavsaGvfDpPJgGtXLqPKLfCMzrLvSQAqXCLCs6M4e/EGKkpccDvNuHX3Hqo9+cDKoAMqnSpu3bmHhtoaZEUrXzZ7VCipwl/iw9T0LDx2/bKORZJV9I4ncGcogWO723H5+l3cudOB4aE+TI8No7OnA7PBGYiigHs9w+js7kU0nsRHX9iD2XACFqcXMdmCgVkF1/vC6BiOoXMkjuFgjh9XIWEw+252TuTwwtHdsFstsCxRPL+e3CYN9pc9zN7dmcliNEqBFSErtXl+ugl5H8nmFMQz+aCKtVLgTR/nqGyMSRzjE5O429WPihIPbt7uxEDHZaSmbgLJMQjrOCPuaSIScKB1y05YrSYMDPSjwrm8wIpdtdwpYnpyBLFEGgf37UIMbuispags9aK3uwvt5SIqHDKuXL+NuupyCCYnZmJPB5Sywl5PDYwGPcz6lZUkseWurCriUy/vh9Ggwydf2A2rxQiz0QijwYStbc1oaW7C1pY6XLjWhayUgyQrSEsKpsNZxFY5M4/1zOqbygGCFpOBOMyGzVO7VGnXYpvvYWB1aSKL4CP1gISQZ6T5JyHvV6H7rRSeqqdSFAjZGXT3DcHnc+HlF45CcbaipKoBly5exOWbnfC63di7exvSogNZmDbobx8RSTjQ0rYd4xPTGBrsQ11DA0YCKl/SWopRDwhSDIlYFM0tbeiZUvjtWK1RldsPi0EL5JK4facHbc11kDUOBOYJqObM1XdrRM2yV0mrfUaYNVlcv9WJfpsefQPjGJkIoLWpFv6yEgSiWVzsjiKdVXgmbPvWFtzuHEROyaHMpUf3iPBgF+dqzMZkNNXXYHh0Ai5/LZKZjV/undPi0SKWVTAYyfHnenY0vyOQLRESQgpHPzGErGHTzyfrqQQpjJ47VzE0EcFHPvJRKK52QG+HYKvFwROv4rOf/klUlPnxozffw9TQHZgRhoiNWo4ReMaqvLIGJpMeE8PD8FgKy7CwMDKTTaPU70Ewma8tmjMSVOH1+nCnawhtjXXIiXYEEosvebJ6apU1z1yqE+gTavxmaJQURsansW9XG9qam/DPP/MSSrwOVJb7caM/gqHpFA+oGBZg9U9lsHVLAyamgsil4/A9Udy+UlIuH5Cy5eClGpOuN5ZJ3V2qh9ec/wMgncsHVqzlAiGkcBRUEbIGwumHgdBcJ3XIWSA5iY7uXrz43BGIrlZAZ73/k6iFanBDMVejZcdBvPKh4xgZmcDd61egSY1Ci/yom/XHuo0rqK+twUwwCK9Nxf0RcotimSWBLSMmkrAaHw8gzDogGo0hEktDY7AhmCzgjft+ULWcvllsfI3dIGNyahqNjXU4dy+Et2/M4PZgHGlZyAc588RygZiE6bCCI3vbec+qfFXU6rH6e63BjLGpIIxaZclO8Ysx6QXYjKw3f/GwgvXDFQZY7menWLuFi+O0I5CQ5aCgipA1EErKjxUDs4BKiQ3h7ZPn0d7aDFhKAdYE9KmfSBGqwYuYWIaDhw7B7bbjzNmLUBPj0Kxzl/M5bLltKqqgtrIUA0Mj8FqXfitPZQG3x4PZcBS2Jzbs+RwCuvsG0d7agJl4YZmQdBYQNFrEYlGUOJfeAchK2Kr9JgwOj6KloQaDUyle58bEUhL0Wh3C0Shctvl34o0F01AEHToHpmCzFCdTxWrDUpKAMp8TUDIrbvnKgrESG+AwZGE3FTfjZdAKOFplgO5+Ad14LIfbM0UcVEjI+xwFVYQUGev1M9dOwaIXoRekfED1znuoq6lEY/suqFrn4vcBDVIaH3w1W3Fg326cPncFSE5sWGDF2gb4SkoxNRWATa8sWbTOkkqZHKDTavgb9aMBgR5ZiBoBBrMDiQKfzmxcQWtLE27cG0S5UwvjEs2eWNZFr5Fh0GuhaPSIJB5mDtk4mvamGvQMjKPUZZz/+SYkCDoLAuEESuw6mIrUXIplxmQ5/zqsNP/FXk6WuQzNTi3a+X2l7AYRBysMDzZXdAUkDIRpRyAhhaCgipAiS2QVZFnTIpalMqiQo/mAqqmhFvWtu6Aa/DwjVcg8viys0DkqcWjfTpw9dxkiD6ye6DmwDliWJZQEyst8mJ6agqvA2iq2QCU88lztRgGhUBhWixnhhFLwTj4WoIVSGj4CZnpmGhVu0+KPK+Q7pZuMBsQfyRry+5IUxFiRuKrAZhShm6e+iWXn+ifj2N5ei87+IfhdhfXHWvJ5yIBWp0U0loDNtMJfv2wpVFYeGzZfbKVWDXaWPMziXZ3MYjpBOwIJWQoFVYQUWXBu+70qw67M4J133kNrUz3qWnbypT3+jr8MEkzQOyuxf+92nOKB1cYsBQYTKhrrqzE+NQOneennwLJZj3boZtmZUqeA3oFxNNRWI5xaXhE0G//idrkQjsaf6oz+9GMLyCkyf6nn6yY1E0nD73VjNhBA2QIBUyyZg15vABuYYyikkKyQ55BU0FRfjf6hSXitK/v1m39dFV7vVYxdiQtpdOn4iWHfRzZ8OX6/oJ8QMj8KqghZq5l/cgYzw92or/ajunFrPqBaYXZBghkGZzX2796Gk2cvQZOeWvfAimWrVFmAQaeBpoDAkNVBaTQaxBJxWPQCKl0Cbt/pQlVlKSZjLOhZ3uOz+CGVVaDX62DULx7kCALL87FAToR8P2v4qMlgFjanG5NTQThMKhyWp7vLsOUvOafyxqBFiqkgyUBSEnlQZNCwuYLLvw/1/vciHyuu7S7CHSU6lFryB8myr2z48lwWlhDyNAqqCCmyMM9UseF1KaSCEygrq+A7+5aboZovY2V0V+PAnm04fe4SNKmp9V8KFHB/m/3Sb6yBuIItzXXo7h1ChUtAPDzLa5xcvlIECixQf+rheepJgbJEhoYtO+Zyczmqp6/LitYHJlPYva0RPX2DqC+1PvXtUVSVF9zPBKN8wHKxWivMxnKoqy7F4OgE7Mbl/wpmnehFqBDYgOY1ns7MMn4HKgy8zophvaxYxoq9NoSQp1FQRUiR8SJ1WUIqEUWJ3QCLs5R30i4GlrEyuauxe8cWnDxzAbrMFK+8Wi9JSUUuJ/PeWUtlWbIyeJF4JpuFy6xgaHQUdXXVmAyv/A2ZJfpYwLRUMMGyS7zcX8wPaJ5PLCXzDu6svktKx+Cy6p4qKh+cSaGttRnd/YMosQuwm1f/fUxmVehNVqSSSTgKWEZ9kteqQd/IBMxmG681W2usrxabEcg+Mqy26vqkRMOXCZkHBVWEFBGrcYmmcxDkJNKhadRUVULVO1adpXpUFhZYPDXYs2sLTp+9AH12Zt3G2gTjCmqqSjE6MflU/6knsWRSWhLhtFkQjYRhMRqgQMeDrZUSVBZQLT0ekYdUvAkVK0hf+Hpjs0lUVpSiZ3AcTeVmlDj0j32r2K7BgakMdm9t4kOXa0vNq/5WZiTAZDQjm5UgqtllLS2yhzYZFMi5HMw2OxLp9ckYsdmVLLBimSumPyyhJ0Q7Agl5EgVVhBS56acqJTE6OgKfTYuaxvaHDT6LKAszbN5q1FSVobe3BwbEsR5SWRUmg57P0hMKeD+PZwC71YRkIgVZFZBeZcujTE6GlFOg0aowLDJCZa5AnXVgXyyrFU8rCCYEVJb5+fxFqy6F57Z7cWyrB8e3ebCrwcEfJ5JmwYwWkNOwPdIhfyXU+0X3RpMJSi4F0zLbIugEhQ+7ZjVr67kIx7qt731k+PLNKQnjMdoRSMijKKgipNhNP5UM0qkU9jRXQTGVAcLa/JixjFV1XQPGJ6eRCIytS9d1ngFiyR9eU7P0WzqLQxQpjRudg2huqkdwiXE0S5kMpXnhP5vfx+b0LXWcLLhaqv5qeDqJDMx85l8qlcK1W524fbcLN+90oaOzC+VOAQa9CJ/XhUwyBZtx9VXroaSKlvpKdPSOwGsr/P7Y88nJKu8urxap0/ty1Di0aPPOLZOquDie4Z3XCSF5FFQRUkSheBJSOsWXvpxW85oFVAzb3yZpPXjuyB5cvnoLJsQKCnRWgz0ddmK7/wp5K7WbgWAohvamSqQk3aozVeF4DkaDGaKgwrxoQ04B2ZyKZDIN5xO1UvMZnU3hen8MGpMXdXX1qK1rQH1dA7a2NaGjawBjrB6s3I3xqVmUeRbvkVWIjKRC0Br47sTlZKqcZhHhUBg6PctUbcz8wC1eHSpt+Wwd27TAZgSyWYGEEAqqCCmqWDKG0fEpvpzksLnW/NWVoeetGtweJ3q6OmBc68DqfpaKN/Us4OqJNFBa4obP40a4GB0gVBUyBESicdgsugU7VCQyMkxmG2ZDcbjMGhgKCFzYLMCR2TRu9Ef5oOXr/RH0jKewZUsrSj1OnLveBZ/LDDkT48HNaqWzrOhfgapkHus6vxivXYOe4Um0NNY8NgppPbEdmPvK9XDdz9glJYUHVmvZM4uQZwVlqggpomQmC1mWYbWaYbQ41uW1TcGKPbt3YnRsEkoqgMJySCsksDErbOkpXzC+FNYrMpZSEUkofDzLarEeSUlJgNVsgpJNwcj6C8yDvcEPTifRUFuOgeFRlC3RgX0hkWQOtwaimE5qUVlZiUQqhbGJSZS5Vr8EOBOT0VBbhuHRKdgKnOFn0ABGvRZZWUBuA8uZWE3dkUo9TPdf/2BKxpUJGr5MCAVVhBRRkm9tU2HWaR/slFp7bE1OAw0rylYKH/2yEsLcqdCYQr2/XKgRi9amMpaUYDTooV+kUJ0JRLPwez3IZCW4C1gCXAirzZoMZjATE7B/WzMkKYdizFhmS4AGvZ6PySn4tRHYDkj2Hd6Ypb9HmXQiH77MAixmOJrD1ZHoRh8WIRuKgipCioRlR1ISyxIJMC3R8buYRMjI5kT4/aXQml1r/mOtsH4GDzp6L46FC+x1YStDxQr22My7nKrwZcil7jORziGXy8FkEPmQ5dWYDmeQU0VYzGZEi1CczY6G9fziz0Fdxoia+2NjNgOnUcT+chZh5l/by0MR9M4kNvqwCNkwFFQRUiRpNoNE0CAnyzBA4rP/1oMCDRStBXVtu5ESHGuexWA5J5Z9KuxtXeWtFzQFtmAoBMvUaO4HV0uFVTPhNDxOO6ZngwUVrC/6uEJ+dl9GVqEoQnGK/oX8Ulqh/1N4lpDtaFQLf3xBlflprVTYtNjmf/javtsdxFR0/WdTErIZUFBFSJGw+iFVo4fFYkImEQGU9WqOKECCkfeuAg831vKRgNz95adCkiUCCxhYVollq4p1EGL+GHhf9SWCi+lIFh6XAzlJKrgYfDGJtIJILAnIWd4uYrUUReHLxIVknvRalqGSkZEUXlRfCEHOwqzM8pMgr3Lr5SJa3FrUOh7uCPxRxyxiaWoOSj54KKgipEhYETXLxvCu13y7/8bXvRSdkG+nwAcqC4VlldgrIS5QUL7CQ+Cd1Vmmaql8GYtVWNNRtlvQ59SvagmQ3ddsPIOGqjIkEjHo7o9teRIb3+O3a+A0L14rxQc2s3VRkQVVSx8X62d1824P2ptrMJsoLPOkVVMY6LmN0YEuaNRl9DFb5vIiey57yvQodxge1Bb+8N4Mn7FIyAcJBVWEFIkk5yOqjJSDWc+KXzZH3UuxybKSr5Eq6OkVNlZmudkig8GAsakASl2L7+pLZWUkZR1MJhOGhkbQUmFZNLBisSIrHF/seyyr8v2gkmXL8nVOLL5jwVSJQ0RLqYiZiQFY9QrMhkUe6/6J9aoqZDCySS9AkiS4nU6+o3JJigxRTWJkfApmiwlqIfMnVRU6NQmDEoEuF4VWTkBU0gV9s1nG7eU2Lxz3O84HEhLe6grQ8GXygUJBFSFFkpUVQNDB7XRgZGQUQm59RsesJxZMabQ6RBOJJWf/cSIrUlchFKugir1ZxzIoKfEiGIrC71x8Gx6LBfrG47A4fDAaDZiaHENrpYUHQk9yWLRoq7aiwmNacHCynAOMWh1UKY7dlRq0lwNtpQpafDKafBJiMyM4d+kWyv1OiBoNb0C6EBaXSawvgirmC/+XwJJ9LHAppB2UoCowKCFcuXINbm8ZHL4GyKJx6RuyIE/N4OL5UxjsvIChzguIT3XDoEQLCqxMOg1ebffBcD8zORRM4cJguKDHJeT9gIIqQoqEZTFUUQen04lIMAQ5FVi3YvX1wmIAl9OGodFp6HUFtAJQ5wrbi/erhs1JZvP/DHrdolmlB9dXgZ7xOPw+fz4fJKfhtuofBDY2swbba22ocgsYHhzgzT39TgO21NjgsT1e3B5JSqiu8qOjdxQ37/Wgo7MP3b1D6OkfRu/AOIxmAw7s24WY6sBIQAHbu7AQnuXi7SaWjqlY1/WclOLPmxXLL0pVYJQDuHzxPGwWM9q27EJa4yxsqLfA6vMM2L1zG7Q6E8xGPW7euouh3tswKOGCAiuXWcczVnOB683RGO5Nvv/+wCBkPkUotSSEzNVUsS1dgsYAv9uG6alJlNqqAO3qx5psFuw9NZkFDHoNjJpCFq3ymRXWP2vJawr5YmwWYbB2X4vdN1t4k5X8MmShx903mURDeRm6ewfQ0lgHm0kDm1kHrZBBd38/XxZsrq9GNCPCbtYhGJxFa7kbt0dURJP5oms2d286lIXbZceeHW3onZYgKyy4zLeNSGZVdE1IhWWTWE1VToGo1yy5/Gc3Cxgfn0JzfRVvGroYjZLG2FAfjHqgtX070mxH6DLGJcmiGYK5EuWNZTxAe6GqEecuXIKs3EZ98zZk2P0tESRXOo041ujGyZ4g//p0bxAOoxYVzsKyZYQ8qyhTRUiRzC31sGyVzWxCIs52AKbeV68vC3bY8p/ZZIJBq867jPY4Nf/+W0APBr9NhN+Uht+cQJ1PgHWJeiS2FLaclqKJtIzxUA7NjbXoG+iH15zByFA/+ocn0d5ch5LKWnRPZNE7nsgvMXpsuHK7E3UlZhh1Irx2PSxGDdKSwoOnaErBaFDBWEjGaEjBeFhBOJkPrgquNhNU3hh1sdeGBZo2o4pAMAK9yczH2yxIVXlx+mwwgLKSEmQFy5IB0Lx3I+oga4yQtWaktT4cPnwIU7MhdN+7DpMa4vVaS2kvtWJHhY1/zl6T1ztmEU6t3Q5EQjYDylQRcl86vYzdUfNIpDO80ST7W6WxvhY3zr8Hp9sPa0krVE1+V1ShZmZmNs33paur67GvIzMmeE1GXL5+F4rWjuHp5IK3lcutUDMJRCIR9PSO8HYA82GhkVJhgyinkEzEkc5KKCnxQZK06J94uHR06tQp/tGY3YZYNAqbxYCT717kWR+HzQhBEKGqCkRRQDKVRTj28HtqMujQWO2DbRfLUmnx9pnrOLC7Bbe7J/Dm2TsIRh5/Hvu31cDnMGB4sAfR2RhmJRlelxV3AzK0WgGvvXUSsqrF+ZtDkFg93TI1VXuxpcEDs0GPNy/2YyY0f9PM5/c14G4kDL/XjX987STu9U8/dnky+fC4SxxaiNkwH/ysinqcufMWVnBoT2ElUiy47O8fwMjICIz2UkyGnw6Q2IaAR5VrVPSpSYxF85m+vz0TwYcaLA9qrtZSXV0dNgudbnU90sizg4IqQoq5/MeJMFpLsWfnVty514kjnlLkNCXvm9d5OpTCjoYyXLvZiYaG0kWDKrbrj2Vi2G65xaYFskuGphLw2PXw+8pg1Cno6R+Bx+1EQ5kN/ZOxx8p5+kZmsL2pFLOzIXz4cCuMRj0vzjYatLz5KrsuW6qLJbJIprPQaEX4XBakM1nc6x6G123Dji0NeO9iD250j897THd6JvCZD+9Cz8AomuoqEY4lMBsIo8TrQHtDNTr6RhCMpXBkVx3O3Bjgw5GXQ8syVIrK+zopC6S3StxWlPtsSCXjyGTVpwKqx+9PQLlbi7MXx3Bg73Z0jmeLElAx7Kn1TWawt6UeF67cxI6qqnmDqiexbOLhKjPe7E8gnJIRzSg4M5zCc7XmVXe4J2QzouU/QorZUuE+rd4Ib1kV4okkJkcHIUrvn5lo7P1/MpDiPZbkXAYO88J/hbMZgazBpcQagC6xVMd6Gk0E07jVH8K9oQSqq6t5ECMqrBbK9tit+0ZmeSBlNOrgdRgwOTULWckhK8uQcjkewE1NBwFFgtWkgV7DvmbLVioqyrzoGQnjz79zYcGAimHB2PWOUdhtVkzNstogASVeN7KSjLPXO+BxWbGzpQKlLiMObatZ1mvIAoqaMhdmQzHksqyZ5/zLaa31fvQPTmJLYzWudo4ueH96rYA6nw437vSgsa6KL3MW2iB0Od/3UCLHi9/kTApua2GNZlk/r+M1ZhjvbyqYiudwZTy9aUbtEFJMFFQRsgZBlU6rgaz34YXnjuHmnQ6ExnugycxAkJPFbdq0QUZnkqirqcLw6CQayq0LZh3Y+yZbmtMukal67DZsaHI6h47hKGprazAdCEFJR9FSaX8wpJp99Dpt6Owfg1anRV11KfrHwrh0cwRX703gWuckLFYrSnwuVJS4UVnigcdtx9BEBN999w5u94wju0Ag86g7feMQNTrkJBkGvYg7fROYCiZRXVGKYDiBydkwLt/qxoFtlaitYHMXC1NZ4oDJoIEoajAdSSGaeHqsC1uurPQ7wMLRmXAC0fj8y9NGnYBanxZ3Ozrh87ghGBwILFHMvlITIQmtLU24cqsDpQ6RZ8cKYdWLOM6zU/mv+4JZdM5m1+QYCdlItPxHSJFI95dw2Cy3fJChh2ipxHPHDuH1t0+itmIIfn8ZyiqqkdO7oWqe3V2BoXgWfpcRFrMRs4FpVPqcfPnuSRaDFpFELt9ugueaCs9OsPqru0MRtFVXY2x8DJVWPf7ZJ/bie2/fwb5t1bhxbwDbG6swMR2CAj3u9k4inX04GqVzYAoie9OfG7zMuqsXWkV+nyyruHRrAEd3N2BsIoD2+lKcutqH7pEQ6is9OLSzGicOWPDehdv46NFW3OiaxPWuMSQXKch2283Y3lSGkYkZ+H1unL0+OO/12ur9GJ8OoszvxL2B+Zf9bGY9qjwa3Lh1D411lZA1dowF164YPJ5WEE3rUF1RgqnJSVS6SzE0KxXUCNZr1uJApQnnhvObN25MpmEziKi0U70Ref+gTBUhRa6penR8iao1QmevwkdefhEetwtd3V144803EJvogCBF+Ay59ZsRWDwsNukaiaKsrBShUAxbqq2oKzXDa9PDff9U5jLAbhIRS6SRU1mt0/KXe7KSgntDEWxpqUM4HIFFL+Lf/tRRyFIGgqiBJGggyyLC0QheOtgCq+lhM1DWdJTVObHHZcHRcgOqOSxLdLd/An6PCzOBEI7uaeBd0DsHpvGDUx28OH5bSw3udI1AyqZxbFcdzKb5AwWWYdvdVskHPDfVlOJaxxgi8cy8mawKrxWBYBQZCegfy7cmeJTbYcbhnbXo6OhGU30Ncho7piJrv7tuNirxDRiReBKx8CyqPPqC92DWOvXYVpLftMECsXMjKYRS769ebuSDjYIqQoocVOmfWBJRtGbAVo3Sxn048cIrOLxvBy5cvobJ3qtITtyAGumHJssahT5bwRWLUUZnkziwsx5nL91Eg0+LGp+Aep8G9T4BlS6R94BqqfUhLUkrDmpYlqt3LIbDu5sxFYjgTvcwLFYzIgkJ337tCmbjaTisFswEwjixtwlmY/EzH92DMxiYCMHjskMDBU01Hn4+K8CPJSWkMhIqK0rgcVoRCIRxbEftYwEew1Yu926pgqpIfLvj+GwCU4Gnm2KynYv7t1TxHXyNtRU88HqyCJ4V5LPrTE8HUFdXhYxgxvQ6BFQMO5SBGQlNjY0IBIMwCGlYjIW/lWz1G1DjzH+PWMB7aiiJ5AK7Qgl51lBQRUgRsKJbtouL0c33UyXqoGqtyBlKYPS24sSxI5iYDaOzuw+vv/EW7l4/BzXaB1FiXaufjTcYq0nLO47f6x5Fc10lFFlBLicjJ7MiadaYU8bgyBS6Bsbhs2pR5ll540d2f91DM/yjRmPA7e5JXLo9xLurX7o1iIlAnO/oYxmr5/Y2w25eXguLQnT2T8FiMWI2GEVrXSl0rC2AwIYhq1BkAZduDmEymILTYUY4GsVz+xqxrbEEu1vLsae9Eh8+1AKzHnzzgs1qx8U7w08tm7Fl4z2tlYizMUAWC3pGZzEVfDrwcllNvMarsowtI5sxe79lwXphuwpHgxKa6qrR0z+EkvtBUiFYjR1bBvSa84XuiayC00PJBz8/hDzLKKgipEj1VHNvkI8u/z2FvQnrzNC7GrD74PPYf/hFvPKRl6HTaPD66+/izuVT0KYnoBMkiIUMhNsgVqMWLZU2dHX1w+PxQtZa0RdQMRHVYDwi8o+TERG7trXh+UPbcPPeAHxWEWWeldWRlbhNGJsMwWw24/T1fgyMBx8M6mUfrneOYjqYhNNhxWwohBP7mmAtcmDFslE3O8dhsZgQDIawf0t1fgekomIqGEZ1uQs3usagqBo4rCa01HhQU2JDmdvEZxSmUqwtggST2YLT1/qRzjweCGlFEQe21cCgUxEIJwBRi66B+fuVabQaGHQijAY9r3PaCLGUArPFxt9EnJblleeyusNjNWa+nMsEkjIujKZoRyB55lGhOiFF8OiMN/3cFqdFqBo9PynsD3yDB03bPWhta8H167dx5tR78HkccLu8SMOIhGRYsh3BejLpNWirtuFuZy/qaisRSgKjI/MPzf3e2RHYrBo01FbjTmcvmhuqIcKEsUDhneb5m7ZZhylZhqwq+YDjCSywunx3GDtaKlBd4kAgGOZNM09d7UdkgV1zK9E1OI1Snx3ZnMSX/rbUlyCeyiGbzaGy3AKnzYyhiRAObi3H+FQARp0GHq8D6XQWyYyMydkYzt8cRmaeoYDbW8uh1yjIZmXYbFacuznE2zfMh2W0WFZQw2rKVpnhMelFlDi1sBo0EESBN/pkmahQPIexYHbRDvE5mWUOV/a3uUkn8lYLrIcVWwYcDkuwG0RsL6FRNuTZRUEVIUVt/MkyVcu8saCBonfx7uQ799owOtCBocEBXL/TibrqSlTVNiKcNUHh4cXGB1dlXhPGx8exo7UagwEFE4sESCwkCMdl9IwnsLW1Cd29g6itKYMKE8YLDKw0WgEmg8gDiUAo9SBDNZ9b3WNsfDMq/FbMBiJ4+XALbnSNY2A0wAOA1WL3cepyL1441AZBySGVTsLgsKOtsQq9g+NorfPxGqi6yt04f70Tx/a14U++fZb3vGINPlkbh4UOv7HSg+GxSVSU+fFP791dsJkoK3avrXDyQnGryQLNKoIqu0kDv01GX38Pn1StYVlWAchkZTgcTpS4S3kbhYWw6yuqsuLAzmXS4EiViddVsdflzlQGNr2IOtfj9WiEPCto+Y+QIsg+8ob9ZKF64T+NGuQMXpQ170V18w6cOHKQj725ee0KHEIANh3bJbbxdSc2o5YPM7ayppgFBkZsIHHnaBwtjbXo7R+F26yi0mte8nZ8yHGlHR09w7DabRidnD8jNoe9Md/oGsXoVBRejwPjE7PY0VSKE3sbVpxReRIbScNG0yiCFqIoIhaNo6bcw4vHa8qdfAlrcDwAk9GAgbEgApEkUpkcz04t1nqAjdwxGfUIx1KLdmf3OC3w2I1IJLNIZWU+h3AlWPNOj0XCrbs9fHfljh3t2NLehpaWNuzZtQ1uj4fXrC2G7YJkhfXKCnZ2zqmw67Cr9GF26uJoCjOsySghzyAKqggpgkc3L+lWM36Dza7TWBCRTAjKLlQ3bEF5eSnOX7qGwEQ/7Dyw2rhaK1YvZjFpkM1mEU/LUJfxVBPpHDrH4mhtbsTgyAScPLBavMaq1G2EKiV4cbPB7ED/6GxBj3Wzexz9oyG0NlXBZtJh/9ZqtNcXb1QQy1idvzUIrcYArVbEvd5hZDNZOMx6fOr5bSjx2vn8wmS6sB15bGegzLNYrOh98evuaC7jvbkqSj28J9ZKGpOzwN9rAe7c7cb2Lc0YCgA3BlK4OZTC3ZEUbg0mEUiImI1Ji/5f0IgqUhn5sUztSrR49Wh057NTLOnFCtfj2c1bU0jIQiioIqTY3dRXmql6ggoNIpIRVl89jh89yAOR4EQv/MY4jJr12T7/JBagRCNx+L0uTIfYqJHl3Z7VH3WPxdDcVIfB4TE4jCoqFshYsSwVGwEzMjaFsrIS9I5Fl7XMdLdvAp19k3xX4LXb/Tiysw4ep5kHMMXAel+dvTGAdFZAZamHBwNsRM7o+AT6hsb56BibqbBiebZkybJeLPOTWyRoZu0pbGYdvz7r7L7QEOalGPSAlEmgpa4csYwGsSeK3dlzSWTYst78t2ed1Ov8Oj5Uu6aqfNXtHFjQvKfciBJrviIlnVNxajDx2M8VIc8CCqoIKYJHf/mvePlvXgJSsh6zGTsOHdiHQDCC906e5SNv1juwYsFIudeEVDoBnd6IYHRlY0ZYxqprJI7mxnr0D4/BZVJQ6Xs6sGKrdayHJhtHk8yoSK8gczEyE+H1QfU1JegbmcRHj7XjQwdbUeqxoxhYkHf53gg6BmZhNZug0Wj47L2ju5sxPB6A120p6H74EhpUiKxIfIGeTT63BQ2VbgyOTsFmt+JG59iKj5vtvmMBoFarRWoFr2uJQ4vpqQmU+txQNHYE46tv4MmC6KPVJl6szoTTCs4OJxetoSNks6GgipCiF6oXv5icFamHJCuat+7Gwf07cOHKLYiZGRjE9Qms7BYddjW6kU5GEEtIELRGRJMrf2weWI3G0N7Cxr9MwWsR4LI9XpzM3kvZSqoqsmHLK3vTZhmdQCTBMy8Vfg9Gxmf5kOWju2qxo7kCxcAK0O/0TsBut2I2nMCZq31ISwoEQYVeV9heIFZ8rvL/Qxqo8xQy6XUa7GmrRCgcQW1VKR+HE0+tfHYeqy+TcxIMeu2ys43sjwarXsHk9Aycbi+mo8X7P2jQ5mcEGu4PXx6P5XB9oni7NwlZaxRUEVLkoKq4maqHFFVEJGtCRuPD4QM7cfXGHehyszCKa1vUW+I0oqnEgMHBQUTjSZSXl6NjKLLqrfyJtIyukRjam2sxMjaOxnIbD6LmsHsXNCJEth1tpeU1qsozXulMFre6x2G2WOBx2TA5E0RVqR172quKshzIlslkWeaDo1nWUqsVILL6uAIbufIZhVB5QM42ATzKoNPgyM5aTM8EYNDreRH+zDwNQZeDtTDQ6gyYnA3BaVnedlUWJ8pSCrWVJYik8s+9mOwGDY5Wmx/8X+iazaInQMOXybOBWioQUsRhyqsuVC9ARtFB1Xiwd9dWnLt4E8cObIPB4EZc0kMuctsFkzaLMqcG3QMj2NnegFAiP+T40eVOl1WHMg/LLuT/RmOXzF0aT0kYm00hnZUXDKxYPY/RoENOSvNsVeD+siJ7FsJcg88VRj6sVkfh+SqBz/Bj7RVKvLb7WZ8oyjw2bG+u4K0YVrPKxJbvcrIMnU7LdwGyu2LLVkvtnnuULCt8F92TwWpjtQ+KlEGZz4nJYJoXp692SSyalNHU4MPQyDhqarQYCRSebbIYNUgm0xAFLVKL7FJcDVZbta/CxHcCMlfHU3z4cun9mitCNivKVBGySQvVF5NVdJB1PhzatwOXrt7BvVuX4NQE4dCxpZLi1KCIkGFUYujuG0JLYx1uD8RwZzDMR8XMYd3Ca316TE2MYHJiBBPj7DSMafb1+DA02SBe3VeKcvf8DR3ZkQ5MJOAv8fNWC7UlZhj1mofBmZpfXltpnMhiMVVR80EIS3ipKiZmonjncg/cLiemA2FU+e18Jt+TcZtRr+UBTVWpc8nHYQ1GJUVE3/AkttT7YRA1YDk2ucDghy3HsZNWr3lqXIuJzTIUAJvVjNHpSP71WCV2F+F4DlqNBshJMOoKe4HZf22fTcDQ2BScbjfiqbXbodfg1qPNZ3hwvGeGkoimafgy2dwoqCJkjQrVBUWCoGTzkcEaSCs6SHofjh0/jKqKUpw5fwXjw93wGRLQF2FJ0KyVMDLcj6pyH2YiEsJP1FCxkTPsDbZvcAx7tjVix5Ym7NjSjG1tTdja2ojdW5rQUF2C81fu8Q7sNvP8WYZYKofpiIK2piqMjI6hvsz2WKaJFW+v9DXM12UJvPv5o7FmMiXh3cvd8Hs9CMfiKHFZsLOl4rHAyuOyosJrw87WctRWuBd9nGg8jbt9U2iuK8f0bAgWs57PPiz0uNkxSorMgwc2Q3GOTquBg43bEVSMTAShLVKvLWY2lkNNVRn6hkdQdr+dweLHCFR59RgeHUNpiQ+BuLrmu/N2lBpQYdc+WGI/OZREZo2yY4QUAwVVhKxFobqagyhFkAoOQSNF1+w1zipaTKes0Lvq8dyxI4iEozh39ixM2TFUmcMoMcZh1aagE3IQlpHBYnMHrdo0hsdm4Pf7MBZIPnZ5uccEr1VAd98wmhpqce5eED+6PIHXr4zjrWuTePPaJH54ZRKTUaClqQaXbnWhudIGn9PId3k9aWw2CRl6JFMZGDQ5fv+8ykhgfZvYkJ6Vpar8bgvvZp5MZngLhEfFk1m8fakLdpsdwXAUFT4btjWVP7g8HE2iub6EN/dsrV26xxVr9DkbTiMr5RCJxvPF4AUGHWz5UAMBOnabRwKxyhIHdFpW8K6DCi0mZ4v3fymSlGGxORGLJWDR5RadBJAPqAyYnhrjY3SsTj8PytYaCzYPV5l553UmlskPX15tPR8ha4WCKkKKGFSxgIq9EbD1GiWXxekzZzE1cheiFFvD11lAWtZhJmPF1h17cGj/Ntzq6MPJs5dw8vQpBEY74dVH4DPEYOS7BZd+QzJpJfT09KKxtgwDEzFe2PxYhsoCDAyPYUtrA3rG47z/1Hyu94bQPZ5GfU0Venr6UOZQ0V7r4H2OnsT6VzU11qNvcASsE4HLZmDdmyCy7Iyw/DdRFrzVlnsQjsag1en5LsAnpdISLtzqR1tTNUYmAnBYjTw7xLCsEMtw8eCowOKoy3dHcXxfK/7+Rxdht5jRV2CzUtbigM01ZLP3FPnhEpfLbuLLl2U+N272jBY1mGB3NRnJ8bE4Y2OT8NjZIMqnsZe/1q/H5NggpJyMiupajMxmi16gvhD2M8VmBJruL1FOJ2RcHmc90iiwIpsPBVWEFLFQ/UGRuqCBavLgQ8/tx7Ubd6DJRdb8dWZtF4JZE8KqDzv2HML+Q0dw7NB+HlBcuHIdf/+d7yMbHYZdl4YWEs9eaTF/BksnyEinU/B5XJgKsy7ueUa9iEqPgReutzbUomsszkfQLGYimMZkWEZjfS0CgTCmJ8axpcbBm2M+KpaUMBVKo76qFJOT03y5UFFYA0p5RZkqdhu73QSjXo+pYAyZ7PzHyfpY3e4eh8/rwmwkyQMHpqXWj/6RKTRWl/KWCYVgI2bcTjN6Bibx6Vf24eLt4cKOVRR5rRQrzGfxK+vSXlPmQl2lG3q9yJclHw1siyUYy6G2uowHnl6rZv6AyqfHQH8/dDo9KiurMTiZWXTI8lqw6PPDl+dWP/uDWXTM0o5AsvnQVgpCimCutuSxInXRAJ3Bxs/jtVXrQkBO1SGczWcdRMEEi9+OnWW12LU9ztswlPojKPG6YDAYEEtn4LJ5kJANvMkoW2hjWBKCZYlYTdNc0MXixcYKO6amp1FfU4rxUAbxVGGFwyxYYjsBG8rLEI+EMTI8gvbqKtwbjiCbUx/bDZgysCyKAq9dz9b/EE+kUVamn3fZcPGXQuUtDjRaDZTMwrvbEqkseoZn+RJcIPwwm2UxG6DTClAEYDpQWKZxe3M5Yok0HHYLrtwdRF2lBxOzS99WywrHVHasWp6UO7C1GjaTFqIiQSuoaKjy4EMHm/lg6L7RwIK7KZeLBUfBmMw3H/DdlxYNQon8fbPNnDU+PQYH+2G3mWF3l2JoJrthQ5I8Zi0OVZpxZji/FH1zMs2HL1c55s+wEbIRKFNFyCqxHWVzQdWTPap4NRAPBjZmqYL1tkrLeoSyZkTgwZ49+/h5M4Ew7nV248rla+i6ewUWaQTN9llUmoMwivkdhOx9nq168cDqfkAVjwZ5ZkfQWjAVepjBKgQLmG73hyEarHC5HRgZG8H+Vi+q/WbotSIP2iIJCamcHmUlftzu6IXZqEdTlQdeqwqzYXn9lPgSLJ+l93QYYDLo+K4+qylfoB2KJh8LqJi5GI6NjilkpWlPewVePliPv/3uaXz+E0cxOhVBpdcKp3X+nY+PPZZGRE7O8kzVjpZS5LJpyLKEqlI3BkancbNjEIFAEHXlDrxypAX1lR4Uy0RIQntLM67f7oHfpsBqFHl9VZ1fj8H+XtitFjjcpRgNZNc1Q8U2eoi5ODRSBJpsCNpsAPXmCHZ7ktAoCUDO4vxIEsECA3tC1gNlqghZy3YKQn5ZR1Wk/E6wYg2eWzZWs6NFOGeFr6oNNm0Gs9OjyGQlHN/Xhqt3evGNb78Gk1GPL3z6Reg1ZoxqcuydjfclavU7EA4FkEikUFlZyVsrrKS+h92ibyLOG316XMCNu12oLfehsskOSdZgaCaB0ZkEL1RvrqvA4PAgHBY9EvEY9re68doby9gIKLC/GkU+U+/J7qEVfgfKfDbsbKvEuxd7EE8+HSCy2ym5HH+e7N9SDmyrxYXrPfipTxzGnYEZuBw2SHIOfo8F4fjiXcHZfxuTwQiXXY+bXeMwGQ1IZIG+sRBqK0uxe2sjbIPTmAqEMTYyieZqLw/6ekcCWK1oSoYgaHDiYDtu3+vF9i1tfFh2Z1cnSr0uePxluDWU7xe1HgQ1B00uBik5i6GBAUg5CdlMBpKU473AUuksYlkvVGcVrDYnTg9I+FCTG2Yd5QjIxqP/hYQUsfHn093UBd4LqBi9hYqBNcIUBRWTU9Po6p/Avr27cLkzgLFACp965Rg+9sJe3O4axnd+eApvvncdyMTRXm1FcGaSv7GVlVfg7mB4VfU9LCjqGYshLRuxa0sLspKM4bFJ9PX1ocSqornSjvFACqrGCCmbw9h0iLcsCEXiqClbvLXBo9jCpSKwVJv6VCCWkXKoKfdAymbRWOOd//aCyGudWBF5IYEcO1a3Iz+n8PS1AaiCiNlgFNWlnnljabac6Xdb4bSb0FTjgyAo+N4713lxvaQIuHBrGMmMzAvsuwdn8Lc/uoHBiRhqqsswOR1AS40XTVXzH/tysTYFLosegWAYQ4MD6Onq4M1c2WMXY65foXgbkuQEblw+gzfefIf/j3U77KguL0Nrcx1279iKF44fxC8cr4WYCqGntxehUBBn+gPIrVflPCGLoEwVIcVsp/BU3Q/bvaZBJpWC1ioBmqX7Aa0VUZBh02UQnhnlDT0PHdiP6YwVplIv6ku38lyOSZ/ClnIJ27ZLuH7lGt48dx0aUYey0hLIghEdw5GiFUwPzyQxEUzB5zTB63WiskzF4MgEL4jeUuPF4EQUx7c14q+/8wZa6itwt2cch3bUYSoQQ2qRGqlHsR1ifOPeE+NiWNG6xazD9IwMPWuAOQ+2Q1HO5XtHLcVmMSCTy/HZf6ncDC9YT0syv48Sn5XvCH2yEShbwqstd6CtrgSTs2H+vH78pf3oGZ7kmTM2l8/jNGEwGkEknuLBZ8fANCYDMRzZUYvh8an80qhdi9no8tsbsKyqUQ+U2PUwaLM4efEOXjy4BaJOA3VwBsmsgvLyGgxOz7/My4LghoYGFAuvO0xN4L33zqKhpgw7drwK6B1QRANbjOZZX5YwlFiwa1XwhRdK8f17IXT0j/M5hleNGhyoKTzoJmQtUKaKkGIu/7GfKDnHhqPxN3JFa0F9bR3OX73N/wJn/avWlwqjRoJbn4BbE8JYfwcGBkZw+OBeRGQrZPXxgCKcNWEyZcd02om2rVvh9/h4Y8+YpC1qQPXoa8eyUrf6w7g1GIOvpAw5RUY4NINSr4W3ZPj8J1/AD967ATtrqClncHhnXYGrqOytWJy3JmprQxn6hiZRVe5F/wJLaBreHkPzoHh/Maw56Mj4NOqq/Ojsn+KPl0xlIYoaGFimcoFUV4nbhrvdw4jHk3zzQDIrI5pIw+O0oLbcBTUnoaWuDJ0DMw9uE4qmcO7mIKrL/RibmoFdm+IF5svB5v3V+kR49EkMDfagp28Q7U016JsI472LPRB0JnhKqjEwncFCvTaz2eJtvhCUDNTkGN586yTa2xpR3bILsrkSss7BM5b8jxFRC2i0bF0WqqCF1ujB860VaKkvx9T0DAaDScwk1vvni5DHUVBFSDGCKlWFoKRgkiaghjqQmroFMTHIC21r6mpRWerDjRtXoZFCRXu92VQ7NpamzBxDuSWCElMMNm0aZjEDnzGOSnMUVeYIcuF+XLl0DqfPXoRWp8XevXsQztmfCqgelVM1iMGDHdu34PKtfjgsulXPm1tKMqPg3lAUbo+f188kIwHep+lKXxQ/+ZFjuNYxiFg8hcM7a1Hucyx9hyzyYq0IcrnHKqL0Wg1qyt3ISQpiiSxmIwmeSXLbzTw7NIc1ucxkJF5Er1+kMyZbxqspdfDlJ1bEPxWO8xE3PpcV8WQa0URm3uXD/tEAbvZM4ujeNr7UmEznkM5IfNelx2HCq0fbeOBS4XPy+3lUkAVWt4axrbUOXb2DqPTqHxtGvRi3RQOnXsL1m3ehylnsbK2C22bB1bsD0OlN2L5tK3JaJ4aX6EXFBkgXJbBSVV6E/u7b72HvznaUVLdB1jrymaklOMwm7C418tYbuWwKV0fja/7/lJDF0PIfIavEWgKIShqhwCQu9XQhaMvwwbrTMyGUlnhht1jR3lKN7791ATMjffBW66DwNw1hVQGVx5DE7ds3EYvHoBM1vE6outwHs8GI6wMj0OlYj27w1gkHd2+FqjUhpRgRzul5T6ulSKoONrOX70yLhkKoK7WifyKOtcSKwjuHI2irKUUwMIPZ6Ql4vCW43hfFz/zY8/ir//MmD7h+9uP78M3vX8HIVHjB+6otcyGVSvO6qEj84c6+6nIXwtE4vB47eobyGaCaCjevT4olMzh/c5CfNzgeRGutF519Y3hxfzPevdyD9Dy9rlhNFGsSajboMBNO8s7ox3bXoW9wHC6XlbdAWOi53u6Z5P2oEqkMvF4X343od1nhtBlw404f0hmWtbLD47BgdPrxburBSBL3+mfQXF+OsdExVHnzLQ8W47FpYNNk0NU7hBP7t2E6GMTZq11orK/G9m1VmAhl0T1ZWGNPv9+PyclJVFdXYzVEOYHJ0X5YrBb4y6qR1ViX9bNR67WjpdKFwckZaPUmDASMaPAuveOSkLVAmSpCViknS5CyKQRDUZw4vAcnXvgwjhx7ER//yCvY0tKInCrj5IVb+NDx3bhxpwPjA3fyGasV/kXNAiqnPolbN2/xrt0njh7GwYMH8cLRgxA0OsTTGRw+sAuHDh7CgQOH0bp9P2ZVH2aydsRzxoICqrlHCmWNaGmo5QXMCw1FLjb2ht4xFIXT5ePHkIgFUV9ux8BUGj/56iFMB6O4ersPn31l14Pu5/NpqvFjeHwWlWUe9I087Gzutlsgywr/2DMyxc9jgY2cy6K1ruTB+zkLuIKRNHRaLWLxOJ7b1zhvxop1XjfoNbCYTZgOxnBoZy1CkQjvVRWKSrjRNbbo8xXuL1HaTAaemZsKhDA8NovSUh92b2vGjQ7WaLUEJsPTfwPf6ZlAbU0NguEITJoMLIb899ZiFFHm0qLSo+PNO3fXm3Gk1QKHNoWO3gEc3deO4YkZjEyEsHv3DiRUO+4MpzAbkwvulO7xeBAOh1fd2VynRHHzTjcfDi7pXMv/Y0NnxYttJTxbNT01idsTIWRpPiDZIBRUEbJKbPmHLZvUNzQgYyhHzlgGyVgG1VEPU+l2bN91FFVVlTh76R6eP7gVXV29GOy5BU12Nl97VTCVd0FndTD37tyGyWREZV0rJpI2TKVtmMw44aloQ0ntVt5VnZ3HCtGjkgmKql3RjzurSmId081GHYzL7hO1ciyL0zUcga+klIcdN293QE7FMTkbw6984VVkslloBBVbGtjl87OY9PnWBCmJz/9jWPau0u9AKpvhWam5iTBsh6bBoHts+Y8tI529MYBALAOr2Yh0Oo0X9jfxrNGj5gY2s9do35ZqRKNRWEwmRFM5XO8cWzJ2VqHw+i2Wpbp8px97tzfC7Xbi+6fu4a0LvXC77RgYnsDxPfUwPxFY2awGfpy72mswMjSMfQ0m7Kg1ocqpIB4YzZ9mh3Dh4gVcunIDg8OjeO7gVvQOTWAmGEVTUxM6RjMIxB5fIi2ERqOBljUrXU3GVckgGw/zbKjG6IAqrKCRpyDC7fThuW2ViMcTSKaSuDO1fi0gCHkULf8Rskpmgx6KxsA/T+QeCTwEDXu3Rk6jR13zduj1Orxz7jZeOLwVZ650IBaNoK21BVqzE6po5kXt/Dbz0AoK7Po0MvEgrtzshsPhQH1zK0IZ9rhzXdAFJOVi7y5UeRaG9QfK5fIl28WoWHHb9LCatAjFJT6eZj6sVO3OQIg30Nyx1Y+xiRnMzkxDyaVR4XdieDyAmnInX5LrHMhnnB4jsOalCp+dN1dLdXxPA6YDYVgtBoxMRpDOPnxslnFRn5jxxwKWK3eGcXR3PUx6HbJSBi8facHAeBS3e8Z5wHRsTz1KPGYEQ3EMjIzDabciFMviasdoQa+F3WJEQs3i+r1B6HV6/PBsN7oGZ3hgGY1Pw2rWw2W1IBgM8excLJWBTstaPWh4e4yOzm4YNWwAdATfee1dVJaVIiXJaG6ogs9uwLU7fWipK0djTSVkQYerdwaRymTR0NCI/qnMqmb4rSagYkvmUnQUJ89ewd6d25ET7Ss/EFGHnaUWnNWJUOQcugNZBBNZuC0bt9uWfDBRUEXIKln4lr98FigpzfMOxbbT6z2oqN3C5/C9dSYfWLG5cq+/+Q68HgccDie2tDSxP//5mJIKc5SPh+FvWYKKnJTB+St3ebaENWc0O0sRzrDluLVsJqryOYH90QhyisAzNsUIqFgwVeMzYCYQgdNiXTCoYlg8xFovTIbS2F7nQYlLw5fGnjvYjo7+KZy52oXWGi9vnnm3//HAimWP8t3sAYfNiL3t1chJEkwmHSJJCZduDz/IIt2vaYcwN1zusWNQceZaP/Zvq0GV347R8RmUuh3Qt1ViMhDnj//9d6+gpbYc5aU+dPTP4HaBswL9HivsFh0GhiJoqq/A1Y5J3Ouffuw6PSOzeG53Hcr9dvQOsFmCAlx2CyKJDC/Cf+nEYej0ejgtwNtnbmLvtkaEM6zprIJTV3vg97khG7y4PZaDnJqGlMuioqoGgzPrNxT5SYKcQiY8jLffO4cjh/bA6a+HrDWv6j4tehU1+hhS8PP/N2f7Q/jYVv+qAj9C1jSomp6exuuvv46bN2/ytXSn04kdO3bgQx/6EEpLF07DE/IsMJlMK7qd3qBCp8vPI8tCs/D9GI2oMplhNhlx8uJVnDi8C9u2bUFgNojxiQn86O2TvEaIZVaS6dSDDuxseYmViOxoa4DZWYKEbERS1UOnX9s3C6OYQXxmDFMzM6iuqsLt/gCy2dW/Czu9BszOzqLC78HdkfiSO8jYe6LXZkI6ncCb526gvtqPr/z+/+FDkj98eCvGp9h9mdHVl8bwRPDB7WLxJkhZCVazBsd3VSMUjvNeXIFwGm+dvQf5kaxUNFoKi1GHWDSGiYlJHpA8aWJiArWVXhze2cAHPvs8dlS2uHHywh18+pUDeO296/g/P7yEqcDjBeWLObijEeFwOYw6LSLhKL7zg3f5DsDKUhd2tNbA67LAabPxZq2RiI7XXLHvAYv9WGH9jXuD+Ie3bvLA1Os0oqXKie++fQmHdzXj6p0BmM1mjE6G0TXcjx1NfijpOBrry/D9d66suu6I7f5j7wmZzMM+VocOHSrglgocYhjvnTqN/bt3Ig0rhibZhoOFNx0Uwiom4JFnMZYtQVwxYGDGjq4JPWrdK/u5LiabzbbRh0A2U1DV0dGB3/zN38S7776LPXv2oK2tjQdRsVgMf/M3f4Nf+qVfwvPPP4/f/u3fRnt7+9ofNSGbrKbKpBORkhQkFgs6WHSgz9c9HT0o4q33zvJidm/tHviq0tiZi0JVZd4JfHxq6v46G8tXKVBUDZKKAaEcqzlZn7+8TWIW13r7sXdbC966OobMfFm4ZXJZ9WiqtCMayqHCb4VWb+BNMecyRqFYmo+pYTMA2Xksq9Va7YBWyKGrdxQ+twPffes6JmYi/PpvnL2Fz33sEEYnAji+twX/7w8vQcrJaKsvwytHtuHqvX4YdDpMTIfgcdkwNBbAyUtdjwVUbL5gqceJ2XAMs6HEgoXX7DZ9w9OYnAnj//fFVxAMxbClsZJny/7wL36EN8/eXvbr4XXbeCZFr9dgYHSGB1RbmytxbE8LIokkr1sKxeIocTt4Q9Cu/kleR2XUG9DRN857WFVWViGRzqJ/PIru0TAOb63DlRsdaKyr5PP6uoYC/L8Saw2RkHPISWxzxfzfy7nsHs+9agR+vYV6k7Ggih3fcpnENEYG+lDq98Fg8yFepCXrtKrnLSYwNoXr7L9HeRUuDEZQ6TTyrviEbJqg6ud+7ufwa7/2a/jWt77Ft2c/if2l8r3vfQ8///M/j/Pnz6/FcRKyqVn0Gh5UpbIKr4VhgdaC9HY4vOUo8TqQiM7C7qqHqrdARX5ILnsLC4wsPituXQj5YmSJ9V9aZUDF3tCrS6x8S39nTz9mZoKYmg0iJ7N1N4Fn5+beuturS5FltWki4LMbcfF6JyxmA5qbavHf/uffYToQe3C/M6EEugYm4XGYIcs5HNndiOv3hvH5jx/E+etdiGeySCQzcNosOHutF31D048FVEyZz4mslOWtDK52DC25my2RyqK7fwKHdzbiTvcotjVX4u9fu7Ts16S9oRzVZW4EQgleIM/+x3zkxA5UlLgxHYhiS3Ml7/zOdjD+f+9e4+exwc8sm9lY7cexfa0YHJtFShKQzmRRVurDVJjtDRWR5a0fZFT67DyLFUtm4bQaMD2VRSIjPdYlntVnscaqJW4zyjwWGPVsuLXAu9azvxFmQ2nMRlK8XcSjLw1beszPVSycCAVmIYXeoXF86IWjCOWKt6M0p+rgsLmASA88RhtUVUE0ncOd8Th2VlKmiGyioOrixYuLXs4CrU9/+tP8RMgHkUUvYjbBAiKV11XZltopp9VCoxEhSfnO65tRRtFh+/YdvEnkahj1GmytdSEaDaGrJ8h3n03PzKCmwo+pSH5gMYuoWNIjl81iZHwSVqMW8XgKXfeiOLSnHTMxAbf7I48FVHPeu9iJn/roAYSiMRza0cB7Tl2+3Y/nDrTB57bj/7x+Be+cv8c7lc+HfR9sFhPPGE1O5zNgS/nu21fxkee3427PKCIJw2MF74Xav72RHxMLji5d78PW1krc6hxFMBqH1WrE//z22zyQelJWyuFe3zhfZtzeVo3GphZU2/S43TXIM2c2kxFtjZUIhhMIRWZRW+ZBQ0UlXj97G9UVpegdfbjMZjZqsa3RB42agyRlMTgyxodq63VavgQaiiTgdzvgqbJiX3sZxmZiGJmOIRRJ88vZ7r/lBFRWIYwzF65ga3sTEoptGe09CpOSDSgvdUOaHUcqlwJ0Flwfi6HJb+Z/+BCy1qhQnZAiePQXdiIrLx1UCQbY7HYeQHiro1C1m69ZIXuD0hl96BkrvEboSexNe0utE4NDwyjzudDc1IihqSRS8Qx0xjgudUT4TjXGxIKvehfa6stx7U4vD4gqyjzoHpqCx1v2VIbp0SDj1JVuvHy4nbdOcFrNEAURf/v9S7h8Z2DJzBOrU2LBrZR7mC1bitdpRTSWgajVIB7PIJZIrWjpLxJP8nYOZrMBvYPTKPU4MDoVwuunbs0bUD0qEI7j3fP3YPHUw2bWYVdzFcamZjE5OYOsnMOB7a2YiiQhZ5J4/dQ1HN+/BVd6gxiazN+vhQVUDV6Mj0/A57FBpzOgurKSd2vPKCpMRi3qHC6YDAKGRqcxORWAKArYUe9DNKng5JXosoIqk5hBx927aKgphdNfi6SygvYJS0gqetRUlmN0/AZa3EB3jE08UHBpKILnm2guIFl7y/4zgRWpv/DCC3C73dDr9fyk0+n4R0I+qKz6hz9K8UKKuXU2bGltwdjENASpsOzIemN7D7OKjo9eWQmjToMtNU509/Sj1OdGWtHjem8A0WSWZ4V45Y7A+jyxwEaPHfUuTE9O4fyNfmxpa4akcSCUNcBgMGNoaBhbat0wGuZ/I2b1SOFEGk6HGQ6bBZKk4NLt/iUDKtZ0s6m2FDOhfHbI7bLyGqulzIbjiEQTfBfemWvdvJnocrEMmd9t48t7EzNBOKxmvH72Jv7+hxcwObu8/xNsie9qxxS8Ph8qy71IJFKIZbK41TMLi82O/TubMBWKIZ3O8aXpCp8Vu5r8GBmbhN/rRiqnR994AqdvjuJm7wzu9s/iSsckLtybxPl7MxCNdtTXVfNM19j4LBKxMKq8Jghq4f83WF1cKpVAqc+DpLJWO1cFyNAhlZawy5OGTsh/X3pmkpiKFW9WISFFC6p+6qd+CkeOHMGpU6d4ATs7dXZ28o+EfFA9lqnKFPBGI2qgai3QsgGxcmbTLgGuhsumx9j4OOqrSpATDOgejUG6v+OMl5ypKm96ubXOheYSE/oGh1Ba4kRdXS0udwXRORLFvcEwZNHE206MjY/i48/t4PVV82EzCudexvM3+go6RhbclfocsJgM0LC6r1IXXj2+nS9/LYYVPrPAKhhmS2EPR+Ash81q5OOMWPE7WwJ87eQN3O4ag/JowdMyJDI59AyHeN3TlpZq3LzXj9ZaN1KZHLKygmRKgs9lxtEdFaj2GdE/OIzyEg9mojncGwhgJpx6qoA9nZURjmVwp28Wr18YwNWuWfh8fl5rl0jG0VrnKzA0UqEVZN7vTGdYy1YgIrIwo7amEu+8/R52ONjmj/xzOjew+u7vhBQ9qGKzntguv61bt6KhoeGxEyEfVI9mqhbdAfgorRlOtwu37nRBSE2/7wIrq1kLn9OKeCKF2UjmsQyYqrKMAptFZ0A8FsHI5DRqqysxFpRxg2ez8jVK7D2wbywKgb1WDisvOn/1+LZ5M1ZsyY8tp0XjyYKH6vrdVuhENsw4g3RKgsdphcthgs+9eGEzm/Ur52S+c3ElAUJNuQe1ZV7c7hrGif0t+N5bV3G3d/FxNoUocZl51k0QdKitKsfQ8Aii4Vlcut6F1jo/HGYBg0OjSCZTaKirwmQ4+2A5sBDBWBrn7oxBa7SiuqocZrOFB8ZL0Qs5RCJByLKKjMIygWu3Gy+umFBZ1wyPywpLbAjO+4nHmXgW3TP51ieEbJqg6gtf+AL+9m//dm2OhpD3SU1VIVSDCwcOHsL07CzGh7sAVlj7PqHVCChzWzA0Po2aqnKE448svSgqr83RCvl6F63RBp+/DN1jcYzOsIDo8ftiX7Ihy7LAAiszpGwOr57YzrNLjz2mlgVr+XYBAuugWkCW6sieZnQPTaKyzIvzN3v4W71G0KC9sXzRppEake1OFPjyYS63/OXRH//wPpy91sXrx/7hjSv4x7euYbUMOg3cDiPiiSTSsojhqThO7G/n9V6vntiFc9d7MDUdREtTDQ/or/cEMDL1dOH/Utj351bvDEJxFeOziQVbLjx2bJoMOrt7sW93O2LyWveNEpGRDfC4PZiYHMXBMuXBrsVLQ1GaC0g2V1D1la98hfes2rJlC6+tevREyAeVQSs86IVTUE0VI2oBvQt1LOiYnQGU90/NR7nHjFAohIoSD4am4w+W/R5keZR8/6NwXMLARAy3+oK8N9VC2Hti33gUE7MRmEx6SJksD6zYTjV+n4KA1royvhzH+lSxtgdLqShxweO0QKvV4F7PGO50jyMSz2AmFOHtFQ7ubFgwsMqfrfKPy12u87mtOLK7GWPTIdRX+vH9d2+gGJw2A19iYzMhJ2YTPON2+e4gdDoTpsISHC4/FJ0Vp27k66biBbxGC2HPmbVZYK0aCqFheUk5B4vJDFld+114kqpFU1MzZmYjKNFGUXt/GDjbFHF9dPmBJCFrFlT95E/+JOrq6vBv/s2/wc/8zM88diLkg4q9+c5lq1imquDaDVEHk9WG2WAYghTLr3c941gWqtxj4kX4TpcLI1MPa47mitJj8SQkReDLdCzgKuRZs5fmvYtdGJsMw24zQcpm8crRrShx2+G0m9BQWwLWNimezGImuPQbJ1viU2QZteVe3Okd5Y03Xzt5k2+6YbsItzZV8M7m86ku9yKTkXih+U9//BC2t1QX9NqwerB//dMv4Z/evoodLTV4+8I9JFMPl0ZXo7HShf7hSV4I7rUbEQ4GefTX0lCBsekwJoMJdA4GkS6k5q/I2IxClpUU+W7B4rZRWGgQuKBlNWus55aMAzX2B73jbk/EEU4tvwUGIWvSUuHGjRsIBAK024+QeXpVRdJATlGRyakw6gqoG9GaUFZWiRs3byMVDcBoLgeEZ7vTSanTCFlKwe20YyaaRfp+y4S5JSodVOh1GmRZfc0ydxayYPXs9R4c17aghAVFioovfvoocjkFWxvK0aUReAalkOwRG/XCmleycS3J+1kbFkydudKFT7y4C8FIHHu31mF0khV/q48F0M21pRAh8p2CvcPT2L+9Hre62Fy+xX3yhT2QMjIvhDeb9Pi71y6gGNjrWuK2YGpChdtpweAo6ySvxZaGCly53Qur1c5fo43C5gKwmEZVxfV7TDE/PVNQVTiMGmwvt+H6aJQH8qzT+itt3nU7FvLBsezf3seOHcO9e/ewc+fOtTkiQt4ndVVGPmh5CYIIVWeBzWJBTkqwdZX1+EN+zbBsQEOFHXc7e7F7WwtO3Z587HI2+sRkFKHXGxCNSysa0MwCJjZq5vjeZtRVeTE9G+U1XKNTQT4Xz6QvrP8Ri5PYG6xeJz62229sOoJILMXrq1hBuZY1aX2ibqqq1M0bd37r++fwH/71p3DpVh/+5WefhyoI0PBnxVpdqhgZn8WNjiE+Yub4vhYc2duM1969jpeP7cD/89c/WlErBqbEY+d9vNiOxbpyO+rLXHx+5K72GtzsGIBGq4XX68bYVBhuhxWSqsNEYHWz9VaDvxrq+iZiRZ0Vfp8f5y7fxJHjHuwoK0f3dIL/bA6H0hgJpVHl2nz94cgHLKhiS38vv/wyfuzHfgwlJSWPXcZ2BRLyQfXkDkCPpcAbaoxwu13oGxjFTn8LVK0Pmwl7VmU+C5JpCaFFev2w+qK2GgdGxsbhdjswMBVD9onxNmVuE8YnAzAZDRiPsFEqK8MyR6evdmNoPIBSrwM6HSsur+TLfj2D0wXdR4C3QhAwPh3iBeNz8wTZfXcPTqK9vgyCqqCuyofugYfB4faWSp7ZMup1+NLnX8Frp24im8nxgFFh2SCRBX7suQkoL3Fj77Z6+L022MxmfO/ta3jpyFb83x9d5K0UlsvlsODYnlZUlrLnrIPdbEJpqRnpbAwDQxNQZAU6rQ450YCekRBaq6zQikZ0jq2s7UMxaFgrBSkDSVaRU9cvCysY3Thw+DjOnnwTd25ewfYDL+BAjQPv9OSHbp8fjKDcYVh8pBQhy7Tsv4mTySQ++tGP8snyIyMjj52W48Mf/jB8Ph9+53d+h3/93nvvoaysDM899xw/Xb16lZ8fDAbxsY99jGfIvvSlL1GfEbJpWR7poh5fzrKW3o72tiaMjE1ByG22IloFu5s9aCwxYE+Tm8/wWwi7zG4UeZ2S1+PhBehPYk0nWTG51+vBLFsrXc2RKSqffXfhZh8u3eznncjD8TSkBTqvP2lkPMgHEYejSexoq4bfY39w2b3ecVSUejAyFcKWhvIH5+9orcLW5nL0j84gFE3gG//3XcQSaVgsBphNBl4zZTYaYDHp4XaYeRAUjCQQj6fx1tnbvE6L9bW6cntgWc+VzftrrivFT768D1aLHpFEGrUVPmj1IqZmghiZmMGxQ1vh9XkgCXp09AdQVWLH6MQsBFHL5/htFIsmhQuXb2L39lYk5PXLDAlsh6bJi6qKckQjISjZBBq8JpTa8rtGWV3V3cn4uh0P+WBY9p8Nf/EXf1GUB/7GN76Bt956C6Ojow/OY8Han/3Znz12vd/7vd/DZz/7Wfyzf/bP8MUvfhGvv/46XnnllaIcAyEb2lV9jqCBIOp4nRGW0aF6PVjELEQljSs3BrB3eyOq/Gb0jc//RuR3mSDLWT4LNJKUYNZrEU8/zEY5LDqouSxfapsIJvMz/4qFdWYXxXzWocA1JrYD8eyVHrx4uB2dfWN4+cgWvH7mLmaCUaQzOf4np9tm5+NbPHYHaqtdaK0r5TvKHFYj/uH1y3xUzGKqyjz48Q/twdRsFJ94YTcu3x7A0PgMPvWhPfje21eX3KXIiv4bqktwbG8LD9TYvL/aCj+fp9g9NAFVkbF/93ZEEjlcuhPgY2myWZnXL/mcBgQDgCxoEH20pcW6UWEQs7CJSahKDk63GzPZ9Z28odHqUVJRiTMXrmJPPASzpRSH6xz4x1szfE7n1ZEYGr1mmGkuINmooKq/v/+p81g2iQU+fX2FdTFmKisrnzqPBUwsI8XqtVgwZTKZcPLkSXz5y1/ml3/84x/nXy8UVGUyGX6aE42ufGYZIevRq+oh8an+TBtNgAKLJo7e4Ul87KX9eOfCXZSV+FBdYuU9kB5V7jXDYxHRMziBnVsaEYmlsaXWhnRORO9oBMl0Dk0VdvQPTaCqshQdIw9vzxZffE4jSlwm/sVMOI2pUGr59Tf3b8CKkws1OD6LCzd6eS3STCCCV45uwdmr/fjCyx/Bz534ODy2/Ly4//p5IBgP4Y3rp3Cu+xq+/f3TSwZUzHQgAkmW+Y7E01e70DM4hcoyD1LpDI7sbsEbZ28vevvDu5rQ1lDOC+jZs3JYTfjuW1dxaFcDz36xruw/PDeIjKw+KM5ny7BN1W4Eg1GY9AaMTsdWVLu2OgpsmhQmRvtwY3gIw2PTSJ+6imjWyFcb2O9/9vudrVawZcy1wv5YMZhdKCvxIhkNwODNwWs1otlvRtd0gu9IvDwcxYnG+Xd5ErLmQVVjYyPf/fLkbphPf/rTWI09e/agp6cHRqMR/+E//Af8/u//Pu+HxQI2p9PJr8M+sq8X8vWvfx1f+9rXVnUchKyUWSeyvUb8L+CCu6o/WrDObqLmNk1ndYsmjY6uHtSU+3ClO4CGump09gygvakWgbDmwTieCp8ZJTYNugdG0NZcj/7JODxWDQaGxniR96H2WgSirHBf4S0PJFmDaEJCQ7kNFV4r7BYtZgMRDI+N8WyT1+mA1+5Cz1gEmSdqshbCXndWdM5+Ly1vFImKyckxTDlyaKyrhtNcgUv//T/BoNXz7+OjnBYHPnv0E/jE/g+jqzOINy4vvXOv1Mt+dwlw2c3o6B3HW+fv4N/9s5d5A9OtLZWLBlWsB5dBr+Vd5NnSZO/QFM7f7EUgFIfPZeUdw9+72IGtuw4+djufywS3RYPJmSB8fj86u5dfu7VSGuSgFWWYhAwfXZZKJnD80F4oGhOiOQsvmGfDq1m5SDgcRm9vL//dbzabF222uhqi3sJbe3T1D+BQeSNUbTn219gxEEjx8T3d00m0l1rgs9L8WrIBQZXyRL1CJBLBH/7hH/JGf6thsz0cC8F6Xn31q1/ln7tcLv4YLKBiH9kg54Ww2/zKr/zKY5mqqqqqVR0XIYViS08mnYikJC87U6XqrHDYLejrH/z/s/cfYHLl53kn+p5TOeeqruqcAxo5AwNgZjic4TBIFCWLXEqiZElc2VzT19K1pMu7TrS1kiz7OsjXq9XKlCju0rJy5AyH5AQMBjk3gM45V3flHM/Z5/+vBtANdDc6VDcawPfDU0+Frjp16tTBOW994f1Qv+vxKO7T6NZSyBlMTM/zLrOu7nkkM1o01vjgnwugymND33iUR6jcJiVGJqfR0dqAvokEN4RMWrSoqaqGQQvc6h6CVqNBTUcVci4T4tkCmqosUEgp9PTPcjsArUaNfbuaeZSlq2cEOm0OB5rtCMbyGJ1NPNEFWxaYEacAQRDXZKdg0cn4ieMF/MKreTS62fNHAI0HsuMfltrw+cBn4bExOAytSo23fvM/4ZP/n3/yRGHV3lQJURBQyBfRPzrD1617cAqVLhsvKj+0u37F+qp0JofRyQAC4QTePncb4ejDESuXbg/yQvlkOovO/Uv3wdZqB2ZmplFf68OVnjlkF1labCUuqw46KYipiSluu6PR6rH34GEEijrI0sNTDYtMNTQ0PDhGM5selmGoq6tDTU0NlNzLqnwIagv2HzyGs2ffx40rH2H//v1QG7w4UG3i1gpMPF8YieKHOp1bJuyIF4dNN29bLBb8i3/xLzY9uoYJpvu89957aG1t5bfPnDmDt956i99m1+z+SrBaDrPZvORCENuJQVP6L5XOS+uqGZJVFrS11GJuLgAUd8a4GknU4cTJlzAwFeOfZS6Sgc3O/I5yaPSZUeXSw21RYHBkHM0NtegeiyGazPE0Jkvh3RgIoWs4joa6eh5ZuXFnEGMTszjUbIfXJCEajWNPRxO8ldWQ1Ba8e2MG378xA4fLC41Wg96+ISAfwyv7KnBmrxe76mywmpYfccKEC49U8R99q2/3j3UU0PdvU/jNz+dQ71x4rmAE7P92YVmrHxZZNI2dfP/8X/9bWIzGFZ/HRt1U++y8ED4US2F2obvwWtcwIMgYmZzDvrZqHNmz8tzUoYk53O4dXyKoGMyKgQmqR/E4jJClHBepoXgOseT21FJV2PVorjLjo/NXoBRkNDc1om3XXiSKRjZKecXXsWP0yZMncfz4cR7BunTp0pISjnIVrIvmKpw5fYbPofyLv/pbzI3cQputCKuulHr0x7MYDOyM/3fEs01ZfhLcuHGDh3DXw5e//GVcuHCB/we6du0at2n4/d//fR4Gdjqd/DbjV37lV/ClL30Jv/M7v4M9e/bw5xHETsWoVmAepU4rlgI0a9c4kkMQoVAZkM6kIRTYCXRjg3rLhQQRyYIGgqjGXLjUpceiLA6TFrM6Jbw2JaIOFXpGptDWwiJUMSTSSy0S2CeIJPO42jePXbVW7Gmr451q3/3gOuw2MzrbG/DBzdnHolB3R0PwOQ1obW1GNp3EzbsDPA3GnvbJM3twu3eCd7ONTwf5nL/7Bd0KQYCoUqya/mOC6s+/muURMd5Jf38T6z/NevB5pGstMGGl12rx0298Cr/953/82N/NRh3OHGnnUaYarx3/5x+/j0yutF9E4ik+muaHXt3PBeinzuxFMBrH0Njm0nRuux4NPhPGx6dQW1OJm/3z63o92xRKJbM0FfgoIbaNsjlpyXBqg1bJC+aZiGVjmQSFAIteDaNOgZHxGXzh7/0IoLHzMTHxomLN+zCrr2I/pNmx//z58zh69CgMhrV6kjwZkY2EMtfg1CufQCo4hrffu4DXtDocrWzEO4Ol7+XyWJSPs1ExV1iC2E7zz8Uh0nQ6jTt37qCjowOnT59+8PiHH3646nJ+7/d+77HHvvKVrzz2mMPhwHe+8531riZBPDVX9cW2CmsWVaISFoeLj0qJBv1QQoMCtq6Ad3XYSVSGxE6IMhuMrIXXZYRJo0QiEUcskca9/ikEojkeobo3ygTVKnP7ZGB0No46jxORRBqVPica66rxvWuTy6b12ExAVgg/NZ/kvlb19XUw6VQIR+OYm/PjS589iYHRWbz14R1Mz5UMLVkZGuvmAxNZK6RwWMrv2/+gJKgeO28af3xDm+lXvvhT+MN3/gaCyAxCC1ArlTiytwGtdV6+nUx6Dbd8YLYLi2FF7j+4cA+/8f/+PG73jePnf+wV/NY3/o4vkwkWVi91sKMOPo+NC7j7Jfgs2nX59iAveF+y+joV2qqtGJmY4gOse8ciq34nj8IEUmejE06LFho1G2goIJUtcCEbiKS5Oznr5jTolCjms1zEFopFLplS2RzGJ8JoqKtGQeNCQd74fsuO94cOHcKVK1e4tU4503GiQgnR5IVRbcSrZ4AfvHsOn3pDRLXBjvGEEqlcaS7gkVpL2d6TePFYt6j6+Z//+a1ZE4J4kTsAWWhA68LeznZcvXEbLbv2IlZQPZWOP5MyA6GYgqDQQoIEt1nE1MQ41Ep2IpVxYE87/MEMCoosuoYiSK/hc2o0SuSzeUxOB/CJj53A31wYR76wepqOpRwnAyl+YTRWmrjQePvsLbx6tBOHdtfhO+93cTHFI1UsLadgBf/L11+xGiq9ZiFCtRjRAijXX3vJxE6lw4Nf+fkfRiKd4ik9h8WEuVAUiWQGHqcFPUPTuHhzcNnXJzNZXgMVS6Sg16nwj3/yDZ4CY9GyolTE9HyEe1yxgc9M3DLRJhVlvHaiE001Fbhws/+B83tbrR2BYAg1Xg9GZhOYjyxNF64GaybY0+RCKhHFZDICg45FKAU+2zCXZ0OQWQQPyGWSmPMnUVNdAYVC5Nuc1T8pVSroDSbcGwliz0ub32dZSpDV0I6MjDyovSonosYER1U7jh9L4TvvvAtfXRNEZQeva2RzAds8Bpi1z/aoKOLpse4956d/+qe3Zk0I4jmLVK27A1BphK+mATfv9EDIRqFUarfVgfr+4FuFIOHCpSvci0mpUsI/H8SBzmYuguaiGZ6ySy7yn1oLbO6cRqvkgiGfK3IxsZ4hNSySYtCoMDIRwMvH2vlIGjaO5vThFnx4tZ9Hw+wWA9RqBYwGHXqGZrhj+sMxMDIvSl82qyrosRlUCiUsZh2CoThudI+gvsqNSo8NoUgKNrMRHocJs4HYkrSkVqPCK0fa8fa5LrTWVyCaSHOX9vviMJ7OwGUzIxpjvlMs4iRwMehxmTE+HYDbYcKPvXEEb394G7saXJDyaQiCDK1Gh2IhwYvGWcSLdbdF49klKbxHDVv3t3p4YbmKjbZxOxGMpCEXZZhNRjj5CB+RpwWLsgyDOY/xQAKZTIGng4vMJV2SkM4WH6RiywGz1WEG0Mxkuq2tDeVG1FhQ2XAAn3O78YP3z8JhM2NOroKs0vPi9dfbHGV/T+LFYE1H7N/+7d/GL/zCL/BC8JVgtVG/+7u/i3/8j/9xOdePIJ65mqoNGYAymFWJ2oGDe9tx/dY97NtvRrhg3NbaqqIsIlXU4KWXjiMUmEOxUIQvlcf7t2aQWe/nWQQ7AbPByjWVTkzN+FHlMmJwau0+ck3VFkTCQT7kmAkUnn7K5/lQ5U+9vAeDo/M8MtR9aYrXM/383zuN+UgC3QNTuHhrCDa9vNDltwzy2qM6y5HJ5uAPB2HQa3HiQDNS6TziCSZymH1EHp9/8xhmAhF8dL0fU/5Sl3R7gxd2qwkqtRLnrvVhfCYEq5nVEMlcALFuQTbGhrm2L8brsuKV4+1wOcwYnZjDL/3sm1BrFQiG8miudSOWymFXrXlhriH7vkSIajWSyRzPjE4H2PZLcG3JBOiBVjemZ2ZhNRmh0Ohw+e4UisVSlJChUyt5dxy/K0lQKBQw6FTQqBVwWHRIpvMYm42VVVAxWNqP1emy+irWxMQaosqNQmeFqDHg5TMK/NV33kbcJMFoq8BIAJiMGFBlpbmAxBaJqtnZWe5P9clPfpJ337GCQmaBEI/H0d/fz0fMvP3227ygnCBeZJbO/9tAK7vKAE9VE9KXb2JudgI2Tx0SRd02CisBWUmFrGSFymrgB4iuD+7xtN9m0LF6rFQeDqsFI1MBdLS5MDGfRHYN20ivVaLKocP1mQlo1Gr85fcvQadR4ZOnd3PzRrNBh8++cQATs0Ec6KjjM+au3BmCXJTQWO3mEZvJ8YGV30CKAoUJQFFZSsOuESZaArEQugaH4XHZcKdvEn/xvau8OJ2l6Xa3VvN5hKFYkntOvXlmL3/O7Z5R7l/FIk9OqxF/8Kd9SGef3KXH0nLMjZ7NGWyu8eD43ha889FtLkBsFhOPdrG5zyzSxWCRsVAkwtN4TLylMwW0VbtwcrcPuUIRNosWQ8OT2NtUUfIAjKXhtlTzKOR8JAurWY1iQcKdoQBfVk2FBbVuE7K5DNRqkftmOZwubolRblHFYJ+LRam6urpw7NixLTEJ5eag9hr80Cc/jr8514XbYxnU1dXi/KCAHztQRXMBia0RVb/+67/O/Z+++c1v8vEyrDCdGbcxDynWkcfEFnsOKzIkiBcZlULg3UPsZL/u9B+DndR1Hhw7egSXL19DAwRYPfVIFjXb3A0oIC+XzBA3K6iYKGqoMKB/eBy72+rQVKfC2MQ0fHYTr/9ZDZae6qy1oKtnEC31VfjeB5dweE8DjnTWw2TQ8noqNkQ5GIyWTvw+J/73P3qPp9RYsThLE1a6bfDYmEXLjZXfKPEngOUX1/W5mI8Vc1hnFgy//6dnua/UYs7f6MfkbJA7p7ucRswH4zh1qIW7pDutBj6/j9WaFaTHhWVVhR21PidPuzGRxEQZe0ynUXOH9ls9Y6ivdvOI0esv7cN4IIPesRAfYM2iSgL/yiR4XRZUevX8O2DF+f2jU5idC3HB4rTocHdgHAc66jE+OwpJEqBQgovChioXDDqZi8Of/lQnpucTmJyZw8j4BNwuG8S8AnVVFZgOZpDMbN1cQdYN2N7eziNWzc3NqKhg9VxrbP5YI6LKAJ2zBT/2mh7j3+lCX/8g6mqr0T2lw+5qZ1nfi3j+Ua5n5/6n//Sf8gtBEMvDTlasriqSZqKqyE/06+5gUmgQK1pw9OhhnDt/Ee0KEVZnDVJFFTemlLm93LNjUuhz6DEzN4eO5moMTsVR7zMjmwugslKHUX9i1XE0VqMahVwKTdVu2O0G1FU6oVerEIjEEIun4HSaMDoVxK9++ZP4T3/4Fj7zsQPwB+KYnovictcI3jjZiVyhAJfdjXDWCIsqwV3dHyP1d4D5H7KSej6LcS1RKkkq4n988A7evXiHd20ux9h0EBOzF+Fz2/Cx4x0lvylmVCoCqXQWLx1owb/66o9iaNzPU5rse9VrVLxQnDmpsyHNuXwRCgE84sWsJVi9k0Gv44Opq70uvPVRDxrrfEimCph7pEB9OvjwPosoVVeYYbOYYTNooddJaKmrhMliRyDJUrEyFCoRLfV2qBUyfC4j/vS7l5FIpXna0O20oq62CpOBBE9vprL5bfHBYueew4cP8zFoY2NjOHLkSNkNQkWlhlsu/MQrAv7k2jT3s5oIJUlUEeuGWhwIYgs6ACPpAq9LyRRk6FTrF0ASFEgUTTh14hguXb6CukwCVrMRer0OosaIVIGNUVEhJytQ3OZi9vWgVAiosLM0U5adsjETysJlK4KbBBTz3Aognlo50qFSirCZlBgamcHY9BxMei1PNbltZl4E3jsyiZcONOFWzygCISamwmiodmJgbI4Xfn/nbBf+/o++xIXKB6PV+GxLz/JvJCeA0K8Cjv9UGmq9irDitUoy8H9/9KcYnphdUVA9eD7rYpwN4c/fuYaORh+aaz2ocFpQ53Ph23/7Efa21vLn8fFfkoRkJsftCqrcVh65ZM7r8kK34PW7ozzNyWqzWBE+i8z9v37+RzE8Oo32Oh/iPTmk2TDoZWDO6oMTYd7t99IeH/q7J9FUV413r44hvsh+gQ1rZsO9T6jUaGuowsHdTRD7Axj3RzHZN4XCUxhSyTyrWFZkenqa+xuy6BUTW+W1XFBBMPigtwEGuQijbnmjWYJYjZ17NCaI56CuinlVsdE1G6EAJeKyGceOHMLw8CAS0THc6R3FrpYa6PRmSKIKNVWVUGoMvEswWVQteATtjCgW6/DrrLNheHQSBr0BgXien5Dnwim4rBbIUpGLrtWwmzQIhSMwGjWora3Fv//dP+MO5Ux4vHGiE6ICpUiUxoxf/vlP4y/euY4jexowMhng4ouN1WLvwFJzau8ZZIt9UCukx20VGNlLQPCfLDira0uNgotqrO6P6MoW8vij83+Cv7twHif3N3PR1Dcy88TtkUhlcOXOMK7eHUFrnQe/+ctfxOUuJU4eaMFcOM4FAktnypLMndR/cP4u97pi0U5WvJ7PF5FnRVOLYJ2Aw9MxVFbYkUzG0OCzcGuD1bAY1Cjks3DazJiPZpYIKkYmV+SXaCyLRDqHSX8SH96awE7A5/Nxo1AWtUomk3y0TTmZS+QhKktpb4+1fOajxIsDiSqC2GJbBdcmjs0sChWHFa3NDbh85TqO7W/lbuRsMC0bU3L+8jXeCs9O/gf3tEHU25Aq6rmj9dMUVwqFgI4aNgB9Hhq1Ciq9BX0TpTEtzFCSBRiYoGJWCavBUkzNXjsXaPdGotwqYXHN0o+8fhCjk/O42zfF39Ni0nO7AoNewz2cWuoquBjK5Yr4/b++iYHG3fjHx2/zuqMVhdXspyDpPwXB8HlA9dC/amR2Bv/H3/w5vv3uOxCEPD5xag+vP/rYiQ4k0llMza487H0xTCRptRrc6RuD3azHO+e7cP7GAK52DWEjTAeSaKm2Y2ZkFG1NDegbC60aTWIeUywVqFZq0TuxcucjE3lcSO4Mjf4AVsvLDELXNzh7bbBxNffxmGjAMrF+SFQRxBbaKiSzmx9mK4oSZufmYTIa4Wvcg2RBBUFQw2rN4UxNE9RiAelkApdudEOQJXTuaoPD5kCmqEG6qOEjZ7YTVgfVWmXG5PQsLyo2WR24OxJ+MOiYpadUGj3GpvzwuSswH1151hsrkg/GUhBk8bFtOT0f5dEbVujdVOfG5a4huJ1mmAw6buNuNetxdG8Tr7GqcFtw6dYQPrxSQN+IB/+/vzcHraq0PovFFQ9GCQmkgn+ML/5vf4VbE3YYdXpu7hmKP7SAYFGS752/g5//8Zd5F9y+tpo1i6r7wiYYTqCjqZqLw32t1SgUirjZPYr1ki9I6J8IwWG1Yto/j91NTtweDKw4WLqh0gqNUkYyK6GIlZspMrnCQpOCBJNezQdl7yTKPfyYiTR/vPQZtUoFLGQASmyHqPrFX/xFbgDKzNkIgniSq/rmW80FNii4mIfJpEeqqEWOFVPLQB5KpBfOc0qlBSdO2pEIz+Nubx9/zGwwYu/uVj6/L1NkNVp6FOTydk49Sq3HBJdFwPjkJPQ6HbRGC+4Nh0o+RwvEknkoVVouBipsenQhsqwNKDtleiw6DI+NoLWpHolUyeNpMXcHplDnc/BU36de3o/h8dkHvkqvHGxBOBKF22HGla4RHrli/F9n8/ibKzp88XgBv/gm4LM8FAsjAQH/x3sqfPuiErE0W4PYEjG1GFYnlc3keaTQbll5sPJyzMyFIYsCrvewdG4lLt0cxEsHWWdgI9KZkqs6+xxM8GVzBe7MfrNnbJGZ6VIm5hKocHqRi4VgNomwGTUIxpaOxmFUu0xoqTbh3OV7eOX4XtwYXNlqYmQ6gjN7a3Cvfwx1XivuDK1vluCzRjRdQHZhbBKLUpVbtBEvBusWVcViEW+88QZcLhd+6qd+Cj/xEz+BqqqqrVk7gngO5v+VA1Ybzdvk2XF+GQXCaqpCOSNURi2OHnNByjKbgTm8f+4Kb8uXZRGHDx1ESrDxWq2toNZjhEVXxOj4PJpqq8AyKT1jkSWCin+Wha40g1GLSCwGt00L/8LQ5iUIgNWsgkmnBQtSLTcO51bvOE4fbsbQqB+SVECt14F4Osf9qeqrnZiYCSEYTuJm99iS10XTAn7nPRWuzdXicLsTHrsWf/NBL673BdaVNp0NRrnoqXCauTHnzHxpFuGTYDMLFUw4SRKCoQQXZcwBXqdV8S5AUSFwOwNRVEAUC9i/qw51VS68d+keQpGlhqAMFpWa8EdwqMXFC9u1msejkz6nETUePW7dHUVTbQVu9o6ivdaO633+B2afS7YR+wIFBff5sprUPGXI140NUuap2ZKr+vPC/SgVg1J/xEZZ99GVuav/x//4H7nZ57e//W382q/9Gp8ozow/P/e5z8FoXN8vNoJ43tCrxVInlyyv31V9BUoO2cxQ4UneUiqE80pA1MPoseMlXwOUgoRgYB4fXbyCl04cQVKwlb1jsNptgEUrYWLKj+bGevRNxhBJ5la0S2DDkk/vqcT1rl50trcgGMs+5ofFBviy0SssepBaYSwOK9y+NzADl9WA5toKFAoyKlw2pA/l0T04xb2d/vb926usuQCj2YVr/dOQFaz4bfUi70e5cHMArx3vxNh0iFsm/Pe/u7hmocHm6jES6Qz+7v2bOHmwGV6nueSCLshc6LBgCRtJM+0Pw2zQ4kffOIwPr/Ty7kYmTzUaFSqdBoTjGbhtBqgEAaFkGu3VTvjDkxBlPjaQCyqfU4f+kQm0N9chzWYJ5lOQinH80EtNKLAvSpYhspl+XMTLvAPRatRArRDRVGmCSa/ghqpsNE2uICOVlXB7cJ53FT4PzC4WVWaqpyI2xoaOrKxO4tOf/jS/3Lt3D1/84hfxMz/zM/jKV76CL3zhC/j617+OysrKDa4SQTwdyvmDwGZMIpEtoADFhpZrt9sf3FbLCaTnBSjUWpgtFujXOauOnTBdBheO6nS4fqsLp04cR0FjhSSs7cTBotKr4bSoYNPkMTA8gX17OjE4m4ZSZ4HzCR3psayKG0hmczk01ngRSiztQmurMqB/aBidbfUYnJf4eng8nseWMx1Mo7HOi/GZMCZn5lFZ4UA4lkJzXTXO3x6BQm2Ax/N4t0BLrQu7mipwb2gG1b4KDE0nll3+coRCpfopfyiNuXCSR5oqXFbs6WjA6OTahJnJoOdCWaPVIC8r8MG1YX55FOZN9frJXXDZjJgLRvGTnz3NBTury2LGpkxEajVqZAtFXL3Vj0g8iddPVsNs0pRSoUUZ6UwGfcPT6Gxt4g0DTPDua3Ihk4riXv8It1Bg42mUfGi2xBsDmDQcGitCLhRx8VoPrDYrF3xsnXPZPO8QfON4A8ZnExicjPDieDZkeqewXpPQ+WSBp135jEWzlm9fglgvG9prYrEYd1Z/5ZVXcPr0aR6pOnfuHHp6evgJ5M0339zIYgniuStWzxSK3F19w8gSlFIcvUMTqKjwQcIGRnWwwbqCCRZ3A3Z3tOC9s+egzM1BlMtTeOy1aTE2MYUThzowPJtBJre2SM1cLAujyYR0Kgm7aenvO6NWAY2Y53YJeVmDeGrlaMikP4IPrg5Cq9Vj364GVPmcqPK5cO7mMJ8TuBwVDhP2tfgQDMVQ7XXi/M1hBJdJq60FVq/VVOvB+EwQuxrX/mOSRZD4QOJHbBIehaUXv3vuLs7fGITTbsbo1Dxm5iIIhGKY9ofw//+/38G3/vID/Pe//pB7ZrHOwr/8wRUEgwFMzcxjcnaOu843NtTg7mgYITZgWZJ5lIk1M/gqq+Cu8KKi0gu70wOXxwur3QO3qwKtDbV8XuOe9jpo9FYk8mp+MVrtsNlMuH1vAMVsHMf3VPD6uGVz088AbC5leMEvzWFQ86kIBLEtkaof+7EfwzvvvMPF1D/4B/8An/3sZ5cMWv4P/+E/bMnwS4J4lmCiAPHSbda1ZtVv4CAty1AjAf/UBOw2K9QGB9LCxuef5WCA1dOEA3uBj85fwumXjiGncq85YrUcGpUIs7ZkkRBLy0itI93JxJeo1CEcn4FGG0eV04DJQKkTsMqpxdjkGBrqKjEVWqbe6hFm5mP4v/7uCj7/5gGM3B1FXXUFn4W3EswgNJZMYVdLNf78e7cwF159XM5qsPdhnXIGrRrrmejDIikssMNqoJ4ES3P2jfoxF4pjd3MlXHYTmuo9GBmfwxd/6DQcdhN3VA9E0tDp1Jid8cNiNkJTVCAQyyCbLeDmQHCJMShLLw7PxPhlJWorTKixKxGJ5zE8k8L8Qu3b8DS443prSyNCgSCGB8dQ43WiQh1ApqhCUmK2Hs9OCm1uUeqvglJ/xCZY95GeDbYcGBjAd77zHXz+859fIqj4AkURfr9/M+tEEM+VrcJGi9UVyCERnMDd3iEcOHgAGbB6m03AIlbQw+ppwK72Zrx79gJU+flNRawqnRr0DU+gvtoLf3hla4TlYCf1IX8aTQ0NmPbPQVlMotqphU7NRv1ISKdzUGuMiCSXr6daLqJzp38aHpcVyXQabfUrp/LUSiX0WjUvwg7FV/ZqWiusYy+bL8Bo0C6Mm3kyRW7mKUGn06z5NSytebtvkj//Wtcw8gUZt4Zj+Mbf9OCP3h3A965N4vtXx6EzmnG3f5ynCXtGQ9wgdCWn9dVIpPPIS0w4plBhX5pCZfMAP7o1jYKgRWtzLeLJNN47ewkfnP0ASM1AI6xvf9gx9VSmpec0gthSUcVm/7Ghlquh16+v5oMgnjeMmoeiKr5BryoREh+Qe+TQPuSVTshrmEm31lSgraIR+3a14MNzF6DOs1Tg+ofiOkwqfuIMhWNQakwIxte/jGxe5jVYrc1NvMhdUUjgaLMZPf3DqK2pwvh8ZtXZgI/SMzQLlVKNQCCKllo3rxVaHlYILqEgFcri4jUw7i/VGuXyOL6vcU2vYa7pBZbezOVxeHf9ml5jMerw+slORGNJWEwGjM0EuWBisa7724kV9c9HczCbDJClLDz2jR+PI4kstDo9ZgMR+Jz6x7Yn+8y94xGcv+tHVtbj5KlTOHFkLy5evgatHIaAZ6OIfYnpJ0WqiE1AiWOC2AKMmoeZ9cQGRVUBGjgq6qGz1UBi3lRlhKUC7d5GdLQ34YNzl6DMzq5LWLHASr1Hh77BMRzY04bRufRj1gnrEVYDM2m0tbYgHo/g4rVbaKrxoAD1mqNU92FpuMGJACxmA++g29XkXfZ53ANKFKEUlWWpArpwcwhWswHJdAYdjV5eXP4kzt8chMNm5oORD+6q5XMNGSy1t6+9Gq8db8cXP30UP/npY/jSD5/AP/zCy/jf/snnoFYJsFmNfBTPpVuPF7YzBqciqKuu5DMTO2rsTxwHtBKs5qt3LIzmOh8mJ/2odi3fdJHNSxieiSJcsAJaN2oqvRgeGIJRkd7xdVZMGN5P/7EfQ6ZF/3cJYr2QqCKILY5UsS7AjSALIrKCETnBUCpaKieCgKxggsPbjM6OJpw9dxHqvB+inH0Y8lhBTGkUAhoqdJiamYHdYoY/WkQisznrCCashv1pHN7biMmZALQqAbF1Cqr73B2chqhQY8ofgttajXrfPhSLtiUfS5bZCBYZRWZTUYZty2YL9o/6oVIoYDXp4bA+ueMzlcnhw2sDPOLkn4/g1WNt0GnU3My0vtIBj8OIfD6PXD7Hr9msxEu3+rG7pYr7YV25s7L7ejZXxIg/BofNgonpaXTWOzY8bWYulOL1WYlUmtdRPWk5aUmHprZdiGbyiIQCUAsb+x63i2Ayj/xCMRyl/ojNQpKcILa6pqoMo2q2Ch6xqmjEHhn48Nx5HNy3Cya7B1nZhCKLji0IDiamXGYVPDYVlChg2u/nY0uqq2sxML2xrrnFsHfx2jXo7p9CR1MNMgXmmbQxGZBIavEnbx1BIvEziMYfRqqUyjFYLN+C0/7XqHRbEAhHEGfF7GUKpPQOz+LQrjoMjs7ixP4m/Pn3rj9xPh1LAVZWWOG06LlwevPULvSP+bnpJ9sq1V4Xj36xxTTUunhUS6lQ4OqdsScue2A8jJf2VGJyagIOi5rbJKw2E3AlmFyeDWegVIiQi1lYjGpEEivX4ckQES+asGffYf4Z0sWd/dudUn9EOSFRRRBbgFopQqMUuXFluVzVtwRevG6CzduI/RoVbt3phkLsxe5dLbDaXdyJfX+DESqViFAghO6eIR5ZMRiMqLJVYGAqua6Ot5WwmVTcBZ6Nktm/uxEXrvWgubUNc9H11WmlUqfg9/9XyPLjJlmFQjWCwf8V0eg/xaVb/wK7mtMYmggi9wRLg7USjCTQNzLL5+RZTTr4PBZMza7usM6iZWev9OPUwWYemWJDspkb/N2BSSRTOUzPRx6Yib56pBU1lXYUCtKadCB72UwwCZVKzari4bDo4A9vrCh/Zj6JOo8NhVweNuaEv4qoui+s2FikEjt73Is/tqjzj4YoE5tkZ/+EIIjnoK6KWSqwuo2dTA5GaO2NOHPmZexqb8GNW914//0P8P7772FwaBC3b3cjnkhid1sLXBU1SMtGDM6myiKoGHaTCvF4DC1N1UikBGjVatgMynULqtnZb0CWtQuHtkcPb6XHCgUN3rvwm+jqa8eVO0vH12wWJoa8Hhsvgq+pcKzpNSzi9NGNAcyHk6WORBF45XAranwPDWDvR4y4wJJLY2LWwuR8Ag21XvQMTaGtzr7mLsNHiSSzUKu1GJuZQ7XbuMZstLDjBdXizj9Wd8Y8qghiM1CkiiC2MAUYTJYKYZl/0+I6qx2HwPq0tEjIGmicJpx+1Qc12MmmiN6efl6IHIzl0D2d5fVP5USlEGDUAMOROLKVIooLA5HZqJS1UiyaeISqxJO2M5uFKOHspX+JmprvQaFYMBQrA+F4GnJBAvMjf+1EO67dHeUeU0+CiaUPrvThzKEWVHsdmJwLo87rgEIU8dGNQS68WOedyaCF2ahbszhiNgqjMwmYTAYEAwHsqrPj7nBw3RlP1lE4F83CyjoKi1l4HXpMBzZvRfG0YT944gsjkFzGUoqUIDYDRaoIYgcXq287ggBJ0CItOBEVfIgK1bjQE8H1wRhG5zJlF1T3DUSz2RSqvA5E0hISmQJEpYhUKgWzfm1CNJH40YWU31qFKxNWOiQSn0M5SaaycDjMfGxNc00FLMZSR99aOXdjABduDfDXh2IJeBxmvHqUFbCrsK+1BoFwDFoN89haezfowEQEbqcTkVgCTjageoPRmKHJGGqrK9E/MoWOWjsfsPyss7ieilJ/RDkgUUUQ2yGqdnJd1VNGoxL4OJ6iJPCImD+Uw972RnQPTKDC9mTxwDKr0eiXNvTe0ehPr8sHay2w6JRBr0X/2Aw6m6t4tGmtsIjV8EQAf/bOdajVKmRyebhsBvzDL5xBOBqHRqXkz0ln127YyorTu8fCaKr1YXRyBi1VbIbf+mGDk4emIvC47RgcGcfeJseG04k7BTL9JMoNiSqC2CIMi0QVSzMQy+OxajA2Pgu3y4l4qoBMXoIgKKBWiTw1+CQkyYZCoXYDhzNWX1ULSdqYyFiJ752/h1s9E+gdnEFdpQOVnvUvn9ktvPPRPajVSui0al7D5HaaoBAVvMuQDT1eD8FoBqlCqRaLRf+sLN+6AQYno9zlXq1SQaOQ4LI8YWr2DscfI9NPoryQqCKILWKxieBOtlV42lgMKohsDp5CiVT2oVjglgFrqIiWpM1NcJCkpeNXNksuX8CVu8OoqXJApRRhs2xs+aWxO5Noq6/A2NQ8bBYjFEoFRmeDfHDyehmYCKPG58Hw+DQ6eNH6+teJBfV6x8N8tuL4tB+13k2OTnqKsAheIFnajladErrnIJ1JPH1IVBHEttRUkahaDr1GAYUgcVuD5CJBxREAYQ25OVHcXMG0KG7eZ2s5QVQslNZ9M8XPrTVuzIfifJ4h2xQqpQLB0MaGPzMbhHBKgkqlhH/Oj31Nrg2tG5sHWJAFKARhwxGvncB8IsfnTzI85mf3cxA7CxJVBLFF6FUiH9jLiD8rherbCGth9znUuHS9F/U1VfBHHqZiCrIMuShBqXxy9EAUw9zYs2Q6sB7Y8scgiqt7SW0ImfliSdz+wGzcWCTNqNfitZc6cat3DPU+N8LRBIrFIoQNijQmyu4NB6EzWPl+mYyGsbvRAcUGTFZZR6tCIfJauOci9Uf+VESZIFFFEFsEG39yv66KIlWPw6Ik+YKM6poaxLJKhBMPhWc4nue2CoVcCkbt6ocppluZU/pGsFj+sOwTgBjJTA7heALjswHUV9lR413qOfUkjHoNvvI/ncGF6/2o8zkxPD2PVDYPhUK54RmL91Ne90ZCMFsdyMsy4tHQhiJWrDqrNOYHzyz+BX8qRoWJIlVEeSCfKoLYYq8q5oOTK7IUl8Sd1okSrNNvPprnooaJkMXMRXKoqfIglUzAbLAgkcmuvp2Nf45Q6JcWjD/XUhtThEqZQ7XvHcTKn/3jNU/MX+qzr+7F+HQIhzrrMD4T4qNeWhu86GzylYYus7IxFimSZShFkcfaFIKIap8ds3MhROMpnDrUiv/wze/jM6/ugVQsPoh+bhSW8ro1MI/ORify6RiyyTgqXUaM+9fu18U8sxhrtyHdWbB6vfuiik0+sOnpVEiUBzrCE8QWQrYKq5PKFpHMPF5vxh7TaPUYmfTDYVQ+MZrEDDw9nv9l4d6T6teKfHknDv5/8eoxF5zW8haq34eJqdlggteG1Vc50dHoxZc+ewI//sZBPspGKcpQMTsJqQCmtfPFAiAXkctl0dU3xmufPnZ8F+70T+CN053cF0qpFGG16LkJ6HqsGpYTVneHAmipq0QilURrlRW1FUbYzZonyqRqj4l7iLFh1IHIw3q20uukhe3P/d8hoMCNUHca8WwRqQWbE7eJdVc+m+KQ2HmQPCeIbewAtOtVtL3XALNVSOYVsJiNKGST8FjVmA2v7s2k159DRcXPPTL7b7HwKNX/CEIGh/b+rzi4exTz8xG8crQZ75zvRSyRKft3w8bW7G+rxujEHD51Zjcmp4MYHJtFfY0bJp2WF3sXRSY+RMiFIlRqNS9wF1XA1HQIPSPTSCTTMJt0aGmvwqXbQ/ix1/ejs8GLYDSJ8akQmnwWLnDmw2kkMmvvCmTpu5lQEoViEYFQAA69gCq7ETq9i7ulT/hjSKQLSySRQadEnceA3oFRNDfWIpYq4JUDldCzqBvropOnuVt9yRFfQpHVxWlNyApm5OSdk2KbXVRPRaafRDkhUUUQW8gz6aq+Q5gMZNBSWYV7vYNorK2EbH2yEzgTVjU1J7lTOjP2LPlXlXBY56E3/D4Uqv+BYCyB3hEXTu1vwoQ/iNZaN67eGy/7Z+genIHVrOeRqoFxP07sa8bwhJ8Lmj9++zICTNRIMjfRLBRKqT2ZBU1kGdVeJ1obKrCvvR5Do368f6mPF/cPjZdez0Ti7lYf7IZSp2F1iwsX780iv0YPK7aEvvEI2murIco57tQ+PD7Lo1jMZPRQixuJrIzh6RhCsQwvkG+rscHvn0NDTQUXrCKy6BuYhk6t4nYPsXRuIYLGWzehEkX4w3GcOLIPTrMNEkQUZREpSYu8rN4R9VTU+UeUExJVBLFNooqlHIj11VwN+XPYvasZt7t6sH9PG/RaJZ9D96RUICtAN5v/kBt7NtfU4+R+F7KZWUiiAn/5gySY7hgaD+KVwy3cS6qx2skHGLvsRl4nNDUfQd/wHEamAsjlN/e9Xbw5jGl/FA6rAf9n/1l84qXd6B2aRoXThmv3JlZ83dRclEemPA4TPnl6D1wOMwqFAjLZIqoq7LBY9Mhl83DbbZicnUMmFUNTtQW9o+E1J9wiiSyu9c1Bp1FCKQqodLngcxmQzWQxOD7NH2v0OeGy6rigS8QivIvQYbdgbHIO4UgM7S1NSGbzyOcKOHTkFJdr7P1lCFBAQmsmhivXbvJlsb9Isoh9e3ZBY/IhK2meaucfN1U10hBlonyQqCKILS5Uvw+5qm+s5sofLqCmqgKTkzP49Mu7eXRnej6KoYnAqsOK2QlToYhgav4OVKpDSKWKSKcyOL6/ARdvjXBbAEEUYdCq4XUZcatnDMlkAoIgIl8oYE+zh4utD671I5Vev9nm4qLo0akAv7BCdVYrxaJBazUF9Qfj+IO/PI/j+xrR2eRFLpdHz8AUtHoNugenMBXXoL3OhrGJaThsFjRXW/m8v7UKq3xBQr5QityE4lncGQ7CbtKiqdoLnVLG8NgMrFYzKp1WXL09js987BCu3BlBPJlGZaUPI9MRWM06BGNZxCTTY8tXavR46dQZqIUCZEFGNp3E+xdu4ch+GVqzDxneXLB9sIaRYKr0fTr0KmoeIcoKFaoTxItuACpLEOU0FHL5a4rWA4uEaFUCtGoRWrUAnUqETi3yActmi73UJZhIwmJQorPRjc+9tgcGnWpNRpz//a2rvP4nncvDoBHxwy/vxsl9DfC6zZBkCb1DM6jyuaBSa6FWa1DhtvP5etlMGl/4xEEc2V2zKRPP0udT4OMnd2HKH4BKIWJoYn5dr794awiT/iiy+QJ2t9UgkUhhb1stoskcrvUFUOXzwh8IQyPm0VFv31SXYCiewdXuOdwejsHj9SGeSCEaS+DQrjp8eLkLOpUAT4UHvWNhNPgsmJmehtu2vB9XQVYhWrRgvuBAIO9ERuXDy8cP4erN29AKrNB9ewvZ5xK5B/MeKfVHlBsSVQSxhbDIhHbBwHInDlUW5CKM8ixyM1chRu5CLwefyno4zSq0V2rR5lWivUJER4UCzR4BLR4BjU4BYjGD5lo3DnTU8hO72agG06tf+cLpB+39q8FSZmevD/JC8Hy+gHQ6iZoKExSCjImpAHa31uB75/vxtx/cxV+/fwd//d4dRJN5WMwGDIxMw2nW8iiZz2XZ8H5w5nAz7+DL51nHYwHX7oyueznnbwwwDwbc7R+D122BKEiochuRzRVxayiImuoqRGNxyPk0Wmttmxp4LC+kB28PBOByuVAoFnCzZ4hvD8gFOM067G1yomdwFB6nFfPhtTnb52UVJI0Nh/bvh7wm+4vyQqafxFZCooogthijVvEg/cdSTjsJBXLIxOfxR3/1PqZm5yFi42mujeIwKeE0SLhzrweBUAhzgTACoTCC4ShCkRjC0RjCkSgm/RH0j/nRPTwDg1bL63PmAlGcOtgI7UL32Wqw2qj3rgygCCWsZhMOddbiwo1+nDnSjg9vDsMfjD14bjyZxbnrQ7jVO4UKt4MLjFg0ho8fb8FnznSiwrn2mXfMefyVo+2wmfS8047VirGhy7nC+hsXYskM3r14D1UVTpj0OmSzedR4jA+E483+eXg8HsSTSRSzcW7syWqZNgPrLGTrzMrS66p9+J+/+DpGJgPoHxjC9PQUTzlmJCUm5hKLbBQKbFw1v7B9TMH3q4f7flrSQmX2ISGzdd9eO4PZxaafNJ6GKDMkqghim+qqmAi4742zc5C4yeSn3jiOprZOJLA+5+/NpvsqHRp4zEDfwCg6O1qh0rsgGpwoapyAxoGi2oaCyoaixo6cworu4QBu9s3g3K1RaDQ6BCMJ5HNZfOp0J6o8lif6WbHRMR/dGOIiwWExYWImyMUV69JbjuGpEP7y3dvcN6va58RcMIpYIoE3XtqN1461o6HKuWo0iHXCnTncCqNexecbKkQF3r3Uu2ot2JOIJrIoSBIS6Syvhyrmc6h2l4QVu39rMAi3ywOpKCEUnOMmnyxSthHYR9vd4EA2lcB0KIGCoMd3Lk3i+KFO7qa+v70Whzqq0VFnw2dO1ECfGYMuMwZ1chSK+BDE2CCKoQEgNgKbIgyTGINJEYNZkYBOTEMrpqFA4amYfurVCpgWpecJohxQoTpBbHMHoHGRd9VOQOY9/Fqk4ACE7emEUisFNPv0iIYD6BmbR2d7M0bnC4gvYwS6mDsD0w9ud/VN4/i+eliNOoQiURztrMXoTATXu1e3RmDeSV39E/jhVzqh16rx7sVunNjXiHPXBh5zdmcUihLO3RjCnQEd9jRXocrrRP/QBCpcZnhcZtT4HPjw2gAkaamVATOUPHmgEQ6rHukMG94LvHuxB7n85kSEz2Pl9gb+uRjqK10YGJ1GQ40XAowYn0ssCKsAOursyKbjiEcCePVAFSbmEwjHFurmROaMBaSzRUTi2WWrmphY7Ky3IxWPoChJcLtcuDMcgtPCitILOHW4Hd//8Cb/m1GngcmkR5I534tqiKLIC/6ZmOO1cKkskule6DQqHrBiUToWtFWr1di/bz/Sog0FbL2HWzhV4IXq9+f9keknUW521tGdIJ5DdnyxOjvrMX+kbXo7jUpEk1eL4aEhOG1m7NrVhvH57BMF1aOwVOql2yM40lmHhhoHpmcDqHDo8fHjbZj0h/lJ3esywahTY3QmhHxOgtWig16jQqXbgvcu9WBXcyVcdjN6Rubw8pEmfP9i/7KihwmAcCyNs9cHUOu1o73ODpfDhLGpAE/rvXq0Fe9f7uMC4z42sx5NNR7EEikYtBr81Xu3Ni2oLEYtTh1oQv/wDBw2E/7ku9fwE5/7OAZHxlHlqwBEE8Zn47y7kM3462xwQJSzuN0zgEqXDTaPmnc8MmHJZiGLSj00Wiey+SK3khAEtheIYJNzKp1GTM36oRXUaG6owlw4g48frsasP4hQaA6XAzNwu+w8WseEef/oNOxWO+qbmpAqlsYFsegss1ZQiXlI2SQEOQelgokZ8C7IubkAzl28itOnTiEusedvbfJkNr7I9JNSf8QWQKKKILaYxZGpnSaq2AmPZ6+2qdZLpRDQ4tPhXm8/qr0eKDRG9E2mkd/gZF4mHi7dGUH/+ByO7q5FOp2GxaTH8d01MJs0yGTYEGIBPpcJ6WyeF7UbdVpuSbC3s5YXqSuVKrhsJh6ZcdmMmJqLrPqeYzMh3OsfhVGvxvG9TRBEGVaTDqcPt+DizSFkcqW6NNYtyJZpMmgwORfjXYibxWU38RmBPreVC8rB8Tl0DYewq64Gg6MTqKjw8s/I6seY6LwzHIDXYUBHcyOSqRQfGaOAyGrdoVApMD0bRDaXh1qj5OlCtr5sV9DrVOjpKUXV6qo9uHSjj78/Mx3V6TVoaahGJlvgHZVX+lkkS0a914P5aBqFwVF46zuRlnSLaqhkCArTUuGeF6BzmHHyRAWKgnJbaquWmH6ayJ+KKD8kqghiG72qdqKrOjPnFraphoql/AYHh1DldaOoNGDMv3kbByYCgpEkzl4dxJlDTTyCw3yWeoamYDBo0VbvRTyVgyiIUKuU0Os0aK73YXI2imA0hVA8xYVWPJ1BY43ziaKKwcRGKFrA9y924xMv7eLpPZ/LjJ/4zFFc6hrBvYEpRBMZPliZWTa01rlx/voAUsukF9dDMp1DtsCK3QuYXSisj6fyPCpV6a5ANJFbUq/Fts10IAl/OAWrQcO/g1IwrfSl+1wO1Fn1UKtEyJLMB/k4rVpMTflh0mvRUFvJX2svyrweqVCUMRtM4ntXJ7iLOxNu94VSOJbDL335M3j7+2dRX1+NLDTcQb0Ek3OP72WsYF0UVJCLy/99qzr/mOB1kuknsQWQqCKILca00P23E20V2GlM4Oe9rT+luS1qJKJB2K0mKHVmDM+ky7p8Vg/VPzYPm0WHy6Mz2Nteh9HpIP7qg27MzJeiKWwUi0JQcLHDhMkXP3UQ3QOTOLq3CWev9PDxK129WkTWOAeQiat3znfj1WNtXJzOBMLY0+LjJ+2uvkkeNdNpRFR7XKj2WtE3MrepzzgXjOPqghXDfDD+4PF4Oo/esdCKrysWZQTv11MtYj6y9DGHWYtmnw6BUAQ2hxt/9G4/f+1aYONxEgU9Opqq0d8/hJoWy5Jo1UpI22SrkM4VEUmXftS4jKpNd0USxHKQqCKILUarFPlJlp3Ud1r6j8Fqabba6oGdv9xmJbru+bG3swN3J9bmabQean12HGiv5IXb1V43/vSdm5gJPLRJWI6Z+RiP7DDH9OZ6L/xzEXQ0eXHh1sia35elz35woRvtjT4c7KjB+PQ89rVW4WBHLVjTXSiaQiI5iTdP70F9tR/nrvYjmX5Y27MeWM3WwJgfW4XdrEGhkIfLYcXgdGzNguo+OVkNm8WMSGwa4sIA653C0tTfzhnuTDxfkKgiiAVUqq3rPrLo1PxXciovQ6lUPrHryGLZmMnkehEKCoRUGkiFHIwGHWTV4+9bV1e3+fcRALs1A5/HCaPFhcoNarhDhw499hhLXdV7zdzvamBoAscO70fveBSVdS2ofMKqyxojWpqc6B6dw5tn9uJs7C5e3tOBgtq5MLR4eWKx5cXaZFSBl44dQCAwD51aySNI7a2NPG03ODoFj8uBf/o//yi6R+YxOR8vSylbe3v75hfCCusNCtj1efT0DWNvZwOSigKcvvWtoNPhQk6agU6thtVigUG1fRYdj8I6CxcTTCehUJSiYlUOw2N/J4hyQKKKILapWJ2JKlaQnS1I0K7BBXxbEFRwub344Ox51DbMQzBoISu3YBabzFr0S4XOjzgPrEuYtdVYUeEwLPguyfwxtVqBkdEZ9A6G0dpUh96xKJ9htxYm5xJQKUw8snX24j247SYk4jHUe42Ynk/z+qXVxNVyETn+fFnGxGwQe9vqMTYbx/BUBB31XkiFNPoGh1HlcsJp1ePWgH+7egRWRacW4DBI6OkdQWd7CyZCxQ03DyhENU/Fsq5D/mWzL34HMLtQT8WooEgVsUXsjL2dIJ5zdqqtgiyqoXfU4PDhA3jvg48gJSYAaWtmAIq8ZX9jTV7sdVUWGcVsDMMjoxgZHcPQyBiGRyfQdXcQRlaQ3tSAgcn4mgXVfUZm4gjEZXgrXNz+gA1uPthix9FWG462udFUaYHF8OQoptmgxv5WN/qGx2Gx2nB0fyd6R/1AMYcKuwEXuiYQTEjY3d6IeCoFKZ/Gnib3pmcKlgOzToFQYA7tTZWYjwOJzAaVr6iE3ubmo3T6e+9BJa2eft0uWOp9bmG/MOuUMOwwrzji+YH2LILYdluFws7pPBIESEoLXNWt2C8A33/3Q7z26mkoTNVljVixmAeLyKy3Ruc+Nh0wMTbMzTob66qQZSN/+OrLyOSKPOI0E5zjJ8+NMD7HUnFG7GuoQVd3P/oHJ1CQRMQSaRgMOuxvdvK0LV9/AchknDwqxT4T61vTaVWocBrx4aV7qPG5MTyTwPk7szjYXoHZmVlYrWbsa63A8GQYwUgaHfUOzPjnYNAL2N/iwY3+2Q1H8MoFs2Jg6bHMBr8jjiAgq3Di5PHD+N7330d7ayvySiueNoFEDoWFfYP8qYithEQVQWxzByBzVd9pMGHlqGrDEUHEB2c/wpnTJ6C01EBWPLl7az0z8Hin4QYCM0YtMBqPorHGh78+P7KulNxaYY7j7XUWHNvfXJr1lxGRSOegECSMT0w9SNMx4VFX6cDg2GzJQFMEdBoluvuTaKnzIZqRMTYT5cu43juLw+0V3OTSYpRwYlcFt1hg7uodzbUYGJ7k8/sOtnlxs8/P3dufBuyzsfUtyhIE7rC/ie0rKiApDFCp1IhGAtC6HCiKeuyY1B+ZfhJbCKX/CGIbMO1gA9D7SEoz7JUtOHRgD9794CPkI+MQiuWzPWCCiomQjSS7WFRIWGjb3wpBxTBoFNjX4sK9/jH0j0zz4cfdo2HcG43BbPegob4GDfW1qKutxvBUGAqlBlXVPlRWeuHzVeBjx/dhdDKATDqLtloHX2Y2V8TluzM8HahSqxGNJ5HKpDE0NoVILI4Dexph0qtRSMdxtMOLSpcRJt32RzGZf5WC5VhZ5I27qm+OgmjCsaOH8dHlO4jPD0FRiG2bweyTRJXXvAU1gwSxAEWqCGLb5//tPAPQxcLK6mvBsaMi3j97Hq+eyqDSyk5KrC5lk8suMnPJjS2Ep9nYPDlsDXqtEnsa7Dh7qQcH9zSgUBDwg0v9aK2vxt2RCG4NBJbv/ht6aBRq0CpxoN2LiYlpOGxm7G5w4u5IgAvBm/1zcNl0MGjZmBgZtdVVPP036w/gcGc9Rib9qLAK2NfSgHRW4mae/mAC08Ekd0ffSrRqASadhFt9fuzb3Y5NzHp+gKTQQmGpwcsvCzh79iIO7EnBXVGNnMoBSdx+O4PZBY8u5uhvX0N9HEFsFBJVBLENLC6M3Ymu6ouRlCZYPc04cUzA+x9d5aNfOtrbMRkVNyWsRJb+Y8GKjSgjHuSQwTNTZUarVmBPgwP9w6NoqHZjYCaHqfkkqnwe9A6OYldTLe4MR5BMl8bPrEQyU8C17hkcaK2A3z8Hq8WE9jonekYDPK03E0iyZ/HnTs4m0Fprh89hRN/YPBzMsPT2EMyGadgtRuTzMiosKhxoa+LiamQ6wp3NN1ozthrVDjX6+/uwd1cLgikFsoXy7J+SqIXCWINXX1bgytXruHarG6++fAqiqYr/bbuIZwoPosMeswbiE+xMCGIzUPqPILYB5t6sXxhXk1jn4OCngaQ0wuhuxSfffBMuhw33uu+h0SnBYdjEQuXSEOSNmElI9+t+ylzNrdcosa/RgbHxSVRXuhFICLhwZ5bbIMzFimio9mJ4dBJ76q2wGJ6clktnC7jWM4sKrwfBcBRaZQH7WjylrsfFz8sVcGtgDuduTyCcZs4WenQ018Cg06K9yYe6Sjc0WiXu9A4iEJxDR50FZ/ZVo7bCsmAnUR6cZiWQT/ERNLJCi0C8vIKfRaVkYzVOnn4FJ44ewNlzl1CIjkEhlddNf+2pPzL9JLYWElUEsc0pwFS+uCURh3IjK3XIaXwwOXzwuJ346OI1xILj8JrXH2xiokKpFPkoF3Zh+tJpACosQKMTaHEDLS6g0cWK+pdfhoKn/8p3yHJZtXjtYCXGJibg8diRzIgYmXloATAxF8d8vIjaylLEqr3WsiZhlc0Xca17Ft6KCqRSGciFDHY3upaNkDBz0MGJCN6/NgGL1Q5RIeBG9xjSWRnToTy8Ph/am2owH4hifGoa1U419jW7odqgsNJrBDRXaHCwQY8jjXo4dDnc7hlGS1MTJoKrR+I2iiyokFU6YXA14fjRA/jw/BVkw0xYlaJ225X6Y1RQPRWxxVD6jyC2CZNWibl4jkdckrkizNpn4L+fIMAfAyxGL04eq0DX3V4I8jjqq2swF2OfY/U+sfsF5izCNTo6hiqPGTYDoBYyGBqdgBJ53Jj2I58rlArZZQEfO7kP1TYnhueBzKLACdturCZrk71pHItehTePVuPs5bvY3VqNwZkMhqejjz1v3J9AsWjgNg6Dw+PobKjFvfEIVjBUf0AmV8DVnhkcbK1AMMjmHSrwxvEGDIyHMO6PPVYnxZ4/ORcDe9hlMyGfT/F044c3JqDXqtBSY0edy4lgOIR0uoCDHR5c7/EjX1h75M6gEVFpA/r6e3htERP2CoUS+/e0YyIkIZPfWqFfVBigs9fh1EkFPjh3GSePFGBw1aGoMG5bpIql/whiK3kGjuoE8RwWq2cKz4aoWiCaZussoLWtDUOD/bh85Ro6WmrhsDmQzIlcDDDuCx52bdQBYiENhUKCXlnE/7h6Bx3NVZiYvckVUkeDB3f6x7C3rQ4mvQ6CKCCeTOKP//ZDaNQqfOFH3sBwWI0UE24L53uVKHCzzPueQxtBq1Hg1F4v3nr/KuoqPRBEDYanVx50PBVI8vRYY10leofH0NZYg1QqiUBk9RQWEzzMUuFQewXSqTj6B0ZQ4bKjyu1F12AAoUcGHA9MhHCozY3RsQm4HVa01doxHUgglcnjVr8feq0C7XUu6JBBcD6Ig60e3OwvzQG876lq1IlwW1TQKBfU7IMrEUqhgPNX72HfrkZodXowPZbMShgP5JHeYkF1n6JCD5WlBq+cEvDRhSs4uF+CpaIBBXFrhBVrEmAeVQyHgW0XSs4QW8uzc1QniOfIVmEndwCuBNMxUxEBVXWt6FDnMDAwjNjwCJpqvVAWixBFEbmijGKR+R0Bc+Nx5PIF6HQaqBUyvB4bTh3Zg1BaCbXIhhDfRntzOyS1DZPsvCcBRj3w5S814F53D775x3+L/+VLn8F8Us0jVk67DSMTflS6jbzmaSNo1SL2N9q5Gzv7PFWVXnzn0vgTXzcdLA2AbqypRG//KHbVV+DecAgBpjafcFK/2jOLugozH6ETCIUwMzGNl/bUc8PR0ekoooksF6JMpN0dDuHVA634s7cv4IufOYnc3kreOciiVqlMkXfoHen0wqBTcuf7f/C5/VCrNVxksshTPJnCnb4Bnh5k8yWZGGRdk1KxiHxBxu72BgQzKgTnt8Y1fy1Iog4Kcy1OvSTivbMXcHh/HnZvCwpKU9nfi0WG7+tv8qcitgMSVQTxgo+qWRVZhl0POIyASpB4bZQMGWqFEna7HtF4BO9fuAmjUQ+dWgWDXouO1nrk8oDTZoXRaAGry3foJbx3/gbiOTYAMI+Prt1FZ3MjcmobIiW9wgmlgNA40FjbjpMy8Bdvn4fNakFtQyN2tdZgYHgEFRXeDYkq1uW3t8mB8ckpNFY6YDUbMDgVXXMKjQkrJhZbGqsxMDTOZ/n1jYfhZyu9Cqzzb3Aqwgco11ZYUVvtw73+Eeg0ahxpcyGeldE7GkQ4nsHkXBwD0zG8dKAV17qGoNao8UMvNWJ8Jo5MvgCjXgOFKMGiM+BW7zDu/fkY3E4rdFqW1pJhN5vwxslOZItKJJnr/IKrpwABiZyE2XAO0dTT3/dkhYa79n/85WP4/nsf4dOfcKHADELF8s7EpHoqYrshUUUQT2lUzY6HdeoVopDSc7h4d4x3o7Fi62JRgiiIMJuNOHPiKIoLPgdKBdA/PIl7A9Oo9rmY8yXiiTg/oY9FAoCUQ3R+Cudv9ePYvhYoVSLkFc6hQ0GgqbEduzvbefrr7KU7sOvquTGmVr0+nyEmBFnaZ3ejg6fWvG4HnE4LBkb9yGN9RptMQDGhUlvlRf/QOFoaarhp5uzC46vBxun0jQcRjOqwq6ESCkiYmJnnEaVjnW6oVWoUijL0GhUcFiX6R6dQobHhg/M30dzghUKWEAzGIEkSJKcV+ztb4bQaeepVKuZ5tKtveBrvXuqBQadDU0Mt5uMF+KNF5Ao7rzGCdQYq9R7UVlXg7t07aNtnQV60lPU9yEmd2G5IVBHEU4xUyTJzCC8JLN7WnonwizoV5MUwsqBGQWHmg495yEFUlqzJV4OlfIppKIsxiFJ6YT7dctEYBYpKPXe/FqQsVFKSX/M8XGnEHUbHJ7lQeunoAWQLioc+URKQyANd06W04H089iqYTWZkMomSWacgQCnIXFhZTHooVGqc2N+OSDyDK12X8eqpY9Crzbxu6lEGF8qcNEoVDuzbjdvdXRgcm8IPt9fDalAjwqrkn4DHpkNzlRlWkwZdPSNwO23Iy0ok0oUFm4P1i435cBqJeBGtjTWYmJhBZ4MPdT4rbg+W0nRPgqUMP7w5AadNj5YaF4xqERNTc/x74q7mAouqKaHXa3DmWDvGpiswMDqFg7uaEIyl4Q9nMDwbxbW+EBdqp08c5nVhKhFoaOqAw6TAjD+Ai9duw+Oyo95Tgbk4EE4+/QjVoxQUJuzf3YbvvncenVISeZRPVLH/T/dFlU4lwsJSpgSxxdBeRhDbhFYp8q6rfFHmokoqZFCMTyAyN41iMQtZkjE+NYORsWnILPKw4Ou0u60BeoMBEBQwO9yQRHa7NFKEXQtMjAnMH0XmAkcsphGcm8LN2/f4Y0XI3I5AYhEmxf1rgXegWUwGNDdUI5nKoGdgFEqFAqIoQGYun6IAtVaHIwf2YjSsQG4NwTV/HNCqzFCozfw+0y0KNWB3lObK5ZQeZAVAZQNePe1Ad98QDh/cC39MRPxhk9YSWFAvmVdhV2s9Mpk0zl/tQVutD91jUcRWEVYeuw61bj0GR8Z4dMvpsCKVU2BkOoZKp44PRxY2WLjsDyW5Z9auBh8mpueRKxRxsK2CWymk1hCFZF/dfDiFQCQFm0mLep+FG4CWtpkAg06NYCiI89dHAbUWOr0Fb527g5b6atzu93MrhvvEMw8FczCRw5AfsBnNfNxQMBjC7bvd6GxrglGnRSBW4F1+T3FizFIEETnBwKOfgbkZWLxG/iOiHETS7LNKD7r+mMAniK2GRBVBbBPsoM5SgOFUHrFUBqm5fnzvBz+AKBehVrEIlACL2YIf+uRrSKazXCwl4hHc6xsF5HluOxCOXUdlhZNHuARB5HPwmAji8/CYJUFRRiyR4ALs8ME9sNqdEARFqWCZC7GFsykXYwWMjk9geiYIUaHEK6dPQKu34L7tOXu+JGjx3sU7vFNsrWQeCdawpbGKn1xBQiHHBhWXHnebLPBVuHHx0lXs3d2O4goRKwZrlLzVO4G2lgZM+iMYHBnH7vpaDMzEEYhmHpsH6LbpUF9hQN/gOPa2NyCWLvIuvrlQHCoV87tin29zRn1zkTRSvXNor3NAJRQwMTWLQx0VuNU/t6rYW7JtZPAuwEc7AZlZ7I+83Iru/hE4XVqMzKexu6UawxN+7Gp04dLd6ZWXyWrTEkVeO2UzWLC/04zhkUE01Dhhd5uQl7WYCOUQTz+d4c2PklNacObMKbz3wXkckACHr6kkrDYpgpbWU5GVArE9kKgiiG3EpFEglEgjmw7hre9dQEdLA5pb2gAFG58hQlDpoNDZEZ4ptcqrtVkcdNRD4PNhcsgkwkjEwnwyMRc9LKCkEEoZOxEQJEBjMMJodaOosiHPxoGsdHKSJfiaK1DZkOXPkUU98iys9AjrEVTLvg3Te4LwmPklS0l53ZUw6RWIBIMwulcWVSzkpVEqkM4UMBnIorG2EkNjE2ioqUCl04A7w0Fej/RAULn1GBqeQHtzHbpGwggt8iriApNtswWhuxkSqRyuds+gpdqOCpcNQyOT2N9chRssmpTauJkm6+abCSZ496RaKfB0aSRlQD5f5Klci1HDuwZXg+0yzCE9nxdw/EAb/vp75+FxWlEoCqiuqYNRo8FM5OnX9smiFqKhEq+9cgpnz32EAyoljO4WSIpS5K489VQ0RJnYHkhUEcQ2YtAoIGVjGBwaxr6OGrTtPgyF0bfiyZ11SRUVGoDVZssylGoXrLbig9TfQsHUovslx82CoHryL32BFYrr+WUrYaskCQqk0kk4LMBi30xmIFplceB293Uc81VDFJRLarQehc/QCyZ5WrS+tgr++Xn+BnsanRidiaHKbYLLrMb1u4Noa6pF73gUoUfyirwhrlhalqpMs3X7J0Jo8FlRW+XB6OQ0jneyeYFzC/P+Nsb4bAxtNR6kM1mYDWrcGQygtdaFaLLA132tRDMyuqeK+Njp4+jq7kdHUwW6Byfhq/LAqjcgsgO6AVnRuqBx4/DeNnT39uOoswq5MokqZkDrNq2vIYEgNgo5oRHENmJQKyDl0yjk83BW1q8qqB6D56tUgEILKLU8ulW6XnxfA7Ci9h1UP8JqsawWO+bnQ9Aq8/wkdx+mDfKyCl63lY9zWRHuDCDwqI1SFDEdSOHeaAQOhxtKpQrh4ByOtNqRiMyjd3AMu1rrMDideExQMVh2U6kQILKjXxk30/B0BLPhDJprKxCLBvC5M62wGjd+Mk9mcnzfEMVS6jaRzuH2wBwGJ0JrKohfzFysgHuTBXS2N6N7yI/TR9sxODyBKqcKC0G7pw77AaEz2hCNxSDn4rxpQiFleER1vWQLMkLJ0jZyGtUbHutDEOuFIlUEsc3pP5arY6mwVEH1QhTPsqxcuqCA2WiEAJbfWxoeKvBASSncxgTXcpEqVqJksVrQNzSBthor7o6FEUvlca2PDRu2w2TQYWw6gAqXA5JSjXujYUQWnLQfhflsFSSBR3uU69z+GpXIx8a0Vvrgsul4bVZJmMn83D8TSsBk1iMRj2Jyxg+vw4hIIrSu93iwnkxIyvwdoFKV1nM9EapHYa7peUmBbD7PTVrdDjv6+odRX1eLkbk8F7jbbtlRTEElpwDWASvIUKgk1PqsGB+5i7qaJOKSATqzG0VhfdHUYPph9I3qqYjthEQVQWy7V5UAtVqJxEJn0osA10ksOrQQHpceEVUKlQqxWBxGnQmRZQJWrObY56rC9OQkFGIOLqsOs8EUFx49oyE4rTqYDQb0z6QRjIZXNUpgES+Fgq0OK1hfexucy6JFY6UJerWAwdFJTCRZb2VJCLLOTW43wQqtTQ4EmWmXBKg2MRYlXyhyD7DJ2SBqqnyYmU8ivUl/s0Bcgs/twMh4AFVVlZiensbU5Dgq3DWYCm3NQOXlEKUMVIUQZidHcLd3kBfmc58vPnE7g2tdA9jfOYl9B45AZ65Y9/KDi1KaVE9FbCckqghi2yNVAuaDEe6V9KAr7zmHZatMRiMmp/yweBoQTCwVTI21tfjw0nW8dNyLWJadYJe+nt2dSwA+jwP+YARG7cPCY/bcuXCaX9YC9wOTgEKhCM2TPL8WoVErkM3mEAklUV1ZAVFQ8MiRxIQVjyapkE2nMT0bxvCkHxpNCHt2taFrKICNwArdJ+aS8LpdmJ2dR0edE9f7ZrEZEpki3EYdctk8ZiN5VFZW4satLrTWA9GUiMQie4atFFSF2Dje+/AiLGYTXjtzDEqlhotdHq2UcvC4nTya63a6kXkksrmW7zeQSENSChAUaopUEdsKiSqC2EaMWiWUah0/mYzNhyHnUxDUhuf+O4hngIbKSnx08SpO19YgmlI+6Cpk18G0AjWVLkxNTsBiq0F4lckvzCBzszpUVMilrsl1LMcfYkaqOui0Bly+N/uYDQLDadXj+B4fzhzZjfcudsFpUsPjMMAf3FjB+sB4CJ791SgWi3Batah0mTA1v7G5hw/UKUsrLvQ4TASyaGtpxPnr97BvTztmwgIS2S0wsWI/HqQcN6TNJebxwbmreOnYfhgdlcgpLMgKi05FsoRd+y24euUybt25jT0HtMgJjjXVCTLvsHv+GCbmApBkEc2NdTA9Q4PLiWcfqt4jiG2EmXA6zAbYbWbMhOLIpjdxgnyGYNGk+biA9qYa9A4Ow2lc+nc2/6+ysgqjE7OwqnPQLhOc4BZbzJiUxTQ2Iar4cuQFj691LIcNR2ZeV4OT0WUFFYOZef7g0ghElQZH9zbju2dv4cy+GijW80aL1xXA3aE5VHs96O4bRlutFTr1xufjleRSadQQ24aRlIRIRoXd7U24e68PPpsAo7bMpwVZhqoQQSE8gPMf/gDnLl7HyRMHoXM1Iad0QF4sqPjqicgqXThy9DCCoTASgakFp/8n0+eP4cZoAFPTfjjsFhxvdJb3sxDEEyBRRRDbjNtigsViRSAYwXw4yNMVLwKsw91kdWE+EIGUjcCkXVrMHk6rsHtXC67duoOKlUy1ZZSc0DcoUh4gsBTg1qRe07ki/uh7Pais9JbGEOUzcLOp1BskHMtizJ9ATZUHkXAEHQ2uxzy/1gz36GIDilg9WGkZwUQR4YwKu9oacftuH7wWGWZdGU4NbL8uFKAqhDHcdxsXrtxEc2M9Xv/4x6CzN6HIBiivhCgip7Di4N7duHzzDoTUDATWCbjKew34Q7g45MfM7Bwa6mvw8b2NaPORqCK2FxJVBLHNOM0GaLR6bgUwF45Alp6+T9B2wM6x80kFjh/Zi57eQbgfjValAZXOCq1Wg3Q8CNsj51xuGi+WrBCE1cysnrQePODFFsLubU09G6u1CkaScNrNiCdT8Nof+bDrZMwf4zMLswUJopzjflwbgXUTsnqyvFRcYqXA5gIGU0rsamvC7bu98JhkOAwKaFWl7sN1vEHJCqEQgzo/CyExgP6uK5j2z+O1j70CR80eZFReSMwG5AkwN3+Dqx77d3fi/bPnISemeD3Wcu85Eojgo/55zAdDqKurwb5qO/bUutez5gRRFijZTBDbjNOgBpQ6WCwWnO8awe46L9TWOj525kUoWJcEDdQqBXTLWDgxl/X29jZcu3YTezo10CqNyNxveFsogWIF5oJ6c9uKabKiVLK22CryeYkLxPlwHE6nCzq1Eum1DFBcQaTd7PXj9WP1PA24q7keoVgaiXX6VUFkKU+B+3Q9ajjBhJUMJfbuakVv3yCa6rxwGHRQqHS8wJ2PNiq5zHLvLFaYxUvL2ffCvxsB2vwskrEQZmenMTA4Dp1eC5vdhtOnTiOrdJQGgq8VQUBRaYbF24QjShHvvf8RXj1zGGq9CwXRCJmNX2ImqaEY3uthgiqMhvpadHptaHVtraEtQawEiSqC2GYcBhVElQ4VXh+Co2GMDXajaa8Lgnpj0YdnDRYpYREnPmLwEfJFVuejRFtTNeKxEHSWRaKKmccLIh8KvTCRZlO1bazgXWRzfbaIbKHIh1Y3VnswOBlAZ6MLN/pmUdxglI3VdPWPh+CrcOFu7wgOtFfhWvfMupYhyGzIjcxH+siKx9cjwoSVJKKtrQnhYACx2XkubrTMel5gadqSKGNDuVkKtsgELjfyZx2bEj6Mh5BIptHRWo+TJ47AZHOhIOiRVZQGgm+EosIIo7sRJ44KOHfhOjQqBTpbGyAoFBiLizg7KSKeynJB1e6xosNDgop4epCoIohtRq0UYdGpEM5rAZ0Z8VgUUjH/wuTiCzJzWS9ClotQiorHZgsyEeUyWtBz4w6OHPYimVUht5AhZTKgUJCg1G0uwsQEABM38hZGB6fmYiXxwv2wgFw6gb3NHtzq95c8mTbAwEQYgA0+rxOTEzM41FYBWSUgk1/b8liRP6unYgbjxRWidNG0hExBgFnvQZ3LC1HOQ8PMRxfCUiURVRJXfK4jzyOKvDawqaEJCrUJOaURsqhBRiiPu39RNEDvasLHP+6Cf3oCo1NTCBZ06Eo5oFCKqKmpQYvbis6KzY22IYjNQqKKIJ4CDoMa4Rj7dS8iVWB1Li9GsTojlgZaG2tx824/fHXtmF/kWcVgAipV1KGjvQk3bt/Fvt2dmE+rwHwveU1VGTJ2pYjX5q0ZVmNsNoajHW6k02m8fKQN717qgUUvwmrUIMQ8JjYIE1YtNXZ4mInn2ATOnKrBWKCwZmHFIlUSS32uYnyazcuYzxcQiPGacQissH/h6Xzc5IIlw334TRmo3d2EfOkFG/58K663QoeMqIWtyoKcpQndEwW4LKU0YYNdj71e3Qvh+UbsbF6UH8cEsaNwGlQQRAUMRiNuDc9DyoRemC5ANo7P43Iik82ClZctB/OpklR2tDTU4drN23DrcmC+qdy0nEVHNnnyZPVUEusi5DboW0MilUO1x4bZ+SBC4Qiaq5y8KYH5Vm0Wlgb0R7Ko9lXgXncvap2sRm0NPk68sU4sFUKtAfZ8Nr6Gud6za3Yp1aMtmJ8vXPhIHfYCZlW/lcJGEDCdVuGDaSUKghaSqEWt3YiDPhJUxAsuqt544w24XC782q/9Gr/PTihf/epXcerUKXz6059GKFSal8Wu2X32OPv7i3LiIZ5v2JBXQaGC3mhBStAhNDuCYm5jBpHPIvxEzP6tcv5lBulFtQ0drU243nUXLkMOGrWIQpHV8Wz+xH2/k3CryBUkhBJZ1PtcSCQzmPAHEY3GUGFTo7aChVg2x/BUhAurutoq3OvuQ7VDibVMxSll8QR+edaYSxbw0Xj6wZzCGosSh30ailARO4anJqq+8Y1v4N/9u3/34P4777yDVCqFc+fO4cd//MfxW7/1W/xxdv35z3+eP55MJvnzViKbzSIWiy25EMROLVbn/VJqIyrrGnDpWhfkzMYG7z6LsNO5Yg3N+sxmoai0oqO1EXfu3EEunYZGrUaMTVjeBMxagK/HFuuKroE5BKJZ6LQ6PqaHCblAMIQqpw613pXMuNbO0FSE70NulxXxSBBuyxMqOpiYZVGmhdE6zxJsnt+58cyDGrwqsxJHK7Vb2sFJEM9MTVVVVdWS+2fPnuURKcZnPvMZ/M7v/M6Dx3/1V3/1wePs/ic+8Ylll/kbv/Eb+PrXv77l6048n6jVK+SitgCbSgWjTo1UVkQqq4dOkqCQ8w/WwencOaaFhw4dKvsyLdIE9EYD6mpr4Kp/sp+QRopCr5Zx+eodvPnaKdzzi6hp2fjJtNojY8YfQHNzC5T21nW/Ppdbm6hzGoBEYARaswMdvnpcv3kbnzzWhrc/uItPnjmM0YjysTmH66W5swOawjwuXLiE3U0OdOxtQAGaZZ+rQA65+W6IQQXq2vYig/J2nHq9XmwFwWQeNyaD0OoNYA5XVVYNXmux80HMK8FmMRLEdrNjfqwEg0HYbDZ+22q1IhwOP0j/sfv3H7+fFlyOr33ta4hGow8uExMT27T2BLE+WPrKxVKAApCDBrF0AelkFFJhcxGYZwXWgi8+8D16MjkY0NLcCJvVjIIkoihtLjrB+9X4yJv1oVLIMKjlJcaZT3wvlmqTJMRSgMVgxNRMBB6nCcwpqhxBFglK7gH18ol9vL5KK6xcBM8+r1KpgIYLjh1z+F+VcCqPt3uCyC3k/LxmDV5rXl1QEcTTYsf8r7Lb7YhEIvw2E0T3BRa7ZvfvP86etxIajQZms3nJhSB2tAkoBChUeth91RgbG0Mxv8ok4ecEQS5CLha479Jak1ACighG0khkClhh7N76a7rYmJp1vo6N1mFNBZVWNtj5yc/Xa1jBegZFKBBNAZ0djegfnYZKIfKuQH2ZgqMS1FCp9bwzUonVDEEF6LUahGOs5XLrPLrKRTRdwFs9IWQWcn5uoxqvt9q4eSlB7ER2jKg6c+YM3nrrLX6bXbP7qz1OEM9DsTpDUCiREfQoFjKAvDHH7WcJBfKY8MfQ0tyEHNZg1CjLUCOB7p4+tLc28AL2zcJPyaLIDMbXfcBMRkOIBGdgfcKqa5RsnE4ayVQGGr0J6QITcwIUohIdLbW42zcGj3mdY2BWIcciVvk8koko38bLIyOWSCEQZD9Ud7YwiWeZoAoizRxhF36EvNFm54KUIHYqT23v/PKXv8wL1b/5zW/is5/9LO8GZDlw1uX37W9/G7/8y7/Mn/crv/Ir/D57nP399ddff1qrTBBbI6pEJUSTG/f6RpFPBJ77DleWrvL46lFRswt5YW2iSs7GkEymYbbYkcqVK1LFrN3X9zpWOF9bW4v+kQnoFVnoVijbUYmAxyzjXvcg6utq+fgd9q2yr5bZOeQFFSxmA0Lzs0sGS2+GjKRDW1MtpqemVxFVAncir/a5sJNJZot4qzuE5ILrq12vwifa7NCspb2RIF7EQvXf+73fe+yx//pf/+tjjzkcDnznO9/ZprUiiO3DqlfxNEYBKuQEOwwaDeamBlFlWdrE8bwhCUpkhXUWSMsFaLQq5JhRapkiLMwAtBT0KM2zWwsFSUAkq8LR/Z24092Lvfv2YSSwVASzFJzXIqP73j14PG4odDYk4wvvKZZG5KQzQHNdFYbHp1FV6ylLSrMIJZQqNYqJFBRYZUi3LG+6OH4rSeWKeKs3yCNVDItOyQWVlilVgtjh0F5KEE/rP58gcGd1dkKPS3ocPbyXWytIqQB9J48gCAoU8gWo+Pg4+YnF5EaNDOUqub0Ey7TKMmLR6LKDnVcjnhX42BSlSoVocA4u46PvDxQycRh1KjicHh6lenSQM49aKXWYC4ShEgtr8pd6EhIUcDjdGJ2YhViM8zq05RC30PB0s2TyEr7bG+K1VAyTRolPtjmgV29sbiBBbDckqgjiqRers7oqFTIKEyAVUSxm6TtZDOsSVBtRkCRkkjFoV+mUV4kyPIY8iqkgDMu7CnBYXdaulgZMTM2AW4atE39MRnt7G4YnZpBLzGGxSbpRC8RiUegNRkQfjUCxjKOCzckDkjkRtZUe/plY/dVmYVP9BKUBHpcVhQwrRH9cVLI4n8yO+nK54n3lI1soCapQqpS6NKgV+GQHi+CSoCKeHUhUEcRTxGV6GCYJp6XSCJEdd7p7yggCCoIRrY01iCdiUK9y1DJrgdHREeiUTJyu/DxW+ywoFVzEqjcgaPISMB0VcezQboyOTcJufPidWXUCJmcCqKn2IbGMPua1XAKrGwIsFiuGRidhM5TnO2cpQFlQIp1mKcDC8lYWCjWS6RSUAqv43xl5QNYJ+k5vCIEFU1cWmfpkh4NHqgjiWYJEFUHsgGJ1xnxKhsROejvjPLejKHKhuTB4epXtw1JvUrEAk0GP9CrOAqxBX1DqEIwkIEqZVVOFqwmzRFaAQqmAQs4+sEdgmSq1SsHrr+6PU1nM/X4/ph/MFguKRQlmHcoC8zxjfl637w1BSPkfK1hnTQJWixHFTAJiYhIKlKGYa5MUijK+1xfGXKIkqLRKEW+22WHRkqAinj1IVBHEU8RuKBmAysUshmaj0Gu1EDSbH7j7vCFAAb3RhPlgeEGALC+CmIZhxf98mz5hTE0yp0BNlQeZRAyaDZpvhxJAW0szPrpyD3ZNFkYNe38mFIo8xffY+z6yXizipVCK6zITXY0iVBAMXuze1YJ73T3QC4+mAQWIEBFPpHD+8h1Y5HloheQKnlUsrsXCfVun8guSjB8MhDATK4X01AoRb7Y7YNOTGzrxbEKiiiCeIuwkYtWpIOWS6JsI48SR/VDqd86Imp1CUVDB5vSiwAxDiwmsWGbDAlmyAEmSeRfeaiTzgN3mQO/wBGwbjBSx8p94UY+9Hc24decumtwy7vUOl0yLlwkC5fJsxE0BGlEqRbREGdlsAQuNbmUhDy3sTi8SiQQyifBj0aoM1KirroDJZMDb757H+GAXzEIEaqQhosCfr0UCRjkIdXYW2i1KExYlGe8PhDEZKQkq5j/1iXb7wlxMgng2IVFFEE8Zh15EIc8GxcroS1m4gCAeQRCQhQVNTY241dUPhz4HnerxE33pEYH5ej6xMi2TB5RaE9RKJeRcDPpllrcW4hlApTPCadGiv3+Af4+V1fUIsiDRI4TTMmqqWIfeNJwmwD83D6/bhkiqnKJFQAZGdHa04tqtO9AjAWFRJKoIDfKCBjV1tXjz42eQiCdw4+plTI/chKEwDcRHMNF/Ax+8/x6GhkegXKY2a7NIsowPhiIYC5eUJxs580arnTumE8SzDIkqgnjKuA0iIGpQU1uN6wE1vn1lEr3+JD/xEA8pihrkBBPaWxtx48ZtuAxFiMLSbZQpABazGQMjU090PGfiYy4BHNjTgrs9Q7Bspq5JZlYFMmYDYbQ01WMyLC+b/ounAbPJhEIhxzv+CvkszGYTF2blhNVWWT11qPI4cO/uTWh4tOkhoqjk+1xMtmPP/kOob6iFIEl49+xFXL3eBYNBh+PHj6C9vRMpWV/W5glmZfHhUBQjwdI6KUQBH2+1o8JMgop49qFKQIJ4yuyqdiKQyKF/3gyIKiSyRZwbjuDOTBIHq02ot2v5UF4CiGbYIGoLKtx2BPzTsFqrEUov9Z9qrfRibHIaHXpgPrG6sScz7FarNLwOazPTTwxaYHB8Bq8e7cR8XFjVXPP+d2nUCugNR2E22yCvNq5vQwhcDDU21OLchWvQIoMMHwnEqqRU8FbVQqPRIQ8lErIVarsRlfYMGpo7+CidjKzlz4tDUXZBdX4khsFA6oFX22vNNlRaVvG/IIhnCIpUEcRTRqNU4vXdNfjCkXrULTI8iqTzeLc/hL++G8DUQt0JAYRTQFNjHcanZmHVPV5azUbJsJFW4VBwoVZq9YgfM95UCNKCsej6YWNmCtkk4okkHE7bqlGnogwoVXpMzgaAfAJSUYbOZCxrTdVDRBRFPfLFIqKx0IPaqjzUUJsrIakd3DD0vtDKwISoZEdctiEPHe8ULLegujQWQ+9c8oG4fLXZimpbmeb0EMQOgEQVQewge4VP7/bgc/u98Jge/nKfT+TwVk8Ab3UH+O0XHWZVkM4r+JgZpZiHRrlUNIVSQEdHO7q6RyCng7DrlxNWMrRKGV4LKxbPIhSJwaKV1m2twHyxTGIK17r6sbu1Hpm8yDv8VoJZLGRlJSo9DmSSKT56J53bqv46VltlwL7d7bh7twc6gUWHSpG7nKzh4mo7PdGuTcRxb3ZBUEHAmUYr6uxl8pIgiB0CiSqC2GH4LFp8ZpcDb7Q5+CDZ+0xFs/irO/M8esWiWC96tKq1pRHnr3TBpc8vEUO5ooD5lApHDu/DwOgECqkgKsyl8TUlZDiNgF2VQH93F967fA8dTVX44GIXvGYJijUKKyaojIokbt/rw7H9uyCo1CiUfD1XJVdgB14WHZIhF6UtPQjnoYHN4UGxWICcjT41s8+bU3Hcnn5Yuf9SgwVNThJUxPMH1VQRxA6EpUZqbFpUWzUYDKRxfSL+YMDscDCNkVAGLS49DlSZYHwBx3ik8gL0BiuqfW7MzUzD4q5FsBQE4WQLAvxxJfbt7cStW10wGub4WJpEsRQBjAVnMDExjfbWehhMdm7k6RVn0dV1F517OuGPiygUV5ZHrCzKqZdw5XovDu3fhaysZubsTCY9UbawaJWgVCGRSEGlFFaNbG0eNrBbCa2GRaW21nNqJbqmE3z/vc+JOgta3U/sIiCIZxKKVBHEDhdXzS49/t4+N07UW6BdKPxh9Sl9c0n8yS0/Lo9FkWEhkhcENt/Poit11zVUezHj98NrlGDXyrDqZdj0Mqw6NlSZuZ4rcfrofjRUuXD91h3MjnYjH5mA3x/AoYP7kBbsGAsD0zHAaKtAhceJWze7UGEoQPkgsrXCeigKsFr0UCi1kIp5ROIp5GXVEyNV8Szg9VZiYiaIQCjC13NrEcEm4xRyOXYL20n3bBJXxmMP7h+pMaOjgsxtiecXilQRxDMAazvfVWHk0am7M0meSmHz0piBIosE9PpT2OMzotNr4CaKzxxMIXEPgvvdeo9el8qpnQYZRlUOk1MzUAgyksEiBLmIH3xwDg31VSgUmYCQIfBxNcwAVEBYKC2hpsKOgZFJbs75pR9/E6NhBTcAvb981inodPhQK4q41XUX+/bu4RGrvPS4TOJODswdXZahVxXw/sW72NXWjHBKXLXzj8H0b6YowqDXIRRPIhwMwGV0Yn4ZX6tykJW1aG9pwK27/Th03IukbMF20DeXwoVRlnIswTpZ2T5KEM8zJKoI4hmCCab9VSa0e/S4NZ3gkQAmrHJFCdcmYrwQmKUEWXqFCbEdjyxDlLPQIAEpF+VeTwsTEPk1G6ki3bf0lCXMjPYiFI2huc4HnU7L5754Oi240zMIuZCHy+lCntUs8XEwMgTmArowLpCl7I4dsiMcieHtD26gsb4ablsF5uL3hZuAABNW1grUCgLu3LmD3Z2dmI4ruM3AYoxaIBqJQq8Wcen6PXS0NCInmhEpOQU8ETYnMJ4q4EfffAnfPXcP9TUiTFp72f2qGAWo4HTYkc8XoBbySG5DBpClrD8afiio9vqM2EeCingBIFFFEM8gLA14rNaCzgoDbkwm0D+X4iIinS/i/EiER68O1ZjQ6NDtHI8rWYJaTkGB+/YQMh+LEgrM4cq9HmazDZVKAUmSIIoijwKxVWcSqxTJEmCzmtHe3ob5JBBZaITUFIHWZiAUjiOndCBaAARpQUgtZLsexL0KgNlqxUvHq3DjdjdcBYlHpwLJRcIqKaPC7oEtHkUyHoJG6VoynFkQWNegjGtXRyGIAhqaWlBYh6Diy1gQevGMAkcP7MK5izdx7KgNyezqHlcbQ0AeKuQKRT5jUiHkuYXCVjEaSuPsUORBddmuCgMOVZt2zn5IEFsIiSqCeIYxapQ43WjFHp8B18bjGFlwwmRF7WyuWtcUE1dmXvD+VE9qkgSdHERf920EgiHIggwlGz2TL0KpUGBvZwdsDjeKDw5Jj1sgsNqgu71jGAqU/KgW/02jVCGWTMGjBOZ5Pf/KnzWQZONiRHTs6sCtrjuoEWU0eH2YiwOJXElYJTIybDYz8ukoautc6J1dGmVKhud5PdTHTx9BsGDm3YhrpVQWl0cuX0AyCySyInxeN7p7BtDQ2ILJCMpOWtZjV1sL3j93FadPvYSEYOeSttxMhDN4byDCBTGjzW3AsVozCSrihYFEFUE8B7ChzK+12jGXyOHqWAzTsVI0KJjK451eZimg4UXCHtPyo0BkmVUyZwBRCUFRxnEhsgyFnIVOjuDKtZvQaUScOnbgwYw+FoUS1BZk2YQ6QVvK0a1CLDu+rCu6ymCGLCgwOjqMypoGzMZ48m/F5RQlAbMxEft278bw0ACGRq9yPye9yYRQsjQo+UC1G//t25fxldZaKEQVfw0TcFYtMDUVgkGvhqC1Ijy3vtCS0wAMj06hvqYK4ZTMI1wN1dW4d/cO1EIWoqjhheXlJCdr4fTWwTY/j5npMdgr9chxh/WVYd+OHbMwKlJISVoEZC9kbha6PPMpCZcGwg/GKzU59ThZT4KKeLF4BitaCYJYCTaQ9lO7nPhkuxNOw0NxNBvL4m/uznOBFWKK4VHySSSCk0gGBlHMryPssgqilIVBnkd6vhfvvv8+dFoVOvYcRlJdh5S6ASl1HTLqOt6BJ4m6JwqqlWDiaTYuoL6pFal0FrOTY/CaSn95konoTEyEr64VRw7txq07PZgc7kW9jRXEs2ifiAq3FeevdnP/KotWRo0VUBWi6Bkcx6E9bbwGay1oVUC1TUCLqwA5E0IoFIXZ4UIsXVrLaArQafVIJmJY5PtaRgSkYUBHayP6+oehE5fOAnwU5r5ulEMITA3gr985h8uXLkEnRZcMZl5MMC3h0myR1/cx6h06nG60UISKeOGgSBVBPIdUWjX4rMXJ/ayujccQZZOGAYyHM5gIZ9Hk0uFglQkm7cIhQFQgEQvh8pXL+NjLZ2Bwt0BUb9xLSCFlIKem8f7lq1ApFTh6aC+0Zi/SsLBpvig3rJB8Ng60trVhcKAfE+PDqKpdQ8RKZsXpgF6lw7EjhxCPzuOjyzfgsJngbK2D02ZBlc+Be1030d5Qia5bEzDoNDi2rwlKpYpHrXTqkh7kcSx5QRsuXDOJoVYC+UwKg30jyBeK0Gg12LuvE7NRgY+tYUTZzMKWOnx0+RaOHXYinil/bRUbO6PSmaBSilBi9bk4BiGBc+fOwWXV4PVThxDOCpDF5euwwhkZl2aYoCrdr7Vp8XKjlXdeEsSLBokqgnhOYTVUDQ4d6uxaXsh+YzKOZI77eGNgPoWhQBrtHgP2VxmhU+nhrm7B0WIWb7/zfXz2hzVQOVogMG+CDUSomKD64NwlnDyyF0abFxkYkRFUG45GrQVZZpEn8MLxocE+zE6Nor6ujkeTkrnS3L2Vaq2YmehYRIRR48GxI24EA3O4cPU2xqf90GuVvAfxxt0+WIwGaNVK3B2chF47B5PJggJTP3LJWlMBodS9KAgocksHoFAo8u7MtmZmNGrh0anpKPPQevj+7HY4pUCF04Z5/yyMei9iW9AJyAfECKWeysV2FYtRI4NEeBYKhYiOPUcQkC0QNUCOf7algjialXFxpoD8gqCqsmrwSrPt2eg8JYgtgEQVQTznsIhBm8fAx4J0+1O4NRVHtiDx2pd7swn0z6e4v9UerxXu6mZU+sYw0HMPbXsMgMYMhXR/XlsJVldTFDSPCyRZgkpOQUrP4aOLV3H88F5obPVIi9vnns0iVv440NLSipHhQVy4dAWdrXUw6Q2QRD38idJzlkdAIgsuwMx6D06fcOH8patobahBqqCAqBRRLMhQKgQ4HAZMTM5h/+4GpNJsU4i8pe++FQS7z8Qr2/YsGpYpKHit1uzcyklJVuzuq3BhfHIWVXZsiajKyWpuRTE+OQmLz4YctI8Jqlx0ApdvdOPMySOIyxZIUC2b9IvlZFyYLvCaNoZTJ+C1ZjuUJKiIFxgSVQTxgqBUiNx8kXlYMcuFuzMJHmVhJqI3J+PomU1ir0+PPfsO4P1330U8/i5MJgMSqeRCXovpJhk6gwlerxeScL9mq5RgE+U8RkZHcbdnECePHYbeXov8Ngqq+zDRNBUFKmua0d6UR9/gKFLpGajUGtQ3tD5BWJUiXiwdF0qKEJQa5AQ9RmILh8qF4I5d64NKn8WtnhleAM46Clcr4VpLJo+Zgiq1RgTDUdTV5qAUS7MEy0lG1uHw7npcuHoHJytrEJIXiyoJWjmKc9du4eWXjiKv8axovZDIlwRVdkFQ2bUCjnoVXHASxIsMiSqCeMHQKEUcXhgXwsRUL/O4kmU+6ubyeBJ3lDbsPvwalKEhSIV0KUIliqXAlABMTEzgbncf1ErmJbWwUAHI5gpwO+342KNBLhQAABshSURBVCunIOoqnoqgWiyM5hJAWKGCq6oZFi0wMDiMoaE+tDS38rE0qwkrvgyeQmURJ26h9TBWJ4OnGVvq63HxynXu5B5OKVHYZA0Uew/mU1XldaKQz0AhqJ9Q+bR+mPxVa1S40zuMI/taoDRYUODRKhl6IYmRwUF4PU5Aa0dBXr4LNMUFVRELZXqwagQc9yqgoggVQZCoIogXFYNagZcarNjtM/KBt0OBUtdfqgBcCpphVe/DwTotjAn/ki6uyoY0FMUkFEIphahQKLncYB5TeWiRhQFFsYy2DJsgXxQQSgGhlIyaugZMT46ht7cXLa1tvLB9VWG1MIaGpTUfhT3MCtxrq72YnJiGw1MDf6wM68ucLWQR2WwWWjWQXb1JbwMokJWN6GisxPsXb+LVj1cgIQvQCRlMDA9gZj6K48ePISEvL4jTBRnnp4tcWDHMagHHfQqoKEJFEByyVCCIFxyLVolXm2343B43qlk720KEJppX4L3RPH4wqcBsRoOiqOeXjOhAUlGFmFiDhKIWUVQiIlQhDg8yog3yDhFUSykVsXsqa2Ew6DA40Ae3kcVtVg8vKXgL3/LCK5IGXK4KzPjnYNIUUI6Ri4kMUFtVgaGxKdgNW5NKS8KCXZ3tGB6bxVjfXRQDfRjsvoHZOT+OHTuKBCzLGoNmC6UIVXJBUJnUAk74FNCQoCKIB5CoIgiC4zCo8Il2Bz69y7nEJDSUlnB2PItzE1mEMwtRG2aLsPjCxMcWWCWUEyahmGu6r6oOJrMFhaIE5SrNjTy1KTJrg+WFF7MQCGdEVFb6MDw2DdPSmu8NwYq+BaWad94xb6utIA8NjK5GvHrqMG53D2PWP83rzY4cPYqkYF3W4DNXlHFhpoh4rrQtDKqSoNIqqYaKIBZDNVUEQSzBa9bgM7ucGA9ncXUihnC49Lg/WeSXarMSHU4lTOqdLaJWNAqNyTBYvUgXltoaPMZCYX6pq2/5YnNm2lnh9KEoSUvmA25qHaXSQOit27oCkrIFda0HkC9I0Gq1qGpo5xGs5SJU+QVBxewTGHqVgJM+BXQkqAjiMUhUEcQCavXOSVtZLJanvQqwWoHOWjdujZpxbSKGeKakQFij2/UouE3DgWozr83aLpxO57a9l5ieRnhuElWVPtTv2wsolCurIJmHmDbvwyVLUCaGMDwygqbmVtQdaHziS8xm84beqphNQVmIYWRsGtV1TVAYKh57DusMfbsnCLU5B7cZ0KkUXHBbdMqyrstWoFJt3dBoglgJElUEQayIKApocRvQ4NSj15/EjYkY0nlWoA50zyYXPK6M2OszQat69iJXKyIVIRQzfOgxnmRayj2qyvPZBSmLUCwDn68KknqLBYpCAZHNehSWT2+y9Oj3ekPwx3P8vlYp4lMdjhUFFUEQJKoIglgDzNCRiacWlx53ZhLomo4jV5BRKMq4teBxta/SxE1EmR/WM40sQczN4eatLhhNFmjMLkhlEk1PfGtBBaurEvudXkgq29a/oSBA4n4RS4UV8y/7fn/4wWButULEJzucsOkp+kMQq0E/OQiCWDPMm+pgtRkdHgN3Zr83m+RDdJlD++WxKDcUPVBtQqvb8GyOKmGCKjOPu7evI5PJ4djxk5A07i0dr7MEUVkSU9s4N69kG/HwPvs+3xsIYzJSsnRXKUS82eHgjQwEQazOM/6TkiCIp4FOrcDxeiu+cMCDVo/+gQZgswXPDUXwp7f8GJwvmYo+M0glQXXv9jWEwlEcO34Ckt7Lh01vK9soqEq6lxty8fus0/GDwTDGQukHEcpPtNnhNu6cekOC2MmQqCIIYsMYNUq83GTH39vnQb1D9+DxaLqAd/tD+IuuOUyEMztfXMkyxFwA9+5cRzQWx+nTpyHpKoANDJR+ZuAtjWzwc8kmg31HTBAPB0uCikUaX291oMKsecorShDPDiSqCILYNKzW5vU2Bz67xwWf5eFJOJDI463uAP7uXgD+eKk+Z0dGqLLz6L17HfPzIZx46SQkvY+n4p5rZBEKhcADY7Ik4fxIlDceMNgg6Nda7Ki0kqAiiPVAooogiLLhMWm4eSgranYaH9bgTEez+KuuebzTG0Q4VSZDp3JFqPIB9N27gbn5EF55+TQkrff5jlDdh/lviSJvNrg8nUWPP7mQfRS4w36NrQxupgTxgvGc/xQjCGK7YSflapsWVVYNhgJp7nHF0oGM0WCa1+uwLsJDNWaePnyaCIUEJvrvYWp6Bq+8/CqKuhcgQvVIBnAoawT8OYgaLQQIeLnJuiSVSxDE2nlxjh4EQWy7uGpy6fkJum+OeVzFeSE7K6/qm0thMJDGrgoDt2Jghe/bjlTghel3evvx8ktHIOs9L5SgYmnProCAkbQJ9QvF8acarWhyLj9MmSCIJ/MCHUEIgngasILnjoqSx9XdmSS3YmAWDKx1v2s6gd65JPb4TNjtNXLLhu1CzAZx7vxFNNZVQ2+vhiS+OPVDbNvfHJ3Gd3uisNttEEQ1TtRb0OomQUUQm4FEFUEQ2wIzBd1XZeLjbW5Px7mnFavnYSai18ZjuMc9rsz876yVf0spppGLzyISi+HU6VMoqh3bamWwXbCOvmROQiiV55dwqlC6TmaQjgaRyxVgsdpxtMGFXRXGp726BPHMQ6KKIIhthY2zOVpr4Q7tbOwNG3/DTL3Z+JvzwxHu1n6o2sxTh6wLrewU8yjEJvCDDy/i+OEDkFTO50JQ5QoSwukCQsk8Qmkmogq8KYBFBR+Fdfsp1HrU1tXiYJ0beytNT2WdCeJ5g0QVQRBPBTaI+VSjDbt9Rh6pYkXtDDa4+f2BMG5PJXC41oxam5bXZ5ULIR/DYF8P6muqYPc2QlY9WykvZtAZyxQRyRQRTheRmS5FoOLZUjPAk2Db0mrUwe7QoM6uQ6PHuuXrTBAvCiSqCIJ4qlh1KrzW6sC+yhyujMe4WSiDpane6QnCY1bjaI0F3kX+VxtGkiDnwhgaHccnXv8YZLV1R6fu0nkZkUyBiycWhWJCKpouorjITFWjWXm76NUK2PUq2PRKfu3Qq/hA5C1PrxLECwqJKoIgdgROo5r7W01FMrg6HoM/nuOP+2M5/M3dee6b1GKRYddv4rAlFZBPRqHV6qDS2SDtkG6/fFFG9IF4YlGo0u3lUnfLwebz2XRKbsJqXxBQ7FqregH8tghiB7EzjigEQRALVFq13JV9LJTBlfEoT20xxsMZ9M+kUW/TYK9PD7Nm/YJBLERx5eZddLaytJ/pqaTuEtlS7VNJPJUiUOwxefFU4xVgPlImrQibVgmrTsGFVLXbyrdFOVOkBEFsDBJVBEHsOJhAqHPoUGPXYmA+xWuuEtki/9tIOIvRSA4tDg12V+ihV6/RhkGWIRTiSKYyqKyqREFh2NLPwArvI4+IJ3bN7AzWgk4lwvpAPCke3H40dWfW0mGcIHYK9L+RIIgdC+v+a3Ub0OjUo2c2gfMDWZ4SY/VGfYEMBkNZtLt16HRrn+hxJRTTmJ2e4aJEUprK1vFXkGREFqXs2G0moDJrTN0xHy+rthR14gJKq4BVp+SiiiCIZwsSVQRB7HiYENrtM8GtzqFnLoN7/jQXMyzqc3c2hf75DDordGhzaVcuwi6kMD07hc62RkhK87rXgQm5eK6UuovcF0+ZAuKZtafujJqF2iceeSoJKfbYllhHEASx7ZCoIgjimUGtELHXq0eLU4s7s2n0BzK8TilXlHBjKoneuQz2eHVocmiWChWZdf1FMTo2g7bWDkBUr/o+LMp0P+J0P33HUnlMyK0FjZKJp4XoExdPCli0SqgUJJ4I4nmGRBVBEM8cLDV2pNqADrcWt2ZSGAnleLQolS/i0ngC3f409vv0qLGqeX2WkI9gZHgAVVVe6CwuSAoVXw6LdEUX/J7u1zyxa1YPtRYUggDLoqjTfSGlVQpUOE4QLyAkqgiCeGYxahR4qc6EXZ4Cbk6nMBkt2TDEskWcHYnDoVPioLsIITiAroEZ7DlyErdCOkSycS6k2PNYWm9N76VmtU4PxRMTUmatglJ3BEE8gEQVQRDPPEzovNpoxlwijxvTKX7NCCbS+M70NEYm5tHUeBwfzlsAsSS8Vksx3u+4u5++Y/fZ4wRBEKtBooogiOcGt1GFN5rNmIrleeQqHIsjn8+h2uuAqNIA4kNvK1ZzZVkQTItrn/QqkVJ3BEFsCBJVBEE8V7AaqiqLGpVmFS6MSBgplsbe2M0mVFj1C5YFCm6YyewMCIIgygWJKoIgnltxdazOhgPVViRzRTgNpeJ0giCIrYJEFUEQzy0sEqVjFzLSJAhiG6DKS4IgCIIgiDJAooogCIIgCKIMkKgiCIIgCIIoAySqCIIgCIIgygCJKoIgCIIgiDJAooogCIIgCKIMkKgiCIIgCIIoA+RTRRD3/zMod85/h520LlqtFjsFp9P5tFeBIAhiRShSRRAEQRAEUQZIVBEEQRAEQZQBElUEQRAEQRBlgEQVQRAEQRBEGSBRRRAEQRAEUQZIVBEEQRAEQZQBElUEQRAEQRBlgEQVQRAEQRBEGSBRRRAEQRAEUQZIVBEEQRAEQZQBElUEQRAEQRBlgEQVQRAEQRBEGSBRRRAEQRAEUQZIVBEEQRAEQTyPokqn0+Hll1/ml2984xuQZRlf/epXcerUKXz6059GKBR62qtIEARBEATxGErsMCorK/HBBx88uP/d734XqVQK586dw7e+9S381m/9Fn7zN3/zqa4jQRAEQRDEjo9Uzc7O4syZM/jc5z6H0dFRnD17lkeoGJ/5zGf4/ZXIZrOIxWJLLgRBEARBEC9kpIoJKafTiXfeeQc/93M/h8bGRthsNv43q9WKcDi84mt/4zd+A1//+te3cW0JgiAIgiB2aKSKCSrGG2+8gbGxMdjtdkQiEf5YNBp9ILCW42tf+xp/zv3LxMTEtq03QRAEQRAvNjtKVCUSCRSLRX67q6uLCyyWCnzrrbf4Y+ya3V8JjUYDs9m85EIQBEEQBPHCpf+6u7vxC7/wCzCZTBAEAb/7u7+L3bt34+/+7u949x8TSaxYnSAIgiAIYqchyMyz4DmFFapbLBaeCqSoFUEQBEEQW6kTdlT6jyAIgiAI4lmFRBVBEARBEEQZIFFFEARBEARRBkhUEQRBEARBlAESVQRBEARBEGWARBVBEARBEEQZIFFFEARBEARRBkhUEQRBEARBlAESVQRBEARBEGWARBVBEARBEEQZIFFFEARBEARRBkhUEQRBEARBlAESVQRBEARBEGWARBVBEARBEEQZIFFFEARBEARRBkhUEQRBEARBlAESVQRBEARBEGWARBVBEARBEEQZIFFFEARBEARRBkhUEQRBEARBlAESVQRBEARBEGWARBVBEARBEEQZIFFFEARBEARRBkhUEQRBEARBlAESVQRBEARBEGWARBVBEARBEASJKoIgCIIgiJ0BRaoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgigDJKoIgiAIgiDKAIkqgiAIgiCIMkCiiiAIgiAIogyQqCIIgiAIgniRRNU3v/lNnDhxAidPnsSNGzee9uoQBEEQBEEsQYlngHA4jN/+7d/GpUuXMDU1hZ/6qZ/CRx999LRXiyAIgiAI4tkSVVeuXMGpU6egVqtRX1+PeDyObDYLjUaz5HnsMXa5TzQa5dexWGzb15kgCIIgiJ3NfX0gy/KLI6qCwSBsNtuD+1arFaFQCF6vd8nzfuM3fgNf//rXH3t9dXX1tqwnQRAEQRDPHkxnWCyWF0NU2e12RCKRJREo9tijfO1rX8Mv/dIvPbjPXlNbW4vx8fGybCxiqbpnYnViYgJms5k2TRmhbbt10LalbfssQvvt1sH0RE1NzbKa4rkVVUePHsU/+2f/DPl8HjMzMzAajY+l/hjsseUeZ4KKTvxbA9uutG1p2z5r0H5L2/ZZhPbbrUMUxRdHVLHU31e+8hWcOXMGgiDgP//n//y0V4kgCIIgCOLZE1WMn/3Zn+UXgiAIgiCIncgz41O1EVgq8F/+y3+5bEqQoG27U6H9lrbtswjtt7Rtn0XKvd8Kcrn6CAmCIAiCIF5gnutIFUEQBEEQxHZBooogCIIgCKIMkKgiCIIgCIIoA8+tqKIBzOVHp9Ph5Zdf5pdvfOMb3Nb/q1/9Kh8h9OlPf5q73BNr44033oDL5cKv/dqv8fsrbUt2ze6zx9nfqQRy/dv2gw8+4NMX7u+7169fp227QW7evMmH2p8+fRqvvvoqhoeHkclk8BM/8RN8H2XX7D5jdHSUP4c9/9d//dc3+pYv9LZl5zE2mu3+vstm3zJo227MQPXEiRN8Ox45cgTvvvvu1hx35eeQUCgk79+/X85ms/Lw8LB88uTJp71KzwWNjY1L7r/99tvyz/7sz/Lbf/iHfyj/6q/+6lNas2ePiYkJ+Q/+4A/kf/Nv/s2q25Jdf+tb3+K3//7f//v8ecT6tu37778v/9zP/dxjz6Ntu35mZmbkWCzGb3/nO9+Rf/Inf1L+nd/5Hflf/+t/zR/7+te/zu8zPv/5z8sffvghv/2xj31M7unpoV13ndt28X68GNq266dYLMr5fJ7fHhoakg8dOrQlx93nMlK10gBmYnPMzs5yA9bPfe5z/JfS2bNnuZpnfOYzn+H3ibVRVVW15P5K25K28ea3LeOdd9558KsznU7Ttt0gFRUVMJlM/DZrQVcqlSvuo7du3eLbnPGpT32Kjg8b2LaMb33rW3jppZfwz//5P4ckSbRtN+GYfn+bsqjVnj17tuS4+1yKqpUGMBOb476Q+oVf+AX83M/93JLtzLZxOBymTVyGfXbxtmT7LbtP+/HGOXjwIAYGBnDu3Dk+5uPf//t/T9t2kySTST467Jd/+Zcf23fvH2vvCwDadze+bX/4h38YPT09/Lg7NjaGb3/727RtNwFLnzKB+vrrr+NHfuRHtuS4+1yKqrUOYCbWh9PpfFCzwv6DL97ObBsvFrLExvfZxduSXbP7tB9vHPbrX6vV8tus5ufatWu0bTcBm8H6+c9/Hr/6q7+Kjo6Ox/bd+8faxbPU6Bi8sW3L/v8rFAp++cIXvvBg36VtuzEqKyvx0Ucf8WzWP/pH/2hLjrvPpahiA5jZhmM76Pj4+IoDmIm1k0gkUCwW+e2uri4usFgq8K233uKPsWt2n9gYK21L2sab5/7BkfHee++htbWVtu0GYdGnn/zJn8RnP/tZflltH927dy8uXLjAb7/99tu8AJtY37ZdHBxYvO/Stl0/i0uAWMSa/djaiuPuc+uo/vu///v4b//tvz0YwHzo0KGnvUrPNEzZs7Qf2xHZNv3t3/5t7N69m9eoMJHFdlKW+3c4HE97VZ8JvvzlL/MTDvuP3tnZib/4i79Ydluy8PSXvvSlBzUA/+W//JeyTVN/UbYtC/Wz44Fer+c/BthtFtKnbbt+/uzP/gw/8zM/8+B4yo4Bv/Vbv8Xnsk5OTvJ6tj/4gz/gkUHWvcbKBHK5HN58802e0iLWt23ZseAHP/gBrwVigup3f/d3oVKpaNtuANb1+4u/+Is86lcoFPCv/tW/wiuvvFL24+5zK6oIgiAIgiC2E/rJSxAEQRAEUQZIVBEEQRAEQZQBElUEQRAEQRBlgEQVQRAEQRBEGSBRRRAEQRAEUQZIVBEEQRAEQZQBElUEQRAEQRBlgEQVQRDPHV/72tf+n/buH5S+OIzj+GdQMigLysqAhBCJwWKhlKK7KElKSmSUwYCyYLNQFgNlkBITtywUElJiRfkTERb16/kOcn8/V133nH7nnt6vxTm3733uPaZPz/ne82hmZsaX2tXV1To9PfWlNoDUxsM/AYTK7e2tysvLdXFxoYyMDM/rLy8va2lpSSsrK57XBpDa6FQBCJWFhQU1NTX5EqhMS0uLtra2dHNz40t9AKmLUAUg0C4vL92U+IODA3d+dXWl7OxsbW9vf7vehvd+HYBqIau+vj5mjc2vtE6WsXlrfX19bj6dDV+vq6tzgWlwcNBNqy8sLNTh4eHne22uXWVlpTY3N326YgCpilAFINDy8/M1OTmpjo4Ovb6+qqurS52dnWpoaPh2/fHxsRs+m+gtvbGxMd3d3Sk9PV21tbWqqKhw521tbRoaGopZX1RUpKOjo6SuC0D4EKoABF5PT48KCgpUU1Oj6+trjY+Px137+PiozMzMhOq3tra67pN1oezY/tqUeptoH4lEYjpVxurb5wDAV4QqACkTrE5OTtTf3++6SfHYLbvn5+eEaufm5n4e216sv89fXl5i1lv9rKyshD4DQPgRqgAEnoUa2+PU3d2t0dFRPTw8xF1bWlqq8/PzmNfe3t4+j5+enpL+PmdnZyorK0u6DoBwIVQBCLyBgQFVVVVpbm5Ozc3N6u3tjbvWfvkXjUb/2We1t7enj48PTU9Pu9d+CmY/eX9/1/7+vhobG3/1fgDhRagCEGirq6va2NjQ7OysO5+amnK/BFxcXPx2ve2FWl9fj+lOFRcXa2RkRDk5Obq/v1d7e7vbK/Uba2trbpN8Xl7eL68IQFjx8E8AoTM8POwClN0ytEcqWIdrZ2fHk9q2WX5+fl4lJSWe1AMQHmn/+wsAgNcmJiZ8+6fu7u76VhtAauP2HwAAgAe4/QcAAOABOlUAAACEKgAAgGCgUwUAAOABQhUAAIAHCFUAAAAeIFQBAAB4gFAFAADgAUIVAACAkvcHjZ18/1w6s1cAAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 600x600 with 1 Axes>"
       ]
@@ -337,18 +337,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Last updated: 2025-11-14 14:32:42CET\n",
+      "Last updated: 2026-02-12 13:43:34 CET\n",
       "\n",
       "Python implementation: CPython\n",
-      "Python version       : 3.13.9\n",
-      "IPython version      : 9.7.0\n",
+      "Python version       : 3.13.11\n",
+      "IPython version      : 9.10.0\n",
       "\n",
-      "pywarper  : 0.2.4\n",
-      "numpy     : 2.3.4\n",
-      "matplotlib: 3.10.7\n",
-      "skeliner  : 0.2.3\n",
+      "matplotlib: 3.10.8\n",
+      "numpy     : 2.4.2\n",
+      "pywarper  : 0.2.5\n",
+      "skeliner  : 0.2.6\n",
       "\n",
-      "Watermark: 2.5.0\n",
+      "Watermark: 2.6.0\n",
       "\n"
      ]
     }
@@ -361,7 +361,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv (3.11.11)",
+   "display_name": "pywarper",
    "language": "python",
    "name": "python3"
   },
@@ -375,7 +375,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.9"
+   "version": "3.13.11"
   }
  },
  "nbformat": 4,
diff --git a/uv.lock b/uv.lock
index fd116c2..9d31fad 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2,7 +2,12 @@ version = 1
 revision = 3
 requires-python = ">=3.10.0"
 resolution-markers = [
-    "python_full_version >= '3.11'",
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
     "python_full_version < '3.11'",
 ]
 
@@ -14,12 +19,12 @@ dependencies = [
     { name = "click" },
     { name = "click-log" },
     { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "rtree" },
     { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.16.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "shapely" },
     { name = "trimesh" },
 ]
@@ -28,6 +33,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e4/ad/77fad9d6f974ec58d837cb49fb9b483d6227a420c4f908c3578633de1d47/alphashape-1.3.1-py2.py3-none-any.whl", hash = "sha256:96a5ddd5f09534a35f03a8916aeeaac00fe4d6bec2f9ad78f87f57be3007f795", size = 13122, upload-time = "2021-04-16T17:47:17.773Z" },
 ]
 
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
 [[package]]
 name = "appnope"
 version = "0.1.4"
@@ -37,13 +56,104 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" },
 ]
 
+[[package]]
+name = "argon2-cffi"
+version = "25.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "argon2-cffi-bindings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" },
+]
+
+[[package]]
+name = "argon2-cffi-bindings"
+version = "25.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" },
+    { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" },
+    { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" },
+    { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" },
+    { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" },
+    { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" },
+    { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" },
+    { url = "https://files.pythonhosted.org/packages/11/2d/ba4e4ca8d149f8dcc0d952ac0967089e1d759c7e5fcf0865a317eb680fbb/argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6dca33a9859abf613e22733131fc9194091c1fa7cb3e131c143056b4856aa47e", size = 24549, upload-time = "2025-07-30T10:02:00.101Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/82/9b2386cc75ac0bd3210e12a44bfc7fd1632065ed8b80d573036eecb10442/argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:21378b40e1b8d1655dd5310c84a40fc19a9aa5e6366e835ceb8576bf0fea716d", size = 25539, upload-time = "2025-07-30T10:02:00.929Z" },
+    { url = "https://files.pythonhosted.org/packages/31/db/740de99a37aa727623730c90d92c22c9e12585b3c98c54b7960f7810289f/argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d588dec224e2a83edbdc785a5e6f3c6cd736f46bfd4b441bbb5aa1f5085e584", size = 28467, upload-time = "2025-07-30T10:02:02.08Z" },
+    { url = "https://files.pythonhosted.org/packages/71/7a/47c4509ea18d755f44e2b92b7178914f0c113946d11e16e626df8eaa2b0b/argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5acb4e41090d53f17ca1110c3427f0a130f944b896fc8c83973219c97f57b690", size = 27355, upload-time = "2025-07-30T10:02:02.867Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/82/82745642d3c46e7cea25e1885b014b033f4693346ce46b7f47483cf5d448/argon2_cffi_bindings-25.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:da0c79c23a63723aa5d782250fbf51b768abca630285262fb5144ba5ae01e520", size = 29187, upload-time = "2025-07-30T10:02:03.674Z" },
+]
+
+[[package]]
+name = "arrow"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" },
+]
+
 [[package]]
 name = "asttokens"
-version = "3.0.0"
+version = "3.0.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" },
+]
+
+[[package]]
+name = "async-lru"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ef/c3/bbf34f15ea88dfb649ab2c40f9d75081784a50573a9ea431563cab64adb8/async_lru-2.1.0.tar.gz", hash = "sha256:9eeb2fecd3fe42cc8a787fc32ead53a3a7158cc43d039c3c55ab3e4e5b2a80ed", size = 12041, upload-time = "2026-01-17T22:52:18.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/e9/eb6a5db5ac505d5d45715388e92bced7a5bb556facc4d0865d192823f2d2/async_lru-2.1.0-py3-none-any.whl", hash = "sha256:fa12dcf99a42ac1280bc16c634bbaf06883809790f6304d85cdab3f666f33a7e", size = 6933, upload-time = "2026-01-17T22:52:17.389Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "babel"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" },
 ]
 
 [[package]]
@@ -55,13 +165,43 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" },
 ]
 
+[[package]]
+name = "beautifulsoup4"
+version = "4.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" },
+]
+
+[[package]]
+name = "bleach"
+version = "6.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/07/18/3c8523962314be6bf4c8989c79ad9531c825210dd13a8669f6b84336e8bd/bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22", size = 203533, upload-time = "2025-10-27T17:57:39.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cd/3a/577b549de0cc09d95f11087ee63c739bba856cd3952697eec4c4bb91350a/bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6", size = 164437, upload-time = "2025-10-27T17:57:37.538Z" },
+]
+
+[package.optional-dependencies]
+css = [
+    { name = "tinycss2" },
+]
+
 [[package]]
 name = "certifi"
-version = "2025.11.12"
+version = "2026.1.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
 ]
 
 [[package]]
@@ -237,14 +377,14 @@ wheels = [
 
 [[package]]
 name = "click"
-version = "8.3.0"
+version = "8.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
 [[package]]
@@ -352,10 +492,15 @@ name = "contourpy"
 version = "1.3.3"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version >= '3.11'",
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
 wheels = [
@@ -434,45 +579,45 @@ wheels = [
 
 [[package]]
 name = "cryptography"
-version = "46.0.3"
+version = "46.0.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "cffi", marker = "(python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'emscripten') or (python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'win32') or (platform_python_implementation != 'PyPy' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
-    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
-    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
-    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
-    { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
-    { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
-    { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
-    { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
-    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
-    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
-    { url = "https://files.pythonhosted.org/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload-time = "2025-10-15T23:18:18.695Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload-time = "2025-10-15T23:18:20.597Z" },
-    { url = "https://files.pythonhosted.org/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload-time = "2025-10-15T23:18:22.18Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload-time = "2025-10-15T23:18:24.209Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
+    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
+    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
+    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
+    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/6f/6cc6cc9955caa6eaf83660b0da2b077c7fe8ff9950a3c5e45d605038d439/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a", size = 4218321, upload-time = "2026-02-10T19:18:22.349Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/5d/c4da701939eeee699566a6c1367427ab91a8b7088cc2328c09dbee940415/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356", size = 4381786, upload-time = "2026-02-10T19:18:24.529Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/97/a538654732974a94ff96c1db621fa464f455c02d4bb7d2652f4edc21d600/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da", size = 4217990, upload-time = "2026-02-10T19:18:25.957Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/11/7e500d2dd3ba891197b9efd2da5454b74336d64a7cc419aa7327ab74e5f6/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257", size = 4381252, upload-time = "2026-02-10T19:18:27.496Z" },
 ]
 
 [[package]]
@@ -486,31 +631,31 @@ wheels = [
 
 [[package]]
 name = "debugpy"
-version = "1.8.17"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/ad/71e708ff4ca377c4230530d6a7aa7992592648c122a2cd2b321cf8b35a76/debugpy-1.8.17.tar.gz", hash = "sha256:fd723b47a8c08892b1a16b2c6239a8b96637c62a59b94bb5dab4bac592a58a8e", size = 1644129, upload-time = "2025-09-17T16:33:20.633Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/36/b57c6e818d909f6e59c0182252921cf435e0951126a97e11de37e72ab5e1/debugpy-1.8.17-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:c41d2ce8bbaddcc0009cc73f65318eedfa3dbc88a8298081deb05389f1ab5542", size = 2098021, upload-time = "2025-09-17T16:33:22.556Z" },
-    { url = "https://files.pythonhosted.org/packages/be/01/0363c7efdd1e9febd090bb13cee4fb1057215b157b2979a4ca5ccb678217/debugpy-1.8.17-cp310-cp310-manylinux_2_34_x86_64.whl", hash = "sha256:1440fd514e1b815edd5861ca394786f90eb24960eb26d6f7200994333b1d79e3", size = 3087399, upload-time = "2025-09-17T16:33:24.292Z" },
-    { url = "https://files.pythonhosted.org/packages/79/bc/4a984729674aa9a84856650438b9665f9a1d5a748804ac6f37932ce0d4aa/debugpy-1.8.17-cp310-cp310-win32.whl", hash = "sha256:3a32c0af575749083d7492dc79f6ab69f21b2d2ad4cd977a958a07d5865316e4", size = 5230292, upload-time = "2025-09-17T16:33:26.137Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/19/2b9b3092d0cf81a5aa10c86271999453030af354d1a5a7d6e34c574515d7/debugpy-1.8.17-cp310-cp310-win_amd64.whl", hash = "sha256:a3aad0537cf4d9c1996434be68c6c9a6d233ac6f76c2a482c7803295b4e4f99a", size = 5261885, upload-time = "2025-09-17T16:33:27.592Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/53/3af72b5c159278c4a0cf4cffa518675a0e73bdb7d1cac0239b815502d2ce/debugpy-1.8.17-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:d3fce3f0e3de262a3b67e69916d001f3e767661c6e1ee42553009d445d1cd840", size = 2207154, upload-time = "2025-09-17T16:33:29.457Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/6d/204f407df45600e2245b4a39860ed4ba32552330a0b3f5f160ae4cc30072/debugpy-1.8.17-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:c6bdf134457ae0cac6fb68205776be635d31174eeac9541e1d0c062165c6461f", size = 3170322, upload-time = "2025-09-17T16:33:30.837Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/13/1b8f87d39cf83c6b713de2620c31205299e6065622e7dd37aff4808dd410/debugpy-1.8.17-cp311-cp311-win32.whl", hash = "sha256:e79a195f9e059edfe5d8bf6f3749b2599452d3e9380484cd261f6b7cd2c7c4da", size = 5155078, upload-time = "2025-09-17T16:33:33.331Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/c5/c012c60a2922cc91caa9675d0ddfbb14ba59e1e36228355f41cab6483469/debugpy-1.8.17-cp311-cp311-win_amd64.whl", hash = "sha256:b532282ad4eca958b1b2d7dbcb2b7218e02cb934165859b918e3b6ba7772d3f4", size = 5179011, upload-time = "2025-09-17T16:33:35.711Z" },
-    { url = "https://files.pythonhosted.org/packages/08/2b/9d8e65beb2751876c82e1aceb32f328c43ec872711fa80257c7674f45650/debugpy-1.8.17-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:f14467edef672195c6f6b8e27ce5005313cb5d03c9239059bc7182b60c176e2d", size = 2549522, upload-time = "2025-09-17T16:33:38.466Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/78/eb0d77f02971c05fca0eb7465b18058ba84bd957062f5eec82f941ac792a/debugpy-1.8.17-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:24693179ef9dfa20dca8605905a42b392be56d410c333af82f1c5dff807a64cc", size = 4309417, upload-time = "2025-09-17T16:33:41.299Z" },
-    { url = "https://files.pythonhosted.org/packages/37/42/c40f1d8cc1fed1e75ea54298a382395b8b937d923fcf41ab0797a554f555/debugpy-1.8.17-cp312-cp312-win32.whl", hash = "sha256:6a4e9dacf2cbb60d2514ff7b04b4534b0139facbf2abdffe0639ddb6088e59cf", size = 5277130, upload-time = "2025-09-17T16:33:43.554Z" },
-    { url = "https://files.pythonhosted.org/packages/72/22/84263b205baad32b81b36eac076de0cdbe09fe2d0637f5b32243dc7c925b/debugpy-1.8.17-cp312-cp312-win_amd64.whl", hash = "sha256:e8f8f61c518952fb15f74a302e068b48d9c4691768ade433e4adeea961993464", size = 5319053, upload-time = "2025-09-17T16:33:53.033Z" },
-    { url = "https://files.pythonhosted.org/packages/50/76/597e5cb97d026274ba297af8d89138dfd9e695767ba0e0895edb20963f40/debugpy-1.8.17-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:857c1dd5d70042502aef1c6d1c2801211f3ea7e56f75e9c335f434afb403e464", size = 2538386, upload-time = "2025-09-17T16:33:54.594Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/60/ce5c34fcdfec493701f9d1532dba95b21b2f6394147234dce21160bd923f/debugpy-1.8.17-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:3bea3b0b12f3946e098cce9b43c3c46e317b567f79570c3f43f0b96d00788088", size = 4292100, upload-time = "2025-09-17T16:33:56.353Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/95/7873cf2146577ef71d2a20bf553f12df865922a6f87b9e8ee1df04f01785/debugpy-1.8.17-cp313-cp313-win32.whl", hash = "sha256:e34ee844c2f17b18556b5bbe59e1e2ff4e86a00282d2a46edab73fd7f18f4a83", size = 5277002, upload-time = "2025-09-17T16:33:58.231Z" },
-    { url = "https://files.pythonhosted.org/packages/46/11/18c79a1cee5ff539a94ec4aa290c1c069a5580fd5cfd2fb2e282f8e905da/debugpy-1.8.17-cp313-cp313-win_amd64.whl", hash = "sha256:6c5cd6f009ad4fca8e33e5238210dc1e5f42db07d4b6ab21ac7ffa904a196420", size = 5319047, upload-time = "2025-09-17T16:34:00.586Z" },
-    { url = "https://files.pythonhosted.org/packages/de/45/115d55b2a9da6de812696064ceb505c31e952c5d89c4ed1d9bb983deec34/debugpy-1.8.17-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:045290c010bcd2d82bc97aa2daf6837443cd52f6328592698809b4549babcee1", size = 2536899, upload-time = "2025-09-17T16:34:02.657Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/73/2aa00c7f1f06e997ef57dc9b23d61a92120bec1437a012afb6d176585197/debugpy-1.8.17-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:b69b6bd9dba6a03632534cdf67c760625760a215ae289f7489a452af1031fe1f", size = 4268254, upload-time = "2025-09-17T16:34:04.486Z" },
-    { url = "https://files.pythonhosted.org/packages/86/b5/ed3e65c63c68a6634e3ba04bd10255c8e46ec16ebed7d1c79e4816d8a760/debugpy-1.8.17-cp314-cp314-win32.whl", hash = "sha256:5c59b74aa5630f3a5194467100c3b3d1c77898f9ab27e3f7dc5d40fc2f122670", size = 5277203, upload-time = "2025-09-17T16:34:06.65Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/26/394276b71c7538445f29e792f589ab7379ae70fd26ff5577dfde71158e96/debugpy-1.8.17-cp314-cp314-win_amd64.whl", hash = "sha256:893cba7bb0f55161de4365584b025f7064e1f88913551bcd23be3260b231429c", size = 5318493, upload-time = "2025-09-17T16:34:08.483Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/d0/89247ec250369fc76db477720a26b2fce7ba079ff1380e4ab4529d2fe233/debugpy-1.8.17-py2.py3-none-any.whl", hash = "sha256:60c7dca6571efe660ccb7a9508d73ca14b8796c4ed484c2002abba714226cfef", size = 5283210, upload-time = "2025-09-17T16:34:25.835Z" },
+version = "1.8.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/b7/cd8080344452e4874aae67c40d8940e2b4d47b01601a8fd9f44786c757c7/debugpy-1.8.20.tar.gz", hash = "sha256:55bc8701714969f1ab89a6d5f2f3d40c36f91b2cbe2f65d98bf8196f6a6a2c33", size = 1645207, upload-time = "2026-01-29T23:03:28.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/be/8bd693a0b9d53d48c8978fa5d889e06f3b5b03e45fd1ea1e78267b4887cb/debugpy-1.8.20-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:157e96ffb7f80b3ad36d808646198c90acb46fdcfd8bb1999838f0b6f2b59c64", size = 2099192, upload-time = "2026-01-29T23:03:29.707Z" },
+    { url = "https://files.pythonhosted.org/packages/77/1b/85326d07432086a06361d493d2743edd0c4fc2ef62162be7f8618441ac37/debugpy-1.8.20-cp310-cp310-manylinux_2_34_x86_64.whl", hash = "sha256:c1178ae571aff42e61801a38b007af504ec8e05fde1c5c12e5a7efef21009642", size = 3088568, upload-time = "2026-01-29T23:03:31.467Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/60/3e08462ee3eccd10998853eb35947c416e446bfe2bc37dbb886b9044586c/debugpy-1.8.20-cp310-cp310-win32.whl", hash = "sha256:c29dd9d656c0fbd77906a6e6a82ae4881514aa3294b94c903ff99303e789b4a2", size = 5284399, upload-time = "2026-01-29T23:03:33.678Z" },
+    { url = "https://files.pythonhosted.org/packages/72/43/09d49106e770fe558ced5e80df2e3c2ebee10e576eda155dcc5670473663/debugpy-1.8.20-cp310-cp310-win_amd64.whl", hash = "sha256:3ca85463f63b5dd0aa7aaa933d97cbc47c174896dcae8431695872969f981893", size = 5316388, upload-time = "2026-01-29T23:03:35.095Z" },
+    { url = "https://files.pythonhosted.org/packages/51/56/c3baf5cbe4dd77427fd9aef99fcdade259ad128feeb8a786c246adb838e5/debugpy-1.8.20-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:eada6042ad88fa1571b74bd5402ee8b86eded7a8f7b827849761700aff171f1b", size = 2208318, upload-time = "2026-01-29T23:03:36.481Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/7d/4fa79a57a8e69fe0d9763e98d1110320f9ecd7f1f362572e3aafd7417c9d/debugpy-1.8.20-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:7de0b7dfeedc504421032afba845ae2a7bcc32ddfb07dae2c3ca5442f821c344", size = 3171493, upload-time = "2026-01-29T23:03:37.775Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/f2/1e8f8affe51e12a26f3a8a8a4277d6e60aa89d0a66512f63b1e799d424a4/debugpy-1.8.20-cp311-cp311-win32.whl", hash = "sha256:773e839380cf459caf73cc533ea45ec2737a5cc184cf1b3b796cd4fd98504fec", size = 5209240, upload-time = "2026-01-29T23:03:39.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/92/1cb532e88560cbee973396254b21bece8c5d7c2ece958a67afa08c9f10dc/debugpy-1.8.20-cp311-cp311-win_amd64.whl", hash = "sha256:1f7650546e0eded1902d0f6af28f787fa1f1dbdbc97ddabaf1cd963a405930cb", size = 5233481, upload-time = "2026-01-29T23:03:40.659Z" },
+    { url = "https://files.pythonhosted.org/packages/14/57/7f34f4736bfb6e00f2e4c96351b07805d83c9a7b33d28580ae01374430f7/debugpy-1.8.20-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:4ae3135e2089905a916909ef31922b2d733d756f66d87345b3e5e52b7a55f13d", size = 2550686, upload-time = "2026-01-29T23:03:42.023Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/78/b193a3975ca34458f6f0e24aaf5c3e3da72f5401f6054c0dfd004b41726f/debugpy-1.8.20-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:88f47850a4284b88bd2bfee1f26132147d5d504e4e86c22485dfa44b97e19b4b", size = 4310588, upload-time = "2026-01-29T23:03:43.314Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/55/f14deb95eaf4f30f07ef4b90a8590fc05d9e04df85ee379712f6fb6736d7/debugpy-1.8.20-cp312-cp312-win32.whl", hash = "sha256:4057ac68f892064e5f98209ab582abfee3b543fb55d2e87610ddc133a954d390", size = 5331372, upload-time = "2026-01-29T23:03:45.526Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/39/2bef246368bd42f9bd7cba99844542b74b84dacbdbea0833e610f384fee8/debugpy-1.8.20-cp312-cp312-win_amd64.whl", hash = "sha256:a1a8f851e7cf171330679ef6997e9c579ef6dd33c9098458bd9986a0f4ca52e3", size = 5372835, upload-time = "2026-01-29T23:03:47.245Z" },
+    { url = "https://files.pythonhosted.org/packages/15/e2/fc500524cc6f104a9d049abc85a0a8b3f0d14c0a39b9c140511c61e5b40b/debugpy-1.8.20-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:5dff4bb27027821fdfcc9e8f87309a28988231165147c31730128b1c983e282a", size = 2539560, upload-time = "2026-01-29T23:03:48.738Z" },
+    { url = "https://files.pythonhosted.org/packages/90/83/fb33dcea789ed6018f8da20c5a9bc9d82adc65c0c990faed43f7c955da46/debugpy-1.8.20-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:84562982dd7cf5ebebfdea667ca20a064e096099997b175fe204e86817f64eaf", size = 4293272, upload-time = "2026-01-29T23:03:50.169Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/25/b1e4a01bfb824d79a6af24b99ef291e24189080c93576dfd9b1a2815cd0f/debugpy-1.8.20-cp313-cp313-win32.whl", hash = "sha256:da11dea6447b2cadbf8ce2bec59ecea87cc18d2c574980f643f2d2dfe4862393", size = 5331208, upload-time = "2026-01-29T23:03:51.547Z" },
+    { url = "https://files.pythonhosted.org/packages/13/f7/a0b368ce54ffff9e9028c098bd2d28cfc5b54f9f6c186929083d4c60ba58/debugpy-1.8.20-cp313-cp313-win_amd64.whl", hash = "sha256:eb506e45943cab2efb7c6eafdd65b842f3ae779f020c82221f55aca9de135ed7", size = 5372930, upload-time = "2026-01-29T23:03:53.585Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2e/f6cb9a8a13f5058f0a20fe09711a7b726232cd5a78c6a7c05b2ec726cff9/debugpy-1.8.20-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9c74df62fc064cd5e5eaca1353a3ef5a5d50da5eb8058fcef63106f7bebe6173", size = 2538066, upload-time = "2026-01-29T23:03:54.999Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/56/6ddca50b53624e1ca3ce1d1e49ff22db46c47ea5fb4c0cc5c9b90a616364/debugpy-1.8.20-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:077a7447589ee9bc1ff0cdf443566d0ecf540ac8aa7333b775ebcb8ce9f4ecad", size = 4269425, upload-time = "2026-01-29T23:03:56.518Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/d9/d64199c14a0d4c476df46c82470a3ce45c8d183a6796cfb5e66533b3663c/debugpy-1.8.20-cp314-cp314-win32.whl", hash = "sha256:352036a99dd35053b37b7803f748efc456076f929c6a895556932eaf2d23b07f", size = 5331407, upload-time = "2026-01-29T23:03:58.481Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/d9/1f07395b54413432624d61524dfd98c1a7c7827d2abfdb8829ac92638205/debugpy-1.8.20-cp314-cp314-win_amd64.whl", hash = "sha256:a98eec61135465b062846112e5ecf2eebb855305acc1dfbae43b72903b8ab5be", size = 5372521, upload-time = "2026-01-29T23:03:59.864Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/c3/7f67dea8ccf8fdcb9c99033bbe3e90b9e7395415843accb81428c441be2d/debugpy-1.8.20-py2.py3-none-any.whl", hash = "sha256:5be9bed9ae3be00665a06acaa48f8329d2b9632f15fd09f6a9a8c8d9907e54d7", size = 5337658, upload-time = "2026-01-29T23:04:17.404Z" },
 ]
 
 [[package]]
@@ -522,25 +667,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },
 ]
 
+[[package]]
+name = "defusedxml"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" },
+]
+
 [[package]]
 name = "docutils"
-version = "0.22.3"
+version = "0.22.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d9/02/111134bfeb6e6c7ac4c74594e39a59f6c0195dc4846afbeac3cba60f1927/docutils-0.22.3.tar.gz", hash = "sha256:21486ae730e4ca9f622677b1412b879af1791efcfba517e4c6f60be543fc8cdd", size = 2290153, upload-time = "2025-11-06T02:35:55.655Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/b6/03bb70946330e88ffec97aefd3ea75ba575cb2e762061e0e62a213befee8/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968", size = 2291750, upload-time = "2025-12-18T19:00:26.443Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/11/a8/c6a4b901d17399c77cd81fb001ce8961e9f5e04d3daf27e8925cb012e163/docutils-0.22.3-py3-none-any.whl", hash = "sha256:bd772e4aca73aff037958d44f2be5229ded4c09927fcf8690c577b66234d6ceb", size = 633032, upload-time = "2025-11-06T02:35:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" },
 ]
 
 [[package]]
 name = "exceptiongroup"
-version = "1.3.0"
+version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
 ]
 
 [[package]]
@@ -552,73 +706,128 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
 ]
 
+[[package]]
+name = "fastjsonschema"
+version = "2.21.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" },
+]
+
 [[package]]
 name = "fonttools"
-version = "4.60.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4b/42/97a13e47a1e51a5a7142475bbcf5107fe3a68fc34aef331c897d5fb98ad0/fonttools-4.60.1.tar.gz", hash = "sha256:ef00af0439ebfee806b25f24c8f92109157ff3fac5731dc7867957812e87b8d9", size = 3559823, upload-time = "2025-09-29T21:13:27.129Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/26/70/03e9d89a053caff6ae46053890eba8e4a5665a7c5638279ed4492e6d4b8b/fonttools-4.60.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9a52f254ce051e196b8fe2af4634c2d2f02c981756c6464dc192f1b6050b4e28", size = 2810747, upload-time = "2025-09-29T21:10:59.653Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/41/449ad5aff9670ab0df0f61ee593906b67a36d7e0b4d0cd7fa41ac0325bf5/fonttools-4.60.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c7420a2696a44650120cdd269a5d2e56a477e2bfa9d95e86229059beb1c19e15", size = 2346909, upload-time = "2025-09-29T21:11:02.882Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/18/e5970aa96c8fad1cb19a9479cc3b7602c0c98d250fcdc06a5da994309c50/fonttools-4.60.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee0c0b3b35b34f782afc673d503167157094a16f442ace7c6c5e0ca80b08f50c", size = 4864572, upload-time = "2025-09-29T21:11:05.096Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/20/9b2b4051b6ec6689480787d506b5003f72648f50972a92d04527a456192c/fonttools-4.60.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:282dafa55f9659e8999110bd8ed422ebe1c8aecd0dc396550b038e6c9a08b8ea", size = 4794635, upload-time = "2025-09-29T21:11:08.651Z" },
-    { url = "https://files.pythonhosted.org/packages/10/52/c791f57347c1be98f8345e3dca4ac483eb97666dd7c47f3059aeffab8b59/fonttools-4.60.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4ba4bd646e86de16160f0fb72e31c3b9b7d0721c3e5b26b9fa2fc931dfdb2652", size = 4843878, upload-time = "2025-09-29T21:11:10.893Z" },
-    { url = "https://files.pythonhosted.org/packages/69/e9/35c24a8d01644cee8c090a22fad34d5b61d1e0a8ecbc9945ad785ebf2e9e/fonttools-4.60.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0b0835ed15dd5b40d726bb61c846a688f5b4ce2208ec68779bc81860adb5851a", size = 4954555, upload-time = "2025-09-29T21:11:13.24Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/86/fb1e994971be4bdfe3a307de6373ef69a9df83fb66e3faa9c8114893d4cc/fonttools-4.60.1-cp310-cp310-win32.whl", hash = "sha256:1525796c3ffe27bb6268ed2a1bb0dcf214d561dfaf04728abf01489eb5339dce", size = 2232019, upload-time = "2025-09-29T21:11:15.73Z" },
-    { url = "https://files.pythonhosted.org/packages/40/84/62a19e2bd56f0e9fb347486a5b26376bade4bf6bbba64dda2c103bd08c94/fonttools-4.60.1-cp310-cp310-win_amd64.whl", hash = "sha256:268ecda8ca6cb5c4f044b1fb9b3b376e8cd1b361cef275082429dc4174907038", size = 2276803, upload-time = "2025-09-29T21:11:18.152Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/85/639aa9bface1537e0fb0f643690672dde0695a5bbbc90736bc571b0b1941/fonttools-4.60.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7b4c32e232a71f63a5d00259ca3d88345ce2a43295bb049d21061f338124246f", size = 2831872, upload-time = "2025-09-29T21:11:20.329Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/47/3c63158459c95093be9618794acb1067b3f4d30dcc5c3e8114b70e67a092/fonttools-4.60.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3630e86c484263eaac71d117085d509cbcf7b18f677906824e4bace598fb70d2", size = 2356990, upload-time = "2025-09-29T21:11:22.754Z" },
-    { url = "https://files.pythonhosted.org/packages/94/dd/1934b537c86fcf99f9761823f1fc37a98fbd54568e8e613f29a90fed95a9/fonttools-4.60.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5c1015318e4fec75dd4943ad5f6a206d9727adf97410d58b7e32ab644a807914", size = 5042189, upload-time = "2025-09-29T21:11:25.061Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/d2/9f4e4c4374dd1daa8367784e1bd910f18ba886db1d6b825b12edf6db3edc/fonttools-4.60.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e6c58beb17380f7c2ea181ea11e7db8c0ceb474c9dd45f48e71e2cb577d146a1", size = 4978683, upload-time = "2025-09-29T21:11:27.693Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c4/0fb2dfd1ecbe9a07954cc13414713ed1eab17b1c0214ef07fc93df234a47/fonttools-4.60.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec3681a0cb34c255d76dd9d865a55f260164adb9fa02628415cdc2d43ee2c05d", size = 5021372, upload-time = "2025-09-29T21:11:30.257Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/d5/495fc7ae2fab20223cc87179a8f50f40f9a6f821f271ba8301ae12bb580f/fonttools-4.60.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f4b5c37a5f40e4d733d3bbaaef082149bee5a5ea3156a785ff64d949bd1353fa", size = 5132562, upload-time = "2025-09-29T21:11:32.737Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/fa/021dab618526323c744e0206b3f5c8596a2e7ae9aa38db5948a131123e83/fonttools-4.60.1-cp311-cp311-win32.whl", hash = "sha256:398447f3d8c0c786cbf1209711e79080a40761eb44b27cdafffb48f52bcec258", size = 2230288, upload-time = "2025-09-29T21:11:35.015Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/78/0e1a6d22b427579ea5c8273e1c07def2f325b977faaf60bb7ddc01456cb1/fonttools-4.60.1-cp311-cp311-win_amd64.whl", hash = "sha256:d066ea419f719ed87bc2c99a4a4bfd77c2e5949cb724588b9dd58f3fd90b92bf", size = 2278184, upload-time = "2025-09-29T21:11:37.434Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/f7/a10b101b7a6f8836a5adb47f2791f2075d044a6ca123f35985c42edc82d8/fonttools-4.60.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7b0c6d57ab00dae9529f3faf187f2254ea0aa1e04215cf2f1a8ec277c96661bc", size = 2832953, upload-time = "2025-09-29T21:11:39.616Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/fe/7bd094b59c926acf2304d2151354ddbeb74b94812f3dc943c231db09cb41/fonttools-4.60.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:839565cbf14645952d933853e8ade66a463684ed6ed6c9345d0faf1f0e868877", size = 2352706, upload-time = "2025-09-29T21:11:41.826Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/ca/4bb48a26ed95a1e7eba175535fe5805887682140ee0a0d10a88e1de84208/fonttools-4.60.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8177ec9676ea6e1793c8a084a90b65a9f778771998eb919d05db6d4b1c0b114c", size = 4923716, upload-time = "2025-09-29T21:11:43.893Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/9f/2cb82999f686c1d1ddf06f6ae1a9117a880adbec113611cc9d22b2fdd465/fonttools-4.60.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:996a4d1834524adbb423385d5a629b868ef9d774670856c63c9a0408a3063401", size = 4968175, upload-time = "2025-09-29T21:11:46.439Z" },
-    { url = "https://files.pythonhosted.org/packages/18/79/be569699e37d166b78e6218f2cde8c550204f2505038cdd83b42edc469b9/fonttools-4.60.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a46b2f450bc79e06ef3b6394f0c68660529ed51692606ad7f953fc2e448bc903", size = 4911031, upload-time = "2025-09-29T21:11:48.977Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/9f/89411cc116effaec5260ad519162f64f9c150e5522a27cbb05eb62d0c05b/fonttools-4.60.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6ec722ee589e89a89f5b7574f5c45604030aa6ae24cb2c751e2707193b466fed", size = 5062966, upload-time = "2025-09-29T21:11:54.344Z" },
-    { url = "https://files.pythonhosted.org/packages/62/a1/f888221934b5731d46cb9991c7a71f30cb1f97c0ef5fcf37f8da8fce6c8e/fonttools-4.60.1-cp312-cp312-win32.whl", hash = "sha256:b2cf105cee600d2de04ca3cfa1f74f1127f8455b71dbad02b9da6ec266e116d6", size = 2218750, upload-time = "2025-09-29T21:11:56.601Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8f/a55b5550cd33cd1028601df41acd057d4be20efa5c958f417b0c0613924d/fonttools-4.60.1-cp312-cp312-win_amd64.whl", hash = "sha256:992775c9fbe2cf794786fa0ffca7f09f564ba3499b8fe9f2f80bd7197db60383", size = 2267026, upload-time = "2025-09-29T21:11:58.852Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/5b/cdd2c612277b7ac7ec8c0c9bc41812c43dc7b2d5f2b0897e15fdf5a1f915/fonttools-4.60.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f68576bb4bbf6060c7ab047b1574a1ebe5c50a17de62830079967b211059ebb", size = 2825777, upload-time = "2025-09-29T21:12:01.22Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/8a/de9cc0540f542963ba5e8f3a1f6ad48fa211badc3177783b9d5cadf79b5d/fonttools-4.60.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:eedacb5c5d22b7097482fa834bda0dafa3d914a4e829ec83cdea2a01f8c813c4", size = 2348080, upload-time = "2025-09-29T21:12:03.785Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/8b/371ab3cec97ee3fe1126b3406b7abd60c8fec8975fd79a3c75cdea0c3d83/fonttools-4.60.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b33a7884fabd72bdf5f910d0cf46be50dce86a0362a65cfc746a4168c67eb96c", size = 4903082, upload-time = "2025-09-29T21:12:06.382Z" },
-    { url = "https://files.pythonhosted.org/packages/04/05/06b1455e4bc653fcb2117ac3ef5fa3a8a14919b93c60742d04440605d058/fonttools-4.60.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2409d5fb7b55fd70f715e6d34e7a6e4f7511b8ad29a49d6df225ee76da76dd77", size = 4960125, upload-time = "2025-09-29T21:12:09.314Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/37/f3b840fcb2666f6cb97038793606bdd83488dca2d0b0fc542ccc20afa668/fonttools-4.60.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8651e0d4b3bdeda6602b85fdc2abbefc1b41e573ecb37b6779c4ca50753a199", size = 4901454, upload-time = "2025-09-29T21:12:11.931Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/9e/eb76f77e82f8d4a46420aadff12cec6237751b0fb9ef1de373186dcffb5f/fonttools-4.60.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:145daa14bf24824b677b9357c5e44fd8895c2a8f53596e1b9ea3496081dc692c", size = 5044495, upload-time = "2025-09-29T21:12:15.241Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/b3/cede8f8235d42ff7ae891bae8d619d02c8ac9fd0cfc450c5927a6200c70d/fonttools-4.60.1-cp313-cp313-win32.whl", hash = "sha256:2299df884c11162617a66b7c316957d74a18e3758c0274762d2cc87df7bc0272", size = 2217028, upload-time = "2025-09-29T21:12:17.96Z" },
-    { url = "https://files.pythonhosted.org/packages/75/4d/b022c1577807ce8b31ffe055306ec13a866f2337ecee96e75b24b9b753ea/fonttools-4.60.1-cp313-cp313-win_amd64.whl", hash = "sha256:a3db56f153bd4c5c2b619ab02c5db5192e222150ce5a1bc10f16164714bc39ac", size = 2266200, upload-time = "2025-09-29T21:12:20.14Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/83/752ca11c1aa9a899b793a130f2e466b79ea0cf7279c8d79c178fc954a07b/fonttools-4.60.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:a884aef09d45ba1206712c7dbda5829562d3fea7726935d3289d343232ecb0d3", size = 2822830, upload-time = "2025-09-29T21:12:24.406Z" },
-    { url = "https://files.pythonhosted.org/packages/57/17/bbeab391100331950a96ce55cfbbff27d781c1b85ebafb4167eae50d9fe3/fonttools-4.60.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8a44788d9d91df72d1a5eac49b31aeb887a5f4aab761b4cffc4196c74907ea85", size = 2345524, upload-time = "2025-09-29T21:12:26.819Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/2e/d4831caa96d85a84dd0da1d9f90d81cec081f551e0ea216df684092c6c97/fonttools-4.60.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e852d9dda9f93ad3651ae1e3bb770eac544ec93c3807888798eccddf84596537", size = 4843490, upload-time = "2025-09-29T21:12:29.123Z" },
-    { url = "https://files.pythonhosted.org/packages/49/13/5e2ea7c7a101b6fc3941be65307ef8df92cbbfa6ec4804032baf1893b434/fonttools-4.60.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:154cb6ee417e417bf5f7c42fe25858c9140c26f647c7347c06f0cc2d47eff003", size = 4944184, upload-time = "2025-09-29T21:12:31.414Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/2b/cf9603551c525b73fc47c52ee0b82a891579a93d9651ed694e4e2cd08bb8/fonttools-4.60.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5664fd1a9ea7f244487ac8f10340c4e37664675e8667d6fee420766e0fb3cf08", size = 4890218, upload-time = "2025-09-29T21:12:33.936Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/2f/933d2352422e25f2376aae74f79eaa882a50fb3bfef3c0d4f50501267101/fonttools-4.60.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:583b7f8e3c49486e4d489ad1deacfb8d5be54a8ef34d6df824f6a171f8511d99", size = 4999324, upload-time = "2025-09-29T21:12:36.637Z" },
-    { url = "https://files.pythonhosted.org/packages/38/99/234594c0391221f66216bc2c886923513b3399a148defaccf81dc3be6560/fonttools-4.60.1-cp314-cp314-win32.whl", hash = "sha256:66929e2ea2810c6533a5184f938502cfdaea4bc3efb7130d8cc02e1c1b4108d6", size = 2220861, upload-time = "2025-09-29T21:12:39.108Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/1d/edb5b23726dde50fc4068e1493e4fc7658eeefcaf75d4c5ffce067d07ae5/fonttools-4.60.1-cp314-cp314-win_amd64.whl", hash = "sha256:f3d5be054c461d6a2268831f04091dc82753176f6ea06dc6047a5e168265a987", size = 2270934, upload-time = "2025-09-29T21:12:41.339Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/da/1392aaa2170adc7071fe7f9cfd181a5684a7afcde605aebddf1fb4d76df5/fonttools-4.60.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:b6379e7546ba4ae4b18f8ae2b9bc5960936007a1c0e30b342f662577e8bc3299", size = 2894340, upload-time = "2025-09-29T21:12:43.774Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/a7/3b9f16e010d536ce567058b931a20b590d8f3177b2eda09edd92e392375d/fonttools-4.60.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9d0ced62b59e0430b3690dbc5373df1c2aa7585e9a8ce38eff87f0fd993c5b01", size = 2375073, upload-time = "2025-09-29T21:12:46.437Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/b5/e9bcf51980f98e59bb5bb7c382a63c6f6cac0eec5f67de6d8f2322382065/fonttools-4.60.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:875cb7764708b3132637f6c5fb385b16eeba0f7ac9fa45a69d35e09b47045801", size = 4849758, upload-time = "2025-09-29T21:12:48.694Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/dc/1d2cf7d1cba82264b2f8385db3f5960e3d8ce756b4dc65b700d2c496f7e9/fonttools-4.60.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a184b2ea57b13680ab6d5fbde99ccef152c95c06746cb7718c583abd8f945ccc", size = 5085598, upload-time = "2025-09-29T21:12:51.081Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/4d/279e28ba87fb20e0c69baf72b60bbf1c4d873af1476806a7b5f2b7fac1ff/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:026290e4ec76583881763fac284aca67365e0be9f13a7fb137257096114cb3bc", size = 4957603, upload-time = "2025-09-29T21:12:53.423Z" },
-    { url = "https://files.pythonhosted.org/packages/78/d4/ff19976305e0c05aa3340c805475abb00224c954d3c65e82c0a69633d55d/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f0e8817c7d1a0c2eedebf57ef9a9896f3ea23324769a9a2061a80fe8852705ed", size = 4974184, upload-time = "2025-09-29T21:12:55.962Z" },
-    { url = "https://files.pythonhosted.org/packages/63/22/8553ff6166f5cd21cfaa115aaacaa0dc73b91c079a8cfd54a482cbc0f4f5/fonttools-4.60.1-cp314-cp314t-win32.whl", hash = "sha256:1410155d0e764a4615774e5c2c6fc516259fe3eca5882f034eb9bfdbee056259", size = 2282241, upload-time = "2025-09-29T21:12:58.179Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/cb/fa7b4d148e11d5a72761a22e595344133e83a9507a4c231df972e657579b/fonttools-4.60.1-cp314-cp314t-win_amd64.whl", hash = "sha256:022beaea4b73a70295b688f817ddc24ed3e3418b5036ffcd5658141184ef0d0c", size = 2345760, upload-time = "2025-09-29T21:13:00.375Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/93/0dd45cd283c32dea1545151d8c3637b4b8c53cdb3a625aeb2885b184d74d/fonttools-4.60.1-py3-none-any.whl", hash = "sha256:906306ac7afe2156fcf0042173d6ebbb05416af70f6b370967b47f8f00103bbb", size = 1143175, upload-time = "2025-09-29T21:13:24.134Z" },
+version = "4.61.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/ca/cf17b88a8df95691275a3d77dc0a5ad9907f328ae53acbe6795da1b2f5ed/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69", size = 3565756, upload-time = "2025-12-12T17:31:24.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/94/8a28707adb00bed1bf22dac16ccafe60faf2ade353dcb32c3617ee917307/fonttools-4.61.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c7db70d57e5e1089a274cbb2b1fd635c9a24de809a231b154965d415d6c6d24", size = 2854799, upload-time = "2025-12-12T17:29:27.5Z" },
+    { url = "https://files.pythonhosted.org/packages/94/93/c2e682faaa5ee92034818d8f8a8145ae73eb83619600495dcf8503fa7771/fonttools-4.61.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5fe9fd43882620017add5eabb781ebfbc6998ee49b35bd7f8f79af1f9f99a958", size = 2403032, upload-time = "2025-12-12T17:29:30.115Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/62/1748f7e7e1ee41aa52279fd2e3a6d0733dc42a673b16932bad8e5d0c8b28/fonttools-4.61.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8db08051fc9e7d8bc622f2112511b8107d8f27cd89e2f64ec45e9825e8288da", size = 4897863, upload-time = "2025-12-12T17:29:32.535Z" },
+    { url = "https://files.pythonhosted.org/packages/69/69/4ca02ee367d2c98edcaeb83fc278d20972502ee071214ad9d8ca85e06080/fonttools-4.61.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a76d4cb80f41ba94a6691264be76435e5f72f2cb3cab0b092a6212855f71c2f6", size = 4859076, upload-time = "2025-12-12T17:29:34.907Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/f5/660f9e3cefa078861a7f099107c6d203b568a6227eef163dd173bfc56bdc/fonttools-4.61.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a13fc8aeb24bad755eea8f7f9d409438eb94e82cf86b08fe77a03fbc8f6a96b1", size = 4875623, upload-time = "2025-12-12T17:29:37.33Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d1/9d7c5091d2276ed47795c131c1bf9316c3c1ab2789c22e2f59e0572ccd38/fonttools-4.61.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b846a1fcf8beadeb9ea4f44ec5bdde393e2f1569e17d700bfc49cd69bde75881", size = 4993327, upload-time = "2025-12-12T17:29:39.781Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/2d/28def73837885ae32260d07660a052b99f0aa00454867d33745dfe49dbf0/fonttools-4.61.1-cp310-cp310-win32.whl", hash = "sha256:78a7d3ab09dc47ac1a363a493e6112d8cabed7ba7caad5f54dbe2f08676d1b47", size = 1502180, upload-time = "2025-12-12T17:29:42.217Z" },
+    { url = "https://files.pythonhosted.org/packages/63/fa/bfdc98abb4dd2bd491033e85e3ba69a2313c850e759a6daa014bc9433b0f/fonttools-4.61.1-cp310-cp310-win_amd64.whl", hash = "sha256:eff1ac3cc66c2ac7cda1e64b4e2f3ffef474b7335f92fc3833fc632d595fcee6", size = 1550654, upload-time = "2025-12-12T17:29:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/69/12/bf9f4eaa2fad039356cc627587e30ed008c03f1cebd3034376b5ee8d1d44/fonttools-4.61.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c6604b735bb12fef8e0efd5578c9fb5d3d8532d5001ea13a19cddf295673ee09", size = 2852213, upload-time = "2025-12-12T17:29:46.675Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/49/4138d1acb6261499bedde1c07f8c2605d1d8f9d77a151e5507fd3ef084b6/fonttools-4.61.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ce02f38a754f207f2f06557523cd39a06438ba3aafc0639c477ac409fc64e37", size = 2401689, upload-time = "2025-12-12T17:29:48.769Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/fe/e6ce0fe20a40e03aef906af60aa87668696f9e4802fa283627d0b5ed777f/fonttools-4.61.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77efb033d8d7ff233385f30c62c7c79271c8885d5c9657d967ede124671bbdfb", size = 5058809, upload-time = "2025-12-12T17:29:51.701Z" },
+    { url = "https://files.pythonhosted.org/packages/79/61/1ca198af22f7dd22c17ab86e9024ed3c06299cfdb08170640e9996d501a0/fonttools-4.61.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c1a6dfac6abd407634420c93864a1e274ebc1c7531346d9254c0d8f6ca00f9", size = 5036039, upload-time = "2025-12-12T17:29:53.659Z" },
+    { url = "https://files.pythonhosted.org/packages/99/cc/fa1801e408586b5fce4da9f5455af8d770f4fc57391cd5da7256bb364d38/fonttools-4.61.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0de30bfe7745c0d1ffa2b0b7048fb7123ad0d71107e10ee090fa0b16b9452e87", size = 5034714, upload-time = "2025-12-12T17:29:55.592Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/aa/b7aeafe65adb1b0a925f8f25725e09f078c635bc22754f3fecb7456955b0/fonttools-4.61.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58b0ee0ab5b1fc9921eccfe11d1435added19d6494dde14e323f25ad2bc30c56", size = 5158648, upload-time = "2025-12-12T17:29:57.861Z" },
+    { url = "https://files.pythonhosted.org/packages/99/f9/08ea7a38663328881384c6e7777bbefc46fd7d282adfd87a7d2b84ec9d50/fonttools-4.61.1-cp311-cp311-win32.whl", hash = "sha256:f79b168428351d11e10c5aeb61a74e1851ec221081299f4cf56036a95431c43a", size = 2280681, upload-time = "2025-12-12T17:29:59.943Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ad/37dd1ae5fa6e01612a1fbb954f0927681f282925a86e86198ccd7b15d515/fonttools-4.61.1-cp311-cp311-win_amd64.whl", hash = "sha256:fe2efccb324948a11dd09d22136fe2ac8a97d6c1347cf0b58a911dcd529f66b7", size = 2331951, upload-time = "2025-12-12T17:30:02.254Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/16/7decaa24a1bd3a70c607b2e29f0adc6159f36a7e40eaba59846414765fd4/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e", size = 2851593, upload-time = "2025-12-12T17:30:04.225Z" },
+    { url = "https://files.pythonhosted.org/packages/94/98/3c4cb97c64713a8cf499b3245c3bf9a2b8fd16a3e375feff2aed78f96259/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2", size = 2400231, upload-time = "2025-12-12T17:30:06.47Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/82dbef0f6342eb01f54bca073ac1498433d6ce71e50c3c3282b655733b31/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796", size = 4954103, upload-time = "2025-12-12T17:30:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/44/f3aeac0fa98e7ad527f479e161aca6c3a1e47bb6996b053d45226fe37bf2/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d", size = 5004295, upload-time = "2025-12-12T17:30:10.56Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e8/7424ced75473983b964d09f6747fa09f054a6d656f60e9ac9324cf40c743/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8", size = 4944109, upload-time = "2025-12-12T17:30:12.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/8b/6391b257fa3d0b553d73e778f953a2f0154292a7a7a085e2374b111e5410/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0", size = 5093598, upload-time = "2025-12-12T17:30:15.79Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/71/fd2ea96cdc512d92da5678a1c98c267ddd4d8c5130b76d0f7a80f9a9fde8/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261", size = 2269060, upload-time = "2025-12-12T17:30:18.058Z" },
+    { url = "https://files.pythonhosted.org/packages/80/3b/a3e81b71aed5a688e89dfe0e2694b26b78c7d7f39a5ffd8a7d75f54a12a8/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9", size = 2319078, upload-time = "2025-12-12T17:30:22.862Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/cf/00ba28b0990982530addb8dc3e9e6f2fa9cb5c20df2abdda7baa755e8fe1/fonttools-4.61.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c56c488ab471628ff3bfa80964372fc13504ece601e0d97a78ee74126b2045c", size = 2846454, upload-time = "2025-12-12T17:30:24.938Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ca/468c9a8446a2103ae645d14fee3f610567b7042aba85031c1c65e3ef7471/fonttools-4.61.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc492779501fa723b04d0ab1f5be046797fee17d27700476edc7ee9ae535a61e", size = 2398191, upload-time = "2025-12-12T17:30:27.343Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/4b/d67eedaed19def5967fade3297fed8161b25ba94699efc124b14fb68cdbc/fonttools-4.61.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:64102ca87e84261419c3747a0d20f396eb024bdbeb04c2bfb37e2891f5fadcb5", size = 4928410, upload-time = "2025-12-12T17:30:29.771Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/8d/6fb3494dfe61a46258cd93d979cf4725ded4eb46c2a4ca35e4490d84daea/fonttools-4.61.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c1b526c8d3f615a7b1867f38a9410849c8f4aef078535742198e942fba0e9bd", size = 4984460, upload-time = "2025-12-12T17:30:32.073Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/f1/a47f1d30b3dc00d75e7af762652d4cbc3dff5c2697a0dbd5203c81afd9c3/fonttools-4.61.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41ed4b5ec103bd306bb68f81dc166e77409e5209443e5773cb4ed837bcc9b0d3", size = 4925800, upload-time = "2025-12-12T17:30:34.339Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/01/e6ae64a0981076e8a66906fab01539799546181e32a37a0257b77e4aa88b/fonttools-4.61.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b501c862d4901792adaec7c25b1ecc749e2662543f68bb194c42ba18d6eec98d", size = 5067859, upload-time = "2025-12-12T17:30:36.593Z" },
+    { url = "https://files.pythonhosted.org/packages/73/aa/28e40b8d6809a9b5075350a86779163f074d2b617c15d22343fce81918db/fonttools-4.61.1-cp313-cp313-win32.whl", hash = "sha256:4d7092bb38c53bbc78e9255a59158b150bcdc115a1e3b3ce0b5f267dc35dd63c", size = 2267821, upload-time = "2025-12-12T17:30:38.478Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/59/453c06d1d83dc0951b69ef692d6b9f1846680342927df54e9a1ca91c6f90/fonttools-4.61.1-cp313-cp313-win_amd64.whl", hash = "sha256:21e7c8d76f62ab13c9472ccf74515ca5b9a761d1bde3265152a6dc58700d895b", size = 2318169, upload-time = "2025-12-12T17:30:40.951Z" },
+    { url = "https://files.pythonhosted.org/packages/32/8f/4e7bf82c0cbb738d3c2206c920ca34ca74ef9dabde779030145d28665104/fonttools-4.61.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fff4f534200a04b4a36e7ae3cb74493afe807b517a09e99cb4faa89a34ed6ecd", size = 2846094, upload-time = "2025-12-12T17:30:43.511Z" },
+    { url = "https://files.pythonhosted.org/packages/71/09/d44e45d0a4f3a651f23a1e9d42de43bc643cce2971b19e784cc67d823676/fonttools-4.61.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d9203500f7c63545b4ce3799319fe4d9feb1a1b89b28d3cb5abd11b9dd64147e", size = 2396589, upload-time = "2025-12-12T17:30:45.681Z" },
+    { url = "https://files.pythonhosted.org/packages/89/18/58c64cafcf8eb677a99ef593121f719e6dcbdb7d1c594ae5a10d4997ca8a/fonttools-4.61.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fa646ecec9528bef693415c79a86e733c70a4965dd938e9a226b0fc64c9d2e6c", size = 4877892, upload-time = "2025-12-12T17:30:47.709Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/ec/9e6b38c7ba1e09eb51db849d5450f4c05b7e78481f662c3b79dbde6f3d04/fonttools-4.61.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11f35ad7805edba3aac1a3710d104592df59f4b957e30108ae0ba6c10b11dd75", size = 4972884, upload-time = "2025-12-12T17:30:49.656Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/87/b5339da8e0256734ba0dbbf5b6cdebb1dd79b01dc8c270989b7bcd465541/fonttools-4.61.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b931ae8f62db78861b0ff1ac017851764602288575d65b8e8ff1963fed419063", size = 4924405, upload-time = "2025-12-12T17:30:51.735Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/47/e3409f1e1e69c073a3a6fd8cb886eb18c0bae0ee13db2c8d5e7f8495e8b7/fonttools-4.61.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b148b56f5de675ee16d45e769e69f87623a4944f7443850bf9a9376e628a89d2", size = 5035553, upload-time = "2025-12-12T17:30:54.823Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/b6/1f6600161b1073a984294c6c031e1a56ebf95b6164249eecf30012bb2e38/fonttools-4.61.1-cp314-cp314-win32.whl", hash = "sha256:9b666a475a65f4e839d3d10473fad6d47e0a9db14a2f4a224029c5bfde58ad2c", size = 2271915, upload-time = "2025-12-12T17:30:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/52/7b/91e7b01e37cc8eb0e1f770d08305b3655e4f002fc160fb82b3390eabacf5/fonttools-4.61.1-cp314-cp314-win_amd64.whl", hash = "sha256:4f5686e1fe5fce75d82d93c47a438a25bf0d1319d2843a926f741140b2b16e0c", size = 2323487, upload-time = "2025-12-12T17:30:59.804Z" },
+    { url = "https://files.pythonhosted.org/packages/39/5c/908ad78e46c61c3e3ed70c3b58ff82ab48437faf84ec84f109592cabbd9f/fonttools-4.61.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e76ce097e3c57c4bcb67c5aa24a0ecdbd9f74ea9219997a707a4061fbe2707aa", size = 2929571, upload-time = "2025-12-12T17:31:02.574Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/41/975804132c6dea64cdbfbaa59f3518a21c137a10cccf962805b301ac6ab2/fonttools-4.61.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9cfef3ab326780c04d6646f68d4b4742aae222e8b8ea1d627c74e38afcbc9d91", size = 2435317, upload-time = "2025-12-12T17:31:04.974Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/5a/aef2a0a8daf1ebaae4cfd83f84186d4a72ee08fd6a8451289fcd03ffa8a4/fonttools-4.61.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a75c301f96db737e1c5ed5fd7d77d9c34466de16095a266509e13da09751bd19", size = 4882124, upload-time = "2025-12-12T17:31:07.456Z" },
+    { url = "https://files.pythonhosted.org/packages/80/33/d6db3485b645b81cea538c9d1c9219d5805f0877fda18777add4671c5240/fonttools-4.61.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91669ccac46bbc1d09e9273546181919064e8df73488ea087dcac3e2968df9ba", size = 5100391, upload-time = "2025-12-12T17:31:09.732Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/d6/675ba631454043c75fcf76f0ca5463eac8eb0666ea1d7badae5fea001155/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c33ab3ca9d3ccd581d58e989d67554e42d8d4ded94ab3ade3508455fe70e65f7", size = 4978800, upload-time = "2025-12-12T17:31:11.681Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/33/d3ec753d547a8d2bdaedd390d4a814e8d5b45a093d558f025c6b990b554c/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:664c5a68ec406f6b1547946683008576ef8b38275608e1cee6c061828171c118", size = 5006426, upload-time = "2025-12-12T17:31:13.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/40/cc11f378b561a67bea850ab50063366a0d1dd3f6d0a30ce0f874b0ad5664/fonttools-4.61.1-cp314-cp314t-win32.whl", hash = "sha256:aed04cabe26f30c1647ef0e8fbb207516fd40fe9472e9439695f5c6998e60ac5", size = 2335377, upload-time = "2025-12-12T17:31:16.49Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ff/c9a2b66b39f8628531ea58b320d66d951267c98c6a38684daa8f50fb02f8/fonttools-4.61.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2180f14c141d2f0f3da43f3a81bc8aa4684860f6b0e6f9e165a4831f24e6a23b", size = 2400613, upload-time = "2025-12-12T17:31:18.769Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/4e/ce75a57ff3aebf6fc1f4e9d508b8e5810618a33d900ad6c19eb30b290b97/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371", size = 1148996, upload-time = "2025-12-12T17:31:21.03Z" },
+]
+
+[[package]]
+name = "fqdn"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
 [[package]]
 name = "id"
-version = "1.5.0"
+version = "1.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "requests" },
+    { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/22/11/102da08f88412d875fa2f1a9a469ff7ad4c874b0ca6fed0048fe385bdb3d/id-1.5.0.tar.gz", hash = "sha256:292cb8a49eacbbdbce97244f47a97b4c62540169c976552e497fd57df0734c1d", size = 15237, upload-time = "2024-12-04T19:53:05.575Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/04/c2156091427636080787aac190019dc64096e56a23b7364d3c1764ee3a06/id-1.6.1.tar.gz", hash = "sha256:d0732d624fb46fd4e7bc4e5152f00214450953b9e772c182c1c22964def1a069", size = 18088, upload-time = "2026-02-04T16:19:41.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/cb/18326d2d89ad3b0dd143da971e77afd1e6ca6674f1b1c3df4b6bec6279fc/id-1.5.0-py3-none-any.whl", hash = "sha256:f1434e1cef91f2cbb8a4ec64663d5a23b9ed43ef44c4c957d02583d61714c658", size = 13611, upload-time = "2024-12-04T19:53:03.02Z" },
+    { url = "https://files.pythonhosted.org/packages/42/77/de194443bf38daed9452139e960c632b0ef9f9a5dd9ce605fdf18ca9f1b1/id-1.6.1-py3-none-any.whl", hash = "sha256:f5ec41ed2629a508f5d0988eda142e190c9c6da971100612c4de9ad9f9b237ca", size = 14689, upload-time = "2026-02-04T16:19:40.051Z" },
 ]
 
 [[package]]
@@ -657,14 +866,14 @@ wheels = [
 
 [[package]]
 name = "importlib-metadata"
-version = "8.7.0"
+version = "8.7.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "zipp" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
 ]
 
 [[package]]
@@ -678,14 +887,14 @@ wheels = [
 
 [[package]]
 name = "ipykernel"
-version = "7.1.0"
+version = "7.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "appnope", marker = "sys_platform == 'darwin'" },
     { name = "comm" },
     { name = "debugpy" },
-    { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "ipython", version = "9.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "ipython", version = "8.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "ipython", version = "9.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "jupyter-client" },
     { name = "jupyter-core" },
     { name = "matplotlib-inline" },
@@ -696,14 +905,14 @@ dependencies = [
     { name = "tornado" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b9/a4/4948be6eb88628505b83a1f2f40d90254cab66abf2043b3c40fa07dfce0f/ipykernel-7.1.0.tar.gz", hash = "sha256:58a3fc88533d5930c3546dc7eac66c6d288acde4f801e2001e65edc5dc9cf0db", size = 174579, upload-time = "2025-10-27T09:46:39.471Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/8d/b68b728e2d06b9e0051019640a40a9eb7a88fcd82c2e1b5ce70bef5ff044/ipykernel-7.2.0.tar.gz", hash = "sha256:18ed160b6dee2cbb16e5f3575858bc19d8f1fe6046a9a680c708494ce31d909e", size = 176046, upload-time = "2026-02-06T16:43:27.403Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/17/20c2552266728ceba271967b87919664ecc0e33efca29c3efc6baf88c5f9/ipykernel-7.1.0-py3-none-any.whl", hash = "sha256:763b5ec6c5b7776f6a8d7ce09b267693b4e5ce75cb50ae696aaefb3c85e1ea4c", size = 117968, upload-time = "2025-10-27T09:46:37.805Z" },
+    { url = "https://files.pythonhosted.org/packages/82/b9/e73d5d9f405cba7706c539aa8b311b49d4c2f3d698d9c12f815231169c71/ipykernel-7.2.0-py3-none-any.whl", hash = "sha256:3bbd4420d2b3cc105cbdf3756bfc04500b1e52f090a90716851f3916c62e1661", size = 118788, upload-time = "2026-02-06T16:43:25.149Z" },
 ]
 
 [[package]]
 name = "ipython"
-version = "8.37.0"
+version = "8.38.0"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
     "python_full_version < '3.11'",
@@ -721,17 +930,22 @@ dependencies = [
     { name = "traitlets", marker = "python_full_version < '3.11'" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/85/31/10ac88f3357fc276dc8a64e8880c82e80e7459326ae1d0a211b40abf6665/ipython-8.37.0.tar.gz", hash = "sha256:ca815841e1a41a1e6b73a0b08f3038af9b2252564d01fc405356d34033012216", size = 5606088, upload-time = "2025-05-31T16:39:09.613Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/61/1810830e8b93c72dcd3c0f150c80a00c3deb229562d9423807ec92c3a539/ipython-8.38.0.tar.gz", hash = "sha256:9cfea8c903ce0867cc2f23199ed8545eb741f3a69420bfcf3743ad1cec856d39", size = 5513996, upload-time = "2026-01-05T10:59:06.901Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/91/d0/274fbf7b0b12643cbbc001ce13e6a5b1607ac4929d1b11c72460152c9fc3/ipython-8.37.0-py3-none-any.whl", hash = "sha256:ed87326596b878932dbcb171e3e698845434d8c61b8d8cd474bf663041a9dcf2", size = 831864, upload-time = "2025-05-31T16:39:06.38Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/df/db59624f4c71b39717c423409950ac3f2c8b2ce4b0aac843112c7fb3f721/ipython-8.38.0-py3-none-any.whl", hash = "sha256:750162629d800ac65bb3b543a14e7a74b0e88063eac9b92124d4b2aa3f6d8e86", size = 831813, upload-time = "2026-01-05T10:59:04.239Z" },
 ]
 
 [[package]]
 name = "ipython"
-version = "9.7.0"
+version = "9.10.0"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version >= '3.11'",
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
     { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" },
@@ -746,9 +960,9 @@ dependencies = [
     { name = "traitlets", marker = "python_full_version >= '3.11'" },
     { name = "typing-extensions", marker = "python_full_version == '3.11.*'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/29/e6/48c74d54039241a456add616464ea28c6ebf782e4110d419411b83dae06f/ipython-9.7.0.tar.gz", hash = "sha256:5f6de88c905a566c6a9d6c400a8fed54a638e1f7543d17aae2551133216b1e4e", size = 4422115, upload-time = "2025-11-05T12:18:54.646Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/60/2111715ea11f39b1535bed6024b7dec7918b71e5e5d30855a5b503056b50/ipython-9.10.0.tar.gz", hash = "sha256:cd9e656be97618a0676d058134cd44e6dc7012c0e5cb36a9ce96a8c904adaf77", size = 4426526, upload-time = "2026-02-02T10:00:33.594Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/aa/62893d6a591d337aa59dcc4c6f6c842f1fe20cd72c8c5c1f980255243252/ipython-9.7.0-py3-none-any.whl", hash = "sha256:bce8ac85eb9521adc94e1845b4c03d88365fd6ac2f4908ec4ed1eb1b0a065f9f", size = 618911, upload-time = "2025-11-05T12:18:52.484Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/aa/898dec789a05731cd5a9f50605b7b44a72bd198fd0d4528e11fc610177cc/ipython-9.10.0-py3-none-any.whl", hash = "sha256:c6ab68cc23bba8c7e18e9b932797014cc61ea7fd6f19de180ab9ba73e65ee58d", size = 622774, upload-time = "2026-02-02T10:00:31.503Z" },
 ]
 
 [[package]]
@@ -763,6 +977,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" },
 ]
 
+[[package]]
+name = "ipywidgets"
+version = "8.1.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "comm" },
+    { name = "ipython", version = "8.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "ipython", version = "9.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "jupyterlab-widgets" },
+    { name = "traitlets" },
+    { name = "widgetsnbextension" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/ae/c5ce1edc1afe042eadb445e95b0671b03cee61895264357956e61c0d2ac0/ipywidgets-8.1.8.tar.gz", hash = "sha256:61f969306b95f85fba6b6986b7fe45d73124d1d9e3023a8068710d47a22ea668", size = 116739, upload-time = "2025-11-01T21:18:12.393Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/6d/0d9848617b9f753b87f214f1c682592f7ca42de085f564352f10f0843026/ipywidgets-8.1.8-py3-none-any.whl", hash = "sha256:ecaca67aed704a338f88f67b1181b58f821ab5dc89c1f0f5ef99db43c1c2921e", size = 139808, upload-time = "2025-11-01T21:18:10.956Z" },
+]
+
+[[package]]
+name = "isoduration"
+version = "20.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "arrow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" },
+]
+
 [[package]]
 name = "jaraco-classes"
 version = "3.4.0"
@@ -777,26 +1020,26 @@ wheels = [
 
 [[package]]
 name = "jaraco-context"
-version = "6.0.1"
+version = "6.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "backports-tarfile", marker = "python_full_version < '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/df/ad/f3777b81bf0b6e7bc7514a1656d3e637b2e8e15fab2ce3235730b3e7a4e6/jaraco_context-6.0.1.tar.gz", hash = "sha256:9bae4ea555cf0b14938dc0aee7c9f32ed303aa20a3b73e7dc80111628792d1b3", size = 13912, upload-time = "2024-08-20T03:39:27.358Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cb/9c/a788f5bb29c61e456b8ee52ce76dbdd32fd72cd73dd67bc95f42c7a8d13c/jaraco_context-6.1.0.tar.gz", hash = "sha256:129a341b0a85a7db7879e22acd66902fda67882db771754574338898b2d5d86f", size = 15850, upload-time = "2026-01-13T02:53:53.847Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ff/db/0c52c4cf5e4bd9f5d7135ec7669a3a767af21b3a308e1ed3674881e52b62/jaraco.context-6.0.1-py3-none-any.whl", hash = "sha256:f797fc481b490edb305122c9181830a3a5b76d84ef6d1aef2fb9b47ab956f9e4", size = 6825, upload-time = "2024-08-20T03:39:25.966Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/48/aa685dbf1024c7bd82bede569e3a85f82c32fd3d79ba5fea578f0159571a/jaraco_context-6.1.0-py3-none-any.whl", hash = "sha256:a43b5ed85815223d0d3cfdb6d7ca0d2bc8946f28f30b6f3216bda070f68badda", size = 7065, upload-time = "2026-01-13T02:53:53.031Z" },
 ]
 
 [[package]]
 name = "jaraco-functools"
-version = "4.3.0"
+version = "4.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "more-itertools" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/ed/1aa2d585304ec07262e1a83a9889880701079dde796ac7b1d1826f40c63d/jaraco_functools-4.3.0.tar.gz", hash = "sha256:cfd13ad0dd2c47a3600b439ef72d8615d482cedcff1632930d6f28924d92f294", size = 19755, upload-time = "2025-08-18T20:05:09.91Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/27/056e0638a86749374d6f57d0b0db39f29509cce9313cf91bdc0ac4d91084/jaraco_functools-4.4.0.tar.gz", hash = "sha256:da21933b0417b89515562656547a77b4931f98176eb173644c0d35032a33d6bb", size = 19943, upload-time = "2025-12-21T09:29:43.6Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/09/726f168acad366b11e420df31bf1c702a54d373a83f968d94141a8c3fde0/jaraco_functools-4.3.0-py3-none-any.whl", hash = "sha256:227ff8ed6f7b8f62c56deff101545fa7543cf2c8e7b82a7c2116e672f29c26e8", size = 10408, upload-time = "2025-08-18T20:05:08.69Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/c4/813bb09f0985cb21e959f21f2464169eca882656849adf727ac7bb7e1767/jaraco_functools-4.4.0-py3-none-any.whl", hash = "sha256:9eec1e36f45c818d9bf307c8948eb03b2b56cd44087b3cdc989abca1f20b9176", size = 10481, upload-time = "2025-12-21T09:29:42.27Z" },
 ]
 
 [[package]]
@@ -820,9 +1063,96 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" },
 ]
 
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "json5"
+version = "0.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/77/e8/a3f261a66e4663f22700bc8a17c08cb83e91fbf086726e7a228398968981/json5-0.13.0.tar.gz", hash = "sha256:b1edf8d487721c0bf64d83c28e91280781f6e21f4a797d3261c7c828d4c165bf", size = 52441, upload-time = "2026-01-01T19:42:14.99Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/9e/038522f50ceb7e74f1f991bf1b699f24b0c2bbe7c390dd36ad69f4582258/json5-0.13.0-py3-none-any.whl", hash = "sha256:9a08e1dd65f6a4d4c6fa82d216cf2477349ec2346a38fd70cc11d2557499fbcc", size = 36163, upload-time = "2026-01-01T19:42:13.962Z" },
+]
+
+[[package]]
+name = "jsonpointer"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114, upload-time = "2024-06-10T19:24:42.462Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[package.optional-dependencies]
+format-nongpl = [
+    { name = "fqdn" },
+    { name = "idna" },
+    { name = "isoduration" },
+    { name = "jsonpointer" },
+    { name = "rfc3339-validator" },
+    { name = "rfc3986-validator" },
+    { name = "rfc3987-syntax" },
+    { name = "uri-template" },
+    { name = "webcolors" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "jupyter"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ipykernel" },
+    { name = "ipywidgets" },
+    { name = "jupyter-console" },
+    { name = "jupyterlab" },
+    { name = "nbconvert" },
+    { name = "notebook" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" },
+]
+
 [[package]]
 name = "jupyter-client"
-version = "8.6.3"
+version = "8.8.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jupyter-core" },
@@ -831,9 +1161,29 @@ dependencies = [
     { name = "tornado" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105, upload-time = "2024-09-17T10:44:15.218Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" },
+]
+
+[[package]]
+name = "jupyter-console"
+version = "6.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ipykernel" },
+    { name = "ipython", version = "8.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "ipython", version = "9.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "prompt-toolkit" },
+    { name = "pygments" },
+    { name = "pyzmq" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" },
 ]
 
 [[package]]
@@ -849,9 +1199,144 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" },
 ]
 
+[[package]]
+name = "jupyter-events"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonschema", extra = ["format-nongpl"] },
+    { name = "packaging" },
+    { name = "python-json-logger" },
+    { name = "pyyaml" },
+    { name = "referencing" },
+    { name = "rfc3339-validator" },
+    { name = "rfc3986-validator" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196, upload-time = "2025-02-03T17:23:41.485Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/48/577993f1f99c552f18a0428731a755e06171f9902fa118c379eb7c04ea22/jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb", size = 19430, upload-time = "2025-02-03T17:23:38.643Z" },
+]
+
+[[package]]
+name = "jupyter-lsp"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/5a/9066c9f8e94ee517133cd98dba393459a16cd48bba71a82f16a65415206c/jupyter_lsp-2.3.0.tar.gz", hash = "sha256:458aa59339dc868fb784d73364f17dbce8836e906cd75fd471a325cba02e0245", size = 54823, upload-time = "2025-08-27T17:47:34.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/60/1f6cee0c46263de1173894f0fafcb3475ded276c472c14d25e0280c18d6d/jupyter_lsp-2.3.0-py3-none-any.whl", hash = "sha256:e914a3cb2addf48b1c7710914771aaf1819d46b2e5a79b0f917b5478ec93f34f", size = 76687, upload-time = "2025-08-27T17:47:33.15Z" },
+]
+
+[[package]]
+name = "jupyter-server"
+version = "2.17.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "argon2-cffi" },
+    { name = "jinja2" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "jupyter-events" },
+    { name = "jupyter-server-terminals" },
+    { name = "nbconvert" },
+    { name = "nbformat" },
+    { name = "overrides", marker = "python_full_version < '3.12'" },
+    { name = "packaging" },
+    { name = "prometheus-client" },
+    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "pyzmq" },
+    { name = "send2trash" },
+    { name = "terminado" },
+    { name = "tornado" },
+    { name = "traitlets" },
+    { name = "websocket-client" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949, upload-time = "2025-08-21T14:42:54.042Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/80/a24767e6ca280f5a49525d987bf3e4d7552bf67c8be07e8ccf20271f8568/jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f", size = 388221, upload-time = "2025-08-21T14:42:52.034Z" },
+]
+
+[[package]]
+name = "jupyter-server-terminals"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "terminado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" },
+]
+
+[[package]]
+name = "jupyterlab"
+version = "4.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "async-lru" },
+    { name = "httpx" },
+    { name = "ipykernel" },
+    { name = "jinja2" },
+    { name = "jupyter-core" },
+    { name = "jupyter-lsp" },
+    { name = "jupyter-server" },
+    { name = "jupyterlab-server" },
+    { name = "notebook-shim" },
+    { name = "packaging" },
+    { name = "setuptools" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "tornado" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/6b/21af7c0512bdf67e0c54c121779a1f2a97a164a7657e13fced79db8fa5a0/jupyterlab-4.5.4.tar.gz", hash = "sha256:c215f48d8e4582bd2920ad61cc6a40d8ebfef7e5a517ae56b8a9413c9789fdfb", size = 23943597, upload-time = "2026-02-11T00:26:55.308Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/9f/a70972ece62ead2d81acc6223188f6d18a92f665ccce17796a0cdea4fcf5/jupyterlab-4.5.4-py3-none-any.whl", hash = "sha256:cc233f70539728534669fb0015331f2a3a87656207b3bb2d07916e9289192f12", size = 12391867, upload-time = "2026-02-11T00:26:51.23Z" },
+]
+
+[[package]]
+name = "jupyterlab-pygments"
+version = "0.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" },
+]
+
+[[package]]
+name = "jupyterlab-server"
+version = "2.28.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babel" },
+    { name = "jinja2" },
+    { name = "json5" },
+    { name = "jsonschema" },
+    { name = "jupyter-server" },
+    { name = "packaging" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" },
+]
+
+[[package]]
+name = "jupyterlab-widgets"
+version = "3.0.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/2d/ef58fed122b268c69c0aa099da20bc67657cdfb2e222688d5731bd5b971d/jupyterlab_widgets-3.0.16.tar.gz", hash = "sha256:423da05071d55cf27a9e602216d35a3a65a3e41cdf9c5d3b643b814ce38c19e0", size = 897423, upload-time = "2025-11-01T21:11:29.724Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl", hash = "sha256:45fa36d9c6422cf2559198e4db481aa243c7a32d9926b500781c830c80f7ecf8", size = 914926, upload-time = "2025-11-01T21:11:28.008Z" },
+]
+
 [[package]]
 name = "keyring"
-version = "25.6.0"
+version = "25.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "importlib-metadata", marker = "python_full_version < '3.12'" },
@@ -862,9 +1347,9 @@ dependencies = [
     { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" },
     { name = "secretstorage", marker = "sys_platform == 'linux'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/70/09/d904a6e96f76ff214be59e7aa6ef7190008f52a0ab6689760a98de0bf37d/keyring-25.6.0.tar.gz", hash = "sha256:0b39998aa941431eb3d9b0d4b2460bc773b9df6fed7621c2dfb291a7e0187a66", size = 62750, upload-time = "2024-12-25T15:26:45.782Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d3/32/da7f44bcb1105d3e88a0b74ebdca50c59121d2ddf71c9e34ba47df7f3a56/keyring-25.6.0-py3-none-any.whl", hash = "sha256:552a3f7af126ece7ed5c89753650eec89c7eaae8617d0aa4d9ad2b75111266bd", size = 39085, upload-time = "2024-12-25T15:26:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" },
 ]
 
 [[package]]
@@ -975,6 +1460,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload-time = "2025-08-10T21:27:48.236Z" },
 ]
 
+[[package]]
+name = "lark"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "4.0.0"
@@ -987,9 +1481,94 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
 ]
 
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" },
+    { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" },
+    { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" },
+    { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" },
+    { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" },
+    { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" },
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
 [[package]]
 name = "matplotlib"
-version = "3.10.7"
+version = "3.10.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
@@ -998,68 +1577,68 @@ dependencies = [
     { name = "fonttools" },
     { name = "kiwisolver" },
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "packaging" },
     { name = "pillow" },
     { name = "pyparsing" },
     { name = "python-dateutil" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/e2/d2d5295be2f44c678ebaf3544ba32d20c1f9ef08c49fe47f496180e1db15/matplotlib-3.10.7.tar.gz", hash = "sha256:a06ba7e2a2ef9131c79c49e63dad355d2d878413a0376c1727c8b9335ff731c7", size = 34804865, upload-time = "2025-10-09T00:28:00.669Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/87/3932d5778ab4c025db22710b61f49ccaed3956c5cf46ffb2ffa7492b06d9/matplotlib-3.10.7-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7ac81eee3b7c266dd92cee1cd658407b16c57eed08c7421fa354ed68234de380", size = 8247141, upload-time = "2025-10-09T00:26:06.023Z" },
-    { url = "https://files.pythonhosted.org/packages/45/a8/bfed45339160102bce21a44e38a358a1134a5f84c26166de03fb4a53208f/matplotlib-3.10.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:667ecd5d8d37813a845053d8f5bf110b534c3c9f30e69ebd25d4701385935a6d", size = 8107995, upload-time = "2025-10-09T00:26:08.669Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/3c/5692a2d9a5ba848fda3f48d2b607037df96460b941a59ef236404b39776b/matplotlib-3.10.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc1c51b846aca49a5a8b44fbba6a92d583a35c64590ad9e1e950dc88940a4297", size = 8680503, upload-time = "2025-10-09T00:26:10.607Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/a0/86ace53c48b05d0e6e9c127b2ace097434901f3e7b93f050791c8243201a/matplotlib-3.10.7-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a11c2e9e72e7de09b7b72e62f3df23317c888299c875e2b778abf1eda8c0a42", size = 9514982, upload-time = "2025-10-09T00:26:12.594Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/81/ead71e2824da8f72640a64166d10e62300df4ae4db01a0bac56c5b39fa51/matplotlib-3.10.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f19410b486fdd139885ace124e57f938c1e6a3210ea13dd29cab58f5d4bc12c7", size = 9566429, upload-time = "2025-10-09T00:26:14.758Z" },
-    { url = "https://files.pythonhosted.org/packages/65/7d/954b3067120456f472cce8fdcacaf4a5fcd522478db0c37bb243c7cb59dd/matplotlib-3.10.7-cp310-cp310-win_amd64.whl", hash = "sha256:b498e9e4022f93de2d5a37615200ca01297ceebbb56fe4c833f46862a490f9e3", size = 8108174, upload-time = "2025-10-09T00:26:17.015Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/bc/0fb489005669127ec13f51be0c6adc074d7cf191075dab1da9fe3b7a3cfc/matplotlib-3.10.7-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:53b492410a6cd66c7a471de6c924f6ede976e963c0f3097a3b7abfadddc67d0a", size = 8257507, upload-time = "2025-10-09T00:26:19.073Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/6a/d42588ad895279ff6708924645b5d2ed54a7fb2dc045c8a804e955aeace1/matplotlib-3.10.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d9749313deb729f08207718d29c86246beb2ea3fdba753595b55901dee5d2fd6", size = 8119565, upload-time = "2025-10-09T00:26:21.023Z" },
-    { url = "https://files.pythonhosted.org/packages/10/b7/4aa196155b4d846bd749cf82aa5a4c300cf55a8b5e0dfa5b722a63c0f8a0/matplotlib-3.10.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2222c7ba2cbde7fe63032769f6eb7e83ab3227f47d997a8453377709b7fe3a5a", size = 8692668, upload-time = "2025-10-09T00:26:22.967Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/e7/664d2b97016f46683a02d854d730cfcf54ff92c1dafa424beebef50f831d/matplotlib-3.10.7-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e91f61a064c92c307c5a9dc8c05dc9f8a68f0a3be199d9a002a0622e13f874a1", size = 9521051, upload-time = "2025-10-09T00:26:25.041Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/a3/37aef1404efa615f49b5758a5e0261c16dd88f389bc1861e722620e4a754/matplotlib-3.10.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6f1851eab59ca082c95df5a500106bad73672645625e04538b3ad0f69471ffcc", size = 9576878, upload-time = "2025-10-09T00:26:27.478Z" },
-    { url = "https://files.pythonhosted.org/packages/33/cd/b145f9797126f3f809d177ca378de57c45413c5099c5990de2658760594a/matplotlib-3.10.7-cp311-cp311-win_amd64.whl", hash = "sha256:6516ce375109c60ceec579e699524e9d504cd7578506f01150f7a6bc174a775e", size = 8115142, upload-time = "2025-10-09T00:26:29.774Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/39/63bca9d2b78455ed497fcf51a9c71df200a11048f48249038f06447fa947/matplotlib-3.10.7-cp311-cp311-win_arm64.whl", hash = "sha256:b172db79759f5f9bc13ef1c3ef8b9ee7b37b0247f987fbbbdaa15e4f87fd46a9", size = 7992439, upload-time = "2025-10-09T00:26:40.32Z" },
-    { url = "https://files.pythonhosted.org/packages/be/b3/09eb0f7796932826ec20c25b517d568627754f6c6462fca19e12c02f2e12/matplotlib-3.10.7-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a0edb7209e21840e8361e91ea84ea676658aa93edd5f8762793dec77a4a6748", size = 8272389, upload-time = "2025-10-09T00:26:42.474Z" },
-    { url = "https://files.pythonhosted.org/packages/11/0b/1ae80ddafb8652fd8046cb5c8460ecc8d4afccb89e2c6d6bec61e04e1eaf/matplotlib-3.10.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c380371d3c23e0eadf8ebff114445b9f970aff2010198d498d4ab4c3b41eea4f", size = 8128247, upload-time = "2025-10-09T00:26:44.77Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/18/95ae2e242d4a5c98bd6e90e36e128d71cf1c7e39b0874feaed3ef782e789/matplotlib-3.10.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d5f256d49fea31f40f166a5e3131235a5d2f4b7f44520b1cf0baf1ce568ccff0", size = 8696996, upload-time = "2025-10-09T00:26:46.792Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/3d/5b559efc800bd05cb2033aa85f7e13af51958136a48327f7c261801ff90a/matplotlib-3.10.7-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11ae579ac83cdf3fb72573bb89f70e0534de05266728740d478f0f818983c695", size = 9530153, upload-time = "2025-10-09T00:26:49.07Z" },
-    { url = "https://files.pythonhosted.org/packages/88/57/eab4a719fd110312d3c220595d63a3c85ec2a39723f0f4e7fa7e6e3f74ba/matplotlib-3.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4c14b6acd16cddc3569a2d515cfdd81c7a68ac5639b76548cfc1a9e48b20eb65", size = 9593093, upload-time = "2025-10-09T00:26:51.067Z" },
-    { url = "https://files.pythonhosted.org/packages/31/3c/80816f027b3a4a28cd2a0a6ef7f89a2db22310e945cd886ec25bfb399221/matplotlib-3.10.7-cp312-cp312-win_amd64.whl", hash = "sha256:0d8c32b7ea6fb80b1aeff5a2ceb3fb9778e2759e899d9beff75584714afcc5ee", size = 8122771, upload-time = "2025-10-09T00:26:53.296Z" },
-    { url = "https://files.pythonhosted.org/packages/de/77/ef1fc78bfe99999b2675435cc52120887191c566b25017d78beaabef7f2d/matplotlib-3.10.7-cp312-cp312-win_arm64.whl", hash = "sha256:5f3f6d315dcc176ba7ca6e74c7768fb7e4cf566c49cb143f6bc257b62e634ed8", size = 7992812, upload-time = "2025-10-09T00:26:54.882Z" },
-    { url = "https://files.pythonhosted.org/packages/02/9c/207547916a02c78f6bdd83448d9b21afbc42f6379ed887ecf610984f3b4e/matplotlib-3.10.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1d9d3713a237970569156cfb4de7533b7c4eacdd61789726f444f96a0d28f57f", size = 8273212, upload-time = "2025-10-09T00:26:56.752Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d0/b3d3338d467d3fc937f0bb7f256711395cae6f78e22cef0656159950adf0/matplotlib-3.10.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37a1fea41153dd6ee061d21ab69c9cf2cf543160b1b85d89cd3d2e2a7902ca4c", size = 8128713, upload-time = "2025-10-09T00:26:59.001Z" },
-    { url = "https://files.pythonhosted.org/packages/22/ff/6425bf5c20d79aa5b959d1ce9e65f599632345391381c9a104133fe0b171/matplotlib-3.10.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b3c4ea4948d93c9c29dc01c0c23eef66f2101bf75158c291b88de6525c55c3d1", size = 8698527, upload-time = "2025-10-09T00:27:00.69Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/7f/ccdca06f4c2e6c7989270ed7829b8679466682f4cfc0f8c9986241c023b6/matplotlib-3.10.7-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22df30ffaa89f6643206cf13877191c63a50e8f800b038bc39bee9d2d4957632", size = 9529690, upload-time = "2025-10-09T00:27:02.664Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/95/b80fc2c1f269f21ff3d193ca697358e24408c33ce2b106a7438a45407b63/matplotlib-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b69676845a0a66f9da30e87f48be36734d6748024b525ec4710be40194282c84", size = 9593732, upload-time = "2025-10-09T00:27:04.653Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/b6/23064a96308b9aeceeffa65e96bcde459a2ea4934d311dee20afde7407a0/matplotlib-3.10.7-cp313-cp313-win_amd64.whl", hash = "sha256:744991e0cc863dd669c8dc9136ca4e6e0082be2070b9d793cbd64bec872a6815", size = 8122727, upload-time = "2025-10-09T00:27:06.814Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/a6/2faaf48133b82cf3607759027f82b5c702aa99cdfcefb7f93d6ccf26a424/matplotlib-3.10.7-cp313-cp313-win_arm64.whl", hash = "sha256:fba2974df0bf8ce3c995fa84b79cde38326e0f7b5409e7a3a481c1141340bcf7", size = 7992958, upload-time = "2025-10-09T00:27:08.567Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/f0/b018fed0b599bd48d84c08794cb242227fe3341952da102ee9d9682db574/matplotlib-3.10.7-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:932c55d1fa7af4423422cb6a492a31cbcbdbe68fd1a9a3f545aa5e7a143b5355", size = 8316849, upload-time = "2025-10-09T00:27:10.254Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/b7/bb4f23856197659f275e11a2a164e36e65e9b48ea3e93c4ec25b4f163198/matplotlib-3.10.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e38c2d581d62ee729a6e144c47a71b3f42fb4187508dbbf4fe71d5612c3433b", size = 8178225, upload-time = "2025-10-09T00:27:12.241Z" },
-    { url = "https://files.pythonhosted.org/packages/62/56/0600609893ff277e6f3ab3c0cef4eafa6e61006c058e84286c467223d4d5/matplotlib-3.10.7-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:786656bb13c237bbcebcd402f65f44dd61ead60ee3deb045af429d889c8dbc67", size = 8711708, upload-time = "2025-10-09T00:27:13.879Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/1a/6bfecb0cafe94d6658f2f1af22c43b76cf7a1c2f0dc34ef84cbb6809617e/matplotlib-3.10.7-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09d7945a70ea43bf9248f4b6582734c2fe726723204a76eca233f24cffc7ef67", size = 9541409, upload-time = "2025-10-09T00:27:15.684Z" },
-    { url = "https://files.pythonhosted.org/packages/08/50/95122a407d7f2e446fd865e2388a232a23f2b81934960ea802f3171518e4/matplotlib-3.10.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d0b181e9fa8daf1d9f2d4c547527b167cb8838fc587deabca7b5c01f97199e84", size = 9594054, upload-time = "2025-10-09T00:27:17.547Z" },
-    { url = "https://files.pythonhosted.org/packages/13/76/75b194a43b81583478a81e78a07da8d9ca6ddf50dd0a2ccabf258059481d/matplotlib-3.10.7-cp313-cp313t-win_amd64.whl", hash = "sha256:31963603041634ce1a96053047b40961f7a29eb8f9a62e80cc2c0427aa1d22a2", size = 8200100, upload-time = "2025-10-09T00:27:20.039Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/9e/6aefebdc9f8235c12bdeeda44cc0383d89c1e41da2c400caf3ee2073a3ce/matplotlib-3.10.7-cp313-cp313t-win_arm64.whl", hash = "sha256:aebed7b50aa6ac698c90f60f854b47e48cd2252b30510e7a1feddaf5a3f72cbf", size = 8042131, upload-time = "2025-10-09T00:27:21.608Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/4b/e5bc2c321b6a7e3a75638d937d19ea267c34bd5a90e12bee76c4d7c7a0d9/matplotlib-3.10.7-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d883460c43e8c6b173fef244a2341f7f7c0e9725c7fe68306e8e44ed9c8fb100", size = 8273787, upload-time = "2025-10-09T00:27:23.27Z" },
-    { url = "https://files.pythonhosted.org/packages/86/ad/6efae459c56c2fbc404da154e13e3a6039129f3c942b0152624f1c621f05/matplotlib-3.10.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07124afcf7a6504eafcb8ce94091c5898bbdd351519a1beb5c45f7a38c67e77f", size = 8131348, upload-time = "2025-10-09T00:27:24.926Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/5a/a4284d2958dee4116359cc05d7e19c057e64ece1b4ac986ab0f2f4d52d5a/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c17398b709a6cce3d9fdb1595c33e356d91c098cd9486cb2cc21ea2ea418e715", size = 9533949, upload-time = "2025-10-09T00:27:26.704Z" },
-    { url = "https://files.pythonhosted.org/packages/de/ff/f3781b5057fa3786623ad8976fc9f7b0d02b2f28534751fd5a44240de4cf/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7146d64f561498764561e9cd0ed64fcf582e570fc519e6f521e2d0cfd43365e1", size = 9804247, upload-time = "2025-10-09T00:27:28.514Z" },
-    { url = "https://files.pythonhosted.org/packages/47/5a/993a59facb8444efb0e197bf55f545ee449902dcee86a4dfc580c3b61314/matplotlib-3.10.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90ad854c0a435da3104c01e2c6f0028d7e719b690998a2333d7218db80950722", size = 9595497, upload-time = "2025-10-09T00:27:30.418Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/a5/77c95aaa9bb32c345cbb49626ad8eb15550cba2e6d4c88081a6c2ac7b08d/matplotlib-3.10.7-cp314-cp314-win_amd64.whl", hash = "sha256:4645fc5d9d20ffa3a39361fcdbcec731382763b623b72627806bf251b6388866", size = 8252732, upload-time = "2025-10-09T00:27:32.332Z" },
-    { url = "https://files.pythonhosted.org/packages/74/04/45d269b4268d222390d7817dae77b159651909669a34ee9fdee336db5883/matplotlib-3.10.7-cp314-cp314-win_arm64.whl", hash = "sha256:9257be2f2a03415f9105c486d304a321168e61ad450f6153d77c69504ad764bb", size = 8124240, upload-time = "2025-10-09T00:27:33.94Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/c7/ca01c607bb827158b439208c153d6f14ddb9fb640768f06f7ca3488ae67b/matplotlib-3.10.7-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1e4bbad66c177a8fdfa53972e5ef8be72a5f27e6a607cec0d8579abd0f3102b1", size = 8316938, upload-time = "2025-10-09T00:27:35.534Z" },
-    { url = "https://files.pythonhosted.org/packages/84/d2/5539e66e9f56d2fdec94bb8436f5e449683b4e199bcc897c44fbe3c99e28/matplotlib-3.10.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d8eb7194b084b12feb19142262165832fc6ee879b945491d1c3d4660748020c4", size = 8178245, upload-time = "2025-10-09T00:27:37.334Z" },
-    { url = "https://files.pythonhosted.org/packages/77/b5/e6ca22901fd3e4fe433a82e583436dd872f6c966fca7e63cf806b40356f8/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d41379b05528091f00e1728004f9a8d7191260f3862178b88e8fd770206318", size = 9541411, upload-time = "2025-10-09T00:27:39.387Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/99/a4524db57cad8fee54b7237239a8f8360bfcfa3170d37c9e71c090c0f409/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a74f79fafb2e177f240579bc83f0b60f82cc47d2f1d260f422a0627207008ca", size = 9803664, upload-time = "2025-10-09T00:27:41.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/a5/85e2edf76ea0ad4288d174926d9454ea85f3ce5390cc4e6fab196cbf250b/matplotlib-3.10.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:702590829c30aada1e8cef0568ddbffa77ca747b4d6e36c6d173f66e301f89cc", size = 9594066, upload-time = "2025-10-09T00:27:43.694Z" },
-    { url = "https://files.pythonhosted.org/packages/39/69/9684368a314f6d83fe5c5ad2a4121a3a8e03723d2e5c8ea17b66c1bad0e7/matplotlib-3.10.7-cp314-cp314t-win_amd64.whl", hash = "sha256:f79d5de970fc90cd5591f60053aecfce1fcd736e0303d9f0bf86be649fa68fb8", size = 8342832, upload-time = "2025-10-09T00:27:45.543Z" },
-    { url = "https://files.pythonhosted.org/packages/04/5f/e22e08da14bc1a0894184640d47819d2338b792732e20d292bf86e5ab785/matplotlib-3.10.7-cp314-cp314t-win_arm64.whl", hash = "sha256:cb783436e47fcf82064baca52ce748af71725d0352e1d31564cbe9c95df92b9c", size = 8172585, upload-time = "2025-10-09T00:27:47.185Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/6c/a9bcf03e9afb2a873e0a5855f79bce476d1023f26f8212969f2b7504756c/matplotlib-3.10.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5c09cf8f2793f81368f49f118b6f9f937456362bee282eac575cca7f84cda537", size = 8241204, upload-time = "2025-10-09T00:27:48.806Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/fd/0e6f5aa762ed689d9fa8750b08f1932628ffa7ed30e76423c399d19407d2/matplotlib-3.10.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:de66744b2bb88d5cd27e80dfc2ec9f0517d0a46d204ff98fe9e5f2864eb67657", size = 8104607, upload-time = "2025-10-09T00:27:50.876Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/a9/21c9439d698fac5f0de8fc68b2405b738ed1f00e1279c76f2d9aa5521ead/matplotlib-3.10.7-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:53cc80662dd197ece414dd5b66e07370201515a3eaf52e7c518c68c16814773b", size = 8682257, upload-time = "2025-10-09T00:27:52.597Z" },
-    { url = "https://files.pythonhosted.org/packages/58/8f/76d5dc21ac64a49e5498d7f0472c0781dae442dd266a67458baec38288ec/matplotlib-3.10.7-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:15112bcbaef211bd663fa935ec33313b948e214454d949b723998a43357b17b0", size = 8252283, upload-time = "2025-10-09T00:27:54.739Z" },
-    { url = "https://files.pythonhosted.org/packages/27/0d/9c5d4c2317feb31d819e38c9f947c942f42ebd4eb935fc6fd3518a11eaa7/matplotlib-3.10.7-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d2a959c640cdeecdd2ec3136e8ea0441da59bcaf58d67e9c590740addba2cb68", size = 8116733, upload-time = "2025-10-09T00:27:56.406Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/cc/3fe688ff1355010937713164caacf9ed443675ac48a997bab6ed23b3f7c0/matplotlib-3.10.7-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3886e47f64611046bc1db523a09dd0a0a6bed6081e6f90e13806dd1d1d1b5e91", size = 8693919, upload-time = "2025-10-09T00:27:58.41Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/be/a30bd917018ad220c400169fba298f2bb7003c8ccbc0c3e24ae2aacad1e8/matplotlib-3.10.8-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:00270d217d6b20d14b584c521f810d60c5c78406dc289859776550df837dcda7", size = 8239828, upload-time = "2025-12-10T22:55:02.313Z" },
+    { url = "https://files.pythonhosted.org/packages/58/27/ca01e043c4841078e82cf6e80a6993dfecd315c3d79f5f3153afbb8e1ec6/matplotlib-3.10.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:37b3c1cc42aa184b3f738cfa18c1c1d72fd496d85467a6cf7b807936d39aa656", size = 8128050, upload-time = "2025-12-10T22:55:04.997Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/aa/7ab67f2b729ae6a91bcf9dcac0affb95fb8c56f7fd2b2af894ae0b0cf6fa/matplotlib-3.10.8-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee40c27c795bda6a5292e9cff9890189d32f7e3a0bf04e0e3c9430c4a00c37df", size = 8700452, upload-time = "2025-12-10T22:55:07.47Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ae/2d5817b0acee3c49b7e7ccfbf5b273f284957cc8e270adf36375db353190/matplotlib-3.10.8-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a48f2b74020919552ea25d222d5cc6af9ca3f4eb43a93e14d068457f545c2a17", size = 9534928, upload-time = "2025-12-10T22:55:10.566Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/5b/8e66653e9f7c39cb2e5cab25fce4810daffa2bff02cbf5f3077cea9e942c/matplotlib-3.10.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f254d118d14a7f99d616271d6c3c27922c092dac11112670b157798b89bf4933", size = 9586377, upload-time = "2025-12-10T22:55:12.362Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e2/fd0bbadf837f81edb0d208ba8f8cb552874c3b16e27cb91a31977d90875d/matplotlib-3.10.8-cp310-cp310-win_amd64.whl", hash = "sha256:f9b587c9c7274c1613a30afabf65a272114cd6cdbe67b3406f818c79d7ab2e2a", size = 8128127, upload-time = "2025-12-10T22:55:14.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" },
+    { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" },
+    { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b9/15fd5541ef4f5b9a17eefd379356cf12175fe577424e7b1d80676516031a/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6", size = 8261076, upload-time = "2025-12-10T22:55:44.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a0/2ba3473c1b66b9c74dc7107c67e9008cb1782edbe896d4c899d39ae9cf78/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1", size = 8148794, upload-time = "2025-12-10T22:55:46.252Z" },
+    { url = "https://files.pythonhosted.org/packages/75/97/a471f1c3eb1fd6f6c24a31a5858f443891d5127e63a7788678d14e249aea/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486", size = 8718474, upload-time = "2025-12-10T22:55:47.864Z" },
+    { url = "https://files.pythonhosted.org/packages/01/be/cd478f4b66f48256f42927d0acbcd63a26a893136456cd079c0cc24fbabf/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce", size = 9549637, upload-time = "2025-12-10T22:55:50.048Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7c/8dc289776eae5109e268c4fb92baf870678dc048a25d4ac903683b86d5bf/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6", size = 9613678, upload-time = "2025-12-10T22:55:52.21Z" },
+    { url = "https://files.pythonhosted.org/packages/64/40/37612487cc8a437d4dd261b32ca21fe2d79510fe74af74e1f42becb1bdb8/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149", size = 8142686, upload-time = "2025-12-10T22:55:54.253Z" },
+    { url = "https://files.pythonhosted.org/packages/66/52/8d8a8730e968185514680c2a6625943f70269509c3dcfc0dcf7d75928cb8/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645", size = 8012917, upload-time = "2025-12-10T22:55:56.268Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/27/51fe26e1062f298af5ef66343d8ef460e090a27fea73036c76c35821df04/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077", size = 8305679, upload-time = "2025-12-10T22:55:57.856Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/1e/4de865bc591ac8e3062e835f42dd7fe7a93168d519557837f0e37513f629/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22", size = 8198336, upload-time = "2025-12-10T22:55:59.371Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cb/2f7b6e75fb4dce87ef91f60cac4f6e34f4c145ab036a22318ec837971300/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39", size = 8731653, upload-time = "2025-12-10T22:56:01.032Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b3/bd9c57d6ba670a37ab31fb87ec3e8691b947134b201f881665b28cc039ff/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565", size = 9561356, upload-time = "2025-12-10T22:56:02.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3d/8b94a481456dfc9dfe6e39e93b5ab376e50998cddfd23f4ae3b431708f16/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a", size = 9614000, upload-time = "2025-12-10T22:56:05.411Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/cd/bc06149fe5585ba800b189a6a654a75f1f127e8aab02fd2be10df7fa500c/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958", size = 8220043, upload-time = "2025-12-10T22:56:07.551Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/de/b22cf255abec916562cc04eef457c13e58a1990048de0c0c3604d082355e/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5", size = 8062075, upload-time = "2025-12-10T22:56:09.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/9c0ff7a2f11615e516c3b058e1e6e8f9614ddeca53faca06da267c48345d/matplotlib-3.10.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b53285e65d4fa4c86399979e956235deb900be5baa7fc1218ea67fbfaeaadd6f", size = 8262481, upload-time = "2025-12-10T22:56:10.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ca/e8ae28649fcdf039fda5ef554b40a95f50592a3c47e6f7270c9561c12b07/matplotlib-3.10.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32f8dce744be5569bebe789e46727946041199030db8aeb2954d26013a0eb26b", size = 8151473, upload-time = "2025-12-10T22:56:12.377Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/6f/009d129ae70b75e88cbe7e503a12a4c0670e08ed748a902c2568909e9eb5/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cf267add95b1c88300d96ca837833d4112756045364f5c734a2276038dae27d", size = 9553896, upload-time = "2025-12-10T22:56:14.432Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/26/4221a741eb97967bc1fd5e4c52b9aa5a91b2f4ec05b59f6def4d820f9df9/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2cf5bd12cecf46908f286d7838b2abc6c91cda506c0445b8223a7c19a00df008", size = 9824193, upload-time = "2025-12-10T22:56:16.29Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/3abf75f38605772cf48a9daf5821cd4f563472f38b4b828c6fba6fa6d06e/matplotlib-3.10.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:41703cc95688f2516b480f7f339d8851a6035f18e100ee6a32bc0b8536a12a9c", size = 9615444, upload-time = "2025-12-10T22:56:18.155Z" },
+    { url = "https://files.pythonhosted.org/packages/93/a5/de89ac80f10b8dc615807ee1133cd99ac74082581196d4d9590bea10690d/matplotlib-3.10.8-cp314-cp314-win_amd64.whl", hash = "sha256:83d282364ea9f3e52363da262ce32a09dfe241e4080dcedda3c0db059d3c1f11", size = 8272719, upload-time = "2025-12-10T22:56:20.366Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ce/b006495c19ccc0a137b48083168a37bd056392dee02f87dba0472f2797fe/matplotlib-3.10.8-cp314-cp314-win_arm64.whl", hash = "sha256:2c1998e92cd5999e295a731bcb2911c75f597d937341f3030cc24ef2733d78a8", size = 8144205, upload-time = "2025-12-10T22:56:22.239Z" },
+    { url = "https://files.pythonhosted.org/packages/68/d9/b31116a3a855bd313c6fcdb7226926d59b041f26061c6c5b1be66a08c826/matplotlib-3.10.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b5a2b97dbdc7d4f353ebf343744f1d1f1cca8aa8bfddb4262fcf4306c3761d50", size = 8305785, upload-time = "2025-12-10T22:56:24.218Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/90/6effe8103f0272685767ba5f094f453784057072f49b393e3ea178fe70a5/matplotlib-3.10.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3f5c3e4da343bba819f0234186b9004faba952cc420fbc522dc4e103c1985908", size = 8198361, upload-time = "2025-12-10T22:56:26.787Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/65/a73188711bea603615fc0baecca1061429ac16940e2385433cc778a9d8e7/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f62550b9a30afde8c1c3ae450e5eb547d579dd69b25c2fc7a1c67f934c1717a", size = 9561357, upload-time = "2025-12-10T22:56:28.953Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/3d/b5c5d5d5be8ce63292567f0e2c43dde9953d3ed86ac2de0a72e93c8f07a1/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:495672de149445ec1b772ff2c9ede9b769e3cb4f0d0aa7fa730d7f59e2d4e1c1", size = 9823610, upload-time = "2025-12-10T22:56:31.455Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/4b/e7beb6bbd49f6bae727a12b270a2654d13c397576d25bd6786e47033300f/matplotlib-3.10.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:595ba4d8fe983b88f0eec8c26a241e16d6376fe1979086232f481f8f3f67494c", size = 9614011, upload-time = "2025-12-10T22:56:33.85Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/e6/76f2813d31f032e65f6f797e3f2f6e4aab95b65015924b1c51370395c28a/matplotlib-3.10.8-cp314-cp314t-win_amd64.whl", hash = "sha256:25d380fe8b1dc32cf8f0b1b448470a77afb195438bafdf1d858bfb876f3edf7b", size = 8362801, upload-time = "2025-12-10T22:56:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/49/d651878698a0b67f23aa28e17f45a6d6dd3d3f933fa29087fa4ce5947b5a/matplotlib-3.10.8-cp314-cp314t-win_arm64.whl", hash = "sha256:113bb52413ea508ce954a02c10ffd0d565f9c3bc7f2eddc27dfe1731e71c7b5f", size = 8192560, upload-time = "2025-12-10T22:56:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/43/31d59500bb950b0d188e149a2e552040528c13d6e3d6e84d0cccac593dcd/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f97aeb209c3d2511443f8797e3e5a569aebb040d4f8bc79aa3ee78a8fb9e3dd8", size = 8237252, upload-time = "2025-12-10T22:56:39.529Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2c/615c09984f3c5f907f51c886538ad785cf72e0e11a3225de2c0f9442aecc/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fb061f596dad3a0f52b60dc6a5dec4a0c300dec41e058a7efe09256188d170b7", size = 8124693, upload-time = "2025-12-10T22:56:41.758Z" },
+    { url = "https://files.pythonhosted.org/packages/91/e1/2757277a1c56041e1fc104b51a0f7b9a4afc8eb737865d63cababe30bc61/matplotlib-3.10.8-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:12d90df9183093fcd479f4172ac26b322b1248b15729cb57f42f71f24c7e37a3", size = 8702205, upload-time = "2025-12-10T22:56:43.415Z" },
+    { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" },
 ]
 
 [[package]]
@@ -1076,26 +1655,26 @@ wheels = [
 
 [[package]]
 name = "maturin"
-version = "1.10.1"
+version = "1.11.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e9/4c/dd1dbc35780fdc5c51ccb0d08e5ece8e63a5ca82f6c9189fcbb031fc589c/maturin-1.10.1.tar.gz", hash = "sha256:69543e8bad4221c3c7ae7d7f31f275757bff8a66936368e013fa0256f8d6b512", size = 218306, upload-time = "2025-11-11T12:03:57.722Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/84/bfed8cc10e2d8b6656cf0f0ca6609218e6fcb45a62929f5094e1063570f7/maturin-1.11.5.tar.gz", hash = "sha256:7579cf47640fb9595a19fe83a742cbf63203f0343055c349c1cab39045a30c29", size = 226885, upload-time = "2026-01-09T11:06:13.801Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ca/37/16af14d312beb689a72a1a6bb378a84413b75f4de63e26fe75059ace072f/maturin-1.10.1-py3-none-linux_armv6l.whl", hash = "sha256:dfc0e509ce0f1f77fe1316a503a35991ef27f2ea6ffa3527d12fc0d238700c94", size = 8773448, upload-time = "2025-11-11T12:03:25.62Z" },
-    { url = "https://files.pythonhosted.org/packages/36/b3/3f59605e81ccf0d064349e19577dbcb57df36afa8c86b16a2547c25dcb6d/maturin-1.10.1-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:5c2557b9c6b615d651f15c04c7baf9cfea9babeecea4cb136f054fc5dd1dab6b", size = 17065512, upload-time = "2025-11-11T12:03:29.392Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f1/6a4ea504b0f4643e1fd934b2f40cd91bf5f84db5f184fbdd4b1f1ac31407/maturin-1.10.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:52c55dc8ee2b9a7a34358af40c24113c179bdbd1be19c14d96f773850f41c216", size = 8819267, upload-time = "2025-11-11T12:03:31.92Z" },
-    { url = "https://files.pythonhosted.org/packages/32/36/7480d94ef040c201207cb84739b889af3f85ff69bd2edde505b267a30992/maturin-1.10.1-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:cc0540148dd896aba2af232ebaf3f9adc1637d54d5dcd501ba3daea8f9e3c84b", size = 8775821, upload-time = "2025-11-11T12:03:34.059Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/da/1cd0257a33904d2d0d9949aaaa67a8f4a7c37cf029ad199336680118a582/maturin-1.10.1-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:9475a6ac15339fc0be5d3f1cdc6e1a50711ea75bd41f49ba50b52b1a46191dde", size = 9241687, upload-time = "2025-11-11T12:03:36.473Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/90/c29527e05df7c148571ee3bddb1877731f16db192d31b52f896e0d9b9ea9/maturin-1.10.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:fdbe5b43e1aefa8925ab19f727ddb3732c2c53fd6ac6b1c1de63983c37527101", size = 8684098, upload-time = "2025-11-11T12:03:38.615Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/3f/4e2250bd45e18ad76121bccc030e7883bf7b939e4ed0b9cb7e9c35b76761/maturin-1.10.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:b37b20f273ec0f95db36eff2b9cdf15c2228dfedae8caf88b745e52944795f47", size = 8645719, upload-time = "2025-11-11T12:03:41.098Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/cb/73118f02d84cf1626c0d5c87bf11ceb870299f373bc3b9c055e85af71c10/maturin-1.10.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:6c6de5da3bcc31b7f16b8f6715afa25507ac7e21c463872903963396aa991dc4", size = 11205915, upload-time = "2025-11-11T12:03:43.656Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/2b/3a171397789d594d7aecf0ac2a6dda9f6e628c3447c8cf6acaf44a7876f5/maturin-1.10.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a68223dcaa1873fc5825983fecfabbfef7671c08d6f8a280dfa351feee48ebe", size = 9328481, upload-time = "2025-11-11T12:03:46.11Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/41/0c7603fd3ac69ab13c5d51f3b1cf31b3c2275a23765e5818f859512df556/maturin-1.10.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:e69bdbade26e0b0a642384595bb392a728e0d23c3ec59a6f09b8f9bc6376e7d1", size = 8983905, upload-time = "2025-11-11T12:03:48.625Z" },
-    { url = "https://files.pythonhosted.org/packages/48/f8/29ae49938360a7db23a3d2f410cecb3a6b8d94d93cc64c49add389b619a8/maturin-1.10.1-py3-none-win32.whl", hash = "sha256:9e62c009c09529e13967e7efe3c78a9be67b6c0b5730485e925e2fce60719462", size = 7655122, upload-time = "2025-11-11T12:03:51.344Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/70/584cdc8244a5b0319568192ddcb4e1f5ae6d560381968e310bb19e7e9c31/maturin-1.10.1-py3-none-win_amd64.whl", hash = "sha256:bb84e1a556490470572fbfba4aab3cb281d6d9ea766a346c96aa9cfd47ba1fc6", size = 8903034, upload-time = "2025-11-11T12:03:53.555Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/93/9f1a7628a39b7527b4bd71c4eb76dbd73f228bda9b779e39321a83707005/maturin-1.10.1-py3-none-win_arm64.whl", hash = "sha256:b285602df88a6ed8aa4d9e5ac893ecf32530515723af5acfd5b32feeb2a8a774", size = 7506661, upload-time = "2025-11-11T12:03:55.994Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6c/3443d2f8c6d4eae5fc7479cd4053542aff4c1a8566d0019d0612d241b15a/maturin-1.11.5-py3-none-linux_armv6l.whl", hash = "sha256:edd1d4d35050ea2b9ef42aa01e87fe019a1e822940346b35ccb973e0aa8f6d82", size = 8845897, upload-time = "2026-01-09T11:06:17.327Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/03/abf1826d8aebc0d47ef6d21bdd752d98d63ac4372ad2b115db9cd5176229/maturin-1.11.5-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:2a596eab137cb3e169b97e89a739515abfa7a8755e2e5f0fc91432ef446f74f4", size = 17233855, upload-time = "2026-01-09T11:06:04.272Z" },
+    { url = "https://files.pythonhosted.org/packages/90/a1/5ad62913271724035a7e4bcf796d7c95b4119317ae5f8cb034844aa99bc4/maturin-1.11.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:1c27a2eb47821edf26c75d100b3150b52dca2c1a5f074d7514af06f7a7acb9d5", size = 8881776, upload-time = "2026-01-09T11:06:10.24Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/66/997974b44f8d3de641281ec04fbf5b6ca821bdc8291a2fa73305978db74d/maturin-1.11.5-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:f1320dacddcd3aa84a4bdfc77ee6fdb60e4c3835c853d7eb79c09473628b0498", size = 8870347, upload-time = "2026-01-09T11:06:12.178Z" },
+    { url = "https://files.pythonhosted.org/packages/58/e0/c8fa042daf0608cc2e9a59b6df3a9e287bfc7f229136f17727f4118bac2d/maturin-1.11.5-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:ffe7418834ff3b4a6c987187b7abb85ba033f4733e089d77d84e2de87057b4e7", size = 9291396, upload-time = "2026-01-09T11:06:02.05Z" },
+    { url = "https://files.pythonhosted.org/packages/99/af/9d3edc8375efc8d435d5f24794bc4de234d4e743447592da970d53b31361/maturin-1.11.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:c739b243d012386902f112ea63a54a94848932b70ae3565fa5e121fd1c0200e0", size = 8827831, upload-time = "2026-01-09T11:06:19.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/12/cc341f6abbf9005f90935a4ee5dc7b30e2df7d1bb90b96d48b756b2c0ee7/maturin-1.11.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:8127d2cd25950bacbcdc8a2ec6daab1d4d27200f7d73964392680ad64d27f7f0", size = 8718895, upload-time = "2026-01-09T11:06:21.617Z" },
+    { url = "https://files.pythonhosted.org/packages/76/17/654a59c66287e287373f2a0086e4fc8a23f0545a81c2bd6e324db26a5801/maturin-1.11.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:2a4e872fb78e77748217084ffeb59de565d08a86ccefdace054520aaa7b66db4", size = 11384741, upload-time = "2026-01-09T11:06:15.261Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/da/7118de648182971d723ea99d79c55007f96cdafc95f5322cc1ad15f6683e/maturin-1.11.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2079447967819b5cf615e5b5b99a406d662effdc8d6afd493dcd253c6afc3707", size = 9423814, upload-time = "2026-01-09T11:05:57.242Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8f/be14395c6e23b19ddaa0c171e68915bdcd1ef61ad1f411739c6721196903/maturin-1.11.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:50f6c668c1d5d4d4dc1c3ffec7b4270dab493e5b2368f8e4213f4bcde6a50eea", size = 9104378, upload-time = "2026-01-09T11:05:59.835Z" },
+    { url = "https://files.pythonhosted.org/packages/77/83/53ea82a2f42a03930ea5545673d11a4ef49bb886827353a701f41a5f11c4/maturin-1.11.5-py3-none-win32.whl", hash = "sha256:49f85ce6cbe478e9743ecddd6da2964afc0ded57013aa4d054256be702d23d40", size = 7738696, upload-time = "2026-01-09T11:06:06.651Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/41/353a26d49aa80081c514a6354d429efbecedb90d0153ec598cece3baa607/maturin-1.11.5-py3-none-win_amd64.whl", hash = "sha256:70d3e5beffb9ef9dfae5f3c1a7eeb572091505eb8cb076e9434518df1c42a73b", size = 9029838, upload-time = "2026-01-09T11:05:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/15/67/c94f8f5440bc42d54113a2d99de0d6107f06b5a33f31823e52b2715d856f/maturin-1.11.5-py3-none-win_arm64.whl", hash = "sha256:9348f7f0a346108e0c96e6719be91da4470bd43c15802435e9f4157f5cca43d4", size = 7624029, upload-time = "2026-01-09T11:06:08.728Z" },
 ]
 
 [[package]]
@@ -1107,6 +1686,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
+[[package]]
+name = "mistune"
+version = "3.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/55/d01f0c4b45ade6536c51170b9043db8b2ec6ddf4a35c7ea3f5f559ac935b/mistune-3.2.0.tar.gz", hash = "sha256:708487c8a8cdd99c9d90eb3ed4c3ed961246ff78ac82f03418f5183ab70e398a", size = 95467, upload-time = "2025-12-23T11:36:34.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/f7/4a5e785ec9fbd65146a27b6b70b6cdc161a66f2024e4b04ac06a67f5578b/mistune-3.2.0-py3-none-any.whl", hash = "sha256:febdc629a3c78616b94393c6580551e0e34cc289987ec6c35ed3f4be42d0eee1", size = 53598, upload-time = "2025-12-23T11:36:33.211Z" },
+]
+
 [[package]]
 name = "more-itertools"
 version = "10.8.0"
@@ -1116,6 +1707,61 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/8e/469e5a4a2f5855992e425f3cb33804cc07bf18d48f2db061aec61ce50270/more_itertools-10.8.0-py3-none-any.whl", hash = "sha256:52d4362373dcf7c52546bc4af9a86ee7c4579df9a8dc268be0a2f949d376cc9b", size = 69667, upload-time = "2025-09-02T15:23:09.635Z" },
 ]
 
+[[package]]
+name = "nbclient"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "nbformat" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/56/91/1c1d5a4b9a9ebba2b4e32b8c852c2975c872aec1fe42ab5e516b2cecd193/nbclient-0.10.4.tar.gz", hash = "sha256:1e54091b16e6da39e297b0ece3e10f6f29f4ac4e8ee515d29f8a7099bd6553c9", size = 62554, upload-time = "2025-12-23T07:45:46.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/a0/5b0c2f11142ed1dddec842457d3f65eaf71a0080894eb6f018755b319c3a/nbclient-0.10.4-py3-none-any.whl", hash = "sha256:9162df5a7373d70d606527300a95a975a47c137776cd942e52d9c7e29ff83440", size = 25465, upload-time = "2025-12-23T07:45:44.51Z" },
+]
+
+[[package]]
+name = "nbconvert"
+version = "7.17.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "bleach", extra = ["css"] },
+    { name = "defusedxml" },
+    { name = "jinja2" },
+    { name = "jupyter-core" },
+    { name = "jupyterlab-pygments" },
+    { name = "markupsafe" },
+    { name = "mistune" },
+    { name = "nbclient" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "pandocfilters" },
+    { name = "pygments" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/47/81f886b699450d0569f7bc551df2b1673d18df7ff25cc0c21ca36ed8a5ff/nbconvert-7.17.0.tar.gz", hash = "sha256:1b2696f1b5be12309f6c7d707c24af604b87dfaf6d950794c7b07acab96dda78", size = 862855, upload-time = "2026-01-29T16:37:48.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/4b/8d5f796a792f8a25f6925a96032f098789f448571eb92011df1ae59e8ea8/nbconvert-7.17.0-py3-none-any.whl", hash = "sha256:4f99a63b337b9a23504347afdab24a11faa7d86b405e5c8f9881cd313336d518", size = 261510, upload-time = "2026-01-29T16:37:46.322Z" },
+]
+
+[[package]]
+name = "nbformat"
+version = "5.10.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastjsonschema" },
+    { name = "jsonschema" },
+    { name = "jupyter-core" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" },
+]
+
 [[package]]
 name = "nest-asyncio"
 version = "1.6.0"
@@ -1139,14 +1785,19 @@ wheels = [
 
 [[package]]
 name = "networkx"
-version = "3.5"
+version = "3.6.1"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version >= '3.11'",
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload-time = "2025-05-29T11:35:07.804Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406, upload-time = "2025-05-29T11:35:04.961Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
 ]
 
 [[package]]
@@ -1182,6 +1833,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/7e/a96255f63b7aef032cbee8fc4d6e37def72e3aaedc1f72759235e8f13cb1/nh3-0.3.2-cp38-abi3-win_arm64.whl", hash = "sha256:cf5964d54edd405e68583114a7cba929468bcd7db5e676ae38ee954de1cfc104", size = 584162, upload-time = "2025-10-30T11:17:44.96Z" },
 ]
 
+[[package]]
+name = "notebook"
+version = "7.5.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+    { name = "jupyterlab" },
+    { name = "jupyterlab-server" },
+    { name = "notebook-shim" },
+    { name = "tornado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b8/cb/cc7f4df5cee315dd126a47eb60890690a0438d5e0dd40c32d60ce16de377/notebook-7.5.3.tar.gz", hash = "sha256:393ceb269cf9fdb02a3be607a57d7bd5c2c14604f1818a17dbeb38e04f98cbfa", size = 14073140, upload-time = "2026-01-26T07:28:36.605Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/98/9286e7f35e5584ebb79f997f2fb0cb66745c86f6c5fccf15ba32aac5e908/notebook-7.5.3-py3-none-any.whl", hash = "sha256:c997bfa1a2a9eb58c9bbb7e77d50428befb1033dd6f02c482922e96851d67354", size = 14481744, upload-time = "2026-01-26T07:28:31.867Z" },
+]
+
+[[package]]
+name = "notebook-shim"
+version = "0.2.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" },
+]
+
 [[package]]
 name = "numpy"
 version = "2.2.6"
@@ -1249,104 +1928,257 @@ wheels = [
 
 [[package]]
 name = "numpy"
-version = "2.3.4"
+version = "2.4.2"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version >= '3.11'",
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b5/f4/098d2270d52b41f1bd7db9fc288aaa0400cb48c2a3e2af6fa365d9720947/numpy-2.3.4.tar.gz", hash = "sha256:a7d018bfedb375a8d979ac758b120ba846a7fe764911a64465fd87b8729f4a6a", size = 20582187, upload-time = "2025-10-15T16:18:11.77Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/60/e7/0e07379944aa8afb49a556a2b54587b828eb41dc9adc56fb7615b678ca53/numpy-2.3.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e78aecd2800b32e8347ce49316d3eaf04aed849cd5b38e0af39f829a4e59f5eb", size = 21259519, upload-time = "2025-10-15T16:15:19.012Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/cb/5a69293561e8819b09e34ed9e873b9a82b5f2ade23dce4c51dc507f6cfe1/numpy-2.3.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7fd09cc5d65bda1e79432859c40978010622112e9194e581e3415a3eccc7f43f", size = 14452796, upload-time = "2025-10-15T16:15:23.094Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/04/ff11611200acd602a1e5129e36cfd25bf01ad8e5cf927baf2e90236eb02e/numpy-2.3.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:1b219560ae2c1de48ead517d085bc2d05b9433f8e49d0955c82e8cd37bd7bf36", size = 5381639, upload-time = "2025-10-15T16:15:25.572Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/77/e95c757a6fe7a48d28a009267408e8aa382630cc1ad1db7451b3bc21dbb4/numpy-2.3.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:bafa7d87d4c99752d07815ed7a2c0964f8ab311eb8168f41b910bd01d15b6032", size = 6914296, upload-time = "2025-10-15T16:15:27.079Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/d2/137c7b6841c942124eae921279e5c41b1c34bab0e6fc60c7348e69afd165/numpy-2.3.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36dc13af226aeab72b7abad501d370d606326a0029b9f435eacb3b8c94b8a8b7", size = 14591904, upload-time = "2025-10-15T16:15:29.044Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/32/67e3b0f07b0aba57a078c4ab777a9e8e6bc62f24fb53a2337f75f9691699/numpy-2.3.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7b2f9a18b5ff9824a6af80de4f37f4ec3c2aab05ef08f51c77a093f5b89adda", size = 16939602, upload-time = "2025-10-15T16:15:31.106Z" },
-    { url = "https://files.pythonhosted.org/packages/95/22/9639c30e32c93c4cee3ccdb4b09c2d0fbff4dcd06d36b357da06146530fb/numpy-2.3.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9984bd645a8db6ca15d850ff996856d8762c51a2239225288f08f9050ca240a0", size = 16372661, upload-time = "2025-10-15T16:15:33.546Z" },
-    { url = "https://files.pythonhosted.org/packages/12/e9/a685079529be2b0156ae0c11b13d6be647743095bb51d46589e95be88086/numpy-2.3.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:64c5825affc76942973a70acf438a8ab618dbd692b84cd5ec40a0a0509edc09a", size = 18884682, upload-time = "2025-10-15T16:15:36.105Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/85/f6f00d019b0cc741e64b4e00ce865a57b6bed945d1bbeb1ccadbc647959b/numpy-2.3.4-cp311-cp311-win32.whl", hash = "sha256:ed759bf7a70342f7817d88376eb7142fab9fef8320d6019ef87fae05a99874e1", size = 6570076, upload-time = "2025-10-15T16:15:38.225Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/10/f8850982021cb90e2ec31990291f9e830ce7d94eef432b15066e7cbe0bec/numpy-2.3.4-cp311-cp311-win_amd64.whl", hash = "sha256:faba246fb30ea2a526c2e9645f61612341de1a83fb1e0c5edf4ddda5a9c10996", size = 13089358, upload-time = "2025-10-15T16:15:40.404Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/ad/afdd8351385edf0b3445f9e24210a9c3971ef4de8fd85155462fc4321d79/numpy-2.3.4-cp311-cp311-win_arm64.whl", hash = "sha256:4c01835e718bcebe80394fd0ac66c07cbb90147ebbdad3dcecd3f25de2ae7e2c", size = 10462292, upload-time = "2025-10-15T16:15:42.896Z" },
-    { url = "https://files.pythonhosted.org/packages/96/7a/02420400b736f84317e759291b8edaeee9dc921f72b045475a9cbdb26b17/numpy-2.3.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef1b5a3e808bc40827b5fa2c8196151a4c5abe110e1726949d7abddfe5c7ae11", size = 20957727, upload-time = "2025-10-15T16:15:44.9Z" },
-    { url = "https://files.pythonhosted.org/packages/18/90/a014805d627aa5750f6f0e878172afb6454552da929144b3c07fcae1bb13/numpy-2.3.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2f91f496a87235c6aaf6d3f3d89b17dba64996abadccb289f48456cff931ca9", size = 14187262, upload-time = "2025-10-15T16:15:47.761Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/e4/0a94b09abe89e500dc748e7515f21a13e30c5c3fe3396e6d4ac108c25fca/numpy-2.3.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f77e5b3d3da652b474cc80a14084927a5e86a5eccf54ca8ca5cbd697bf7f2667", size = 5115992, upload-time = "2025-10-15T16:15:50.144Z" },
-    { url = "https://files.pythonhosted.org/packages/88/dd/db77c75b055c6157cbd4f9c92c4458daef0dd9cbe6d8d2fe7f803cb64c37/numpy-2.3.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ab1c5f5ee40d6e01cbe96de5863e39b215a4d24e7d007cad56c7184fdf4aeef", size = 6648672, upload-time = "2025-10-15T16:15:52.442Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/e6/e31b0d713719610e406c0ea3ae0d90760465b086da8783e2fd835ad59027/numpy-2.3.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77b84453f3adcb994ddbd0d1c5d11db2d6bda1a2b7fd5ac5bd4649d6f5dc682e", size = 14284156, upload-time = "2025-10-15T16:15:54.351Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/58/30a85127bfee6f108282107caf8e06a1f0cc997cb6b52cdee699276fcce4/numpy-2.3.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4121c5beb58a7f9e6dfdee612cb24f4df5cd4db6e8261d7f4d7450a997a65d6a", size = 16641271, upload-time = "2025-10-15T16:15:56.67Z" },
-    { url = "https://files.pythonhosted.org/packages/06/f2/2e06a0f2adf23e3ae29283ad96959267938d0efd20a2e25353b70065bfec/numpy-2.3.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:65611ecbb00ac9846efe04db15cbe6186f562f6bb7e5e05f077e53a599225d16", size = 16059531, upload-time = "2025-10-15T16:15:59.412Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/e7/b106253c7c0d5dc352b9c8fab91afd76a93950998167fa3e5afe4ef3a18f/numpy-2.3.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dabc42f9c6577bcc13001b8810d300fe814b4cfbe8a92c873f269484594f9786", size = 18578983, upload-time = "2025-10-15T16:16:01.804Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e3/04ecc41e71462276ee867ccbef26a4448638eadecf1bc56772c9ed6d0255/numpy-2.3.4-cp312-cp312-win32.whl", hash = "sha256:a49d797192a8d950ca59ee2d0337a4d804f713bb5c3c50e8db26d49666e351dc", size = 6291380, upload-time = "2025-10-15T16:16:03.938Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/a8/566578b10d8d0e9955b1b6cd5db4e9d4592dd0026a941ff7994cedda030a/numpy-2.3.4-cp312-cp312-win_amd64.whl", hash = "sha256:985f1e46358f06c2a09921e8921e2c98168ed4ae12ccd6e5e87a4f1857923f32", size = 12787999, upload-time = "2025-10-15T16:16:05.801Z" },
-    { url = "https://files.pythonhosted.org/packages/58/22/9c903a957d0a8071b607f5b1bff0761d6e608b9a965945411f867d515db1/numpy-2.3.4-cp312-cp312-win_arm64.whl", hash = "sha256:4635239814149e06e2cb9db3dd584b2fa64316c96f10656983b8026a82e6e4db", size = 10197412, upload-time = "2025-10-15T16:16:07.854Z" },
-    { url = "https://files.pythonhosted.org/packages/57/7e/b72610cc91edf138bc588df5150957a4937221ca6058b825b4725c27be62/numpy-2.3.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c090d4860032b857d94144d1a9976b8e36709e40386db289aaf6672de2a81966", size = 20950335, upload-time = "2025-10-15T16:16:10.304Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/46/bdd3370dcea2f95ef14af79dbf81e6927102ddf1cc54adc0024d61252fd9/numpy-2.3.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a13fc473b6db0be619e45f11f9e81260f7302f8d180c49a22b6e6120022596b3", size = 14179878, upload-time = "2025-10-15T16:16:12.595Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/01/5a67cb785bda60f45415d09c2bc245433f1c68dd82eef9c9002c508b5a65/numpy-2.3.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:3634093d0b428e6c32c3a69b78e554f0cd20ee420dcad5a9f3b2a63762ce4197", size = 5108673, upload-time = "2025-10-15T16:16:14.877Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/cd/8428e23a9fcebd33988f4cb61208fda832800ca03781f471f3727a820704/numpy-2.3.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:043885b4f7e6e232d7df4f51ffdef8c36320ee9d5f227b380ea636722c7ed12e", size = 6641438, upload-time = "2025-10-15T16:16:16.805Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d1/913fe563820f3c6b079f992458f7331278dcd7ba8427e8e745af37ddb44f/numpy-2.3.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ee6a571d1e4f0ea6d5f22d6e5fbd6ed1dc2b18542848e1e7301bd190500c9d7", size = 14281290, upload-time = "2025-10-15T16:16:18.764Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/7e/7d306ff7cb143e6d975cfa7eb98a93e73495c4deabb7d1b5ecf09ea0fd69/numpy-2.3.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fc8a63918b04b8571789688b2780ab2b4a33ab44bfe8ccea36d3eba51228c953", size = 16636543, upload-time = "2025-10-15T16:16:21.072Z" },
-    { url = "https://files.pythonhosted.org/packages/47/6a/8cfc486237e56ccfb0db234945552a557ca266f022d281a2f577b98e955c/numpy-2.3.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:40cc556d5abbc54aabe2b1ae287042d7bdb80c08edede19f0c0afb36ae586f37", size = 16056117, upload-time = "2025-10-15T16:16:23.369Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/0e/42cb5e69ea901e06ce24bfcc4b5664a56f950a70efdcf221f30d9615f3f3/numpy-2.3.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ecb63014bb7f4ce653f8be7f1df8cbc6093a5a2811211770f6606cc92b5a78fd", size = 18577788, upload-time = "2025-10-15T16:16:27.496Z" },
-    { url = "https://files.pythonhosted.org/packages/86/92/41c3d5157d3177559ef0a35da50f0cda7fa071f4ba2306dd36818591a5bc/numpy-2.3.4-cp313-cp313-win32.whl", hash = "sha256:e8370eb6925bb8c1c4264fec52b0384b44f675f191df91cbe0140ec9f0955646", size = 6282620, upload-time = "2025-10-15T16:16:29.811Z" },
-    { url = "https://files.pythonhosted.org/packages/09/97/fd421e8bc50766665ad35536c2bb4ef916533ba1fdd053a62d96cc7c8b95/numpy-2.3.4-cp313-cp313-win_amd64.whl", hash = "sha256:56209416e81a7893036eea03abcb91c130643eb14233b2515c90dcac963fe99d", size = 12784672, upload-time = "2025-10-15T16:16:31.589Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/df/5474fb2f74970ca8eb978093969b125a84cc3d30e47f82191f981f13a8a0/numpy-2.3.4-cp313-cp313-win_arm64.whl", hash = "sha256:a700a4031bc0fd6936e78a752eefb79092cecad2599ea9c8039c548bc097f9bc", size = 10196702, upload-time = "2025-10-15T16:16:33.902Z" },
-    { url = "https://files.pythonhosted.org/packages/11/83/66ac031464ec1767ea3ed48ce40f615eb441072945e98693bec0bcd056cc/numpy-2.3.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:86966db35c4040fdca64f0816a1c1dd8dbd027d90fca5a57e00e1ca4cd41b879", size = 21049003, upload-time = "2025-10-15T16:16:36.101Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/99/5b14e0e686e61371659a1d5bebd04596b1d72227ce36eed121bb0aeab798/numpy-2.3.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:838f045478638b26c375ee96ea89464d38428c69170360b23a1a50fa4baa3562", size = 14302980, upload-time = "2025-10-15T16:16:39.124Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/44/e9486649cd087d9fc6920e3fc3ac2aba10838d10804b1e179fb7cbc4e634/numpy-2.3.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d7315ed1dab0286adca467377c8381cd748f3dc92235f22a7dfc42745644a96a", size = 5231472, upload-time = "2025-10-15T16:16:41.168Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/51/902b24fa8887e5fe2063fd61b1895a476d0bbf46811ab0c7fdf4bd127345/numpy-2.3.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:84f01a4d18b2cc4ade1814a08e5f3c907b079c847051d720fad15ce37aa930b6", size = 6739342, upload-time = "2025-10-15T16:16:43.777Z" },
-    { url = "https://files.pythonhosted.org/packages/34/f1/4de9586d05b1962acdcdb1dc4af6646361a643f8c864cef7c852bf509740/numpy-2.3.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:817e719a868f0dacde4abdfc5c1910b301877970195db9ab6a5e2c4bd5b121f7", size = 14354338, upload-time = "2025-10-15T16:16:46.081Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/06/1c16103b425de7969d5a76bdf5ada0804b476fed05d5f9e17b777f1cbefd/numpy-2.3.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85e071da78d92a214212cacea81c6da557cab307f2c34b5f85b628e94803f9c0", size = 16702392, upload-time = "2025-10-15T16:16:48.455Z" },
-    { url = "https://files.pythonhosted.org/packages/34/b2/65f4dc1b89b5322093572b6e55161bb42e3e0487067af73627f795cc9d47/numpy-2.3.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2ec646892819370cf3558f518797f16597b4e4669894a2ba712caccc9da53f1f", size = 16134998, upload-time = "2025-10-15T16:16:51.114Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/11/94ec578896cdb973aaf56425d6c7f2aff4186a5c00fac15ff2ec46998b46/numpy-2.3.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:035796aaaddfe2f9664b9a9372f089cfc88bd795a67bd1bfe15e6e770934cf64", size = 18651574, upload-time = "2025-10-15T16:16:53.429Z" },
-    { url = "https://files.pythonhosted.org/packages/62/b7/7efa763ab33dbccf56dade36938a77345ce8e8192d6b39e470ca25ff3cd0/numpy-2.3.4-cp313-cp313t-win32.whl", hash = "sha256:fea80f4f4cf83b54c3a051f2f727870ee51e22f0248d3114b8e755d160b38cfb", size = 6413135, upload-time = "2025-10-15T16:16:55.992Z" },
-    { url = "https://files.pythonhosted.org/packages/43/70/aba4c38e8400abcc2f345e13d972fb36c26409b3e644366db7649015f291/numpy-2.3.4-cp313-cp313t-win_amd64.whl", hash = "sha256:15eea9f306b98e0be91eb344a94c0e630689ef302e10c2ce5f7e11905c704f9c", size = 12928582, upload-time = "2025-10-15T16:16:57.943Z" },
-    { url = "https://files.pythonhosted.org/packages/67/63/871fad5f0073fc00fbbdd7232962ea1ac40eeaae2bba66c76214f7954236/numpy-2.3.4-cp313-cp313t-win_arm64.whl", hash = "sha256:b6c231c9c2fadbae4011ca5e7e83e12dc4a5072f1a1d85a0a7b3ed754d145a40", size = 10266691, upload-time = "2025-10-15T16:17:00.048Z" },
-    { url = "https://files.pythonhosted.org/packages/72/71/ae6170143c115732470ae3a2d01512870dd16e0953f8a6dc89525696069b/numpy-2.3.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:81c3e6d8c97295a7360d367f9f8553973651b76907988bb6066376bc2252f24e", size = 20955580, upload-time = "2025-10-15T16:17:02.509Z" },
-    { url = "https://files.pythonhosted.org/packages/af/39/4be9222ffd6ca8a30eda033d5f753276a9c3426c397bb137d8e19dedd200/numpy-2.3.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7c26b0b2bf58009ed1f38a641f3db4be8d960a417ca96d14e5b06df1506d41ff", size = 14188056, upload-time = "2025-10-15T16:17:04.873Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/3d/d85f6700d0a4aa4f9491030e1021c2b2b7421b2b38d01acd16734a2bfdc7/numpy-2.3.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:62b2198c438058a20b6704351b35a1d7db881812d8512d67a69c9de1f18ca05f", size = 5116555, upload-time = "2025-10-15T16:17:07.499Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/04/82c1467d86f47eee8a19a464c92f90a9bb68ccf14a54c5224d7031241ffb/numpy-2.3.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:9d729d60f8d53a7361707f4b68a9663c968882dd4f09e0d58c044c8bf5faee7b", size = 6643581, upload-time = "2025-10-15T16:17:09.774Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/d3/c79841741b837e293f48bd7db89d0ac7a4f2503b382b78a790ef1dc778a5/numpy-2.3.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd0c630cf256b0a7fd9d0a11c9413b42fef5101219ce6ed5a09624f5a65392c7", size = 14299186, upload-time = "2025-10-15T16:17:11.937Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/7e/4a14a769741fbf237eec5a12a2cbc7a4c4e061852b6533bcb9e9a796c908/numpy-2.3.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5e081bc082825f8b139f9e9fe42942cb4054524598aaeb177ff476cc76d09d2", size = 16638601, upload-time = "2025-10-15T16:17:14.391Z" },
-    { url = "https://files.pythonhosted.org/packages/93/87/1c1de269f002ff0a41173fe01dcc925f4ecff59264cd8f96cf3b60d12c9b/numpy-2.3.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:15fb27364ed84114438fff8aaf998c9e19adbeba08c0b75409f8c452a8692c52", size = 16074219, upload-time = "2025-10-15T16:17:17.058Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/28/18f72ee77408e40a76d691001ae599e712ca2a47ddd2c4f695b16c65f077/numpy-2.3.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:85d9fb2d8cd998c84d13a79a09cc0c1091648e848e4e6249b0ccd7f6b487fa26", size = 18576702, upload-time = "2025-10-15T16:17:19.379Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/76/95650169b465ececa8cf4b2e8f6df255d4bf662775e797ade2025cc51ae6/numpy-2.3.4-cp314-cp314-win32.whl", hash = "sha256:e73d63fd04e3a9d6bc187f5455d81abfad05660b212c8804bf3b407e984cd2bc", size = 6337136, upload-time = "2025-10-15T16:17:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/89/a231a5c43ede5d6f77ba4a91e915a87dea4aeea76560ba4d2bf185c683f0/numpy-2.3.4-cp314-cp314-win_amd64.whl", hash = "sha256:3da3491cee49cf16157e70f607c03a217ea6647b1cea4819c4f48e53d49139b9", size = 12920542, upload-time = "2025-10-15T16:17:24.783Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/0c/ae9434a888f717c5ed2ff2393b3f344f0ff6f1c793519fa0c540461dc530/numpy-2.3.4-cp314-cp314-win_arm64.whl", hash = "sha256:6d9cd732068e8288dbe2717177320723ccec4fb064123f0caf9bbd90ab5be868", size = 10480213, upload-time = "2025-10-15T16:17:26.935Z" },
-    { url = "https://files.pythonhosted.org/packages/83/4b/c4a5f0841f92536f6b9592694a5b5f68c9ab37b775ff342649eadf9055d3/numpy-2.3.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:22758999b256b595cf0b1d102b133bb61866ba5ceecf15f759623b64c020c9ec", size = 21052280, upload-time = "2025-10-15T16:17:29.638Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/80/90308845fc93b984d2cc96d83e2324ce8ad1fd6efea81b324cba4b673854/numpy-2.3.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9cb177bc55b010b19798dc5497d540dea67fd13a8d9e882b2dae71de0cf09eb3", size = 14302930, upload-time = "2025-10-15T16:17:32.384Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/4e/07439f22f2a3b247cec4d63a713faae55e1141a36e77fb212881f7cda3fb/numpy-2.3.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0f2bcc76f1e05e5ab58893407c63d90b2029908fa41f9f1cc51eecce936c3365", size = 5231504, upload-time = "2025-10-15T16:17:34.515Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/de/1e11f2547e2fe3d00482b19721855348b94ada8359aef5d40dd57bfae9df/numpy-2.3.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8dc20bde86802df2ed8397a08d793da0ad7a5fd4ea3ac85d757bf5dd4ad7c252", size = 6739405, upload-time = "2025-10-15T16:17:36.128Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/40/8cd57393a26cebe2e923005db5134a946c62fa56a1087dc7c478f3e30837/numpy-2.3.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e199c087e2aa71c8f9ce1cb7a8e10677dc12457e7cc1be4798632da37c3e86e", size = 14354866, upload-time = "2025-10-15T16:17:38.884Z" },
-    { url = "https://files.pythonhosted.org/packages/93/39/5b3510f023f96874ee6fea2e40dfa99313a00bf3ab779f3c92978f34aace/numpy-2.3.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85597b2d25ddf655495e2363fe044b0ae999b75bc4d630dc0d886484b03a5eb0", size = 16703296, upload-time = "2025-10-15T16:17:41.564Z" },
-    { url = "https://files.pythonhosted.org/packages/41/0d/19bb163617c8045209c1996c4e427bccbc4bbff1e2c711f39203c8ddbb4a/numpy-2.3.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04a69abe45b49c5955923cf2c407843d1c85013b424ae8a560bba16c92fe44a0", size = 16136046, upload-time = "2025-10-15T16:17:43.901Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/c1/6dba12fdf68b02a21ac411c9df19afa66bed2540f467150ca64d246b463d/numpy-2.3.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e1708fac43ef8b419c975926ce1eaf793b0c13b7356cfab6ab0dc34c0a02ac0f", size = 18652691, upload-time = "2025-10-15T16:17:46.247Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/73/f85056701dbbbb910c51d846c58d29fd46b30eecd2b6ba760fc8b8a1641b/numpy-2.3.4-cp314-cp314t-win32.whl", hash = "sha256:863e3b5f4d9915aaf1b8ec79ae560ad21f0b8d5e3adc31e73126491bb86dee1d", size = 6485782, upload-time = "2025-10-15T16:17:48.872Z" },
-    { url = "https://files.pythonhosted.org/packages/17/90/28fa6f9865181cb817c2471ee65678afa8a7e2a1fb16141473d5fa6bacc3/numpy-2.3.4-cp314-cp314t-win_amd64.whl", hash = "sha256:962064de37b9aef801d33bc579690f8bfe6c5e70e29b61783f60bcba838a14d6", size = 13113301, upload-time = "2025-10-15T16:17:50.938Z" },
-    { url = "https://files.pythonhosted.org/packages/54/23/08c002201a8e7e1f9afba93b97deceb813252d9cfd0d3351caed123dcf97/numpy-2.3.4-cp314-cp314t-win_arm64.whl", hash = "sha256:8b5a9a39c45d852b62693d9b3f3e0fe052541f804296ff401a72a1b60edafb29", size = 10547532, upload-time = "2025-10-15T16:17:53.48Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/b6/64898f51a86ec88ca1257a59c1d7fd077b60082a119affefcdf1dd0df8ca/numpy-2.3.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6e274603039f924c0fe5cb73438fa9246699c78a6df1bd3decef9ae592ae1c05", size = 21131552, upload-time = "2025-10-15T16:17:55.845Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/4c/f135dc6ebe2b6a3c77f4e4838fa63d350f85c99462012306ada1bd4bc460/numpy-2.3.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d149aee5c72176d9ddbc6803aef9c0f6d2ceeea7626574fc68518da5476fa346", size = 14377796, upload-time = "2025-10-15T16:17:58.308Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/a4/f33f9c23fcc13dd8412fc8614559b5b797e0aba9d8e01dfa8bae10c84004/numpy-2.3.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:6d34ed9db9e6395bb6cd33286035f73a59b058169733a9db9f85e650b88df37e", size = 5306904, upload-time = "2025-10-15T16:18:00.596Z" },
-    { url = "https://files.pythonhosted.org/packages/28/af/c44097f25f834360f9fb960fa082863e0bad14a42f36527b2a121abdec56/numpy-2.3.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:fdebe771ca06bb8d6abce84e51dca9f7921fe6ad34a0c914541b063e9a68928b", size = 6819682, upload-time = "2025-10-15T16:18:02.32Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/8c/cd283b54c3c2b77e188f63e23039844f56b23bba1712318288c13fe86baf/numpy-2.3.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e92defe6c08211eb77902253b14fe5b480ebc5112bc741fd5e9cd0608f847", size = 14422300, upload-time = "2025-10-15T16:18:04.271Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/f0/8404db5098d92446b3e3695cf41c6f0ecb703d701cb0b7566ee2177f2eee/numpy-2.3.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13b9062e4f5c7ee5c7e5be96f29ba71bc5a37fed3d1d77c37390ae00724d296d", size = 16760806, upload-time = "2025-10-15T16:18:06.668Z" },
-    { url = "https://files.pythonhosted.org/packages/95/8e/2844c3959ce9a63acc7c8e50881133d86666f0420bcde695e115ced0920f/numpy-2.3.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:81b3a59793523e552c4a96109dde028aa4448ae06ccac5a76ff6532a85558a7f", size = 12973130, upload-time = "2025-10-15T16:18:09.397Z" },
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/fd/0005efbd0af48e55eb3c7208af93f2862d4b1a56cd78e84309a2d959208d/numpy-2.4.2.tar.gz", hash = "sha256:659a6107e31a83c4e33f763942275fd278b21d095094044eb35569e86a21ddae", size = 20723651, upload-time = "2026-01-31T23:13:10.135Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/44/71852273146957899753e69986246d6a176061ea183407e95418c2aa4d9a/numpy-2.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e7e88598032542bd49af7c4747541422884219056c268823ef6e5e89851c8825", size = 16955478, upload-time = "2026-01-31T23:10:25.623Z" },
+    { url = "https://files.pythonhosted.org/packages/74/41/5d17d4058bd0cd96bcbd4d9ff0fb2e21f52702aab9a72e4a594efa18692f/numpy-2.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7edc794af8b36ca37ef5fcb5e0d128c7e0595c7b96a2318d1badb6fcd8ee86b1", size = 14965467, upload-time = "2026-01-31T23:10:28.186Z" },
+    { url = "https://files.pythonhosted.org/packages/49/48/fb1ce8136c19452ed15f033f8aee91d5defe515094e330ce368a0647846f/numpy-2.4.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:6e9f61981ace1360e42737e2bae58b27bf28a1b27e781721047d84bd754d32e7", size = 5475172, upload-time = "2026-01-31T23:10:30.848Z" },
+    { url = "https://files.pythonhosted.org/packages/40/a9/3feb49f17bbd1300dd2570432961f5c8a4ffeff1db6f02c7273bd020a4c9/numpy-2.4.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cb7bbb88aa74908950d979eeaa24dbdf1a865e3c7e45ff0121d8f70387b55f73", size = 6805145, upload-time = "2026-01-31T23:10:32.352Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/39/fdf35cbd6d6e2fcad42fcf85ac04a85a0d0fbfbf34b30721c98d602fd70a/numpy-2.4.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f069069931240b3fc703f1e23df63443dbd6390614c8c44a87d96cd0ec81eb1", size = 15966084, upload-time = "2026-01-31T23:10:34.502Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/46/6fa4ea94f1ddf969b2ee941290cca6f1bfac92b53c76ae5f44afe17ceb69/numpy-2.4.2-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c02ef4401a506fb60b411467ad501e1429a3487abca4664871d9ae0b46c8ba32", size = 16899477, upload-time = "2026-01-31T23:10:37.075Z" },
+    { url = "https://files.pythonhosted.org/packages/09/a1/2a424e162b1a14a5bd860a464ab4e07513916a64ab1683fae262f735ccd2/numpy-2.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2653de5c24910e49c2b106499803124dde62a5a1fe0eedeaecf4309a5f639390", size = 17323429, upload-time = "2026-01-31T23:10:39.704Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/a2/73014149ff250628df72c58204822ac01d768697913881aacf839ff78680/numpy-2.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1ae241bbfc6ae276f94a170b14785e561cb5e7f626b6688cf076af4110887413", size = 18635109, upload-time = "2026-01-31T23:10:41.924Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/0c/73e8be2f1accd56df74abc1c5e18527822067dced5ec0861b5bb882c2ce0/numpy-2.4.2-cp311-cp311-win32.whl", hash = "sha256:df1b10187212b198dd45fa943d8985a3c8cf854aed4923796e0e019e113a1bda", size = 6237915, upload-time = "2026-01-31T23:10:45.26Z" },
+    { url = "https://files.pythonhosted.org/packages/76/ae/e0265e0163cf127c24c3969d29f1c4c64551a1e375d95a13d32eab25d364/numpy-2.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:b9c618d56a29c9cb1c4da979e9899be7578d2e0b3c24d52079c166324c9e8695", size = 12607972, upload-time = "2026-01-31T23:10:47.021Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a5/c43029af9b8014d6ea157f192652c50042e8911f4300f8f6ed3336bf437f/numpy-2.4.2-cp311-cp311-win_arm64.whl", hash = "sha256:47c5a6ed21d9452b10227e5e8a0e1c22979811cad7dcc19d8e3e2fb8fa03f1a3", size = 10485763, upload-time = "2026-01-31T23:10:50.087Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6e/6f394c9c77668153e14d4da83bcc247beb5952f6ead7699a1a2992613bea/numpy-2.4.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:21982668592194c609de53ba4933a7471880ccbaadcc52352694a59ecc860b3a", size = 16667963, upload-time = "2026-01-31T23:10:52.147Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f8/55483431f2b2fd015ae6ed4fe62288823ce908437ed49db5a03d15151678/numpy-2.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40397bda92382fcec844066efb11f13e1c9a3e2a8e8f318fb72ed8b6db9f60f1", size = 14693571, upload-time = "2026-01-31T23:10:54.789Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/20/18026832b1845cdc82248208dd929ca14c9d8f2bac391f67440707fff27c/numpy-2.4.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b3a24467af63c67829bfaa61eecf18d5432d4f11992688537be59ecd6ad32f5e", size = 5203469, upload-time = "2026-01-31T23:10:57.343Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/2eb97c8a77daaba34eaa3fa7241a14ac5f51c46a6bd5911361b644c4a1e2/numpy-2.4.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:805cc8de9fd6e7a22da5aed858e0ab16be5a4db6c873dde1d7451c541553aa27", size = 6550820, upload-time = "2026-01-31T23:10:59.429Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/91/b97fdfd12dc75b02c44e26c6638241cc004d4079a0321a69c62f51470c4c/numpy-2.4.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d82351358ffbcdcd7b686b90742a9b86632d6c1c051016484fa0b326a0a1548", size = 15663067, upload-time = "2026-01-31T23:11:01.291Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c6/a18e59f3f0b8071cc85cbc8d80cd02d68aa9710170b2553a117203d46936/numpy-2.4.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e35d3e0144137d9fdae62912e869136164534d64a169f86438bc9561b6ad49f", size = 16619782, upload-time = "2026-01-31T23:11:03.669Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/83/9751502164601a79e18847309f5ceec0b1446d7b6aa12305759b72cf98b2/numpy-2.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adb6ed2ad29b9e15321d167d152ee909ec73395901b70936f029c3bc6d7f4460", size = 17013128, upload-time = "2026-01-31T23:11:05.913Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c4/c4066322256ec740acc1c8923a10047818691d2f8aec254798f3dd90f5f2/numpy-2.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8906e71fd8afcb76580404e2a950caef2685df3d2a57fe82a86ac8d33cc007ba", size = 18345324, upload-time = "2026-01-31T23:11:08.248Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/af/6157aa6da728fa4525a755bfad486ae7e3f76d4c1864138003eb84328497/numpy-2.4.2-cp312-cp312-win32.whl", hash = "sha256:ec055f6dae239a6299cace477b479cca2fc125c5675482daf1dd886933a1076f", size = 5960282, upload-time = "2026-01-31T23:11:10.497Z" },
+    { url = "https://files.pythonhosted.org/packages/92/0f/7ceaaeaacb40567071e94dbf2c9480c0ae453d5bb4f52bea3892c39dc83c/numpy-2.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:209fae046e62d0ce6435fcfe3b1a10537e858249b3d9b05829e2a05218296a85", size = 12314210, upload-time = "2026-01-31T23:11:12.176Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/a3/56c5c604fae6dd40fa2ed3040d005fca97e91bd320d232ac9931d77ba13c/numpy-2.4.2-cp312-cp312-win_arm64.whl", hash = "sha256:fbde1b0c6e81d56f5dccd95dd4a711d9b95df1ae4009a60887e56b27e8d903fa", size = 10220171, upload-time = "2026-01-31T23:11:14.684Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/22/815b9fe25d1d7ae7d492152adbc7226d3eff731dffc38fe970589fcaaa38/numpy-2.4.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25f2059807faea4b077a2b6837391b5d830864b3543627f381821c646f31a63c", size = 16663696, upload-time = "2026-01-31T23:11:17.516Z" },
+    { url = "https://files.pythonhosted.org/packages/09/f0/817d03a03f93ba9c6c8993de509277d84e69f9453601915e4a69554102a1/numpy-2.4.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bd3a7a9f5847d2fb8c2c6d1c862fa109c31a9abeca1a3c2bd5a64572955b2979", size = 14688322, upload-time = "2026-01-31T23:11:19.883Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b4/f805ab79293c728b9a99438775ce51885fd4f31b76178767cfc718701a39/numpy-2.4.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8e4549f8a3c6d13d55041925e912bfd834285ef1dd64d6bc7d542583355e2e98", size = 5198157, upload-time = "2026-01-31T23:11:22.375Z" },
+    { url = "https://files.pythonhosted.org/packages/74/09/826e4289844eccdcd64aac27d13b0fd3f32039915dd5b9ba01baae1f436c/numpy-2.4.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:aea4f66ff44dfddf8c2cffd66ba6538c5ec67d389285292fe428cb2c738c8aef", size = 6546330, upload-time = "2026-01-31T23:11:23.958Z" },
+    { url = "https://files.pythonhosted.org/packages/19/fb/cbfdbfa3057a10aea5422c558ac57538e6acc87ec1669e666d32ac198da7/numpy-2.4.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3cd545784805de05aafe1dde61752ea49a359ccba9760c1e5d1c88a93bbf2b7", size = 15660968, upload-time = "2026-01-31T23:11:25.713Z" },
+    { url = "https://files.pythonhosted.org/packages/04/dc/46066ce18d01645541f0186877377b9371b8fa8017fa8262002b4ef22612/numpy-2.4.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0d9b7c93578baafcbc5f0b83eaf17b79d345c6f36917ba0c67f45226911d499", size = 16607311, upload-time = "2026-01-31T23:11:28.117Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d9/4b5adfc39a43fa6bf918c6d544bc60c05236cc2f6339847fc5b35e6cb5b0/numpy-2.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f74f0f7779cc7ae07d1810aab8ac6b1464c3eafb9e283a40da7309d5e6e48fbb", size = 17012850, upload-time = "2026-01-31T23:11:30.888Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/20/adb6e6adde6d0130046e6fdfb7675cc62bc2f6b7b02239a09eb58435753d/numpy-2.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c7ac672d699bf36275c035e16b65539931347d68b70667d28984c9fb34e07fa7", size = 18334210, upload-time = "2026-01-31T23:11:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/78/0e/0a73b3dff26803a8c02baa76398015ea2a5434d9b8265a7898a6028c1591/numpy-2.4.2-cp313-cp313-win32.whl", hash = "sha256:8e9afaeb0beff068b4d9cd20d322ba0ee1cecfb0b08db145e4ab4dd44a6b5110", size = 5958199, upload-time = "2026-01-31T23:11:35.385Z" },
+    { url = "https://files.pythonhosted.org/packages/43/bc/6352f343522fcb2c04dbaf94cb30cca6fd32c1a750c06ad6231b4293708c/numpy-2.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:7df2de1e4fba69a51c06c28f5a3de36731eb9639feb8e1cf7e4a7b0daf4cf622", size = 12310848, upload-time = "2026-01-31T23:11:38.001Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/8d/6da186483e308da5da1cc6918ce913dcfe14ffde98e710bfeff2a6158d4e/numpy-2.4.2-cp313-cp313-win_arm64.whl", hash = "sha256:0fece1d1f0a89c16b03442eae5c56dc0be0c7883b5d388e0c03f53019a4bfd71", size = 10221082, upload-time = "2026-01-31T23:11:40.392Z" },
+    { url = "https://files.pythonhosted.org/packages/25/a1/9510aa43555b44781968935c7548a8926274f815de42ad3997e9e83680dd/numpy-2.4.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5633c0da313330fd20c484c78cdd3f9b175b55e1a766c4a174230c6b70ad8262", size = 14815866, upload-time = "2026-01-31T23:11:42.495Z" },
+    { url = "https://files.pythonhosted.org/packages/36/30/6bbb5e76631a5ae46e7923dd16ca9d3f1c93cfa8d4ed79a129814a9d8db3/numpy-2.4.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d9f64d786b3b1dd742c946c42d15b07497ed14af1a1f3ce840cce27daa0ce913", size = 5325631, upload-time = "2026-01-31T23:11:44.7Z" },
+    { url = "https://files.pythonhosted.org/packages/46/00/3a490938800c1923b567b3a15cd17896e68052e2145d8662aaf3e1ffc58f/numpy-2.4.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:b21041e8cb6a1eb5312dd1d2f80a94d91efffb7a06b70597d44f1bd2dfc315ab", size = 6646254, upload-time = "2026-01-31T23:11:46.341Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/e9/fac0890149898a9b609caa5af7455a948b544746e4b8fe7c212c8edd71f8/numpy-2.4.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:00ab83c56211a1d7c07c25e3217ea6695e50a3e2f255053686b081dc0b091a82", size = 15720138, upload-time = "2026-01-31T23:11:48.082Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/5c/08887c54e68e1e28df53709f1893ce92932cc6f01f7c3d4dc952f61ffd4e/numpy-2.4.2-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fb882da679409066b4603579619341c6d6898fc83a8995199d5249f986e8e8f", size = 16655398, upload-time = "2026-01-31T23:11:50.293Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/89/253db0fa0e66e9129c745e4ef25631dc37d5f1314dad2b53e907b8538e6d/numpy-2.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:66cb9422236317f9d44b67b4d18f44efe6e9c7f8794ac0462978513359461554", size = 17079064, upload-time = "2026-01-31T23:11:52.927Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d5/cbade46ce97c59c6c3da525e8d95b7abe8a42974a1dc5c1d489c10433e88/numpy-2.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0f01dcf33e73d80bd8dc0f20a71303abbafa26a19e23f6b68d1aa9990af90257", size = 18379680, upload-time = "2026-01-31T23:11:55.22Z" },
+    { url = "https://files.pythonhosted.org/packages/40/62/48f99ae172a4b63d981babe683685030e8a3df4f246c893ea5c6ef99f018/numpy-2.4.2-cp313-cp313t-win32.whl", hash = "sha256:52b913ec40ff7ae845687b0b34d8d93b60cb66dcee06996dd5c99f2fc9328657", size = 6082433, upload-time = "2026-01-31T23:11:58.096Z" },
+    { url = "https://files.pythonhosted.org/packages/07/38/e054a61cfe48ad9f1ed0d188e78b7e26859d0b60ef21cd9de4897cdb5326/numpy-2.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:5eea80d908b2c1f91486eb95b3fb6fab187e569ec9752ab7d9333d2e66bf2d6b", size = 12451181, upload-time = "2026-01-31T23:11:59.782Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a4/a05c3a6418575e185dd84d0b9680b6bb2e2dc3e4202f036b7b4e22d6e9dc/numpy-2.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:fd49860271d52127d61197bb50b64f58454e9f578cb4b2c001a6de8b1f50b0b1", size = 10290756, upload-time = "2026-01-31T23:12:02.438Z" },
+    { url = "https://files.pythonhosted.org/packages/18/88/b7df6050bf18fdcfb7046286c6535cabbdd2064a3440fca3f069d319c16e/numpy-2.4.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:444be170853f1f9d528428eceb55f12918e4fda5d8805480f36a002f1415e09b", size = 16663092, upload-time = "2026-01-31T23:12:04.521Z" },
+    { url = "https://files.pythonhosted.org/packages/25/7a/1fee4329abc705a469a4afe6e69b1ef7e915117747886327104a8493a955/numpy-2.4.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d1240d50adff70c2a88217698ca844723068533f3f5c5fa6ee2e3220e3bdb000", size = 14698770, upload-time = "2026-01-31T23:12:06.96Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/0b/f9e49ba6c923678ad5bc38181c08ac5e53b7a5754dbca8e581aa1a56b1ff/numpy-2.4.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:7cdde6de52fb6664b00b056341265441192d1291c130e99183ec0d4b110ff8b1", size = 5208562, upload-time = "2026-01-31T23:12:09.632Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/12/d7de8f6f53f9bb76997e5e4c069eda2051e3fe134e9181671c4391677bb2/numpy-2.4.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:cda077c2e5b780200b6b3e09d0b42205a3d1c68f30c6dceb90401c13bff8fe74", size = 6543710, upload-time = "2026-01-31T23:12:11.969Z" },
+    { url = "https://files.pythonhosted.org/packages/09/63/c66418c2e0268a31a4cf8a8b512685748200f8e8e8ec6c507ce14e773529/numpy-2.4.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d30291931c915b2ab5717c2974bb95ee891a1cf22ebc16a8006bd59cd210d40a", size = 15677205, upload-time = "2026-01-31T23:12:14.33Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6c/7f237821c9642fb2a04d2f1e88b4295677144ca93285fd76eff3bcba858d/numpy-2.4.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bba37bc29d4d85761deed3954a1bc62be7cf462b9510b51d367b769a8c8df325", size = 16611738, upload-time = "2026-01-31T23:12:16.525Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/a7/39c4cdda9f019b609b5c473899d87abff092fc908cfe4d1ecb2fcff453b0/numpy-2.4.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b2f0073ed0868db1dcd86e052d37279eef185b9c8db5bf61f30f46adac63c909", size = 17028888, upload-time = "2026-01-31T23:12:19.306Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b3/e84bb64bdfea967cc10950d71090ec2d84b49bc691df0025dddb7c26e8e3/numpy-2.4.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7f54844851cdb630ceb623dcec4db3240d1ac13d4990532446761baede94996a", size = 18339556, upload-time = "2026-01-31T23:12:21.816Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f5/954a291bc1192a27081706862ac62bb5920fbecfbaa302f64682aa90beed/numpy-2.4.2-cp314-cp314-win32.whl", hash = "sha256:12e26134a0331d8dbd9351620f037ec470b7c75929cb8a1537f6bfe411152a1a", size = 6006899, upload-time = "2026-01-31T23:12:24.14Z" },
+    { url = "https://files.pythonhosted.org/packages/05/cb/eff72a91b2efdd1bc98b3b8759f6a1654aa87612fc86e3d87d6fe4f948c4/numpy-2.4.2-cp314-cp314-win_amd64.whl", hash = "sha256:068cdb2d0d644cdb45670810894f6a0600797a69c05f1ac478e8d31670b8ee75", size = 12443072, upload-time = "2026-01-31T23:12:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/37/75/62726948db36a56428fce4ba80a115716dc4fad6a3a4352487f8bb950966/numpy-2.4.2-cp314-cp314-win_arm64.whl", hash = "sha256:6ed0be1ee58eef41231a5c943d7d1375f093142702d5723ca2eb07db9b934b05", size = 10494886, upload-time = "2026-01-31T23:12:28.488Z" },
+    { url = "https://files.pythonhosted.org/packages/36/2f/ee93744f1e0661dc267e4b21940870cabfae187c092e1433b77b09b50ac4/numpy-2.4.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:98f16a80e917003a12c0580f97b5f875853ebc33e2eaa4bccfc8201ac6869308", size = 14818567, upload-time = "2026-01-31T23:12:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/24/6535212add7d76ff938d8bdc654f53f88d35cddedf807a599e180dcb8e66/numpy-2.4.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:20abd069b9cda45874498b245c8015b18ace6de8546bf50dfa8cea1696ed06ef", size = 5328372, upload-time = "2026-01-31T23:12:32.962Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/9d/c48f0a035725f925634bf6b8994253b43f2047f6778a54147d7e213bc5a7/numpy-2.4.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:e98c97502435b53741540a5717a6749ac2ada901056c7db951d33e11c885cc7d", size = 6649306, upload-time = "2026-01-31T23:12:34.797Z" },
+    { url = "https://files.pythonhosted.org/packages/81/05/7c73a9574cd4a53a25907bad38b59ac83919c0ddc8234ec157f344d57d9a/numpy-2.4.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da6cad4e82cb893db4b69105c604d805e0c3ce11501a55b5e9f9083b47d2ffe8", size = 15722394, upload-time = "2026-01-31T23:12:36.565Z" },
+    { url = "https://files.pythonhosted.org/packages/35/fa/4de10089f21fc7d18442c4a767ab156b25c2a6eaf187c0db6d9ecdaeb43f/numpy-2.4.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e4424677ce4b47fe73c8b5556d876571f7c6945d264201180db2dc34f676ab5", size = 16653343, upload-time = "2026-01-31T23:12:39.188Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/f9/d33e4ffc857f3763a57aa85650f2e82486832d7492280ac21ba9efda80da/numpy-2.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2b8f157c8a6f20eb657e240f8985cc135598b2b46985c5bccbde7616dc9c6b1e", size = 17078045, upload-time = "2026-01-31T23:12:42.041Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b8/54bdb43b6225badbea6389fa038c4ef868c44f5890f95dd530a218706da3/numpy-2.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5daf6f3914a733336dab21a05cdec343144600e964d2fcdabaac0c0269874b2a", size = 18380024, upload-time = "2026-01-31T23:12:44.331Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/55/6e1a61ded7af8df04016d81b5b02daa59f2ea9252ee0397cb9f631efe9e5/numpy-2.4.2-cp314-cp314t-win32.whl", hash = "sha256:8c50dd1fc8826f5b26a5ee4d77ca55d88a895f4e4819c7ecc2a9f5905047a443", size = 6153937, upload-time = "2026-01-31T23:12:47.229Z" },
+    { url = "https://files.pythonhosted.org/packages/45/aa/fa6118d1ed6d776b0983f3ceac9b1a5558e80df9365b1c3aa6d42bf9eee4/numpy-2.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:fcf92bee92742edd401ba41135185866f7026c502617f422eb432cfeca4fe236", size = 12631844, upload-time = "2026-01-31T23:12:48.997Z" },
+    { url = "https://files.pythonhosted.org/packages/32/0a/2ec5deea6dcd158f254a7b372fb09cfba5719419c8d66343bab35237b3fb/numpy-2.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:1f92f53998a17265194018d1cc321b2e96e900ca52d54c7c77837b71b9465181", size = 10565379, upload-time = "2026-01-31T23:12:51.345Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f8/50e14d36d915ef64d8f8bc4a087fc8264d82c785eda6711f80ab7e620335/numpy-2.4.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:89f7268c009bc492f506abd6f5265defa7cb3f7487dc21d357c3d290add45082", size = 16833179, upload-time = "2026-01-31T23:12:53.5Z" },
+    { url = "https://files.pythonhosted.org/packages/17/17/809b5cad63812058a8189e91a1e2d55a5a18fd04611dbad244e8aeae465c/numpy-2.4.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:e6dee3bb76aa4009d5a912180bf5b2de012532998d094acee25d9cb8dee3e44a", size = 14889755, upload-time = "2026-01-31T23:12:55.933Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ea/181b9bcf7627fc8371720316c24db888dcb9829b1c0270abf3d288b2e29b/numpy-2.4.2-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:cd2bd2bbed13e213d6b55dc1d035a4f91748a7d3edc9480c13898b0353708920", size = 5399500, upload-time = "2026-01-31T23:12:58.671Z" },
+    { url = "https://files.pythonhosted.org/packages/33/9f/413adf3fc955541ff5536b78fcf0754680b3c6d95103230252a2c9408d23/numpy-2.4.2-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:cf28c0c1d4c4bf00f509fa7eb02c58d7caf221b50b467bcb0d9bbf1584d5c821", size = 6714252, upload-time = "2026-01-31T23:13:00.518Z" },
+    { url = "https://files.pythonhosted.org/packages/91/da/643aad274e29ccbdf42ecd94dafe524b81c87bcb56b83872d54827f10543/numpy-2.4.2-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e04ae107ac591763a47398bb45b568fc38f02dbc4aa44c063f67a131f99346cb", size = 15797142, upload-time = "2026-01-31T23:13:02.219Z" },
+    { url = "https://files.pythonhosted.org/packages/66/27/965b8525e9cb5dc16481b30a1b3c21e50c7ebf6e9dbd48d0c4d0d5089c7e/numpy-2.4.2-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:602f65afdef699cda27ec0b9224ae5dc43e328f4c24c689deaf77133dbee74d0", size = 16727979, upload-time = "2026-01-31T23:13:04.62Z" },
+    { url = "https://files.pythonhosted.org/packages/de/e5/b7d20451657664b07986c2f6e3be564433f5dcaf3482d68eaecd79afaf03/numpy-2.4.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:be71bf1edb48ebbbf7f6337b5bfd2f895d1902f6335a5830b20141fc126ffba0", size = 12502577, upload-time = "2026-01-31T23:13:07.08Z" },
+]
+
+[[package]]
+name = "overrides"
+version = "7.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/36/86/b585f53236dec60aba864e050778b25045f857e17f6e5ea0ae95fe80edd2/overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a", size = 22812, upload-time = "2024-01-27T21:01:33.423Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/ab/fc8290c6a4c722e5514d80f62b2dc4c4df1a68a41d1364e625c35990fcf3/overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49", size = 17832, upload-time = "2024-01-27T21:01:31.393Z" },
 ]
 
 [[package]]
 name = "packaging"
-version = "25.0"
+version = "26.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "2.3.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "python-dateutil", marker = "python_full_version < '3.11'" },
+    { name = "pytz", marker = "python_full_version < '3.11'" },
+    { name = "tzdata", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload-time = "2025-09-29T23:16:53.287Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload-time = "2025-09-29T23:17:04.522Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload-time = "2025-09-29T23:17:18.444Z" },
+    { url = "https://files.pythonhosted.org/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload-time = "2025-09-29T23:17:35.846Z" },
+    { url = "https://files.pythonhosted.org/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload-time = "2025-09-29T23:17:49.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload-time = "2025-09-29T23:18:03.722Z" },
+    { url = "https://files.pythonhosted.org/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload-time = "2025-09-29T23:18:18.505Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" },
+    { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" },
+    { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" },
+    { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" },
+    { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" },
+    { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" },
+    { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" },
+    { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" },
+    { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" },
+    { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" },
+    { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" },
+    { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" },
+    { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" },
+    { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" },
+    { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" },
+    { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" },
+    { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "python-dateutil", marker = "python_full_version >= '3.11'" },
+    { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/da/b1dc0481ab8d55d0f46e343cfe67d4551a0e14fcee52bd38ca1bd73258d8/pandas-3.0.0.tar.gz", hash = "sha256:0facf7e87d38f721f0af46fe70d97373a37701b1c09f7ed7aeeb292ade5c050f", size = 4633005, upload-time = "2026-01-21T15:52:04.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/1e/b184654a856e75e975a6ee95d6577b51c271cd92cb2b020c9378f53e0032/pandas-3.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d64ce01eb9cdca96a15266aa679ae50212ec52757c79204dbc7701a222401850", size = 10313247, upload-time = "2026-01-21T15:50:15.775Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/5e/e04a547ad0f0183bf151fd7c7a477468e3b85ff2ad231c566389e6cc9587/pandas-3.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:613e13426069793aa1ec53bdcc3b86e8d32071daea138bbcf4fa959c9cdaa2e2", size = 9913131, upload-time = "2026-01-21T15:50:18.611Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/93/bb77bfa9fc2aba9f7204db807d5d3fb69832ed2854c60ba91b4c65ba9219/pandas-3.0.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0192fee1f1a8e743b464a6607858ee4b071deb0b118eb143d71c2a1d170996d5", size = 10741925, upload-time = "2026-01-21T15:50:21.058Z" },
+    { url = "https://files.pythonhosted.org/packages/62/fb/89319812eb1d714bfc04b7f177895caeba8ab4a37ef6712db75ed786e2e0/pandas-3.0.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0b853319dec8d5e0c8b875374c078ef17f2269986a78168d9bd57e49bf650ae", size = 11245979, upload-time = "2026-01-21T15:50:23.413Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/63/684120486f541fc88da3862ed31165b3b3e12b6a1c7b93be4597bc84e26c/pandas-3.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:707a9a877a876c326ae2cb640fbdc4ef63b0a7b9e2ef55c6df9942dcee8e2af9", size = 11756337, upload-time = "2026-01-21T15:50:25.932Z" },
+    { url = "https://files.pythonhosted.org/packages/39/92/7eb0ad232312b59aec61550c3c81ad0743898d10af5df7f80bc5e5065416/pandas-3.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:afd0aa3d0b5cda6e0b8ffc10dbcca3b09ef3cbcd3fe2b27364f85fdc04e1989d", size = 12325517, upload-time = "2026-01-21T15:50:27.952Z" },
+    { url = "https://files.pythonhosted.org/packages/51/27/bf9436dd0a4fc3130acec0828951c7ef96a0631969613a9a35744baf27f6/pandas-3.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:113b4cca2614ff7e5b9fee9b6f066618fe73c5a83e99d721ffc41217b2bf57dd", size = 9881576, upload-time = "2026-01-21T15:50:30.149Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2b/c618b871fce0159fd107516336e82891b404e3f340821853c2fc28c7830f/pandas-3.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c14837eba8e99a8da1527c0280bba29b0eb842f64aa94982c5e21227966e164b", size = 9140807, upload-time = "2026-01-21T15:50:32.308Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/38/db33686f4b5fa64d7af40d96361f6a4615b8c6c8f1b3d334eee46ae6160e/pandas-3.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9803b31f5039b3c3b10cc858c5e40054adb4b29b4d81cb2fd789f4121c8efbcd", size = 10334013, upload-time = "2026-01-21T15:50:34.771Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/7b/9254310594e9774906bacdd4e732415e1f86ab7dbb4b377ef9ede58cd8ec/pandas-3.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:14c2a4099cd38a1d18ff108168ea417909b2dea3bd1ebff2ccf28ddb6a74d740", size = 9874154, upload-time = "2026-01-21T15:50:36.67Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d4/726c5a67a13bc66643e66d2e9ff115cead482a44fc56991d0c4014f15aaf/pandas-3.0.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d257699b9a9960e6125686098d5714ac59d05222bef7a5e6af7a7fd87c650801", size = 10384433, upload-time = "2026-01-21T15:50:39.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/2e/9211f09bedb04f9832122942de8b051804b31a39cfbad199a819bb88d9f3/pandas-3.0.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:69780c98f286076dcafca38d8b8eee1676adf220199c0a39f0ecbf976b68151a", size = 10864519, upload-time = "2026-01-21T15:50:41.043Z" },
+    { url = "https://files.pythonhosted.org/packages/00/8d/50858522cdc46ac88b9afdc3015e298959a70a08cd21e008a44e9520180c/pandas-3.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4a66384f017240f3858a4c8a7cf21b0591c3ac885cddb7758a589f0f71e87ebb", size = 11394124, upload-time = "2026-01-21T15:50:43.377Z" },
+    { url = "https://files.pythonhosted.org/packages/86/3f/83b2577db02503cd93d8e95b0f794ad9d4be0ba7cb6c8bcdcac964a34a42/pandas-3.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be8c515c9bc33989d97b89db66ea0cececb0f6e3c2a87fcc8b69443a6923e95f", size = 11920444, upload-time = "2026-01-21T15:50:45.932Z" },
+    { url = "https://files.pythonhosted.org/packages/64/2d/4f8a2f192ed12c90a0aab47f5557ece0e56b0370c49de9454a09de7381b2/pandas-3.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:a453aad8c4f4e9f166436994a33884442ea62aa8b27d007311e87521b97246e1", size = 9730970, upload-time = "2026-01-21T15:50:47.962Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/64/ff571be435cf1e643ca98d0945d76732c0b4e9c37191a89c8550b105eed1/pandas-3.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:da768007b5a33057f6d9053563d6b74dd6d029c337d93c6d0d22a763a5c2ecc0", size = 9041950, upload-time = "2026-01-21T15:50:50.422Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/fa/7f0ac4ca8877c57537aaff2a842f8760e630d8e824b730eb2e859ffe96ca/pandas-3.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b78d646249b9a2bc191040988c7bb524c92fa8534fb0898a0741d7e6f2ffafa6", size = 10307129, upload-time = "2026-01-21T15:50:52.877Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/11/28a221815dcea4c0c9414dfc845e34a84a6a7dabc6da3194498ed5ba4361/pandas-3.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bc9cba7b355cb4162442a88ce495e01cb605f17ac1e27d6596ac963504e0305f", size = 9850201, upload-time = "2026-01-21T15:50:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/da/53bbc8c5363b7e5bd10f9ae59ab250fc7a382ea6ba08e4d06d8694370354/pandas-3.0.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c9a1a149aed3b6c9bf246033ff91e1b02d529546c5d6fb6b74a28fea0cf4c70", size = 10354031, upload-time = "2026-01-21T15:50:57.463Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a3/51e02ebc2a14974170d51e2410dfdab58870ea9bcd37cda15bd553d24dc4/pandas-3.0.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95683af6175d884ee89471842acfca29172a85031fccdabc35e50c0984470a0e", size = 10861165, upload-time = "2026-01-21T15:50:59.32Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/fe/05a51e3cac11d161472b8297bd41723ea98013384dd6d76d115ce3482f9b/pandas-3.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1fbbb5a7288719e36b76b4f18d46ede46e7f916b6c8d9915b756b0a6c3f792b3", size = 11359359, upload-time = "2026-01-21T15:51:02.014Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/56/ba620583225f9b85a4d3e69c01df3e3870659cc525f67929b60e9f21dcd1/pandas-3.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8e8b9808590fa364416b49b2a35c1f4cf2785a6c156935879e57f826df22038e", size = 11912907, upload-time = "2026-01-21T15:51:05.175Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/8c/c6638d9f67e45e07656b3826405c5cc5f57f6fd07c8b2572ade328c86e22/pandas-3.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:98212a38a709feb90ae658cb6227ea3657c22ba8157d4b8f913cd4c950de5e7e", size = 9732138, upload-time = "2026-01-21T15:51:07.569Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bf/bd1335c3bf1770b6d8fed2799993b11c4971af93bb1b729b9ebbc02ca2ec/pandas-3.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:177d9df10b3f43b70307a149d7ec49a1229a653f907aa60a48f1877d0e6be3be", size = 9033568, upload-time = "2026-01-21T15:51:09.484Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/c6/f5e2171914d5e29b9171d495344097d54e3ffe41d2d85d8115baba4dc483/pandas-3.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2713810ad3806767b89ad3b7b69ba153e1c6ff6d9c20f9c2140379b2a98b6c98", size = 10741936, upload-time = "2026-01-21T15:51:11.693Z" },
+    { url = "https://files.pythonhosted.org/packages/51/88/9a0164f99510a1acb9f548691f022c756c2314aad0d8330a24616c14c462/pandas-3.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:15d59f885ee5011daf8335dff47dcb8a912a27b4ad7826dc6cbe809fd145d327", size = 10393884, upload-time = "2026-01-21T15:51:14.197Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/53/b34d78084d88d8ae2b848591229da8826d1e65aacf00b3abe34023467648/pandas-3.0.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24e6547fb64d2c92665dd2adbfa4e85fa4fd70a9c070e7cfb03b629a0bbab5eb", size = 10310740, upload-time = "2026-01-21T15:51:16.093Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/d3/bee792e7c3d6930b74468d990604325701412e55d7aaf47460a22311d1a5/pandas-3.0.0-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48ee04b90e2505c693d3f8e8f524dab8cb8aaf7ddcab52c92afa535e717c4812", size = 10700014, upload-time = "2026-01-21T15:51:18.818Z" },
+    { url = "https://files.pythonhosted.org/packages/55/db/2570bc40fb13aaed1cbc3fbd725c3a60ee162477982123c3adc8971e7ac1/pandas-3.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:66f72fb172959af42a459e27a8d8d2c7e311ff4c1f7db6deb3b643dbc382ae08", size = 11323737, upload-time = "2026-01-21T15:51:20.784Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/2e/297ac7f21c8181b62a4cccebad0a70caf679adf3ae5e83cb676194c8acc3/pandas-3.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4a4a400ca18230976724a5066f20878af785f36c6756e498e94c2a5e5d57779c", size = 11771558, upload-time = "2026-01-21T15:51:22.977Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/46/e1c6876d71c14332be70239acce9ad435975a80541086e5ffba2f249bcf6/pandas-3.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:940eebffe55528074341a5a36515f3e4c5e25e958ebbc764c9502cfc35ba3faa", size = 10473771, upload-time = "2026-01-21T15:51:25.285Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/db/0270ad9d13c344b7a36fa77f5f8344a46501abf413803e885d22864d10bf/pandas-3.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:597c08fb9fef0edf1e4fa2f9828dd27f3d78f9b8c9b4a748d435ffc55732310b", size = 10312075, upload-time = "2026-01-21T15:51:28.5Z" },
+    { url = "https://files.pythonhosted.org/packages/09/9f/c176f5e9717f7c91becfe0f55a52ae445d3f7326b4a2cf355978c51b7913/pandas-3.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:447b2d68ac5edcbf94655fe909113a6dba6ef09ad7f9f60c80477825b6c489fe", size = 9900213, upload-time = "2026-01-21T15:51:30.955Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/e7/63ad4cc10b257b143e0a5ebb04304ad806b4e1a61c5da25f55896d2ca0f4/pandas-3.0.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:debb95c77ff3ed3ba0d9aa20c3a2f19165cc7956362f9873fce1ba0a53819d70", size = 10428768, upload-time = "2026-01-21T15:51:33.018Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/0e/4e4c2d8210f20149fd2248ef3fff26623604922bd564d915f935a06dd63d/pandas-3.0.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fedabf175e7cd82b69b74c30adbaa616de301291a5231138d7242596fc296a8d", size = 10882954, upload-time = "2026-01-21T15:51:35.287Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/60/c9de8ac906ba1f4d2250f8a951abe5135b404227a55858a75ad26f84db47/pandas-3.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:412d1a89aab46889f3033a386912efcdfa0f1131c5705ff5b668dda88305e986", size = 11430293, upload-time = "2026-01-21T15:51:37.57Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/69/806e6637c70920e5787a6d6896fd707f8134c2c55cd761e7249a97b7dc5a/pandas-3.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e979d22316f9350c516479dd3a92252be2937a9531ed3a26ec324198a99cdd49", size = 11952452, upload-time = "2026-01-21T15:51:39.618Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/de/918621e46af55164c400ab0ef389c9d969ab85a43d59ad1207d4ddbe30a5/pandas-3.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:083b11415b9970b6e7888800c43c82e81a06cd6b06755d84804444f0007d6bb7", size = 9851081, upload-time = "2026-01-21T15:51:41.758Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/3562a18dd0bd8c73344bfa26ff90c53c72f827df119d6d6b1dacc84d13e3/pandas-3.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:5db1e62cb99e739fa78a28047e861b256d17f88463c76b8dafc7c1338086dca8", size = 9174610, upload-time = "2026-01-21T15:51:44.312Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/26/430d91257eaf366f1737d7a1c158677caaf6267f338ec74e3a1ec444111c/pandas-3.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:697b8f7d346c68274b1b93a170a70974cdc7d7354429894d5927c1effdcccd73", size = 10761999, upload-time = "2026-01-21T15:51:46.899Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/1a/954eb47736c2b7f7fe6a9d56b0cb6987773c00faa3c6451a43db4beb3254/pandas-3.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8cb3120f0d9467ed95e77f67a75e030b67545bcfa08964e349252d674171def2", size = 10410279, upload-time = "2026-01-21T15:51:48.89Z" },
+    { url = "https://files.pythonhosted.org/packages/20/fc/b96f3a5a28b250cd1b366eb0108df2501c0f38314a00847242abab71bb3a/pandas-3.0.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33fd3e6baa72899746b820c31e4b9688c8e1b7864d7aec2de7ab5035c285277a", size = 10330198, upload-time = "2026-01-21T15:51:51.015Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b3/d0e2952f103b4fbef1ef22d0c2e314e74fc9064b51cee30890b5e3286ee6/pandas-3.0.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8942e333dc67ceda1095227ad0febb05a3b36535e520154085db632c40ad084", size = 10728513, upload-time = "2026-01-21T15:51:53.387Z" },
+    { url = "https://files.pythonhosted.org/packages/76/81/832894f286df828993dc5fd61c63b231b0fb73377e99f6c6c369174cf97e/pandas-3.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:783ac35c4d0fe0effdb0d67161859078618b1b6587a1af15928137525217a721", size = 11345550, upload-time = "2026-01-21T15:51:55.329Z" },
+    { url = "https://files.pythonhosted.org/packages/34/a0/ed160a00fb4f37d806406bc0a79a8b62fe67f29d00950f8d16203ff3409b/pandas-3.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:125eb901e233f155b268bbef9abd9afb5819db74f0e677e89a61b246228c71ac", size = 11799386, upload-time = "2026-01-21T15:51:57.457Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c8/2ac00d7255252c5e3cf61b35ca92ca25704b0188f7454ca4aec08a33cece/pandas-3.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b86d113b6c109df3ce0ad5abbc259fe86a1bd4adfd4a31a89da42f84f65509bb", size = 10873041, upload-time = "2026-01-21T15:52:00.034Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3f/a80ac00acbc6b35166b42850e98a4f466e2c0d9c64054161ba9620f95680/pandas-3.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:1c39eab3ad38f2d7a249095f0a3d8f8c22cc0f847e98ccf5bbe732b272e2d9fa", size = 9441003, upload-time = "2026-01-21T15:52:02.281Z" },
+]
+
+[[package]]
+name = "pandocfilters"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" },
 ]
 
 [[package]]
 name = "parso"
-version = "0.8.5"
+version = "0.8.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621, upload-time = "2026-02-09T15:45:24.425Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" },
 ]
 
 [[package]]
@@ -1354,7 +2186,7 @@ name = "pexpect"
 version = "4.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "ptyprocess" },
+    { name = "ptyprocess", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
 wheels = [
@@ -1363,109 +2195,109 @@ wheels = [
 
 [[package]]
 name = "pillow"
-version = "12.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/cace85a1b0c9775a9f8f5d5423c8261c858760e2466c79b2dd184638b056/pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353", size = 47008828, upload-time = "2025-10-15T18:24:14.008Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/08/26e68b6b5da219c2a2cb7b563af008b53bb8e6b6fcb3fa40715fcdb2523a/pillow-12.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:3adfb466bbc544b926d50fe8f4a4e6abd8c6bffd28a26177594e6e9b2b76572b", size = 5289809, upload-time = "2025-10-15T18:21:27.791Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/e9/4e58fb097fb74c7b4758a680aacd558810a417d1edaa7000142976ef9d2f/pillow-12.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1ac11e8ea4f611c3c0147424eae514028b5e9077dd99ab91e1bd7bc33ff145e1", size = 4650606, upload-time = "2025-10-15T18:21:29.823Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/e0/1fa492aa9f77b3bc6d471c468e62bfea1823056bf7e5e4f1914d7ab2565e/pillow-12.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d49e2314c373f4c2b39446fb1a45ed333c850e09d0c59ac79b72eb3b95397363", size = 6221023, upload-time = "2025-10-15T18:21:31.415Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/09/4de7cd03e33734ccd0c876f0251401f1314e819cbfd89a0fcb6e77927cc6/pillow-12.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c7b2a63fd6d5246349f3d3f37b14430d73ee7e8173154461785e43036ffa96ca", size = 8024937, upload-time = "2025-10-15T18:21:33.453Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/69/0688e7c1390666592876d9d474f5e135abb4acb39dcb583c4dc5490f1aff/pillow-12.0.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d64317d2587c70324b79861babb9c09f71fbb780bad212018874b2c013d8600e", size = 6334139, upload-time = "2025-10-15T18:21:35.395Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/1c/880921e98f525b9b44ce747ad1ea8f73fd7e992bafe3ca5e5644bf433dea/pillow-12.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d77153e14b709fd8b8af6f66a3afbb9ed6e9fc5ccf0b6b7e1ced7b036a228782", size = 7026074, upload-time = "2025-10-15T18:21:37.219Z" },
-    { url = "https://files.pythonhosted.org/packages/28/03/96f718331b19b355610ef4ebdbbde3557c726513030665071fd025745671/pillow-12.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:32ed80ea8a90ee3e6fa08c21e2e091bba6eda8eccc83dbc34c95169507a91f10", size = 6448852, upload-time = "2025-10-15T18:21:39.168Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/a0/6a193b3f0cc9437b122978d2c5cbce59510ccf9a5b48825096ed7472da2f/pillow-12.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c828a1ae702fc712978bda0320ba1b9893d99be0badf2647f693cc01cf0f04fa", size = 7117058, upload-time = "2025-10-15T18:21:40.997Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/c4/043192375eaa4463254e8e61f0e2ec9a846b983929a8d0a7122e0a6d6fff/pillow-12.0.0-cp310-cp310-win32.whl", hash = "sha256:bd87e140e45399c818fac4247880b9ce719e4783d767e030a883a970be632275", size = 6295431, upload-time = "2025-10-15T18:21:42.518Z" },
-    { url = "https://files.pythonhosted.org/packages/92/c6/c2f2fc7e56301c21827e689bb8b0b465f1b52878b57471a070678c0c33cd/pillow-12.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:455247ac8a4cfb7b9bc45b7e432d10421aea9fc2e74d285ba4072688a74c2e9d", size = 7000412, upload-time = "2025-10-15T18:21:44.404Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/d2/5f675067ba82da7a1c238a73b32e3fd78d67f9d9f80fbadd33a40b9c0481/pillow-12.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:6ace95230bfb7cd79ef66caa064bbe2f2a1e63d93471c3a2e1f1348d9f22d6b7", size = 2435903, upload-time = "2025-10-15T18:21:46.29Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/5a/a2f6773b64edb921a756eb0729068acad9fc5208a53f4a349396e9436721/pillow-12.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0fd00cac9c03256c8b2ff58f162ebcd2587ad3e1f2e397eab718c47e24d231cc", size = 5289798, upload-time = "2025-10-15T18:21:47.763Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/05/069b1f8a2e4b5a37493da6c5868531c3f77b85e716ad7a590ef87d58730d/pillow-12.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3475b96f5908b3b16c47533daaa87380c491357d197564e0ba34ae75c0f3257", size = 4650589, upload-time = "2025-10-15T18:21:49.515Z" },
-    { url = "https://files.pythonhosted.org/packages/61/e3/2c820d6e9a36432503ead175ae294f96861b07600a7156154a086ba7111a/pillow-12.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:110486b79f2d112cf6add83b28b627e369219388f64ef2f960fef9ebaf54c642", size = 6230472, upload-time = "2025-10-15T18:21:51.052Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/89/63427f51c64209c5e23d4d52071c8d0f21024d3a8a487737caaf614a5795/pillow-12.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5269cc1caeedb67e6f7269a42014f381f45e2e7cd42d834ede3c703a1d915fe3", size = 8033887, upload-time = "2025-10-15T18:21:52.604Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/1b/c9711318d4901093c15840f268ad649459cd81984c9ec9887756cca049a5/pillow-12.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa5129de4e174daccbc59d0a3b6d20eaf24417d59851c07ebb37aeb02947987c", size = 6343964, upload-time = "2025-10-15T18:21:54.619Z" },
-    { url = "https://files.pythonhosted.org/packages/41/1e/db9470f2d030b4995083044cd8738cdd1bf773106819f6d8ba12597d5352/pillow-12.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bee2a6db3a7242ea309aa7ee8e2780726fed67ff4e5b40169f2c940e7eb09227", size = 7034756, upload-time = "2025-10-15T18:21:56.151Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/b0/6177a8bdd5ee4ed87cba2de5a3cc1db55ffbbec6176784ce5bb75aa96798/pillow-12.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:90387104ee8400a7b4598253b4c406f8958f59fcf983a6cea2b50d59f7d63d0b", size = 6458075, upload-time = "2025-10-15T18:21:57.759Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/5e/61537aa6fa977922c6a03253a0e727e6e4a72381a80d63ad8eec350684f2/pillow-12.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bc91a56697869546d1b8f0a3ff35224557ae7f881050e99f615e0119bf934b4e", size = 7125955, upload-time = "2025-10-15T18:21:59.372Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/3d/d5033539344ee3cbd9a4d69e12e63ca3a44a739eb2d4c8da350a3d38edd7/pillow-12.0.0-cp311-cp311-win32.whl", hash = "sha256:27f95b12453d165099c84f8a8bfdfd46b9e4bda9e0e4b65f0635430027f55739", size = 6298440, upload-time = "2025-10-15T18:22:00.982Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/42/aaca386de5cc8bd8a0254516957c1f265e3521c91515b16e286c662854c4/pillow-12.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b583dc9070312190192631373c6c8ed277254aa6e6084b74bdd0a6d3b221608e", size = 6999256, upload-time = "2025-10-15T18:22:02.617Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/f1/9197c9c2d5708b785f631a6dfbfa8eb3fb9672837cb92ae9af812c13b4ed/pillow-12.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:759de84a33be3b178a64c8ba28ad5c135900359e85fb662bc6e403ad4407791d", size = 2436025, upload-time = "2025-10-15T18:22:04.598Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/90/4fcce2c22caf044e660a198d740e7fbc14395619e3cb1abad12192c0826c/pillow-12.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53561a4ddc36facb432fae7a9d8afbfaf94795414f5cdc5fc52f28c1dca90371", size = 5249377, upload-time = "2025-10-15T18:22:05.993Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/e0/ed960067543d080691d47d6938ebccbf3976a931c9567ab2fbfab983a5dd/pillow-12.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71db6b4c1653045dacc1585c1b0d184004f0d7e694c7b34ac165ca70c0838082", size = 4650343, upload-time = "2025-10-15T18:22:07.718Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/a1/f81fdeddcb99c044bf7d6faa47e12850f13cee0849537a7d27eeab5534d4/pillow-12.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2fa5f0b6716fc88f11380b88b31fe591a06c6315e955c096c35715788b339e3f", size = 6232981, upload-time = "2025-10-15T18:22:09.287Z" },
-    { url = "https://files.pythonhosted.org/packages/88/e1/9098d3ce341a8750b55b0e00c03f1630d6178f38ac191c81c97a3b047b44/pillow-12.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82240051c6ca513c616f7f9da06e871f61bfd7805f566275841af15015b8f98d", size = 8041399, upload-time = "2025-10-15T18:22:10.872Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/62/a22e8d3b602ae8cc01446d0c57a54e982737f44b6f2e1e019a925143771d/pillow-12.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55f818bd74fe2f11d4d7cbc65880a843c4075e0ac7226bc1a23261dbea531953", size = 6347740, upload-time = "2025-10-15T18:22:12.769Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/87/424511bdcd02c8d7acf9f65caa09f291a519b16bd83c3fb3374b3d4ae951/pillow-12.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b87843e225e74576437fd5b6a4c2205d422754f84a06942cfaf1dc32243e45a8", size = 7040201, upload-time = "2025-10-15T18:22:14.813Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/4d/435c8ac688c54d11755aedfdd9f29c9eeddf68d150fe42d1d3dbd2365149/pillow-12.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c607c90ba67533e1b2355b821fef6764d1dd2cbe26b8c1005ae84f7aea25ff79", size = 6462334, upload-time = "2025-10-15T18:22:16.375Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/f2/ad34167a8059a59b8ad10bc5c72d4d9b35acc6b7c0877af8ac885b5f2044/pillow-12.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21f241bdd5080a15bc86d3466a9f6074a9c2c2b314100dd896ac81ee6db2f1ba", size = 7134162, upload-time = "2025-10-15T18:22:17.996Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/b1/a7391df6adacf0a5c2cf6ac1cf1fcc1369e7d439d28f637a847f8803beb3/pillow-12.0.0-cp312-cp312-win32.whl", hash = "sha256:dd333073e0cacdc3089525c7df7d39b211bcdf31fc2824e49d01c6b6187b07d0", size = 6298769, upload-time = "2025-10-15T18:22:19.923Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/0b/d87733741526541c909bbf159e338dcace4f982daac6e5a8d6be225ca32d/pillow-12.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe611163f6303d1619bbcb653540a4d60f9e55e622d60a3108be0d5b441017a", size = 7001107, upload-time = "2025-10-15T18:22:21.644Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/96/aaa61ce33cc98421fb6088af2a03be4157b1e7e0e87087c888e2370a7f45/pillow-12.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:7dfb439562f234f7d57b1ac6bc8fe7f838a4bd49c79230e0f6a1da93e82f1fad", size = 2436012, upload-time = "2025-10-15T18:22:23.621Z" },
-    { url = "https://files.pythonhosted.org/packages/62/f2/de993bb2d21b33a98d031ecf6a978e4b61da207bef02f7b43093774c480d/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643", size = 4045493, upload-time = "2025-10-15T18:22:25.758Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/b6/bc8d0c4c9f6f111a783d045310945deb769b806d7574764234ffd50bc5ea/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4", size = 4120461, upload-time = "2025-10-15T18:22:27.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/57/d60d343709366a353dc56adb4ee1e7d8a2cc34e3fbc22905f4167cfec119/pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399", size = 3576912, upload-time = "2025-10-15T18:22:28.751Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/a4/a0a31467e3f83b94d37568294b01d22b43ae3c5d85f2811769b9c66389dd/pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5", size = 5249132, upload-time = "2025-10-15T18:22:30.641Z" },
-    { url = "https://files.pythonhosted.org/packages/83/06/48eab21dd561de2914242711434c0c0eb992ed08ff3f6107a5f44527f5e9/pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b", size = 4650099, upload-time = "2025-10-15T18:22:32.73Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/bd/69ed99fd46a8dba7c1887156d3572fe4484e3f031405fcc5a92e31c04035/pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3", size = 6230808, upload-time = "2025-10-15T18:22:34.337Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/94/8fad659bcdbf86ed70099cb60ae40be6acca434bbc8c4c0d4ef356d7e0de/pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07", size = 8037804, upload-time = "2025-10-15T18:22:36.402Z" },
-    { url = "https://files.pythonhosted.org/packages/20/39/c685d05c06deecfd4e2d1950e9a908aa2ca8bc4e6c3b12d93b9cafbd7837/pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e", size = 6345553, upload-time = "2025-10-15T18:22:38.066Z" },
-    { url = "https://files.pythonhosted.org/packages/38/57/755dbd06530a27a5ed74f8cb0a7a44a21722ebf318edbe67ddbd7fb28f88/pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344", size = 7037729, upload-time = "2025-10-15T18:22:39.769Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/b6/7e94f4c41d238615674d06ed677c14883103dce1c52e4af16f000338cfd7/pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27", size = 6459789, upload-time = "2025-10-15T18:22:41.437Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/14/4448bb0b5e0f22dd865290536d20ec8a23b64e2d04280b89139f09a36bb6/pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79", size = 7130917, upload-time = "2025-10-15T18:22:43.152Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/ca/16c6926cc1c015845745d5c16c9358e24282f1e588237a4c36d2b30f182f/pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098", size = 6302391, upload-time = "2025-10-15T18:22:44.753Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/2a/dd43dcfd6dae9b6a49ee28a8eedb98c7d5ff2de94a5d834565164667b97b/pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905", size = 7007477, upload-time = "2025-10-15T18:22:46.838Z" },
-    { url = "https://files.pythonhosted.org/packages/77/f0/72ea067f4b5ae5ead653053212af05ce3705807906ba3f3e8f58ddf617e6/pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a", size = 2435918, upload-time = "2025-10-15T18:22:48.399Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/5e/9046b423735c21f0487ea6cb5b10f89ea8f8dfbe32576fe052b5ba9d4e5b/pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3", size = 5251406, upload-time = "2025-10-15T18:22:49.905Z" },
-    { url = "https://files.pythonhosted.org/packages/12/66/982ceebcdb13c97270ef7a56c3969635b4ee7cd45227fa707c94719229c5/pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced", size = 4653218, upload-time = "2025-10-15T18:22:51.587Z" },
-    { url = "https://files.pythonhosted.org/packages/16/b3/81e625524688c31859450119bf12674619429cab3119eec0e30a7a1029cb/pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b", size = 6266564, upload-time = "2025-10-15T18:22:53.215Z" },
-    { url = "https://files.pythonhosted.org/packages/98/59/dfb38f2a41240d2408096e1a76c671d0a105a4a8471b1871c6902719450c/pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d", size = 8069260, upload-time = "2025-10-15T18:22:54.933Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/3d/378dbea5cd1874b94c312425ca77b0f47776c78e0df2df751b820c8c1d6c/pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a", size = 6379248, upload-time = "2025-10-15T18:22:56.605Z" },
-    { url = "https://files.pythonhosted.org/packages/84/b0/d525ef47d71590f1621510327acec75ae58c721dc071b17d8d652ca494d8/pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe", size = 7066043, upload-time = "2025-10-15T18:22:58.53Z" },
-    { url = "https://files.pythonhosted.org/packages/61/2c/aced60e9cf9d0cde341d54bf7932c9ffc33ddb4a1595798b3a5150c7ec4e/pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee", size = 6490915, upload-time = "2025-10-15T18:23:00.582Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/26/69dcb9b91f4e59f8f34b2332a4a0a951b44f547c4ed39d3e4dcfcff48f89/pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef", size = 7157998, upload-time = "2025-10-15T18:23:02.627Z" },
-    { url = "https://files.pythonhosted.org/packages/61/2b/726235842220ca95fa441ddf55dd2382b52ab5b8d9c0596fe6b3f23dafe8/pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9", size = 6306201, upload-time = "2025-10-15T18:23:04.709Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/3d/2afaf4e840b2df71344ababf2f8edd75a705ce500e5dc1e7227808312ae1/pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b", size = 7013165, upload-time = "2025-10-15T18:23:06.46Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/75/3fa09aa5cf6ed04bee3fa575798ddf1ce0bace8edb47249c798077a81f7f/pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47", size = 2437834, upload-time = "2025-10-15T18:23:08.194Z" },
-    { url = "https://files.pythonhosted.org/packages/54/2a/9a8c6ba2c2c07b71bec92cf63e03370ca5e5f5c5b119b742bcc0cde3f9c5/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9", size = 4045531, upload-time = "2025-10-15T18:23:10.121Z" },
-    { url = "https://files.pythonhosted.org/packages/84/54/836fdbf1bfb3d66a59f0189ff0b9f5f666cee09c6188309300df04ad71fa/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2", size = 4120554, upload-time = "2025-10-15T18:23:12.14Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/cd/16aec9f0da4793e98e6b54778a5fbce4f375c6646fe662e80600b8797379/pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a", size = 3576812, upload-time = "2025-10-15T18:23:13.962Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/b7/13957fda356dc46339298b351cae0d327704986337c3c69bb54628c88155/pillow-12.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e5d8efac84c9afcb40914ab49ba063d94f5dbdf5066db4482c66a992f47a3a3b", size = 5252689, upload-time = "2025-10-15T18:23:15.562Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/f5/eae31a306341d8f331f43edb2e9122c7661b975433de5e447939ae61c5da/pillow-12.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:266cd5f2b63ff316d5a1bba46268e603c9caf5606d44f38c2873c380950576ad", size = 4650186, upload-time = "2025-10-15T18:23:17.379Z" },
-    { url = "https://files.pythonhosted.org/packages/86/62/2a88339aa40c4c77e79108facbd307d6091e2c0eb5b8d3cf4977cfca2fe6/pillow-12.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58eea5ebe51504057dd95c5b77d21700b77615ab0243d8152793dc00eb4faf01", size = 6230308, upload-time = "2025-10-15T18:23:18.971Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/33/5425a8992bcb32d1cb9fa3dd39a89e613d09a22f2c8083b7bf43c455f760/pillow-12.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13711b1a5ba512d647a0e4ba79280d3a9a045aaf7e0cc6fbe96b91d4cdf6b0c", size = 8039222, upload-time = "2025-10-15T18:23:20.909Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/61/3f5d3b35c5728f37953d3eec5b5f3e77111949523bd2dd7f31a851e50690/pillow-12.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6846bd2d116ff42cba6b646edf5bf61d37e5cbd256425fa089fee4ff5c07a99e", size = 6346657, upload-time = "2025-10-15T18:23:23.077Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/be/ee90a3d79271227e0f0a33c453531efd6ed14b2e708596ba5dd9be948da3/pillow-12.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c98fa880d695de164b4135a52fd2e9cd7b7c90a9d8ac5e9e443a24a95ef9248e", size = 7038482, upload-time = "2025-10-15T18:23:25.005Z" },
-    { url = "https://files.pythonhosted.org/packages/44/34/a16b6a4d1ad727de390e9bd9f19f5f669e079e5826ec0f329010ddea492f/pillow-12.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa3ed2a29a9e9d2d488b4da81dcb54720ac3104a20bf0bd273f1e4648aff5af9", size = 6461416, upload-time = "2025-10-15T18:23:27.009Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/39/1aa5850d2ade7d7ba9f54e4e4c17077244ff7a2d9e25998c38a29749eb3f/pillow-12.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d034140032870024e6b9892c692fe2968493790dd57208b2c37e3fb35f6df3ab", size = 7131584, upload-time = "2025-10-15T18:23:29.752Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/db/4fae862f8fad0167073a7733973bfa955f47e2cac3dc3e3e6257d10fab4a/pillow-12.0.0-cp314-cp314-win32.whl", hash = "sha256:1b1b133e6e16105f524a8dec491e0586d072948ce15c9b914e41cdadd209052b", size = 6400621, upload-time = "2025-10-15T18:23:32.06Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/24/b350c31543fb0107ab2599464d7e28e6f856027aadda995022e695313d94/pillow-12.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8dc232e39d409036af549c86f24aed8273a40ffa459981146829a324e0848b4b", size = 7142916, upload-time = "2025-10-15T18:23:34.71Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/9b/0ba5a6fd9351793996ef7487c4fdbde8d3f5f75dbedc093bb598648fddf0/pillow-12.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:d52610d51e265a51518692045e372a4c363056130d922a7351429ac9f27e70b0", size = 2523836, upload-time = "2025-10-15T18:23:36.967Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/7a/ceee0840aebc579af529b523d530840338ecf63992395842e54edc805987/pillow-12.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1979f4566bb96c1e50a62d9831e2ea2d1211761e5662afc545fa766f996632f6", size = 5255092, upload-time = "2025-10-15T18:23:38.573Z" },
-    { url = "https://files.pythonhosted.org/packages/44/76/20776057b4bfd1aef4eeca992ebde0f53a4dce874f3ae693d0ec90a4f79b/pillow-12.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b2e4b27a6e15b04832fe9bf292b94b5ca156016bbc1ea9c2c20098a0320d6cf6", size = 4653158, upload-time = "2025-10-15T18:23:40.238Z" },
-    { url = "https://files.pythonhosted.org/packages/82/3f/d9ff92ace07be8836b4e7e87e6a4c7a8318d47c2f1463ffcf121fc57d9cb/pillow-12.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fb3096c30df99fd01c7bf8e544f392103d0795b9f98ba71a8054bcbf56b255f1", size = 6267882, upload-time = "2025-10-15T18:23:42.434Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/7a/4f7ff87f00d3ad33ba21af78bfcd2f032107710baf8280e3722ceec28cda/pillow-12.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7438839e9e053ef79f7112c881cef684013855016f928b168b81ed5835f3e75e", size = 8071001, upload-time = "2025-10-15T18:23:44.29Z" },
-    { url = "https://files.pythonhosted.org/packages/75/87/fcea108944a52dad8cca0715ae6247e271eb80459364a98518f1e4f480c1/pillow-12.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d5c411a8eaa2299322b647cd932586b1427367fd3184ffbb8f7a219ea2041ca", size = 6380146, upload-time = "2025-10-15T18:23:46.065Z" },
-    { url = "https://files.pythonhosted.org/packages/91/52/0d31b5e571ef5fd111d2978b84603fce26aba1b6092f28e941cb46570745/pillow-12.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e091d464ac59d2c7ad8e7e08105eaf9dafbc3883fd7265ffccc2baad6ac925", size = 7067344, upload-time = "2025-10-15T18:23:47.898Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/f4/2dd3d721f875f928d48e83bb30a434dee75a2531bca839bb996bb0aa5a91/pillow-12.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:792a2c0be4dcc18af9d4a2dfd8a11a17d5e25274a1062b0ec1c2d79c76f3e7f8", size = 6491864, upload-time = "2025-10-15T18:23:49.607Z" },
-    { url = "https://files.pythonhosted.org/packages/30/4b/667dfcf3d61fc309ba5a15b141845cece5915e39b99c1ceab0f34bf1d124/pillow-12.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afbefa430092f71a9593a99ab6a4e7538bc9eabbf7bf94f91510d3503943edc4", size = 7158911, upload-time = "2025-10-15T18:23:51.351Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/2f/16cabcc6426c32218ace36bf0d55955e813f2958afddbf1d391849fee9d1/pillow-12.0.0-cp314-cp314t-win32.whl", hash = "sha256:3830c769decf88f1289680a59d4f4c46c72573446352e2befec9a8512104fa52", size = 6408045, upload-time = "2025-10-15T18:23:53.177Z" },
-    { url = "https://files.pythonhosted.org/packages/35/73/e29aa0c9c666cf787628d3f0dcf379f4791fba79f4936d02f8b37165bdf8/pillow-12.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:905b0365b210c73afb0ebe9101a32572152dfd1c144c7e28968a331b9217b94a", size = 7148282, upload-time = "2025-10-15T18:23:55.316Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/70/6b41bdcddf541b437bbb9f47f94d2db5d9ddef6c37ccab8c9107743748a4/pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7", size = 2525630, upload-time = "2025-10-15T18:23:57.149Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/b3/582327e6c9f86d037b63beebe981425d6811104cb443e8193824ef1a2f27/pillow-12.0.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b22bd8c974942477156be55a768f7aa37c46904c175be4e158b6a86e3a6b7ca8", size = 5215068, upload-time = "2025-10-15T18:23:59.594Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/d6/67748211d119f3b6540baf90f92fae73ae51d5217b171b0e8b5f7e5d558f/pillow-12.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:805ebf596939e48dbb2e4922a1d3852cfc25c38160751ce02da93058b48d252a", size = 4614994, upload-time = "2025-10-15T18:24:01.669Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/e1/f8281e5d844c41872b273b9f2c34a4bf64ca08905668c8ae730eedc7c9fa/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cae81479f77420d217def5f54b5b9d279804d17e982e0f2fa19b1d1e14ab5197", size = 5246639, upload-time = "2025-10-15T18:24:03.403Z" },
-    { url = "https://files.pythonhosted.org/packages/94/5a/0d8ab8ffe8a102ff5df60d0de5af309015163bf710c7bb3e8311dd3b3ad0/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeaefa96c768fc66818730b952a862235d68825c178f1b3ffd4efd7ad2edcb7c", size = 6986839, upload-time = "2025-10-15T18:24:05.344Z" },
-    { url = "https://files.pythonhosted.org/packages/20/2e/3434380e8110b76cd9eb00a363c484b050f949b4bbe84ba770bb8508a02c/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09f2d0abef9e4e2f349305a4f8cc784a8a6c2f58a8c4892eea13b10a943bd26e", size = 5313505, upload-time = "2025-10-15T18:24:07.137Z" },
-    { url = "https://files.pythonhosted.org/packages/57/ca/5a9d38900d9d74785141d6580950fe705de68af735ff6e727cb911b64740/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bdee52571a343d721fb2eb3b090a82d959ff37fc631e3f70422e0c2e029f3e76", size = 5963654, upload-time = "2025-10-15T18:24:09.579Z" },
-    { url = "https://files.pythonhosted.org/packages/95/7e/f896623c3c635a90537ac093c6a618ebe1a90d87206e42309cb5d98a1b9e/pillow-12.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b290fd8aa38422444d4b50d579de197557f182ef1068b75f5aa8558638b8d0a5", size = 6997850, upload-time = "2025-10-15T18:24:11.495Z" },
+version = "12.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/30/5bd3d794762481f8c8ae9c80e7b76ecea73b916959eb587521358ef0b2f9/pillow-12.1.1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1f1625b72740fdda5d77b4def688eb8fd6490975d06b909fd19f13f391e077e0", size = 5304099, upload-time = "2026-02-11T04:20:06.13Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/c1/aab9e8f3eeb4490180e357955e15c2ef74b31f64790ff356c06fb6cf6d84/pillow-12.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:178aa072084bd88ec759052feca8e56cbb14a60b39322b99a049e58090479713", size = 4657880, upload-time = "2026-02-11T04:20:09.291Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/0a/9879e30d56815ad529d3985aeff5af4964202425c27261a6ada10f7cbf53/pillow-12.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b66e95d05ba806247aaa1561f080abc7975daf715c30780ff92a20e4ec546e1b", size = 6222587, upload-time = "2026-02-11T04:20:10.82Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/5f/a1b72ff7139e4f89014e8d451442c74a774d5c43cd938fb0a9f878576b37/pillow-12.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89c7e895002bbe49cdc5426150377cbbc04767d7547ed145473f496dfa40408b", size = 8027678, upload-time = "2026-02-11T04:20:12.455Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c2/c7cb187dac79a3d22c3ebeae727abee01e077c8c7d930791dc592f335153/pillow-12.1.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a5cbdcddad0af3da87cb16b60d23648bc3b51967eb07223e9fed77a82b457c4", size = 6335777, upload-time = "2026-02-11T04:20:14.441Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/7b/f9b09a7804ec7336effb96c26d37c29d27225783dc1501b7d62dcef6ae25/pillow-12.1.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9f51079765661884a486727f0729d29054242f74b46186026582b4e4769918e4", size = 7027140, upload-time = "2026-02-11T04:20:16.387Z" },
+    { url = "https://files.pythonhosted.org/packages/98/b2/2fa3c391550bd421b10849d1a2144c44abcd966daadd2f7c12e19ea988c4/pillow-12.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:99c1506ea77c11531d75e3a412832a13a71c7ebc8192ab9e4b2e355555920e3e", size = 6449855, upload-time = "2026-02-11T04:20:18.554Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ff/9caf4b5b950c669263c39e96c78c0d74a342c71c4f43fd031bb5cb7ceac9/pillow-12.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:36341d06738a9f66c8287cf8b876d24b18db9bd8740fa0672c74e259ad408cff", size = 7151329, upload-time = "2026-02-11T04:20:20.646Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/f8/4b24841f582704da675ca535935bccb32b00a6da1226820845fac4a71136/pillow-12.1.1-cp310-cp310-win32.whl", hash = "sha256:6c52f062424c523d6c4db85518774cc3d50f5539dd6eed32b8f6229b26f24d40", size = 6325574, upload-time = "2026-02-11T04:20:22.43Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f9/9f6b01c0881d7036063aa6612ef04c0e2cad96be21325a1e92d0203f8e91/pillow-12.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:c6008de247150668a705a6338156efb92334113421ceecf7438a12c9a12dab23", size = 7032347, upload-time = "2026-02-11T04:20:23.932Z" },
+    { url = "https://files.pythonhosted.org/packages/79/13/c7922edded3dcdaf10c59297540b72785620abc0538872c819915746757d/pillow-12.1.1-cp310-cp310-win_arm64.whl", hash = "sha256:1a9b0ee305220b392e1124a764ee4265bd063e54a751a6b62eff69992f457fa9", size = 2453457, upload-time = "2026-02-11T04:20:25.392Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" },
+    { url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" },
+    { url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" },
+    { url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" },
+    { url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
+    { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
+    { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },
+    { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },
+    { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },
+    { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },
+    { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },
+    { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },
+    { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },
+    { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },
+    { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" },
+    { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" },
+    { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" },
+    { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" },
+    { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" },
+    { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" },
+    { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" },
+    { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" },
+    { url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" },
+    { url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" },
+    { url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" },
+    { url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },
 ]
 
 [[package]]
 name = "platformdirs"
-version = "4.5.0"
+version = "4.5.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" },
 ]
 
 [[package]]
@@ -1477,6 +2309,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
+[[package]]
+name = "prometheus-client"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/58/a794d23feb6b00fc0c72787d7e87d872a6730dd9ed7c7b3e954637d8f280/prometheus_client-0.24.1.tar.gz", hash = "sha256:7e0ced7fbbd40f7b84962d5d2ab6f17ef88a72504dcf7c0b40737b43b2a461f9", size = 85616, upload-time = "2026-01-14T15:26:26.965Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/c3/24a2f845e3917201628ecaba4f18bab4d18a337834c1df2a159ee9d22a42/prometheus_client-0.24.1-py3-none-any.whl", hash = "sha256:150db128af71a5c2482b36e588fc8a6b95e498750da4b17065947c16070f4055", size = 64057, upload-time = "2026-01-14T15:26:24.42Z" },
+]
+
 [[package]]
 name = "prompt-toolkit"
 version = "3.0.52"
@@ -1491,28 +2332,30 @@ wheels = [
 
 [[package]]
 name = "psutil"
-version = "7.1.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz", hash = "sha256:6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74", size = 489059, upload-time = "2025-11-02T12:25:54.619Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc", size = 239751, upload-time = "2025-11-02T12:25:58.161Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0", size = 240368, upload-time = "2025-11-02T12:26:00.491Z" },
-    { url = "https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7", size = 287134, upload-time = "2025-11-02T12:26:02.613Z" },
-    { url = "https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251", size = 289904, upload-time = "2025-11-02T12:26:05.207Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa", size = 249642, upload-time = "2025-11-02T12:26:07.447Z" },
-    { url = "https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee", size = 245518, upload-time = "2025-11-02T12:26:09.719Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353", size = 239843, upload-time = "2025-11-02T12:26:11.968Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b", size = 240369, upload-time = "2025-11-02T12:26:14.358Z" },
-    { url = "https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9", size = 288210, upload-time = "2025-11-02T12:26:16.699Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f", size = 291182, upload-time = "2025-11-02T12:26:18.848Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7", size = 250466, upload-time = "2025-11-02T12:26:21.183Z" },
-    { url = "https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264", size = 245756, upload-time = "2025-11-02T12:26:23.148Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab", size = 238359, upload-time = "2025-11-02T12:26:25.284Z" },
-    { url = "https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880", size = 239171, upload-time = "2025-11-02T12:26:27.23Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3", size = 263261, upload-time = "2025-11-02T12:26:29.48Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b", size = 264635, upload-time = "2025-11-02T12:26:31.74Z" },
-    { url = "https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl", hash = "sha256:f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd", size = 247633, upload-time = "2025-11-02T12:26:33.887Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl", hash = "sha256:bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1", size = 244608, upload-time = "2025-11-02T12:26:36.136Z" },
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },
+    { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" },
+    { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
 ]
 
 [[package]]
@@ -1535,11 +2378,11 @@ wheels = [
 
 [[package]]
 name = "pycparser"
-version = "2.23"
+version = "3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
 ]
 
 [[package]]
@@ -1558,10 +2401,10 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "matplotlib" },
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "pytest" },
     { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.16.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "watermark" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5b/82/4c5120540e0dfebee6b1a6ac8f8da5f76bfa2b9c260427f97235c1e2bbab/pygridfit-0.1.6.tar.gz", hash = "sha256:bc0227dc1d8abfbe3906b57fbcdd3e7e8ecf37ae1b61594d6dde4c466dddba6e", size = 1212514, upload-time = "2025-09-26T14:05:12.018Z" }
@@ -1576,16 +2419,16 @@ scikit-sparse = [
 
 [[package]]
 name = "pyparsing"
-version = "3.2.5"
+version = "3.3.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/181488fc2b9d093e3972d2a472855aae8a03f000592dbfce716a512b3359/pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6", size = 1099274, upload-time = "2025-09-21T04:11:06.277Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890, upload-time = "2025-09-21T04:11:04.117Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
 ]
 
 [[package]]
 name = "pytest"
-version = "9.0.1"
+version = "9.0.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -1596,9 +2439,9 @@ dependencies = [
     { name = "pygments" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/07/56/f013048ac4bc4c1d9be45afd4ab209ea62822fb1598f40687e6bf45dcea4/pytest-9.0.1.tar.gz", hash = "sha256:3e9c069ea73583e255c3b21cf46b8d3c56f6e3a1a8f6da94ccb0fcf57b9d73c8", size = 1564125, upload-time = "2025-11-12T13:05:09.333Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/8b/6300fb80f858cda1c51ffa17075df5d846757081d11ab4aa35cef9e6258b/pytest-9.0.1-py3-none-any.whl", hash = "sha256:67be0030d194df2dfa7b556f2e56fb3c3315bd5c8822c6951162b92b32ce7dad", size = 373668, upload-time = "2025-11-12T13:05:07.379Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
 ]
 
 [[package]]
@@ -1613,6 +2456,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
 ]
 
+[[package]]
+name = "python-json-logger"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/29/bf/eca6a3d43db1dae7070f70e160ab20b807627ba953663ba07928cdd3dc58/python_json_logger-4.0.0.tar.gz", hash = "sha256:f58e68eb46e1faed27e0f574a55a0455eecd7b8a5b88b85a784519ba3cff047f", size = 17683, upload-time = "2025-10-06T04:15:18.984Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548, upload-time = "2025-10-06T04:15:17.553Z" },
+]
+
+[[package]]
+name = "pytz"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" },
+]
+
 [[package]]
 name = "pywarper"
 version = "0.2.5"
@@ -1620,10 +2481,10 @@ source = { editable = "." }
 dependencies = [
     { name = "alphashape" },
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "pygridfit" },
     { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.16.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "skeliner" },
     { name = "watermark" },
 ]
@@ -1668,6 +2529,92 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" },
 ]
 
+[[package]]
+name = "pywinpty"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/54/37c7370ba91f579235049dc26cd2c5e657d2a943e01820844ffc81f32176/pywinpty-3.0.3.tar.gz", hash = "sha256:523441dc34d231fb361b4b00f8c99d3f16de02f5005fd544a0183112bcc22412", size = 31309, upload-time = "2026-02-04T21:51:09.524Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/28/a652709bd76ca7533cd1c443b03add9f5051fdf71bc6bdb8801dddd4e7a3/pywinpty-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:ff05f12d775b142b11c6fe085129bdd759b61cf7d41da6c745e78e3a1ef5bf40", size = 2114320, upload-time = "2026-02-04T21:53:50.972Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/13/a0181cc5c2d5635d3dbc3802b97bc8e3ad4fa7502ccef576651a5e08e54c/pywinpty-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:340ccacb4d74278a631923794ccd758471cfc8eeeeee4610b280420a17ad1e82", size = 235670, upload-time = "2026-02-04T21:50:20.324Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c3/3e75075c7f71735f22b66fab0481f2c98e3a4d58cba55cb50ba29114bcf6/pywinpty-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:dff25a9a6435f527d7c65608a7e62783fc12076e7d44487a4911ee91be5a8ac8", size = 2114430, upload-time = "2026-02-04T21:54:19.485Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/1e/8a54166a8c5e4f5cb516514bdf4090be4d51a71e8d9f6d98c0aa00fe45d4/pywinpty-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:fbc1e230e5b193eef4431cba3f39996a288f9958f9c9f092c8a961d930ee8f68", size = 236191, upload-time = "2026-02-04T21:50:36.239Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/d4/aeb5e1784d2c5bff6e189138a9ca91a090117459cea0c30378e1f2db3d54/pywinpty-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c9081df0e49ffa86d15db4a6ba61530630e48707f987df42c9d3313537e81fc0", size = 2113098, upload-time = "2026-02-04T21:54:37.711Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/53/7278223c493ccfe4883239cf06c823c56460a8010e0fc778eef67858dc14/pywinpty-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:15e79d870e18b678fb8a5a6105fd38496b55697c66e6fc0378236026bc4d59e9", size = 234901, upload-time = "2026-02-04T21:53:31.35Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/cb/58d6ed3fd429c96a90ef01ac9a617af10a6d41469219c25e7dc162abbb71/pywinpty-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9c91dbb026050c77bdcef964e63a4f10f01a639113c4d3658332614544c467ab", size = 2112686, upload-time = "2026-02-04T21:52:03.035Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/50/724ed5c38c504d4e58a88a072776a1e880d970789deaeb2b9f7bd9a5141a/pywinpty-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:fe1f7911805127c94cf51f89ab14096c6f91ffdcacf993d2da6082b2142a2523", size = 234591, upload-time = "2026-02-04T21:52:29.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ad/90a110538696b12b39fd8758a06d70ded899308198ad2305ac68e361126e/pywinpty-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:3f07a6cf1c1d470d284e614733c3d0f726d2c85e78508ea10a403140c3c0c18a", size = 2112360, upload-time = "2026-02-04T21:55:33.397Z" },
+    { url = "https://files.pythonhosted.org/packages/44/0f/7ffa221757a220402bc79fda44044c3f2cc57338d878ab7d622add6f4581/pywinpty-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:15c7c0b6f8e9d87aabbaff76468dabf6e6121332c40fc1d83548d02a9d6a3759", size = 233107, upload-time = "2026-02-04T21:51:45.455Z" },
+    { url = "https://files.pythonhosted.org/packages/28/88/2ff917caff61e55f38bcdb27de06ee30597881b2cae44fbba7627be015c4/pywinpty-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:d4b6b7b0fe0cdcd02e956bd57cfe9f4e5a06514eecf3b5ae174da4f951b58be9", size = 2113282, upload-time = "2026-02-04T21:52:08.188Z" },
+    { url = "https://files.pythonhosted.org/packages/63/32/40a775343ace542cc43ece3f1d1fce454021521ecac41c4c4573081c2336/pywinpty-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:34789d685fc0d547ce0c8a65e5a70e56f77d732fa6e03c8f74fefb8cbb252019", size = 234207, upload-time = "2026-02-04T21:51:58.687Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/54/5d5e52f4cb75028104ca6faf36c10f9692389b1986d34471663b4ebebd6d/pywinpty-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0c37e224a47a971d1a6e08649a1714dac4f63c11920780977829ed5c8cadead1", size = 2112910, upload-time = "2026-02-04T21:52:30.976Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/44/dcd184824e21d4620b06c7db9fbb15c3ad0a0f1fa2e6de79969fb82647ec/pywinpty-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c4e9c3dff7d86ba81937438d5819f19f385a39d8f592d4e8af67148ceb4f6ab5", size = 233425, upload-time = "2026-02-04T21:51:56.754Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
 [[package]]
 name = "pyzmq"
 version = "27.1.0"
@@ -1755,6 +2702,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e1/67/921ec3024056483db83953ae8e48079ad62b92db7880013ca77632921dd0/readme_renderer-44.0-py3-none-any.whl", hash = "sha256:2fbca89b81a08526aadf1357a8c2ae889ec05fb03f5da67f9769c9a592166151", size = 13310, upload-time = "2024-07-08T15:00:56.577Z" },
 ]
 
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
 [[package]]
 name = "requests"
 version = "2.32.5"
@@ -1782,6 +2743,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
 ]
 
+[[package]]
+name = "rfc3339-validator"
+version = "0.1.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" },
+]
+
 [[package]]
 name = "rfc3986"
 version = "2.0.0"
@@ -1791,17 +2764,160 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", size = 31326, upload-time = "2022-01-10T00:52:29.594Z" },
 ]
 
+[[package]]
+name = "rfc3986-validator"
+version = "0.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" },
+]
+
+[[package]]
+name = "rfc3987-syntax"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lark" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" },
+]
+
 [[package]]
 name = "rich"
-version = "14.2.0"
+version = "14.3.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/74/99/a4cab2acbb884f80e558b0771e97e21e939c5dfb460f488d19df485e8298/rich-14.3.2.tar.gz", hash = "sha256:e712f11c1a562a11843306f5ed999475f09ac31ffb64281f73ab29ffdda8b3b8", size = 230143, upload-time = "2026-02-01T16:20:47.908Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/45/615f5babd880b4bd7d405cc0dc348234c5ffb6ed1ea33e152ede08b2072d/rich-14.3.2-py3-none-any.whl", hash = "sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69", size = 309963, upload-time = "2026-02-01T16:20:46.078Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" },
+    { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" },
+    { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" },
+    { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" },
+    { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" },
+    { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" },
+    { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" },
+    { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" },
+    { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" },
+    { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" },
+    { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" },
+    { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" },
+    { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" },
+    { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" },
+    { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" },
+    { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" },
+    { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" },
+    { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" },
+    { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" },
+    { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" },
+    { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" },
+    { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" },
+    { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" },
+    { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" },
+    { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" },
+    { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" },
+    { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" },
+    { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" },
+    { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" },
+    { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" },
+    { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
 ]
 
 [[package]]
@@ -1822,28 +2938,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/82/fa/fbb67a5780ae0f704876cb8ac92d6d76da41da4dc72b7ed3565ab18f2f52/ruff-0.14.5.tar.gz", hash = "sha256:8d3b48d7d8aad423d3137af7ab6c8b1e38e4de104800f0d596990f6ada1a9fc1", size = 5615944, upload-time = "2025-11-13T19:58:51.155Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/31/c07e9c535248d10836a94e4f4e8c5a31a1beed6f169b31405b227872d4f4/ruff-0.14.5-py3-none-linux_armv6l.whl", hash = "sha256:f3b8248123b586de44a8018bcc9fefe31d23dda57a34e6f0e1e53bd51fd63594", size = 13171630, upload-time = "2025-11-13T19:57:54.894Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/5c/283c62516dca697cd604c2796d1487396b7a436b2f0ecc3fd412aca470e0/ruff-0.14.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f7a75236570318c7a30edd7f5491945f0169de738d945ca8784500b517163a72", size = 13413925, upload-time = "2025-11-13T19:57:59.181Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/f3/aa319f4afc22cb6fcba2b9cdfc0f03bbf747e59ab7a8c5e90173857a1361/ruff-0.14.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6d146132d1ee115f8802356a2dc9a634dbf58184c51bff21f313e8cd1c74899a", size = 12574040, upload-time = "2025-11-13T19:58:02.056Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/7f/cb5845fcc7c7e88ed57f58670189fc2ff517fe2134c3821e77e29fd3b0c8/ruff-0.14.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2380596653dcd20b057794d55681571a257a42327da8894b93bbd6111aa801f", size = 13009755, upload-time = "2025-11-13T19:58:05.172Z" },
-    { url = "https://files.pythonhosted.org/packages/21/d2/bcbedbb6bcb9253085981730687ddc0cc7b2e18e8dc13cf4453de905d7a0/ruff-0.14.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2d1fa985a42b1f075a098fa1ab9d472b712bdb17ad87a8ec86e45e7fa6273e68", size = 12937641, upload-time = "2025-11-13T19:58:08.345Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/58/e25de28a572bdd60ffc6bb71fc7fd25a94ec6a076942e372437649cbb02a/ruff-0.14.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88f0770d42b7fa02bbefddde15d235ca3aa24e2f0137388cc15b2dcbb1f7c7a7", size = 13610854, upload-time = "2025-11-13T19:58:11.419Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/24/43bb3fd23ecee9861970978ea1a7a63e12a204d319248a7e8af539984280/ruff-0.14.5-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:3676cb02b9061fee7294661071c4709fa21419ea9176087cb77e64410926eb78", size = 15061088, upload-time = "2025-11-13T19:58:14.551Z" },
-    { url = "https://files.pythonhosted.org/packages/23/44/a022f288d61c2f8c8645b24c364b719aee293ffc7d633a2ca4d116b9c716/ruff-0.14.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b595bedf6bc9cab647c4a173a61acf4f1ac5f2b545203ba82f30fcb10b0318fb", size = 14734717, upload-time = "2025-11-13T19:58:17.518Z" },
-    { url = "https://files.pythonhosted.org/packages/58/81/5c6ba44de7e44c91f68073e0658109d8373b0590940efe5bd7753a2585a3/ruff-0.14.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f55382725ad0bdb2e8ee2babcbbfb16f124f5a59496a2f6a46f1d9d99d93e6e2", size = 14028812, upload-time = "2025-11-13T19:58:20.533Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/ef/41a8b60f8462cb320f68615b00299ebb12660097c952c600c762078420f8/ruff-0.14.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7497d19dce23976bdaca24345ae131a1d38dcfe1b0850ad8e9e6e4fa321a6e19", size = 13825656, upload-time = "2025-11-13T19:58:23.345Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/00/207e5de737fdb59b39eb1fac806904fe05681981b46d6a6db9468501062e/ruff-0.14.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:410e781f1122d6be4f446981dd479470af86537fb0b8857f27a6e872f65a38e4", size = 13959922, upload-time = "2025-11-13T19:58:26.537Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/7e/fa1f5c2776db4be405040293618846a2dece5c70b050874c2d1f10f24776/ruff-0.14.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c01be527ef4c91a6d55e53b337bfe2c0f82af024cc1a33c44792d6844e2331e1", size = 12932501, upload-time = "2025-11-13T19:58:29.822Z" },
-    { url = "https://files.pythonhosted.org/packages/67/d8/d86bf784d693a764b59479a6bbdc9515ae42c340a5dc5ab1dabef847bfaa/ruff-0.14.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f66e9bb762e68d66e48550b59c74314168ebb46199886c5c5aa0b0fbcc81b151", size = 12927319, upload-time = "2025-11-13T19:58:32.923Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/de/ee0b304d450ae007ce0cb3e455fe24fbcaaedae4ebaad6c23831c6663651/ruff-0.14.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d93be8f1fa01022337f1f8f3bcaa7ffee2d0b03f00922c45c2207954f351f465", size = 13206209, upload-time = "2025-11-13T19:58:35.952Z" },
-    { url = "https://files.pythonhosted.org/packages/33/aa/193ca7e3a92d74f17d9d5771a765965d2cf42c86e6f0fd95b13969115723/ruff-0.14.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:c135d4b681f7401fe0e7312017e41aba9b3160861105726b76cfa14bc25aa367", size = 13953709, upload-time = "2025-11-13T19:58:39.002Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/f1/7119e42aa1d3bf036ffc9478885c2e248812b7de9abea4eae89163d2929d/ruff-0.14.5-py3-none-win32.whl", hash = "sha256:c83642e6fccfb6dea8b785eb9f456800dcd6a63f362238af5fc0c83d027dd08b", size = 12925808, upload-time = "2025-11-13T19:58:42.779Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/9d/7c0a255d21e0912114784e4a96bf62af0618e2190cae468cd82b13625ad2/ruff-0.14.5-py3-none-win_amd64.whl", hash = "sha256:9d55d7af7166f143c94eae1db3312f9ea8f95a4defef1979ed516dbb38c27621", size = 14331546, upload-time = "2025-11-13T19:58:45.691Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/80/69756670caedcf3b9be597a6e12276a6cf6197076eb62aad0c608f8efce0/ruff-0.14.5-py3-none-win_arm64.whl", hash = "sha256:4b700459d4649e2594b31f20a9de33bc7c19976d4746d8d0798ad959621d64a4", size = 13433331, upload-time = "2025-11-13T19:58:48.434Z" },
+version = "0.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/39/5cee96809fbca590abea6b46c6d1c586b49663d1d2830a751cc8fc42c666/ruff-0.15.0.tar.gz", hash = "sha256:6bdea47cdbea30d40f8f8d7d69c0854ba7c15420ec75a26f463290949d7f7e9a", size = 4524893, upload-time = "2026-02-03T17:53:35.357Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/88/3fd1b0aa4b6330d6aaa63a285bc96c9f71970351579152d231ed90914586/ruff-0.15.0-py3-none-linux_armv6l.whl", hash = "sha256:aac4ebaa612a82b23d45964586f24ae9bc23ca101919f5590bdb368d74ad5455", size = 10354332, upload-time = "2026-02-03T17:52:54.892Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f6/62e173fbb7eb75cc29fe2576a1e20f0a46f671a2587b5f604bfb0eaf5f6f/ruff-0.15.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:dcd4be7cc75cfbbca24a98d04d0b9b36a270d0833241f776b788d59f4142b14d", size = 10767189, upload-time = "2026-02-03T17:53:19.778Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e4/968ae17b676d1d2ff101d56dc69cf333e3a4c985e1ec23803df84fc7bf9e/ruff-0.15.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d747e3319b2bce179c7c1eaad3d884dc0a199b5f4d5187620530adf9105268ce", size = 10075384, upload-time = "2026-02-03T17:53:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/bf/9843c6044ab9e20af879c751487e61333ca79a2c8c3058b15722386b8cae/ruff-0.15.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:650bd9c56ae03102c51a5e4b554d74d825ff3abe4db22b90fd32d816c2e90621", size = 10481363, upload-time = "2026-02-03T17:52:43.332Z" },
+    { url = "https://files.pythonhosted.org/packages/55/d9/4ada5ccf4cd1f532db1c8d44b6f664f2208d3d93acbeec18f82315e15193/ruff-0.15.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6664b7eac559e3048223a2da77769c2f92b43a6dfd4720cef42654299a599c9", size = 10187736, upload-time = "2026-02-03T17:53:00.522Z" },
+    { url = "https://files.pythonhosted.org/packages/86/e2/f25eaecd446af7bb132af0a1d5b135a62971a41f5366ff41d06d25e77a91/ruff-0.15.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f811f97b0f092b35320d1556f3353bf238763420ade5d9e62ebd2b73f2ff179", size = 10968415, upload-time = "2026-02-03T17:53:15.705Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/dc/f06a8558d06333bf79b497d29a50c3a673d9251214e0d7ec78f90b30aa79/ruff-0.15.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761ec0a66680fab6454236635a39abaf14198818c8cdf691e036f4bc0f406b2d", size = 11809643, upload-time = "2026-02-03T17:53:23.031Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/45/0ece8db2c474ad7df13af3a6d50f76e22a09d078af63078f005057ca59eb/ruff-0.15.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:940f11c2604d317e797b289f4f9f3fa5555ffe4fb574b55ed006c3d9b6f0eb78", size = 11234787, upload-time = "2026-02-03T17:52:46.432Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/d9/0e3a81467a120fd265658d127db648e4d3acfe3e4f6f5d4ea79fac47e587/ruff-0.15.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcbca3d40558789126da91d7ef9a7c87772ee107033db7191edefa34e2c7f1b4", size = 11112797, upload-time = "2026-02-03T17:52:49.274Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/cb/8c0b3b0c692683f8ff31351dfb6241047fa873a4481a76df4335a8bff716/ruff-0.15.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9a121a96db1d75fa3eb39c4539e607f628920dd72ff1f7c5ee4f1b768ac62d6e", size = 11033133, upload-time = "2026-02-03T17:53:33.105Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/5e/23b87370cf0f9081a8c89a753e69a4e8778805b8802ccfe175cc410e50b9/ruff-0.15.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5298d518e493061f2eabd4abd067c7e4fb89e2f63291c94332e35631c07c3662", size = 10442646, upload-time = "2026-02-03T17:53:06.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9a/3c94de5ce642830167e6d00b5c75aacd73e6347b4c7fc6828699b150a5ee/ruff-0.15.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:afb6e603d6375ff0d6b0cee563fa21ab570fd15e65c852cb24922cef25050cf1", size = 10195750, upload-time = "2026-02-03T17:53:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/30/15/e396325080d600b436acc970848d69df9c13977942fb62bb8722d729bee8/ruff-0.15.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:77e515f6b15f828b94dc17d2b4ace334c9ddb7d9468c54b2f9ed2b9c1593ef16", size = 10676120, upload-time = "2026-02-03T17:53:09.363Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/229a23d52a2983de1ad0fb0ee37d36e0257e6f28bfd6b498ee2c76361874/ruff-0.15.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6f6e80850a01eb13b3e42ee0ebdf6e4497151b48c35051aab51c101266d187a3", size = 11201636, upload-time = "2026-02-03T17:52:57.281Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/b0/69adf22f4e24f3677208adb715c578266842e6e6a3cc77483f48dd999ede/ruff-0.15.0-py3-none-win32.whl", hash = "sha256:238a717ef803e501b6d51e0bdd0d2c6e8513fe9eec14002445134d3907cd46c3", size = 10465945, upload-time = "2026-02-03T17:53:12.591Z" },
+    { url = "https://files.pythonhosted.org/packages/51/ad/f813b6e2c97e9b4598be25e94a9147b9af7e60523b0cb5d94d307c15229d/ruff-0.15.0-py3-none-win_amd64.whl", hash = "sha256:dd5e4d3301dc01de614da3cdffc33d4b1b96fb89e45721f1598e5532ccf78b18", size = 11564657, upload-time = "2026-02-03T17:52:51.893Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b0/2d823f6e77ebe560f4e397d078487e8d52c1516b331e3521bc75db4272ca/ruff-0.15.0-py3-none-win_arm64.whl", hash = "sha256:c480d632cc0ca3f0727acac8b7d053542d9e114a462a145d0b00e7cd658c515a", size = 10865753, upload-time = "2026-02-03T17:53:03.014Z" },
 ]
 
 [[package]]
@@ -1852,9 +2967,9 @@ version = "0.4.16"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.16.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/33/f2/b391faf6120b72b994b574caef9dac5ea2b7667de59fbd3c8336c07403b3/scikit_sparse-0.4.16.tar.gz", hash = "sha256:3baf49ac98ae8cc4357005af49a0df93a6a53f4e61708705da2942ea4fa61a56", size = 214435, upload-time = "2025-04-27T18:20:37.052Z" }
 
@@ -1919,98 +3034,112 @@ wheels = [
 
 [[package]]
 name = "scipy"
-version = "1.16.3"
+version = "1.17.0"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version >= '3.11'",
-]
-dependencies = [
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0a/ca/d8ace4f98322d01abcd52d381134344bf7b431eba7ed8b42bdea5a3c2ac9/scipy-1.16.3.tar.gz", hash = "sha256:01e87659402762f43bd2fee13370553a17ada367d42e7487800bf2916535aecb", size = 30597883, upload-time = "2025-10-28T17:38:54.068Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/5f/6f37d7439de1455ce9c5a556b8d1db0979f03a796c030bafdf08d35b7bf9/scipy-1.16.3-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:40be6cf99e68b6c4321e9f8782e7d5ff8265af28ef2cd56e9c9b2638fa08ad97", size = 36630881, upload-time = "2025-10-28T17:31:47.104Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/89/d70e9f628749b7e4db2aa4cd89735502ff3f08f7b9b27d2e799485987cd9/scipy-1.16.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:8be1ca9170fcb6223cc7c27f4305d680ded114a1567c0bd2bfcbf947d1b17511", size = 28941012, upload-time = "2025-10-28T17:31:53.411Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/a8/0e7a9a6872a923505dbdf6bb93451edcac120363131c19013044a1e7cb0c/scipy-1.16.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bea0a62734d20d67608660f69dcda23e7f90fb4ca20974ab80b6ed40df87a005", size = 20931935, upload-time = "2025-10-28T17:31:57.361Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/c7/020fb72bd79ad798e4dbe53938543ecb96b3a9ac3fe274b7189e23e27353/scipy-1.16.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:2a207a6ce9c24f1951241f4693ede2d393f59c07abc159b2cb2be980820e01fb", size = 23534466, upload-time = "2025-10-28T17:32:01.875Z" },
-    { url = "https://files.pythonhosted.org/packages/be/a0/668c4609ce6dbf2f948e167836ccaf897f95fb63fa231c87da7558a374cd/scipy-1.16.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:532fb5ad6a87e9e9cd9c959b106b73145a03f04c7d57ea3e6f6bb60b86ab0876", size = 33593618, upload-time = "2025-10-28T17:32:06.902Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/6e/8942461cf2636cdae083e3eb72622a7fbbfa5cf559c7d13ab250a5dbdc01/scipy-1.16.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0151a0749efeaaab78711c78422d413c583b8cdd2011a3c1d6c794938ee9fdb2", size = 35899798, upload-time = "2025-10-28T17:32:12.665Z" },
-    { url = "https://files.pythonhosted.org/packages/79/e8/d0f33590364cdbd67f28ce79368b373889faa4ee959588beddf6daef9abe/scipy-1.16.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b7180967113560cca57418a7bc719e30366b47959dd845a93206fbed693c867e", size = 36226154, upload-time = "2025-10-28T17:32:17.961Z" },
-    { url = "https://files.pythonhosted.org/packages/39/c1/1903de608c0c924a1749c590064e65810f8046e437aba6be365abc4f7557/scipy-1.16.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:deb3841c925eeddb6afc1e4e4a45e418d19ec7b87c5df177695224078e8ec733", size = 38878540, upload-time = "2025-10-28T17:32:23.907Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/d0/22ec7036ba0b0a35bccb7f25ab407382ed34af0b111475eb301c16f8a2e5/scipy-1.16.3-cp311-cp311-win_amd64.whl", hash = "sha256:53c3844d527213631e886621df5695d35e4f6a75f620dca412bcd292f6b87d78", size = 38722107, upload-time = "2025-10-28T17:32:29.921Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/60/8a00e5a524bb3bf8898db1650d350f50e6cffb9d7a491c561dc9826c7515/scipy-1.16.3-cp311-cp311-win_arm64.whl", hash = "sha256:9452781bd879b14b6f055b26643703551320aa8d79ae064a71df55c00286a184", size = 25506272, upload-time = "2025-10-28T17:32:34.577Z" },
-    { url = "https://files.pythonhosted.org/packages/40/41/5bf55c3f386b1643812f3a5674edf74b26184378ef0f3e7c7a09a7e2ca7f/scipy-1.16.3-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81fc5827606858cf71446a5e98715ba0e11f0dbc83d71c7409d05486592a45d6", size = 36659043, upload-time = "2025-10-28T17:32:40.285Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/0f/65582071948cfc45d43e9870bf7ca5f0e0684e165d7c9ef4e50d783073eb/scipy-1.16.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:c97176013d404c7346bf57874eaac5187d969293bf40497140b0a2b2b7482e07", size = 28898986, upload-time = "2025-10-28T17:32:45.325Z" },
-    { url = "https://files.pythonhosted.org/packages/96/5e/36bf3f0ac298187d1ceadde9051177d6a4fe4d507e8f59067dc9dd39e650/scipy-1.16.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2b71d93c8a9936046866acebc915e2af2e292b883ed6e2cbe5c34beb094b82d9", size = 20889814, upload-time = "2025-10-28T17:32:49.277Z" },
-    { url = "https://files.pythonhosted.org/packages/80/35/178d9d0c35394d5d5211bbff7ac4f2986c5488b59506fef9e1de13ea28d3/scipy-1.16.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3d4a07a8e785d80289dfe66b7c27d8634a773020742ec7187b85ccc4b0e7b686", size = 23565795, upload-time = "2025-10-28T17:32:53.337Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/46/d1146ff536d034d02f83c8afc3c4bab2eddb634624d6529a8512f3afc9da/scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0553371015692a898e1aa858fed67a3576c34edefa6b7ebdb4e9dde49ce5c203", size = 33349476, upload-time = "2025-10-28T17:32:58.353Z" },
-    { url = "https://files.pythonhosted.org/packages/79/2e/415119c9ab3e62249e18c2b082c07aff907a273741b3f8160414b0e9193c/scipy-1.16.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:72d1717fd3b5e6ec747327ce9bda32d5463f472c9dce9f54499e81fbd50245a1", size = 35676692, upload-time = "2025-10-28T17:33:03.88Z" },
-    { url = "https://files.pythonhosted.org/packages/27/82/df26e44da78bf8d2aeaf7566082260cfa15955a5a6e96e6a29935b64132f/scipy-1.16.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fb2472e72e24d1530debe6ae078db70fb1605350c88a3d14bc401d6306dbffe", size = 36019345, upload-time = "2025-10-28T17:33:09.773Z" },
-    { url = "https://files.pythonhosted.org/packages/82/31/006cbb4b648ba379a95c87262c2855cd0d09453e500937f78b30f02fa1cd/scipy-1.16.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5192722cffe15f9329a3948c4b1db789fbb1f05c97899187dcf009b283aea70", size = 38678975, upload-time = "2025-10-28T17:33:15.809Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/7f/acbd28c97e990b421af7d6d6cd416358c9c293fc958b8529e0bd5d2a2a19/scipy-1.16.3-cp312-cp312-win_amd64.whl", hash = "sha256:56edc65510d1331dae01ef9b658d428e33ed48b4f77b1d51caf479a0253f96dc", size = 38555926, upload-time = "2025-10-28T17:33:21.388Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/69/c5c7807fd007dad4f48e0a5f2153038dc96e8725d3345b9ee31b2b7bed46/scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2", size = 25463014, upload-time = "2025-10-28T17:33:25.975Z" },
-    { url = "https://files.pythonhosted.org/packages/72/f1/57e8327ab1508272029e27eeef34f2302ffc156b69e7e233e906c2a5c379/scipy-1.16.3-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:d2ec56337675e61b312179a1ad124f5f570c00f920cc75e1000025451b88241c", size = 36617856, upload-time = "2025-10-28T17:33:31.375Z" },
-    { url = "https://files.pythonhosted.org/packages/44/13/7e63cfba8a7452eb756306aa2fd9b37a29a323b672b964b4fdeded9a3f21/scipy-1.16.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:16b8bc35a4cc24db80a0ec836a9286d0e31b2503cb2fd7ff7fb0e0374a97081d", size = 28874306, upload-time = "2025-10-28T17:33:36.516Z" },
-    { url = "https://files.pythonhosted.org/packages/15/65/3a9400efd0228a176e6ec3454b1fa998fbbb5a8defa1672c3f65706987db/scipy-1.16.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:5803c5fadd29de0cf27fa08ccbfe7a9e5d741bf63e4ab1085437266f12460ff9", size = 20865371, upload-time = "2025-10-28T17:33:42.094Z" },
-    { url = "https://files.pythonhosted.org/packages/33/d7/eda09adf009a9fb81827194d4dd02d2e4bc752cef16737cc4ef065234031/scipy-1.16.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:b81c27fc41954319a943d43b20e07c40bdcd3ff7cf013f4fb86286faefe546c4", size = 23524877, upload-time = "2025-10-28T17:33:48.483Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/6b/3f911e1ebc364cb81320223a3422aab7d26c9c7973109a9cd0f27c64c6c0/scipy-1.16.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0c3b4dd3d9b08dbce0f3440032c52e9e2ab9f96ade2d3943313dfe51a7056959", size = 33342103, upload-time = "2025-10-28T17:33:56.495Z" },
-    { url = "https://files.pythonhosted.org/packages/21/f6/4bfb5695d8941e5c570a04d9fcd0d36bce7511b7d78e6e75c8f9791f82d0/scipy-1.16.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7dc1360c06535ea6116a2220f760ae572db9f661aba2d88074fe30ec2aa1ff88", size = 35697297, upload-time = "2025-10-28T17:34:04.722Z" },
-    { url = "https://files.pythonhosted.org/packages/04/e1/6496dadbc80d8d896ff72511ecfe2316b50313bfc3ebf07a3f580f08bd8c/scipy-1.16.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:663b8d66a8748051c3ee9c96465fb417509315b99c71550fda2591d7dd634234", size = 36021756, upload-time = "2025-10-28T17:34:13.482Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/bd/a8c7799e0136b987bda3e1b23d155bcb31aec68a4a472554df5f0937eef7/scipy-1.16.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eab43fae33a0c39006a88096cd7b4f4ef545ea0447d250d5ac18202d40b6611d", size = 38696566, upload-time = "2025-10-28T17:34:22.384Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/01/1204382461fcbfeb05b6161b594f4007e78b6eba9b375382f79153172b4d/scipy-1.16.3-cp313-cp313-win_amd64.whl", hash = "sha256:062246acacbe9f8210de8e751b16fc37458213f124bef161a5a02c7a39284304", size = 38529877, upload-time = "2025-10-28T17:35:51.076Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/14/9d9fbcaa1260a94f4bb5b64ba9213ceb5d03cd88841fe9fd1ffd47a45b73/scipy-1.16.3-cp313-cp313-win_arm64.whl", hash = "sha256:50a3dbf286dbc7d84f176f9a1574c705f277cb6565069f88f60db9eafdbe3ee2", size = 25455366, upload-time = "2025-10-28T17:35:59.014Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/a3/9ec205bd49f42d45d77f1730dbad9ccf146244c1647605cf834b3a8c4f36/scipy-1.16.3-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:fb4b29f4cf8cc5a8d628bc8d8e26d12d7278cd1f219f22698a378c3d67db5e4b", size = 37027931, upload-time = "2025-10-28T17:34:31.451Z" },
-    { url = "https://files.pythonhosted.org/packages/25/06/ca9fd1f3a4589cbd825b1447e5db3a8ebb969c1eaf22c8579bd286f51b6d/scipy-1.16.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:8d09d72dc92742988b0e7750bddb8060b0c7079606c0d24a8cc8e9c9c11f9079", size = 29400081, upload-time = "2025-10-28T17:34:39.087Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/56/933e68210d92657d93fb0e381683bc0e53a965048d7358ff5fbf9e6a1b17/scipy-1.16.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:03192a35e661470197556de24e7cb1330d84b35b94ead65c46ad6f16f6b28f2a", size = 21391244, upload-time = "2025-10-28T17:34:45.234Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/7e/779845db03dc1418e215726329674b40576879b91814568757ff0014ad65/scipy-1.16.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:57d01cb6f85e34f0946b33caa66e892aae072b64b034183f3d87c4025802a119", size = 23929753, upload-time = "2025-10-28T17:34:51.793Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/4b/f756cf8161d5365dcdef9e5f460ab226c068211030a175d2fc7f3f41ca64/scipy-1.16.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:96491a6a54e995f00a28a3c3badfff58fd093bf26cd5fb34a2188c8c756a3a2c", size = 33496912, upload-time = "2025-10-28T17:34:59.8Z" },
-    { url = "https://files.pythonhosted.org/packages/09/b5/222b1e49a58668f23839ca1542a6322bb095ab8d6590d4f71723869a6c2c/scipy-1.16.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cd13e354df9938598af2be05822c323e97132d5e6306b83a3b4ee6724c6e522e", size = 35802371, upload-time = "2025-10-28T17:35:08.173Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/8d/5964ef68bb31829bde27611f8c9deeac13764589fe74a75390242b64ca44/scipy-1.16.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63d3cdacb8a824a295191a723ee5e4ea7768ca5ca5f2838532d9f2e2b3ce2135", size = 36190477, upload-time = "2025-10-28T17:35:16.7Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/f2/b31d75cb9b5fa4dd39a0a931ee9b33e7f6f36f23be5ef560bf72e0f92f32/scipy-1.16.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e7efa2681ea410b10dde31a52b18b0154d66f2485328830e45fdf183af5aefc6", size = 38796678, upload-time = "2025-10-28T17:35:26.354Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/1e/b3723d8ff64ab548c38d87055483714fefe6ee20e0189b62352b5e015bb1/scipy-1.16.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2d1ae2cf0c350e7705168ff2429962a89ad90c2d49d1dd300686d8b2a5af22fc", size = 38640178, upload-time = "2025-10-28T17:35:35.304Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/f3/d854ff38789aca9b0cc23008d607ced9de4f7ab14fa1ca4329f86b3758ca/scipy-1.16.3-cp313-cp313t-win_arm64.whl", hash = "sha256:0c623a54f7b79dd88ef56da19bc2873afec9673a48f3b85b18e4d402bdd29a5a", size = 25803246, upload-time = "2025-10-28T17:35:42.155Z" },
-    { url = "https://files.pythonhosted.org/packages/99/f6/99b10fd70f2d864c1e29a28bbcaa0c6340f9d8518396542d9ea3b4aaae15/scipy-1.16.3-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:875555ce62743e1d54f06cdf22c1e0bc47b91130ac40fe5d783b6dfa114beeb6", size = 36606469, upload-time = "2025-10-28T17:36:08.741Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/74/043b54f2319f48ea940dd025779fa28ee360e6b95acb7cd188fad4391c6b/scipy-1.16.3-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:bb61878c18a470021fb515a843dc7a76961a8daceaaaa8bad1332f1bf4b54657", size = 28872043, upload-time = "2025-10-28T17:36:16.599Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/e1/24b7e50cc1c4ee6ffbcb1f27fe9f4c8b40e7911675f6d2d20955f41c6348/scipy-1.16.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f2622206f5559784fa5c4b53a950c3c7c1cf3e84ca1b9c4b6c03f062f289ca26", size = 20862952, upload-time = "2025-10-28T17:36:22.966Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/3a/3e8c01a4d742b730df368e063787c6808597ccb38636ed821d10b39ca51b/scipy-1.16.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7f68154688c515cdb541a31ef8eb66d8cd1050605be9dcd74199cbd22ac739bc", size = 23508512, upload-time = "2025-10-28T17:36:29.731Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/60/c45a12b98ad591536bfe5330cb3cfe1850d7570259303563b1721564d458/scipy-1.16.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3c820ddb80029fe9f43d61b81d8b488d3ef8ca010d15122b152db77dc94c22", size = 33413639, upload-time = "2025-10-28T17:36:37.982Z" },
-    { url = "https://files.pythonhosted.org/packages/71/bc/35957d88645476307e4839712642896689df442f3e53b0fa016ecf8a3357/scipy-1.16.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d3837938ae715fc0fe3c39c0202de3a8853aff22ca66781ddc2ade7554b7e2cc", size = 35704729, upload-time = "2025-10-28T17:36:46.547Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/15/89105e659041b1ca11c386e9995aefacd513a78493656e57789f9d9eab61/scipy-1.16.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aadd23f98f9cb069b3bd64ddc900c4d277778242e961751f77a8cb5c4b946fb0", size = 36086251, upload-time = "2025-10-28T17:36:55.161Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/87/c0ea673ac9c6cc50b3da2196d860273bc7389aa69b64efa8493bdd25b093/scipy-1.16.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b7c5f1bda1354d6a19bc6af73a649f8285ca63ac6b52e64e658a5a11d4d69800", size = 38716681, upload-time = "2025-10-28T17:37:04.1Z" },
-    { url = "https://files.pythonhosted.org/packages/91/06/837893227b043fb9b0d13e4bd7586982d8136cb249ffb3492930dab905b8/scipy-1.16.3-cp314-cp314-win_amd64.whl", hash = "sha256:e5d42a9472e7579e473879a1990327830493a7047506d58d73fc429b84c1d49d", size = 39358423, upload-time = "2025-10-28T17:38:20.005Z" },
-    { url = "https://files.pythonhosted.org/packages/95/03/28bce0355e4d34a7c034727505a02d19548549e190bedd13a721e35380b7/scipy-1.16.3-cp314-cp314-win_arm64.whl", hash = "sha256:6020470b9d00245926f2d5bb93b119ca0340f0d564eb6fbaad843eaebf9d690f", size = 26135027, upload-time = "2025-10-28T17:38:24.966Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/6f/69f1e2b682efe9de8fe9f91040f0cd32f13cfccba690512ba4c582b0bc29/scipy-1.16.3-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:e1d27cbcb4602680a49d787d90664fa4974063ac9d4134813332a8c53dbe667c", size = 37028379, upload-time = "2025-10-28T17:37:14.061Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/2d/e826f31624a5ebbab1cd93d30fd74349914753076ed0593e1d56a98c4fb4/scipy-1.16.3-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:9b9c9c07b6d56a35777a1b4cc8966118fb16cfd8daf6743867d17d36cfad2d40", size = 29400052, upload-time = "2025-10-28T17:37:21.709Z" },
-    { url = "https://files.pythonhosted.org/packages/69/27/d24feb80155f41fd1f156bf144e7e049b4e2b9dd06261a242905e3bc7a03/scipy-1.16.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:3a4c460301fb2cffb7f88528f30b3127742cff583603aa7dc964a52c463b385d", size = 21391183, upload-time = "2025-10-28T17:37:29.559Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/d3/1b229e433074c5738a24277eca520a2319aac7465eea7310ea6ae0e98ae2/scipy-1.16.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f667a4542cc8917af1db06366d3f78a5c8e83badd56409f94d1eac8d8d9133fa", size = 23930174, upload-time = "2025-10-28T17:37:36.306Z" },
-    { url = "https://files.pythonhosted.org/packages/16/9d/d9e148b0ec680c0f042581a2be79a28a7ab66c0c4946697f9e7553ead337/scipy-1.16.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f379b54b77a597aa7ee5e697df0d66903e41b9c85a6dd7946159e356319158e8", size = 33497852, upload-time = "2025-10-28T17:37:42.228Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/22/4e5f7561e4f98b7bea63cf3fd7934bff1e3182e9f1626b089a679914d5c8/scipy-1.16.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4aff59800a3b7f786b70bfd6ab551001cb553244988d7d6b8299cb1ea653b353", size = 35798595, upload-time = "2025-10-28T17:37:48.102Z" },
-    { url = "https://files.pythonhosted.org/packages/83/42/6644d714c179429fc7196857866f219fef25238319b650bb32dde7bf7a48/scipy-1.16.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:da7763f55885045036fabcebd80144b757d3db06ab0861415d1c3b7c69042146", size = 36186269, upload-time = "2025-10-28T17:37:53.72Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/70/64b4d7ca92f9cf2e6fc6aaa2eecf80bb9b6b985043a9583f32f8177ea122/scipy-1.16.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ffa6eea95283b2b8079b821dc11f50a17d0571c92b43e2b5b12764dc5f9b285d", size = 38802779, upload-time = "2025-10-28T17:37:59.393Z" },
-    { url = "https://files.pythonhosted.org/packages/61/82/8d0e39f62764cce5ffd5284131e109f07cf8955aef9ab8ed4e3aa5e30539/scipy-1.16.3-cp314-cp314t-win_amd64.whl", hash = "sha256:d9f48cafc7ce94cf9b15c6bffdc443a81a27bf7075cf2dcd5c8b40f85d10c4e7", size = 39471128, upload-time = "2025-10-28T17:38:05.259Z" },
-    { url = "https://files.pythonhosted.org/packages/64/47/a494741db7280eae6dc033510c319e34d42dd41b7ac0c7ead39354d1a2b5/scipy-1.16.3-cp314-cp314t-win_arm64.whl", hash = "sha256:21d9d6b197227a12dcbf9633320a4e34c6b0e51c57268df255a0942983bac562", size = 26464127, upload-time = "2025-10-28T17:38:11.34Z" },
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/56/3e/9cca699f3486ce6bc12ff46dc2031f1ec8eb9ccc9a320fdaf925f1417426/scipy-1.17.0.tar.gz", hash = "sha256:2591060c8e648d8b96439e111ac41fd8342fdeff1876be2e19dea3fe8930454e", size = 30396830, upload-time = "2026-01-10T21:34:23.009Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/4b/c89c131aa87cad2b77a54eb0fb94d633a842420fa7e919dc2f922037c3d8/scipy-1.17.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:2abd71643797bd8a106dff97894ff7869eeeb0af0f7a5ce02e4227c6a2e9d6fd", size = 31381316, upload-time = "2026-01-10T21:24:33.42Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/5f/a6b38f79a07d74989224d5f11b55267714707582908a5f1ae854cf9a9b84/scipy-1.17.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:ef28d815f4d2686503e5f4f00edc387ae58dfd7a2f42e348bb53359538f01558", size = 27966760, upload-time = "2026-01-10T21:24:38.911Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/20/095ad24e031ee8ed3c5975954d816b8e7e2abd731e04f8be573de8740885/scipy-1.17.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:272a9f16d6bb4667e8b50d25d71eddcc2158a214df1b566319298de0939d2ab7", size = 20138701, upload-time = "2026-01-10T21:24:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/89/11/4aad2b3858d0337756f3323f8960755704e530b27eb2a94386c970c32cbe/scipy-1.17.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:7204fddcbec2fe6598f1c5fdf027e9f259106d05202a959a9f1aecf036adc9f6", size = 22480574, upload-time = "2026-01-10T21:24:47.266Z" },
+    { url = "https://files.pythonhosted.org/packages/85/bd/f5af70c28c6da2227e510875cadf64879855193a687fb19951f0f44cfd6b/scipy-1.17.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc02c37a5639ee67d8fb646ffded6d793c06c5622d36b35cfa8fe5ececb8f042", size = 32862414, upload-time = "2026-01-10T21:24:52.566Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/df/df1457c4df3826e908879fe3d76bc5b6e60aae45f4ee42539512438cfd5d/scipy-1.17.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dac97a27520d66c12a34fd90a4fe65f43766c18c0d6e1c0a80f114d2260080e4", size = 35112380, upload-time = "2026-01-10T21:24:58.433Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/bb/88e2c16bd1dd4de19d80d7c5e238387182993c2fb13b4b8111e3927ad422/scipy-1.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ebb7446a39b3ae0fe8f416a9a3fdc6fba3f11c634f680f16a239c5187bc487c0", size = 34922676, upload-time = "2026-01-10T21:25:04.287Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ba/5120242cc735f71fc002cff0303d536af4405eb265f7c60742851e7ccfe9/scipy-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:474da16199f6af66601a01546144922ce402cb17362e07d82f5a6cf8f963e449", size = 37507599, upload-time = "2026-01-10T21:25:09.851Z" },
+    { url = "https://files.pythonhosted.org/packages/52/c8/08629657ac6c0da198487ce8cd3de78e02cfde42b7f34117d56a3fe249dc/scipy-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:255c0da161bd7b32a6c898e7891509e8a9289f0b1c6c7d96142ee0d2b114c2ea", size = 36380284, upload-time = "2026-01-10T21:25:15.632Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/4a/465f96d42c6f33ad324a40049dfd63269891db9324aa66c4a1c108c6f994/scipy-1.17.0-cp311-cp311-win_arm64.whl", hash = "sha256:85b0ac3ad17fa3be50abd7e69d583d98792d7edc08367e01445a1e2076005379", size = 24370427, upload-time = "2026-01-10T21:25:20.514Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/11/7241a63e73ba5a516f1930ac8d5b44cbbfabd35ac73a2d08ca206df007c4/scipy-1.17.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:0d5018a57c24cb1dd828bcf51d7b10e65986d549f52ef5adb6b4d1ded3e32a57", size = 31364580, upload-time = "2026-01-10T21:25:25.717Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1d/5057f812d4f6adc91a20a2d6f2ebcdb517fdbc87ae3acc5633c9b97c8ba5/scipy-1.17.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:88c22af9e5d5a4f9e027e26772cc7b5922fab8bcc839edb3ae33de404feebd9e", size = 27969012, upload-time = "2026-01-10T21:25:30.921Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/21/f6ec556c1e3b6ec4e088da667d9987bb77cc3ab3026511f427dc8451187d/scipy-1.17.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f3cd947f20fe17013d401b64e857c6b2da83cae567adbb75b9dcba865abc66d8", size = 20140691, upload-time = "2026-01-10T21:25:34.802Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/fe/5e5ad04784964ba964a96f16c8d4676aa1b51357199014dce58ab7ec5670/scipy-1.17.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e8c0b331c2c1f531eb51f1b4fc9ba709521a712cce58f1aa627bc007421a5306", size = 22463015, upload-time = "2026-01-10T21:25:39.277Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/69/7c347e857224fcaf32a34a05183b9d8a7aca25f8f2d10b8a698b8388561a/scipy-1.17.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5194c445d0a1c7a6c1a4a4681b6b7c71baad98ff66d96b949097e7513c9d6742", size = 32724197, upload-time = "2026-01-10T21:25:44.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/fe/66d73b76d378ba8cc2fe605920c0c75092e3a65ae746e1e767d9d020a75a/scipy-1.17.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9eeb9b5f5997f75507814ed9d298ab23f62cf79f5a3ef90031b1ee2506abdb5b", size = 35009148, upload-time = "2026-01-10T21:25:50.591Z" },
+    { url = "https://files.pythonhosted.org/packages/af/07/07dec27d9dc41c18d8c43c69e9e413431d20c53a0339c388bcf72f353c4b/scipy-1.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:40052543f7bbe921df4408f46003d6f01c6af109b9e2c8a66dd1cf6cf57f7d5d", size = 34798766, upload-time = "2026-01-10T21:25:59.41Z" },
+    { url = "https://files.pythonhosted.org/packages/81/61/0470810c8a093cdacd4ba7504b8a218fd49ca070d79eca23a615f5d9a0b0/scipy-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0cf46c8013fec9d3694dc572f0b54100c28405d55d3e2cb15e2895b25057996e", size = 37405953, upload-time = "2026-01-10T21:26:07.75Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ce/672ed546f96d5d41ae78c4b9b02006cedd0b3d6f2bf5bb76ea455c320c28/scipy-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:0937a0b0d8d593a198cededd4c439a0ea216a3f36653901ea1f3e4be949056f8", size = 36328121, upload-time = "2026-01-10T21:26:16.509Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/38165845392cae67b61843a52c6455d47d0cc2a40dd495c89f4362944654/scipy-1.17.0-cp312-cp312-win_arm64.whl", hash = "sha256:f603d8a5518c7426414d1d8f82e253e454471de682ce5e39c29adb0df1efb86b", size = 24314368, upload-time = "2026-01-10T21:26:23.087Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/51/3468fdfd49387ddefee1636f5cf6d03ce603b75205bf439bbf0e62069bfd/scipy-1.17.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:65ec32f3d32dfc48c72df4291345dae4f048749bc8d5203ee0a3f347f96c5ce6", size = 31344101, upload-time = "2026-01-10T21:26:30.25Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/9406aec58268d437636069419e6977af953d1e246df941d42d3720b7277b/scipy-1.17.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:1f9586a58039d7229ce77b52f8472c972448cded5736eaf102d5658bbac4c269", size = 27950385, upload-time = "2026-01-10T21:26:36.801Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/98/e7342709e17afdfd1b26b56ae499ef4939b45a23a00e471dfb5375eea205/scipy-1.17.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9fad7d3578c877d606b1150135c2639e9de9cecd3705caa37b66862977cc3e72", size = 20122115, upload-time = "2026-01-10T21:26:42.107Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/0e/9eeeb5357a64fd157cbe0302c213517c541cc16b8486d82de251f3c68ede/scipy-1.17.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:423ca1f6584fc03936972b5f7c06961670dbba9f234e71676a7c7ccf938a0d61", size = 22442402, upload-time = "2026-01-10T21:26:48.029Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/10/be13397a0e434f98e0c79552b2b584ae5bb1c8b2be95db421533bbca5369/scipy-1.17.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe508b5690e9eaaa9467fc047f833af58f1152ae51a0d0aed67aa5801f4dd7d6", size = 32696338, upload-time = "2026-01-10T21:26:55.521Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1e/12fbf2a3bb240161651c94bb5cdd0eae5d4e8cc6eaeceb74ab07b12a753d/scipy-1.17.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6680f2dfd4f6182e7d6db161344537da644d1cf85cf293f015c60a17ecf08752", size = 34977201, upload-time = "2026-01-10T21:27:03.501Z" },
+    { url = "https://files.pythonhosted.org/packages/19/5b/1a63923e23ccd20bd32156d7dd708af5bbde410daa993aa2500c847ab2d2/scipy-1.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eec3842ec9ac9de5917899b277428886042a93db0b227ebbe3a333b64ec7643d", size = 34777384, upload-time = "2026-01-10T21:27:11.423Z" },
+    { url = "https://files.pythonhosted.org/packages/39/22/b5da95d74edcf81e540e467202a988c50fef41bd2011f46e05f72ba07df6/scipy-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d7425fcafbc09a03731e1bc05581f5fad988e48c6a861f441b7ab729a49a55ea", size = 37379586, upload-time = "2026-01-10T21:27:20.171Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/b6/8ac583d6da79e7b9e520579f03007cb006f063642afd6b2eeb16b890bf93/scipy-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:87b411e42b425b84777718cc41516b8a7e0795abfa8e8e1d573bf0ef014f0812", size = 36287211, upload-time = "2026-01-10T21:28:43.122Z" },
+    { url = "https://files.pythonhosted.org/packages/55/fb/7db19e0b3e52f882b420417644ec81dd57eeef1bd1705b6f689d8ff93541/scipy-1.17.0-cp313-cp313-win_arm64.whl", hash = "sha256:357ca001c6e37601066092e7c89cca2f1ce74e2a520ca78d063a6d2201101df2", size = 24312646, upload-time = "2026-01-10T21:28:49.893Z" },
+    { url = "https://files.pythonhosted.org/packages/20/b6/7feaa252c21cc7aff335c6c55e1b90ab3e3306da3f048109b8b639b94648/scipy-1.17.0-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:ec0827aa4d36cb79ff1b81de898e948a51ac0b9b1c43e4a372c0508c38c0f9a3", size = 31693194, upload-time = "2026-01-10T21:27:27.454Z" },
+    { url = "https://files.pythonhosted.org/packages/76/bb/bbb392005abce039fb7e672cb78ac7d158700e826b0515cab6b5b60c26fb/scipy-1.17.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:819fc26862b4b3c73a60d486dbb919202f3d6d98c87cf20c223511429f2d1a97", size = 28365415, upload-time = "2026-01-10T21:27:34.26Z" },
+    { url = "https://files.pythonhosted.org/packages/37/da/9d33196ecc99fba16a409c691ed464a3a283ac454a34a13a3a57c0d66f3a/scipy-1.17.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:363ad4ae2853d88ebcde3ae6ec46ccca903ea9835ee8ba543f12f575e7b07e4e", size = 20537232, upload-time = "2026-01-10T21:27:40.306Z" },
+    { url = "https://files.pythonhosted.org/packages/56/9d/f4b184f6ddb28e9a5caea36a6f98e8ecd2a524f9127354087ce780885d83/scipy-1.17.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:979c3a0ff8e5ba254d45d59ebd38cde48fce4f10b5125c680c7a4bfe177aab07", size = 22791051, upload-time = "2026-01-10T21:27:46.539Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/9d/025cccdd738a72140efc582b1641d0dd4caf2e86c3fb127568dc80444e6e/scipy-1.17.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:130d12926ae34399d157de777472bf82e9061c60cc081372b3118edacafe1d00", size = 32815098, upload-time = "2026-01-10T21:27:54.389Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5f/09b879619f8bca15ce392bfc1894bd9c54377e01d1b3f2f3b595a1b4d945/scipy-1.17.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e886000eb4919eae3a44f035e63f0fd8b651234117e8f6f29bad1cd26e7bc45", size = 35031342, upload-time = "2026-01-10T21:28:03.012Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/9a/f0f0a9f0aa079d2f106555b984ff0fbb11a837df280f04f71f056ea9c6e4/scipy-1.17.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:13c4096ac6bc31d706018f06a49abe0485f96499deb82066b94d19b02f664209", size = 34893199, upload-time = "2026-01-10T21:28:10.832Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b8/4f0f5cf0c5ea4d7548424e6533e6b17d164f34a6e2fb2e43ffebb6697b06/scipy-1.17.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cacbaddd91fcffde703934897c5cd2c7cb0371fac195d383f4e1f1c5d3f3bd04", size = 37438061, upload-time = "2026-01-10T21:28:19.684Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/cc/2bd59140ed3b2fa2882fb15da0a9cb1b5a6443d67cfd0d98d4cec83a57ec/scipy-1.17.0-cp313-cp313t-win_amd64.whl", hash = "sha256:edce1a1cf66298cccdc48a1bdf8fb10a3bf58e8b58d6c3883dd1530e103f87c0", size = 36328593, upload-time = "2026-01-10T21:28:28.007Z" },
+    { url = "https://files.pythonhosted.org/packages/13/1b/c87cc44a0d2c7aaf0f003aef2904c3d097b422a96c7e7c07f5efd9073c1b/scipy-1.17.0-cp313-cp313t-win_arm64.whl", hash = "sha256:30509da9dbec1c2ed8f168b8d8aa853bc6723fede1dbc23c7d43a56f5ab72a67", size = 24625083, upload-time = "2026-01-10T21:28:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/2d/51006cd369b8e7879e1c630999a19d1fbf6f8b5ed3e33374f29dc87e53b3/scipy-1.17.0-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:c17514d11b78be8f7e6331b983a65a7f5ca1fd037b95e27b280921fe5606286a", size = 31346803, upload-time = "2026-01-10T21:28:57.24Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/2e/2349458c3ce445f53a6c93d4386b1c4c5c0c540917304c01222ff95ff317/scipy-1.17.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:4e00562e519c09da34c31685f6acc3aa384d4d50604db0f245c14e1b4488bfa2", size = 27967182, upload-time = "2026-01-10T21:29:04.107Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/7c/df525fbfa77b878d1cfe625249529514dc02f4fd5f45f0f6295676a76528/scipy-1.17.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f7df7941d71314e60a481e02d5ebcb3f0185b8d799c70d03d8258f6c80f3d467", size = 20139125, upload-time = "2026-01-10T21:29:10.179Z" },
+    { url = "https://files.pythonhosted.org/packages/33/11/fcf9d43a7ed1234d31765ec643b0515a85a30b58eddccc5d5a4d12b5f194/scipy-1.17.0-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:aabf057c632798832f071a8dde013c2e26284043934f53b00489f1773b33527e", size = 22443554, upload-time = "2026-01-10T21:29:15.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/5c/ea5d239cda2dd3d31399424967a24d556cf409fbea7b5b21412b0fd0a44f/scipy-1.17.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a38c3337e00be6fd8a95b4ed66b5d988bac4ec888fd922c2ea9fe5fb1603dd67", size = 32757834, upload-time = "2026-01-10T21:29:23.406Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/7e/8c917cc573310e5dc91cbeead76f1b600d3fb17cf0969db02c9cf92e3cfa/scipy-1.17.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00fb5f8ec8398ad90215008d8b6009c9db9fa924fd4c7d6be307c6f945f9cd73", size = 34995775, upload-time = "2026-01-10T21:29:31.915Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/43/176c0c3c07b3f7df324e7cdd933d3e2c4898ca202b090bd5ba122f9fe270/scipy-1.17.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f2a4942b0f5f7c23c7cd641a0ca1955e2ae83dedcff537e3a0259096635e186b", size = 34841240, upload-time = "2026-01-10T21:29:39.995Z" },
+    { url = "https://files.pythonhosted.org/packages/44/8c/d1f5f4b491160592e7f084d997de53a8e896a3ac01cd07e59f43ca222744/scipy-1.17.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dbf133ced83889583156566d2bdf7a07ff89228fe0c0cb727f777de92092ec6b", size = 37394463, upload-time = "2026-01-10T21:29:48.723Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ec/42a6657f8d2d087e750e9a5dde0b481fd135657f09eaf1cf5688bb23c338/scipy-1.17.0-cp314-cp314-win_amd64.whl", hash = "sha256:3625c631a7acd7cfd929e4e31d2582cf00f42fcf06011f59281271746d77e061", size = 37053015, upload-time = "2026-01-10T21:30:51.418Z" },
+    { url = "https://files.pythonhosted.org/packages/27/58/6b89a6afd132787d89a362d443a7bddd511b8f41336a1ae47f9e4f000dc4/scipy-1.17.0-cp314-cp314-win_arm64.whl", hash = "sha256:9244608d27eafe02b20558523ba57f15c689357c85bdcfe920b1828750aa26eb", size = 24951312, upload-time = "2026-01-10T21:30:56.771Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/01/f58916b9d9ae0112b86d7c3b10b9e685625ce6e8248df139d0fcb17f7397/scipy-1.17.0-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:2b531f57e09c946f56ad0b4a3b2abee778789097871fc541e267d2eca081cff1", size = 31706502, upload-time = "2026-01-10T21:29:56.326Z" },
+    { url = "https://files.pythonhosted.org/packages/59/8e/2912a87f94a7d1f8b38aabc0faf74b82d3b6c9e22be991c49979f0eceed8/scipy-1.17.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:13e861634a2c480bd237deb69333ac79ea1941b94568d4b0efa5db5e263d4fd1", size = 28380854, upload-time = "2026-01-10T21:30:01.554Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/1c/874137a52dddab7d5d595c1887089a2125d27d0601fce8c0026a24a92a0b/scipy-1.17.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:eb2651271135154aa24f6481cbae5cc8af1f0dd46e6533fb7b56aa9727b6a232", size = 20552752, upload-time = "2026-01-10T21:30:05.93Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/f0/7518d171cb735f6400f4576cf70f756d5b419a07fe1867da34e2c2c9c11b/scipy-1.17.0-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:c5e8647f60679790c2f5c76be17e2e9247dc6b98ad0d3b065861e082c56e078d", size = 22803972, upload-time = "2026-01-10T21:30:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/74/3498563a2c619e8a3ebb4d75457486c249b19b5b04a30600dfd9af06bea5/scipy-1.17.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5fb10d17e649e1446410895639f3385fd2bf4c3c7dfc9bea937bddcbc3d7b9ba", size = 32829770, upload-time = "2026-01-10T21:30:16.359Z" },
+    { url = "https://files.pythonhosted.org/packages/48/d1/7b50cedd8c6c9d6f706b4b36fa8544d829c712a75e370f763b318e9638c1/scipy-1.17.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8547e7c57f932e7354a2319fab613981cde910631979f74c9b542bb167a8b9db", size = 35051093, upload-time = "2026-01-10T21:30:22.987Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/82/a2d684dfddb87ba1b3ea325df7c3293496ee9accb3a19abe9429bce94755/scipy-1.17.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33af70d040e8af9d5e7a38b5ed3b772adddd281e3062ff23fec49e49681c38cf", size = 34909905, upload-time = "2026-01-10T21:30:28.704Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/5e/e565bd73991d42023eb82bb99e51c5b3d9e2c588ca9d4b3e2cc1d3ca62a6/scipy-1.17.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb55bb97d00f8b7ab95cb64f873eb0bf54d9446264d9f3609130381233483f", size = 37457743, upload-time = "2026-01-10T21:30:34.819Z" },
+    { url = "https://files.pythonhosted.org/packages/58/a8/a66a75c3d8f1fb2b83f66007d6455a06a6f6cf5618c3dc35bc9b69dd096e/scipy-1.17.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1ff269abf702f6c7e67a4b7aad981d42871a11b9dd83c58d2d2ea624efbd1088", size = 37098574, upload-time = "2026-01-10T21:30:40.782Z" },
+    { url = "https://files.pythonhosted.org/packages/56/a5/df8f46ef7da168f1bc52cd86e09a9de5c6f19cc1da04454d51b7d4f43408/scipy-1.17.0-cp314-cp314t-win_arm64.whl", hash = "sha256:031121914e295d9791319a1875444d55079885bbae5bdc9c5e0f2ee5f09d34ff", size = 25246266, upload-time = "2026-01-10T21:30:45.923Z" },
 ]
 
 [[package]]
 name = "secretstorage"
-version = "3.4.1"
+version = "3.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cryptography" },
-    { name = "jeepney" },
+    { name = "cryptography", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
+    { name = "jeepney", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/32/8a/ed6747b1cc723c81f526d4c12c1b1d43d07190e1e8258dbf934392fc850e/secretstorage-3.4.1.tar.gz", hash = "sha256:a799acf5be9fb93db609ebaa4ab6e8f1f3ed5ae640e0fa732bfea59e9c3b50e8", size = 19871, upload-time = "2025-11-11T11:30:23.798Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b0/6d/24ebb101484f1911a6be6695b76ce43219caa110ebbe07d8c3a5f3106cca/secretstorage-3.4.1-py3-none-any.whl", hash = "sha256:c55d57b4da3de568d8c3af89dad244ab24c35ca1da8625fc1b550edf005ebc41", size = 15301, upload-time = "2025-11-11T11:30:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" },
+]
+
+[[package]]
+name = "send2trash"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" },
 ]
 
 [[package]]
 name = "setuptools"
-version = "80.9.0"
+version = "82.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/f3/748f4d6f65d1756b9ae577f329c951cda23fb900e4de9f70900ced962085/setuptools-82.0.0.tar.gz", hash = "sha256:22e0a2d69474c6ae4feb01951cb69d515ed23728cf96d05513d36e42b62b37cb", size = 1144893, upload-time = "2026-02-08T15:08:40.206Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/c6/76dc613121b793286a3f91621d7b75a2b493e0390ddca50f11993eadf192/setuptools-82.0.0-py3-none-any.whl", hash = "sha256:70b18734b607bd1da571d097d236cfcfacaf01de45717d59e6e04b96877532e0", size = 1003468, upload-time = "2026-02-08T15:08:38.723Z" },
 ]
 
 [[package]]
@@ -2019,7 +3148,7 @@ version = "2.1.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" }
 wheels = [
@@ -2092,21 +3221,36 @@ wheels = [
 
 [[package]]
 name = "skeliner"
-version = "0.2.3"
+version = "0.2.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "igraph" },
+    { name = "jupyter" },
+    { name = "jupyterlab" },
     { name = "matplotlib" },
+    { name = "notebook" },
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "pandas", version = "3.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "pytest" },
     { name = "rtree" },
     { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.16.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "trimesh" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/25/adf21a73130789d6373659fc207b271a5e61e5a2a5ac5168bcd5a47c9e84/skeliner-0.2.3.tar.gz", hash = "sha256:c578e995396fae8c91aa6785188c4ba5f2539d6b3bb91c584d6c17acd78ca489", size = 11507850, upload-time = "2025-11-14T13:49:20.272Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/cf/f310ec06998e6519c3657d4710eb98ca0d478d38d8b12b27ff37b5b6d9a6/skeliner-0.2.6.tar.gz", hash = "sha256:03427498fba145980fedd1e3ebf80b35a150a925b3b21810973704c036edec6c", size = 12069336, upload-time = "2026-01-22T13:20:04.726Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/3b/59fd260c91040b56ea8e6d1f3826273654a6a2dcddf7168c08555e2ec4b7/skeliner-0.2.3-py3-none-any.whl", hash = "sha256:7de9fd7567932d1f6a050045b6307b6543365052f07570050ca70caf869b36e4", size = 107024, upload-time = "2025-11-14T13:49:18.902Z" },
+    { url = "https://files.pythonhosted.org/packages/54/8f/9a20d1da376de5e5a58f1e2a4c7b8078a282ebf35ef1ef0a397a9dc638c1/skeliner-0.2.6-py3-none-any.whl", hash = "sha256:bfbd6b6e6d76f7b059720098d7b77c074243b815546abfcf9c0ce9250321748a", size = 112797, upload-time = "2026-01-22T13:20:02.408Z" },
+]
+
+[[package]]
+name = "soupsieve"
+version = "2.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/ae/2d9c981590ed9999a0d91755b47fc74f74de286b0f5cee14c9269041e6c4/soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349", size = 118627, upload-time = "2026-01-20T04:27:02.457Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95", size = 37016, upload-time = "2026-01-20T04:27:01.012Z" },
 ]
 
 [[package]]
@@ -2123,6 +3267,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
 ]
 
+[[package]]
+name = "terminado"
+version = "0.18.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ptyprocess", marker = "os_name != 'nt'" },
+    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "tornado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" },
+]
+
 [[package]]
 name = "texttable"
 version = "1.7.0"
@@ -2133,71 +3291,88 @@ wheels = [
 ]
 
 [[package]]
-name = "tomli"
-version = "2.3.0"
+name = "tinycss2"
+version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/52/ed/3f73f72945444548f33eba9a87fc7a6e969915e7b1acc8260b30e1f76a2f/tomli-2.3.0.tar.gz", hash = "sha256:64be704a875d2a59753d80ee8a533c3fe183e3f06807ff7dc2232938ccb01549", size = 17392, upload-time = "2025-10-08T22:01:47.119Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/2e/299f62b401438d5fe1624119c723f5d877acc86a4c2492da405626665f12/tomli-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:88bd15eb972f3664f5ed4b57c1634a97153b4bac4479dcb6a495f41921eb7f45", size = 153236, upload-time = "2025-10-08T22:01:00.137Z" },
-    { url = "https://files.pythonhosted.org/packages/86/7f/d8fffe6a7aefdb61bced88fcb5e280cfd71e08939da5894161bd71bea022/tomli-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:883b1c0d6398a6a9d29b508c331fa56adbcdff647f6ace4dfca0f50e90dfd0ba", size = 148084, upload-time = "2025-10-08T22:01:01.63Z" },
-    { url = "https://files.pythonhosted.org/packages/47/5c/24935fb6a2ee63e86d80e4d3b58b222dafaf438c416752c8b58537c8b89a/tomli-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1381caf13ab9f300e30dd8feadb3de072aeb86f1d34a8569453ff32a7dea4bf", size = 234832, upload-time = "2025-10-08T22:01:02.543Z" },
-    { url = "https://files.pythonhosted.org/packages/89/da/75dfd804fc11e6612846758a23f13271b76d577e299592b4371a4ca4cd09/tomli-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0e285d2649b78c0d9027570d4da3425bdb49830a6156121360b3f8511ea3441", size = 242052, upload-time = "2025-10-08T22:01:03.836Z" },
-    { url = "https://files.pythonhosted.org/packages/70/8c/f48ac899f7b3ca7eb13af73bacbc93aec37f9c954df3c08ad96991c8c373/tomli-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a154a9ae14bfcf5d8917a59b51ffd5a3ac1fd149b71b47a3a104ca4edcfa845", size = 239555, upload-time = "2025-10-08T22:01:04.834Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/28/72f8afd73f1d0e7829bfc093f4cb98ce0a40ffc0cc997009ee1ed94ba705/tomli-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:74bf8464ff93e413514fefd2be591c3b0b23231a77f901db1eb30d6f712fc42c", size = 245128, upload-time = "2025-10-08T22:01:05.84Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/eb/a7679c8ac85208706d27436e8d421dfa39d4c914dcf5fa8083a9305f58d9/tomli-2.3.0-cp311-cp311-win32.whl", hash = "sha256:00b5f5d95bbfc7d12f91ad8c593a1659b6387b43f054104cda404be6bda62456", size = 96445, upload-time = "2025-10-08T22:01:06.896Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/fe/3d3420c4cb1ad9cb462fb52967080575f15898da97e21cb6f1361d505383/tomli-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:4dc4ce8483a5d429ab602f111a93a6ab1ed425eae3122032db7e9acf449451be", size = 107165, upload-time = "2025-10-08T22:01:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/b7/40f36368fcabc518bb11c8f06379a0fd631985046c038aca08c6d6a43c6e/tomli-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d7d86942e56ded512a594786a5ba0a5e521d02529b3826e7761a05138341a2ac", size = 154891, upload-time = "2025-10-08T22:01:09.082Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/3f/d9dd692199e3b3aab2e4e4dd948abd0f790d9ded8cd10cbaae276a898434/tomli-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:73ee0b47d4dad1c5e996e3cd33b8a76a50167ae5f96a2607cbe8cc773506ab22", size = 148796, upload-time = "2025-10-08T22:01:10.266Z" },
-    { url = "https://files.pythonhosted.org/packages/60/83/59bff4996c2cf9f9387a0f5a3394629c7efa5ef16142076a23a90f1955fa/tomli-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:792262b94d5d0a466afb5bc63c7daa9d75520110971ee269152083270998316f", size = 242121, upload-time = "2025-10-08T22:01:11.332Z" },
-    { url = "https://files.pythonhosted.org/packages/45/e5/7c5119ff39de8693d6baab6c0b6dcb556d192c165596e9fc231ea1052041/tomli-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f195fe57ecceac95a66a75ac24d9d5fbc98ef0962e09b2eddec5d39375aae52", size = 250070, upload-time = "2025-10-08T22:01:12.498Z" },
-    { url = "https://files.pythonhosted.org/packages/45/12/ad5126d3a278f27e6701abde51d342aa78d06e27ce2bb596a01f7709a5a2/tomli-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e31d432427dcbf4d86958c184b9bfd1e96b5b71f8eb17e6d02531f434fd335b8", size = 245859, upload-time = "2025-10-08T22:01:13.551Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/a1/4d6865da6a71c603cfe6ad0e6556c73c76548557a8d658f9e3b142df245f/tomli-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b0882799624980785240ab732537fcfc372601015c00f7fc367c55308c186f6", size = 250296, upload-time = "2025-10-08T22:01:14.614Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/b7/a7a7042715d55c9ba6e8b196d65d2cb662578b4d8cd17d882d45322b0d78/tomli-2.3.0-cp312-cp312-win32.whl", hash = "sha256:ff72b71b5d10d22ecb084d345fc26f42b5143c5533db5e2eaba7d2d335358876", size = 97124, upload-time = "2025-10-08T22:01:15.629Z" },
-    { url = "https://files.pythonhosted.org/packages/06/1e/f22f100db15a68b520664eb3328fb0ae4e90530887928558112c8d1f4515/tomli-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:1cb4ed918939151a03f33d4242ccd0aa5f11b3547d0cf30f7c74a408a5b99878", size = 107698, upload-time = "2025-10-08T22:01:16.51Z" },
-    { url = "https://files.pythonhosted.org/packages/89/48/06ee6eabe4fdd9ecd48bf488f4ac783844fd777f547b8d1b61c11939974e/tomli-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5192f562738228945d7b13d4930baffda67b69425a7f0da96d360b0a3888136b", size = 154819, upload-time = "2025-10-08T22:01:17.964Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/01/88793757d54d8937015c75dcdfb673c65471945f6be98e6a0410fba167ed/tomli-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be71c93a63d738597996be9528f4abe628d1adf5e6eb11607bc8fe1a510b5dae", size = 148766, upload-time = "2025-10-08T22:01:18.959Z" },
-    { url = "https://files.pythonhosted.org/packages/42/17/5e2c956f0144b812e7e107f94f1cc54af734eb17b5191c0bbfb72de5e93e/tomli-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4665508bcbac83a31ff8ab08f424b665200c0e1e645d2bd9ab3d3e557b6185b", size = 240771, upload-time = "2025-10-08T22:01:20.106Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/f4/0fbd014909748706c01d16824eadb0307115f9562a15cbb012cd9b3512c5/tomli-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4021923f97266babc6ccab9f5068642a0095faa0a51a246a6a02fccbb3514eaf", size = 248586, upload-time = "2025-10-08T22:01:21.164Z" },
-    { url = "https://files.pythonhosted.org/packages/30/77/fed85e114bde5e81ecf9bc5da0cc69f2914b38f4708c80ae67d0c10180c5/tomli-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4ea38c40145a357d513bffad0ed869f13c1773716cf71ccaa83b0fa0cc4e42f", size = 244792, upload-time = "2025-10-08T22:01:22.417Z" },
-    { url = "https://files.pythonhosted.org/packages/55/92/afed3d497f7c186dc71e6ee6d4fcb0acfa5f7d0a1a2878f8beae379ae0cc/tomli-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ad805ea85eda330dbad64c7ea7a4556259665bdf9d2672f5dccc740eb9d3ca05", size = 248909, upload-time = "2025-10-08T22:01:23.859Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/84/ef50c51b5a9472e7265ce1ffc7f24cd4023d289e109f669bdb1553f6a7c2/tomli-2.3.0-cp313-cp313-win32.whl", hash = "sha256:97d5eec30149fd3294270e889b4234023f2c69747e555a27bd708828353ab606", size = 96946, upload-time = "2025-10-08T22:01:24.893Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/b7/718cd1da0884f281f95ccfa3a6cc572d30053cba64603f79d431d3c9b61b/tomli-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0c95ca56fbe89e065c6ead5b593ee64b84a26fca063b5d71a1122bf26e533999", size = 107705, upload-time = "2025-10-08T22:01:26.153Z" },
-    { url = "https://files.pythonhosted.org/packages/19/94/aeafa14a52e16163008060506fcb6aa1949d13548d13752171a755c65611/tomli-2.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cebc6fe843e0733ee827a282aca4999b596241195f43b4cc371d64fc6639da9e", size = 154244, upload-time = "2025-10-08T22:01:27.06Z" },
-    { url = "https://files.pythonhosted.org/packages/db/e4/1e58409aa78eefa47ccd19779fc6f36787edbe7d4cd330eeeedb33a4515b/tomli-2.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4c2ef0244c75aba9355561272009d934953817c49f47d768070c3c94355c2aa3", size = 148637, upload-time = "2025-10-08T22:01:28.059Z" },
-    { url = "https://files.pythonhosted.org/packages/26/b6/d1eccb62f665e44359226811064596dd6a366ea1f985839c566cd61525ae/tomli-2.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c22a8bf253bacc0cf11f35ad9808b6cb75ada2631c2d97c971122583b129afbc", size = 241925, upload-time = "2025-10-08T22:01:29.066Z" },
-    { url = "https://files.pythonhosted.org/packages/70/91/7cdab9a03e6d3d2bb11beae108da5bdc1c34bdeb06e21163482544ddcc90/tomli-2.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0eea8cc5c5e9f89c9b90c4896a8deefc74f518db5927d0e0e8d4a80953d774d0", size = 249045, upload-time = "2025-10-08T22:01:31.98Z" },
-    { url = "https://files.pythonhosted.org/packages/15/1b/8c26874ed1f6e4f1fcfeb868db8a794cbe9f227299402db58cfcc858766c/tomli-2.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b74a0e59ec5d15127acdabd75ea17726ac4c5178ae51b85bfe39c4f8a278e879", size = 245835, upload-time = "2025-10-08T22:01:32.989Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/42/8e3c6a9a4b1a1360c1a2a39f0b972cef2cc9ebd56025168c4137192a9321/tomli-2.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b5870b50c9db823c595983571d1296a6ff3e1b88f734a4c8f6fc6188397de005", size = 253109, upload-time = "2025-10-08T22:01:34.052Z" },
-    { url = "https://files.pythonhosted.org/packages/22/0c/b4da635000a71b5f80130937eeac12e686eefb376b8dee113b4a582bba42/tomli-2.3.0-cp314-cp314-win32.whl", hash = "sha256:feb0dacc61170ed7ab602d3d972a58f14ee3ee60494292d384649a3dc38ef463", size = 97930, upload-time = "2025-10-08T22:01:35.082Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/74/cb1abc870a418ae99cd5c9547d6bce30701a954e0e721821df483ef7223c/tomli-2.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:b273fcbd7fc64dc3600c098e39136522650c49bca95df2d11cf3b626422392c8", size = 107964, upload-time = "2025-10-08T22:01:36.057Z" },
-    { url = "https://files.pythonhosted.org/packages/54/78/5c46fff6432a712af9f792944f4fcd7067d8823157949f4e40c56b8b3c83/tomli-2.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:940d56ee0410fa17ee1f12b817b37a4d4e4dc4d27340863cc67236c74f582e77", size = 163065, upload-time = "2025-10-08T22:01:37.27Z" },
-    { url = "https://files.pythonhosted.org/packages/39/67/f85d9bd23182f45eca8939cd2bc7050e1f90c41f4a2ecbbd5963a1d1c486/tomli-2.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f85209946d1fe94416debbb88d00eb92ce9cd5266775424ff81bc959e001acaf", size = 159088, upload-time = "2025-10-08T22:01:38.235Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5a/4b546a0405b9cc0659b399f12b6adb750757baf04250b148d3c5059fc4eb/tomli-2.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a56212bdcce682e56b0aaf79e869ba5d15a6163f88d5451cbde388d48b13f530", size = 268193, upload-time = "2025-10-08T22:01:39.712Z" },
-    { url = "https://files.pythonhosted.org/packages/42/4f/2c12a72ae22cf7b59a7fe75b3465b7aba40ea9145d026ba41cb382075b0e/tomli-2.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5f3ffd1e098dfc032d4d3af5c0ac64f6d286d98bc148698356847b80fa4de1b", size = 275488, upload-time = "2025-10-08T22:01:40.773Z" },
-    { url = "https://files.pythonhosted.org/packages/92/04/a038d65dbe160c3aa5a624e93ad98111090f6804027d474ba9c37c8ae186/tomli-2.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e01decd096b1530d97d5d85cb4dff4af2d8347bd35686654a004f8dea20fc67", size = 272669, upload-time = "2025-10-08T22:01:41.824Z" },
-    { url = "https://files.pythonhosted.org/packages/be/2f/8b7c60a9d1612a7cbc39ffcca4f21a73bf368a80fc25bccf8253e2563267/tomli-2.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8a35dd0e643bb2610f156cca8db95d213a90015c11fee76c946aa62b7ae7e02f", size = 279709, upload-time = "2025-10-08T22:01:43.177Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/46/cc36c679f09f27ded940281c38607716c86cf8ba4a518d524e349c8b4874/tomli-2.3.0-cp314-cp314t-win32.whl", hash = "sha256:a1f7f282fe248311650081faafa5f4732bdbfef5d45fe3f2e702fbc6f2d496e0", size = 107563, upload-time = "2025-10-08T22:01:44.233Z" },
-    { url = "https://files.pythonhosted.org/packages/84/ff/426ca8683cf7b753614480484f6437f568fd2fda2edbdf57a2d3d8b27a0b/tomli-2.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:70a251f8d4ba2d9ac2542eecf008b3c8a9fc5c3f9f02c56a9d7952612be2fdba", size = 119756, upload-time = "2025-10-08T22:01:45.234Z" },
-    { url = "https://files.pythonhosted.org/packages/77/b8/0135fadc89e73be292b473cb820b4f5a08197779206b33191e801feeae40/tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b", size = 14408, upload-time = "2025-10-08T22:01:46.04Z" },
+dependencies = [
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
+    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
+    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
+    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
+    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
+    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
+    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
+    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
+    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
+    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
 ]
 
 [[package]]
 name = "tornado"
-version = "6.5.2"
+version = "6.5.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/09/ce/1eb500eae19f4648281bb2186927bb062d2438c2e5093d1360391afd2f90/tornado-6.5.2.tar.gz", hash = "sha256:ab53c8f9a0fa351e2c0741284e06c7a45da86afb544133201c5cc8578eb076a0", size = 510821, upload-time = "2025-08-08T18:27:00.78Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/1d/0a336abf618272d53f62ebe274f712e213f5a03c0b2339575430b8362ef2/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7", size = 513632, upload-time = "2025-12-15T19:21:03.836Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f6/48/6a7529df2c9cc12efd2e8f5dd219516184d703b34c06786809670df5b3bd/tornado-6.5.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2436822940d37cde62771cff8774f4f00b3c8024fe482e16ca8387b8a2724db6", size = 442563, upload-time = "2025-08-08T18:26:42.945Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/b5/9b575a0ed3e50b00c40b08cbce82eb618229091d09f6d14bce80fc01cb0b/tornado-6.5.2-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:583a52c7aa94ee046854ba81d9ebb6c81ec0fd30386d96f7640c96dad45a03ef", size = 440729, upload-time = "2025-08-08T18:26:44.473Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/4e/619174f52b120efcf23633c817fd3fed867c30bff785e2cd5a53a70e483c/tornado-6.5.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0fe179f28d597deab2842b86ed4060deec7388f1fd9c1b4a41adf8af058907e", size = 444295, upload-time = "2025-08-08T18:26:46.021Z" },
-    { url = "https://files.pythonhosted.org/packages/95/fa/87b41709552bbd393c85dd18e4e3499dcd8983f66e7972926db8d96aa065/tornado-6.5.2-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b186e85d1e3536d69583d2298423744740986018e393d0321df7340e71898882", size = 443644, upload-time = "2025-08-08T18:26:47.625Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/41/fb15f06e33d7430ca89420283a8762a4e6b8025b800ea51796ab5e6d9559/tornado-6.5.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e792706668c87709709c18b353da1f7662317b563ff69f00bab83595940c7108", size = 443878, upload-time = "2025-08-08T18:26:50.599Z" },
-    { url = "https://files.pythonhosted.org/packages/11/92/fe6d57da897776ad2e01e279170ea8ae726755b045fe5ac73b75357a5a3f/tornado-6.5.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:06ceb1300fd70cb20e43b1ad8aaee0266e69e7ced38fa910ad2e03285009ce7c", size = 444549, upload-time = "2025-08-08T18:26:51.864Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/02/c8f4f6c9204526daf3d760f4aa555a7a33ad0e60843eac025ccfd6ff4a93/tornado-6.5.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:74db443e0f5251be86cbf37929f84d8c20c27a355dd452a5cfa2aada0d001ec4", size = 443973, upload-time = "2025-08-08T18:26:53.625Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/2d/f5f5707b655ce2317190183868cd0f6822a1121b4baeae509ceb9590d0bd/tornado-6.5.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b5e735ab2889d7ed33b32a459cac490eda71a1ba6857b0118de476ab6c366c04", size = 443954, upload-time = "2025-08-08T18:26:55.072Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/59/593bd0f40f7355806bf6573b47b8c22f8e1374c9b6fd03114bd6b7a3dcfd/tornado-6.5.2-cp39-abi3-win32.whl", hash = "sha256:c6f29e94d9b37a95013bb669616352ddb82e3bfe8326fccee50583caebc8a5f0", size = 445023, upload-time = "2025-08-08T18:26:56.677Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/2a/f609b420c2f564a748a2d80ebfb2ee02a73ca80223af712fca591386cafb/tornado-6.5.2-cp39-abi3-win_amd64.whl", hash = "sha256:e56a5af51cc30dd2cae649429af65ca2f6571da29504a07995175df14c18f35f", size = 445427, upload-time = "2025-08-08T18:26:57.91Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/4f/e1f65e8f8c76d73658b33d33b81eed4322fb5085350e4328d5c956f0c8f9/tornado-6.5.2-cp39-abi3-win_arm64.whl", hash = "sha256:d6c33dc3672e3a1f3618eb63b7ef4683a7688e7b9e6e8f0d9aa5726360a004af", size = 444456, upload-time = "2025-08-08T18:26:59.207Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a9/e94a9d5224107d7ce3cc1fab8d5dc97f5ea351ccc6322ee4fb661da94e35/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9", size = 443909, upload-time = "2025-12-15T19:20:48.382Z" },
+    { url = "https://files.pythonhosted.org/packages/db/7e/f7b8d8c4453f305a51f80dbb49014257bb7d28ccb4bbb8dd328ea995ecad/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843", size = 442163, upload-time = "2025-12-15T19:20:49.791Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b5/206f82d51e1bfa940ba366a8d2f83904b15942c45a78dd978b599870ab44/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17", size = 445746, upload-time = "2025-12-15T19:20:51.491Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/1a3338e0bd30ada6ad4356c13a0a6c35fbc859063fa7eddb309183364ac1/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335", size = 445083, upload-time = "2025-12-15T19:20:52.778Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d4/e51d52047e7eb9a582da59f32125d17c0482d065afd5d3bc435ff2120dc5/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f", size = 445315, upload-time = "2025-12-15T19:20:53.996Z" },
+    { url = "https://files.pythonhosted.org/packages/27/07/2273972f69ca63dbc139694a3fc4684edec3ea3f9efabf77ed32483b875c/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84", size = 446003, upload-time = "2025-12-15T19:20:56.101Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/83/41c52e47502bf7260044413b6770d1a48dda2f0246f95ee1384a3cd9c44a/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f", size = 445412, upload-time = "2025-12-15T19:20:57.398Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c7/bc96917f06cbee182d44735d4ecde9c432e25b84f4c2086143013e7b9e52/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8", size = 445392, upload-time = "2025-12-15T19:20:58.692Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/1a/d7592328d037d36f2d2462f4bc1fbb383eec9278bc786c1b111cbbd44cfa/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1", size = 446481, upload-time = "2025-12-15T19:21:00.008Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/6d/c69be695a0a64fd37a97db12355a035a6d90f79067a3cf936ec2b1dc38cd/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc", size = 446886, upload-time = "2025-12-15T19:21:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/50/49/8dc3fd90902f70084bd2cd059d576ddb4f8bb44c2c7c0e33a11422acb17e/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1", size = 445910, upload-time = "2025-12-15T19:21:02.571Z" },
 ]
 
 [[package]]
@@ -2215,7 +3390,7 @@ version = "4.7.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0c/1c/6c5dcfd8e5defa1d1481450a7fccd429086c8fc4c57c3ea1a1ad0c2df432/trimesh-4.7.4.tar.gz", hash = "sha256:8d242dfabd9bc4e99a4f0c75bf8c0a41fbb252924e3484b53a8b0096accb49e1", size = 801995, upload-time = "2025-08-14T20:13:51.597Z" }
 wheels = [
@@ -2251,37 +3426,91 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
 
+[[package]]
+name = "tzdata"
+version = "2025.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" },
+]
+
+[[package]]
+name = "uri-template"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" },
+]
+
 [[package]]
 name = "urllib3"
-version = "2.5.0"
+version = "2.6.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" },
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
 ]
 
 [[package]]
 name = "watermark"
-version = "2.5.0"
+version = "2.6.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "importlib-metadata" },
-    { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "ipython", version = "9.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "ipython", version = "8.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "ipython", version = "9.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "setuptools" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b2/b7/f529170d6ac23f538b758286d81c7389c8abb7ac12d8e79ba658f32123f9/watermark-2.5.0.tar.gz", hash = "sha256:108cbad9ecf0cac9dd49c1504f3749cd74a364500e02ac6c72197a1c1aa151d7", size = 10894, upload-time = "2024-09-21T00:40:13.922Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d2/f4/a1e4c497be237e19eb2da3417e7e48973e0f59413d262d1440e769fe0e2b/watermark-2.6.0.tar.gz", hash = "sha256:ee4fadccbebe855a23ae48bb8a20c1da6ddb9d81f53b6c30c77de767c7161930", size = 17144, upload-time = "2025-12-21T23:42:14.73Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ac/1847959031ce09eb65a70b16d0f07633d7ddaf8a97752cc924f9a8cbe253/watermark-2.5.0-py2.py3-none-any.whl", hash = "sha256:d775afa075f5ea15152ad9f4c82dfc95bffb9d0cb4341c9b62073b627191464d", size = 7679, upload-time = "2024-09-21T00:40:12.512Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/bd/5e98be0ff12e580985ad647f2c33be97abde81fccbfd1655fc7536043c0f/watermark-2.6.0-py3-none-any.whl", hash = "sha256:c925daf1c3f7db9aa5fe25aff3a5fd07df0619ff0bd271bf809bfd6b0c628332", size = 13569, upload-time = "2025-12-21T23:42:13.46Z" },
 ]
 
 [[package]]
 name = "wcwidth"
-version = "0.2.14"
+version = "0.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" },
+]
+
+[[package]]
+name = "webcolors"
+version = "25.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" },
+]
+
+[[package]]
+name = "webencodings"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" },
+]
+
+[[package]]
+name = "websocket-client"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" },
+]
+
+[[package]]
+name = "widgetsnbextension"
+version = "4.0.15"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/f4/c67440c7fb409a71b7404b7aefcd7569a9c0d6bd071299bf4198ae7a5d95/widgetsnbextension-4.0.15.tar.gz", hash = "sha256:de8610639996f1567952d763a5a41af8af37f2575a41f9852a38f947eb82a3b9", size = 1097402, upload-time = "2025-11-01T21:15:55.178Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" },
 ]
 
 [[package]]

From 5842ad6f902be0705448b84a1e254453dc49f31a Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Thu, 12 Feb 2026 14:12:49 +0100
Subject: [PATCH 4/8] update: notebooks

---
 notebooks/example.api.low.ipynb | 203 +++++++++++++++++++++++++++++++-
 1 file changed, 197 insertions(+), 6 deletions(-)

diff --git a/notebooks/example.api.low.ipynb b/notebooks/example.api.low.ipynb
index 16ce521..5c9b44f 100644
--- a/notebooks/example.api.low.ipynb
+++ b/notebooks/example.api.low.ipynb
@@ -14,9 +14,11 @@
     "from matplotlib.colors import Normalize\n",
     "\n",
     "from pywarper.surface import fit_sac_surface, build_mapping\n",
-    "from pywarper.warpers import warp_skeleton\n",
+    "from pywarper.warpers import warp_nodes, normalize_nodes, warp_skeleton\n",
     "from pywarper.stats import get_convex_hull, get_hull_centroid, get_xy_center_of_mass\n",
-    "from pywarper.utils import read_sumbul_et_al_chat_bands\n"
+    "from pywarper.utils import read_sumbul_et_al_chat_bands\n",
+    "\n",
+    "from pywarper.unwarper import unwarp_nodes"
    ]
   },
   {
@@ -70,7 +72,7 @@
       "↳ mapping ON (min) surface …\n",
       "    done in 0.01 seconds.\n",
       "↳ mapping OFF (max) surface …\n",
-      "    done in 0.01 seconds.\n"
+      "    done in 0.02 seconds.\n"
      ]
     }
    ],
@@ -91,7 +93,7 @@
      "output_type": "stream",
      "text": [
       "[pywarper] Warping skeleton...\n",
-      "    done in 0.34 seconds.\n",
+      "    done in 0.32 seconds.\n",
       "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
      ]
     }
@@ -267,7 +269,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x1169c91d0>"
+       "<matplotlib.legend.Legend at 0x119ee9450>"
       ]
      },
      "execution_count": 8,
@@ -330,6 +332,195 @@
   {
    "cell_type": "code",
    "execution_count": 9,
+   "id": "5bfbb928",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "local_ls   rewarp residual (mean / p95 / max): 0.0387 / 0.1467 / 0.8510\n",
+      "optimize   rewarp residual (mean / p95 / max): 2.0114e-12 / 9.4318e-12 / 7.4146e-11\n"
+     ]
+    }
+   ],
+   "source": [
+    "# unwarp demo (step 1): warped skeleton -> original space\n",
+    "# --------------------------------------------------------------------------- #\n",
+    "# Unwarp warped skeleton nodes back to the original coordinate frame.\n",
+    "# Compare the recovered nodes to the original skeleton nodes in XZ.\n",
+    "\n",
+    "warped_nodes_norm = warped_skeleton.nodes\n",
+    "med_z_on = warped_skeleton.extra[\"med_z_on\"]\n",
+    "med_z_off = warped_skeleton.extra[\"med_z_off\"]\n",
+    "\n",
+    "# option 1: fast approximate inverse (all nodes)\n",
+    "unwarped_skel_local = unwarp_nodes(\n",
+    "    warped_nodes_norm,\n",
+    "    surface_mapping,\n",
+    "    med_z_on=med_z_on,\n",
+    "    med_z_off=med_z_off,\n",
+    "    on_sac_pos=0.0,\n",
+    "    off_sac_pos=12.0,\n",
+    "    conformal_jump=2,\n",
+    "    method=\"local_ls\",\n",
+    ")\n",
+    "\n",
+    "# option 2: inverse-by-optimization (iterative; use subset for notebook speed)\n",
+    "opt_idx = np.arange(0, len(warped_nodes_norm), 20)\n",
+    "unwarped_skel_opt = unwarp_nodes(\n",
+    "    warped_nodes_norm[opt_idx],\n",
+    "    surface_mapping,\n",
+    "    med_z_on=med_z_on,\n",
+    "    med_z_off=med_z_off,\n",
+    "    on_sac_pos=0.0,\n",
+    "    off_sac_pos=12.0,\n",
+    "    conformal_jump=2,\n",
+    "    method=\"optimize\",\n",
+    "    optimize_max_evals_per_point=100,\n",
+    "    optimize_convergence_tol=1e-9,\n",
+    "    optimize_bound_xy_to_map=True,\n",
+    ")\n",
+    "\n",
+    "err_skel_local = np.linalg.norm(unwarped_skel_local - skel.nodes, axis=1)\n",
+    "err_skel_opt = np.linalg.norm(unwarped_skel_opt - skel.nodes[opt_idx], axis=1)\n",
+    "\n",
+    "print(\"Skeleton local_ls error (mean / p95 / max):\", \n",
+    "      f\"{err_skel_local.mean():.4f} / {np.quantile(err_skel_local, 0.95):.4f} / {err_skel_local.max():.4f}\")\n",
+    "print(\"Skeleton optimize error on subset (mean / p95 / max):\", \n",
+    "      f\"{err_skel_opt.mean():.4e} / {np.quantile(err_skel_opt, 0.95):.4e} / {err_skel_opt.max():.4e}\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7.2, 5.2))\n",
+    "\n",
+    "# background context: all original nodes\n",
+    "ax.scatter(\n",
+    "    skel.nodes[:, 0], skel.nodes[:, 2],\n",
+    "    s=2, alpha=0.12, c='0.65', label='original (all)', zorder=1,\n",
+    ")\n",
+    "\n",
+    "# compare all methods on the same subset so marker overlap is readable\n",
+    "ax.scatter(\n",
+    "    skel.nodes[opt_idx, 0], skel.nodes[opt_idx, 2],\n",
+    "    s=34, facecolors='none', edgecolors='black', linewidths=0.9,\n",
+    "    label='original (subset)', zorder=2,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    unwarped_skel_local[opt_idx, 0], unwarped_skel_local[opt_idx, 2],\n",
+    "    s=28, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n",
+    "    label='unwarp local_ls (subset)', zorder=3,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    unwarped_skel_opt[:, 0], unwarped_skel_opt[:, 2],\n",
+    "    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n",
+    "    label='unwarp optimize (subset)', zorder=4,\n",
+    ")\n",
+    "\n",
+    "ax.set_title('Step 1 (XZ): original vs unwrapped skeleton')\n",
+    "ax.set_xlabel('X (μm)')\n",
+    "ax.set_ylabel('Z (μm)')\n",
+    "ax.legend(frameon=False, loc='best')\n",
+    "fig.tight_layout()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2304b538",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# unwarp demo (step 2): annotated coordinates not on skeleton\n",
+    "# --------------------------------------------------------------------------- #\n",
+    "# Simulate annotations in warped space from arbitrary coordinates that are\n",
+    "# within mapping XY bounds but not constrained to skeleton nodes.\n",
+    "# Compare recovered coordinates in XZ.\n",
+    "\n",
+    "rng = np.random.default_rng(7)\n",
+    "n_annotations = 220\n",
+    "\n",
+    "x_min = float(surface_mapping[\"sampled_x_idx\"].min())\n",
+    "x_max = float(surface_mapping[\"sampled_x_idx\"].max())\n",
+    "y_min = float(surface_mapping[\"sampled_y_idx\"].min())\n",
+    "y_max = float(surface_mapping[\"sampled_y_idx\"].max())\n",
+    "\n",
+    "# synthetic ground truth coordinates (not on original skeleton)\n",
+    "annot_orig = np.column_stack([\n",
+    "    rng.uniform(x_min + 2, x_max - 2, size=n_annotations),\n",
+    "    rng.uniform(y_min + 2, y_max - 2, size=n_annotations),\n",
+    "    rng.uniform(skel.nodes[:, 2].min() - 30, skel.nodes[:, 2].max() + 30, size=n_annotations),\n",
+    "])\n",
+    "\n",
+    "# these are the coordinates that would be annotated in warped space\n",
+    "annot_prenorm, _, _ = warp_nodes(annot_orig, surface_mapping, conformal_jump=2)\n",
+    "annot_warped = normalize_nodes(\n",
+    "    annot_prenorm,\n",
+    "    med_z_on=med_z_on,\n",
+    "    med_z_off=med_z_off,\n",
+    "    on_sac_pos=0.0,\n",
+    "    off_sac_pos=12.0,\n",
+    ")\n",
+    "\n",
+    "annot_unwarped_local = unwarp_nodes(\n",
+    "    annot_warped,\n",
+    "    surface_mapping,\n",
+    "    med_z_on=med_z_on,\n",
+    "    med_z_off=med_z_off,\n",
+    "    on_sac_pos=0.0,\n",
+    "    off_sac_pos=12.0,\n",
+    "    conformal_jump=2,\n",
+    "    method=\"local_ls\",\n",
+    ")\n",
+    "annot_unwarped_opt = unwarp_nodes(\n",
+    "    annot_warped,\n",
+    "    surface_mapping,\n",
+    "    med_z_on=med_z_on,\n",
+    "    med_z_off=med_z_off,\n",
+    "    on_sac_pos=0.0,\n",
+    "    off_sac_pos=12.0,\n",
+    "    conformal_jump=2,\n",
+    "    method=\"optimize\",\n",
+    "    optimize_max_evals_per_point=100,\n",
+    "    optimize_convergence_tol=1e-9,\n",
+    "    optimize_bound_xy_to_map=True,\n",
+    ")\n",
+    "\n",
+    "err_ann_local = np.linalg.norm(annot_unwarped_local - annot_orig, axis=1)\n",
+    "err_ann_opt = np.linalg.norm(annot_unwarped_opt - annot_orig, axis=1)\n",
+    "\n",
+    "print(\"Annotation local_ls error (mean / p95 / max):\", \n",
+    "      f\"{err_ann_local.mean():.4f} / {np.quantile(err_ann_local, 0.95):.4f} / {err_ann_local.max():.4f}\")\n",
+    "print(\"Annotation optimize error (mean / p95 / max):\", \n",
+    "      f\"{err_ann_opt.mean():.4e} / {np.quantile(err_ann_opt, 0.95):.4e} / {err_ann_opt.max():.4e}\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7.2, 5.2))\n",
+    "\n",
+    "# marker stacking for readability at overlapping coordinates\n",
+    "ax.scatter(\n",
+    "    annot_orig[:, 0], annot_orig[:, 2],\n",
+    "    s=40, facecolors='none', edgecolors='black', linewidths=0.9,\n",
+    "    alpha=0.7, label='original annotations (demo GT)', zorder=2,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    annot_unwarped_local[:, 0], annot_unwarped_local[:, 2],\n",
+    "    s=32, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n",
+    "    alpha=0.8, label='unwarp local_ls', zorder=3,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    annot_unwarped_opt[:, 0], annot_unwarped_opt[:, 2],\n",
+    "    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n",
+    "    alpha=0.95, label='unwarp optimize', zorder=4,\n",
+    ")\n",
+    "\n",
+    "ax.set_title('Step 2 (XZ): annotation points')\n",
+    "ax.set_xlabel('X (μm)')\n",
+    "ax.set_ylabel('Z (μm)')\n",
+    "ax.legend(frameon=False, loc='best')\n",
+    "fig.tight_layout()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "id": "48ec81d6",
    "metadata": {},
    "outputs": [
@@ -337,7 +528,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Last updated: 2026-02-12 13:43:34 CET\n",
+      "Last updated: 2026-02-12 13:48:25 CET\n",
       "\n",
       "Python implementation: CPython\n",
       "Python version       : 3.13.11\n",

From 7ded68ed8cd2b5b50eb34dec67e0133a2dfc1a43 Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Thu, 12 Feb 2026 14:13:51 +0100
Subject: [PATCH 5/8] update: notebooks

---
 notebooks/example.api.low.ipynb | 47 ++++++++++++++++++++++++++-------
 1 file changed, 38 insertions(+), 9 deletions(-)

diff --git a/notebooks/example.api.low.ipynb b/notebooks/example.api.low.ipynb
index 5c9b44f..298f688 100644
--- a/notebooks/example.api.low.ipynb
+++ b/notebooks/example.api.low.ipynb
@@ -72,7 +72,7 @@
       "↳ mapping ON (min) surface …\n",
       "    done in 0.01 seconds.\n",
       "↳ mapping OFF (max) surface …\n",
-      "    done in 0.02 seconds.\n"
+      "    done in 0.01 seconds.\n"
      ]
     }
    ],
@@ -93,7 +93,7 @@
      "output_type": "stream",
      "text": [
       "[pywarper] Warping skeleton...\n",
-      "    done in 0.32 seconds.\n",
+      "    done in 0.31 seconds.\n",
       "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
      ]
     }
@@ -269,7 +269,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x119ee9450>"
+       "<matplotlib.legend.Legend at 0x1174a9450>"
       ]
      },
      "execution_count": 8,
@@ -339,9 +339,19 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "local_ls   rewarp residual (mean / p95 / max): 0.0387 / 0.1467 / 0.8510\n",
-      "optimize   rewarp residual (mean / p95 / max): 2.0114e-12 / 9.4318e-12 / 7.4146e-11\n"
+      "Skeleton local_ls error (mean / p95 / max): 0.0060 / 0.0257 / 0.0664\n",
+      "Skeleton optimize error on subset (mean / p95 / max): 5.2062e-04 / 1.9949e-03 / 2.6957e-02\n"
      ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsoAAAICCAYAAADWLeuZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV4FFcXhr+4C/GEkAR3CO7u7lYcSgVaqGL1Ugq0FNpS4QeKuxSH4hR3LW7BLSQQJSHJ/s93N7NMlt1kE0KM+z7PZjZjV2fnzJkjZhqNRgOJRCKRSCQSiUSSAvOU/0okEolEIpFIJBIpKEskEolEIpFIJEaQGmWJRCKRSCQSicQAUlCWSCQSiUQikUgMIAVliUQikUgkEonEAFJQlkgkEolEIpFIDCAFZYlEIpFIJBKJxABSUJZIJBKJRCKRSAwgBWWJRCKRSCQSicQAUlCWSCQZJioqCvnz58fhw4dfSS8uWrQIVapUQVYnEK1fvz7efPPNdB3z9ddfo0iRIplel1d1XknmMnv2bFhaWmb4+J07d8LMzAy3bt3KtjpIJJIXkYKyRJKFxMbG4osvvkDRokVhZ2cHNzc3IQj++uuvun0ooFFQyyru3r2Lnj17onTp0uIm27hxY5OPnTBhAipXrizaQM6fPw97e3tMnz49xX4hISFwcXHBpEmTxP9sH4UCY59vvvlG7Ne9e3fExMRgwYIFyEr+/vtvXV1N5ZNPPsGBAwdeWZ0kklfBd999h6CgINm5EokR5KOnRJKFvPvuu9ixYwd++eUXlC9fHhERETh+/Dhu3LiRbeMQFxcnBPaPPvoIy5YtQ0JCgknHPX36FH/++Sfmzp2rW1eiRAn8+OOP+PDDD9GgQQOhCU1MTESvXr2EQM31iiAaHx//wjmHDBkiNGsU3AmF5oEDB+Lnn38W53jVsE7W1taiP9KLo6Oj+EhezZhIJBJJtqCRSCRZhouLi2bKlClGt3/11Ve0MUjxmTVrltgWGRmpGTp0qMbPz09jZ2enCQ4O1qxYsUJ37LVr18T+8+bN0zRs2FBja2urKViwoGbRokUm169v376aRo0ambTvypUrNfb29ppnz569sK1FixaaatWqiW1jxozRuLq6am7evJnq+SZNmqSxsrLS7NixI8X6q1evinadO3dOk15mz56tKVmypDhv/vz5NZ999lmK+tarV08zYMAAzeeff67x8fHReHt769YPHDhQt19MTIxm0KBBGmdnZ9GWd999VzNy5EhN4cKFU4ydof9XrVqlKV68uOgrnvfixYu6fcLCwjQ9e/bUFChQQIxXsWLFNBMnTtQkJSUZPa8+o0ePFsfp884772hq1aolvj958kTTr18/0T5ra2uNv7+/5sMPPzR6TmUu7d69O8V61oP1UeA+v//+u6ZXr14aR0dH0cfff/+9bvuMGTPEOv2xZJsVpk2bpvH19U1R7vz588UcYp8NHz5c9Mebb76pKVSokG5ejxo1SvP06dMX+mnBggViu42NjaZx48binOnZh2zevFlTs2ZNURavN/ZdaGiobntiYqKYM56enhoHBwdN165dxfy1sLDQpAbnAq9bXr/8LahSpYrm2LFjYhvnPduuXCcsY8iQIWKszpw5I9YdOXJE06RJE1Gmh4eHpkOHDpqQkBDd+flboV+H1I7h/vq/N8r4RkREaN566y1xDOdMpUqVNJs2bXphjixZskTTqlUr0Sb2qfJ7JZHkFaSgLJFkISVKlBA3lUePHhncTmH4jTfe0NSoUUNz9+5d8aGQRkGhfv36QtCi8HLlyhXN//73PyEAbt26NcWNi0IHBY3z588LwdDc3Fx3M85MQfmDDz7QCWL6sN68wXbv3l1jaWmZprC+YcMGcYOnYGUILy8vzR9//PHCA0VqrFu3TrSdgtuFCxc0ixcvFkIuBRwF9icFvLffflsII6dOnTIoKL///vuiDqtXrxb9SiGZQnNagjIFvWbNmglh5cSJE5qKFStqateunaKfxo0bpzl69KgQIvmQQ4Fm5syZRs+rD9vGvjhw4IBuHQXIfPnyiTmi1L9cuXJin+vXr2v27t0rBNTMEJTZLzzX5cuXNb/99ptYp8xJzlP+zz4jHF8KlxQ+FThHOOfV5VK45hxmn/BDoZEPBKw/9+E48MHmyy+/fKG/OScPHz6sOXTokKZq1aqaChUq6B48TNln27ZtQuj79ddfxUMN9+G1V7duXd0+P//8szgPH8TY/xMmTBCCb2qCMsea1yv3ZZvOnj0rBHZlzqkF5djYWE3Hjh01pUqV0ty4cUNs5/zk3GCb+dDI4zp37qwpWrSo2N+QoJzWMfxtGTFihBDGld8b/gYR7hcYGKj5559/RF35kM76Kw+sylhROKawfOnSJfHwwvLZJxJJXkEKyhJJFrJnzx5NQECAEODKli0rtJTUzKo1iBTQKKip4U2U2q/Hjx+nWN+/f39Nu3btUty41IIgodBNjV9mC8osl5o0Y1B4Yn06deqU6nl4M6fQ+dFHHxndh4LMJ598ovufWnlqaVODAmmXLl1SrKOAQy1hXFyc+J/9TKGBgpgataAcFRUlNGr6Qjw15mkJyhQaHjx4oFtHYd3MzEwn2BiCAgm1nMbOawjWZfDgwbr/ly1bJtoZHh4u/m/btq0YW1NJj6BMIVz/YZAPEgoUtqh1JhSIKbQ5OTnpBC5quZW+Vcr99ttv06wjNbhFihR54eGJApv+Q4QiuJuyD8eewqMaPlxwn+PHj4v/KchTcFfDeZ6aoMyHVZ5DX3utoAjKFGbr1KkjhHm+cVDg+HXr1i3FMXwgolDP3xBDgrIpx/CND8dIDfuHdVm/fv0L1yF/c9Rj9dNPP+m2JyQkiAfPqVOnGu0HiSS3IZ35JJIspFatWrhy5Qp2796Nvn374v79++jcuTPatm2bamQHRpWgrSYjTCi2sPzMnz8fly5dSrFvjRo1XijzzJkzr8Qx0dbW1uA22jnPnDkTDg4OOHbsGCIjIw3u9+jRI7Rp0wZ169YVts3GYDksT+G9994TjoOpwTbzvGrq1asnbKs5BgqVKlWCubnxn8LLly+Lvq9evXqq/WwIPz8/eHp6pvif4/zgwQPxf1JSEsaPH4/g4GB4eHiIMZ06dSquX7+O9MC5tGTJEjx79kz8T7txzilXV1fx/+DBg7F8+XKUKVMGw4YNw8aNG0XZmQHrroZt5LxWoK369u3bxXfa5zdr1gx16tQR6zhG3Ldhw4YpzlG1atUXyqGDaLVq1eDt7S36adSoUS/0E/taHSGkWLFiol/V8z+tfXit0SZefZ2VKlVKbOO1Rr+C27dvo2bNminKrl27dqr9VK5cOdF2jkGHDh2En8LNmzdf2K9Vq1ZiuWXLFuTLl0+3nvVauXJlinq5u7uL+az/G/Ayx5CzZ8+Kpf71w//1f0vU429hYQEvL68U4y+R5HakM59EktUXnaWluMny8/HHHwtht3fv3ti1a5cQ5AxBoYZRIwyFYcsuRycKHGFhYUY96XkjPnr0qBAO6MQ3Y8aMFPtQqOvUqZMQphcuXJiqsMpy1AJnZsLyTYGOhelFf2yUcyhC6k8//YRx48Zh8uTJqFChApycnMT39evXp6scRgf54IMPxHF8MPrnn3+watUq3XaOAR1GN23aJJwl6RhZtmxZbNu2TQg3+ihjof/wpgjiabVRLYRTCGbdKHzxgYlCMNdRUKajJyMuFCxYMNUxoZMpHT35UMFrxNnZWaz77LPPkNmw7iNGjBDXpD4+Pj4ZfsBgP/MBhdfw1q1bsWLFCowcOVK0o3Xr1rr9+ODIMG/79+9P8QDBclknHqMPhV9jbUnvMeklrfGXSHI7UlCWSLKZkiVLiqWiZeSNhwKEGkaMePz4sdAEUSOVGgxR1rJlS93/+/bt02nEMpOKFSvit99+e2H9wYMHMXbsWKHhLF68OObMmSNu+O3atRNCgDoCyLlz53Do0CEhIBqD4eGoAWYfpAeGu+PDB7XPCv/++68Iy1e4cGGTz0PtI8eEgou6HzMjFBzr17x5cwwYMEC3LjVNnzGoeWTfzps3TwjEjNpB4VgN1/Xo0UN8+vfvLzTiFF4pMOujPJTcuXNHt47zk5rU9EKNMh90GG6PGkk+KHI+8AGBbx70tcnG+okPEozMog45qM/Dhw/FXFHG9+LFiwgNDU0xbmntw3lGrWlqsav5ZofXlaL9JXv37k2zHRQi+aDAz+jRo8XYz5o1K4WgTE05Hxy4jg87TZs21dXr1KlTot6mPrSZcoyh3xteO0q/q39LlHGQSF4npOmFRJKFUBvGV+tHjhwRr42p0eNrcb4ip0BBeJOkWQFv1ryBM3wbhQnGN+7YsaO4eV69elVoa6dMmfJCzOK//vpLaGgpAHz55ZdCwFMLGIY4ceKE+FCgYRIR5f/UaNGiBa5du5bi9XF0dLTQVvLDuiptZvmDBg0SQgqh0EStGcPL2djY4N69eyk+T548SSGAcB+1tp0COkPRpQYFDmrtqIVkXyxdulQk76AWPz1aeGo33377bXz++edYt26dOBc1mRTyM6JlVsMHCWp4aZLA87IMPmhkhD59+oj6cX4xvJ5aU8z6MiTfhQsXhCDOuNR8DR8QEGDwXHyYoGb6hx9+wMmTJ8Vc4/k5DunF399fxA1XHpiU1/XUVlMDboqgzH46ffo0Vq9eLYRcmi2wPfowhjcfAnh98UOTFJbVqFEjk/f59ttvRTmcs7wGWB419AxTqJj/cA6xDnwwYX/yzQC1xKlBwXrMmDFifPkww2ufQqyhh1jG5OaDBB8uN2zYINZRsOac47XFh0tee5w3NKXh74EhTDmGvze85vg7wd8bPphSsO7SpYv4beJbCP4e8Zj//vsPn376aZrjJZHkKbLbSFoieZ1ghAM6mdHzn855DAvGUFlK+CfCiBgMjUUHN3V4OMVDPSgoSHif0wmKERXopa92rpk7d65wSOL5uS8969NCP0SU8kkLRgMYO3as7n86J7JMhpbSdyCi82L79u3F/9zHWJn8qB3P+vTpI8JUqTEl6gVhVAI6l7G/GGmBDlj64eHU0S2MrVfCw9EJjdENGB5u2LBhmjJlyqSoU2rOfYTOcWqHLjpn0uGQ53VzcxMOeXTGVDtXmeLMR+Lj48W84vkZYUMNneNKly4tIiBwXjGCg76jnj50cuN+jO5ApzmGIjTkzMdIHWroDKrvOMjx477q6CuM6sB1d+7cSdOJkG3jORjJg33Vo0cP4dCpngNKP7E+7D/Of4ZJZISJ9OxDdu3aJdpBxzS2n3OI463MHTp/MsKDu7u72E5HvrTCw/3333/iulZC9NGplw6qimOpfng4wkgvrCPDyhE6+tExk9Fb6KzJtnBeKlF0DIWHS+sY9i37k32rDg/HkIKmhIdLy+FTIsntmPFPdgvrEonk5eGraGqH6CiYlmNRZsGyaB9LhzdqITMbaqvpBEXNXmBgIHIS1ITS5IFaa0n2w7cFtPfnXHyZfSQSiUSNtFGWSCQZhtELvvrqK/EaV7FrzGzhn6Yl2S0k87U/o3fQrpcRMPjKna+w6ZwlkUgkkryLFJQlEslL8dZbb71SQTwnQFtk2lMPHTpUePTTPppht+iMJZFIJJK8izS9kEgkEolEIpFIDCCjXkgkEolEIpFIJAaQgrJEIpFIJBKJRGIAKShLJBKJRCKRSCR51ZmPzjXMIMXsXi+bAEAikUgkEolEkndhZOTIyEj4+fnB3Nw87wvKFJILFCiQ3dWQSCQSiUQikeQSGKuf2UPzvKBMTbLSYGdn5+yujkQikUgkEokkhxIRESEUrIr8mOcFZcXcgkKyFJQlEolEIpFIJGlhirmudOaTSCQSiUQikUgMIAVliUQikUgkEonEAFJQlkgkEolEIpFIDCAFZYlEIpFIJBKJxABSUJZIJBKJRCKRSAwgBWWJRCKRSCQSE+nZs2eq22fPno0tW7akuz/79euHPXv2vLD+wIED+Oqrr4weFxISgsaNG4vvX3/9NebPny++d+zYEdHR0emuhyQlUlCWSCQSiUQiMYHExEQsWLAgTYG3SZMmmdafEyZMwJAhQ9J9XJcuXTBjxoxMq8frihSUJRKJRCKRvPYwrfHbb7+N2rVro2bNmjh06JBO8H3nnXfQunVr7N69G0WKFBHrmQK5ZcuWQpv70UcfoX79+i9odbnviBEjUK9ePXTv3l2sCw0NRaNGjcT+tWrVwsWLF432Pct4+PAhvLy8xP+TJk1Cw4YNUaVKlVS1zKRFixZYvnz5az+uL4sUlCUSiUQikeR6kpKSXur41atX49mzZ8L8gYLue++9p9sWGBiIdevW6YRhMn36dNStWxdbt25FpUqVDJ4zISEBPXr0wL///ouwsDD8999/cHFxwcaNG7Fz5058/vnnGD9+vNE6nT9/HkFBQbr/Kchv375dCPE077hx44bRY11dXXH//v0M9IQkz2Xmk0gkEolE8voSExOD+Ph4WFtbw97ePkPnuHDhgtAkk0KFCiE8PFy3TVmv5tKlS+jcubP4Xq1aNSE462NpaYng4GDxPSAgAI8ePcLjx4+FKcW9e/dEnU1Jo6ywYsUKYU7BjHJXr17FzZs3kT9//gy1V2IaUqMskUgkEokkV2uSKXDSfpjLjGqWixcvjn379onvFEKpkVWwsLB4YX+aVRw5ckR8P3z4sMnmHdRWV6hQAbt27cKXX34p1hmjRIkSwllP4YsvvsCmTZuwY8cOFCxYMNVjKZB7e3ubVC+JcaRGWSKRSCQSSa7F3NxcaJIVjTL/zwht27bF+vXrhY0yhe4pU6akuv+gQYPQtWtXbN68WQi0LNsUmjZtijfeeEMIyqVLl051X2qbPTw8hAkFhV5GsqBdM8tzdHRM9Viad3Tq1MmkOkmMY6ZJ7XEklxARESFsfp48eQJnZ2fkZuJDQhD35Al2/bsL5y+ch62NDRo0aIiChQrCwsEB1ipbJYlEIpFIJFqoSc6okJxRaINM8wpGwti/fz9+++23TC+D56XQ++2336bruA4dOmDevHlpCtSvIxHpkBuloJzDhOQrzVukuk/hfzZKYVkikUgkkmyGgjmjWdBemB8KpbRDluQtQVmaXuQg7ly9KpZrixRGv88/h5OrK6ItbHDr3H+YPHQoRtraIlEGD5dIJBKJJNuh9prh4iR5G+nMlwNQHA+WLFkilkPGjUNskTL46XIS2v99DevMC+PNmdoA57dv337pEDgSiUQikUgkkrSRgnIOCGnDVwAMGcOYiiTq6VPM2ReCGXuu4VZ4rFhuf2wPCy8vbN2yVezP4yQSiUQikUgkrw4pKOeAkDYMcM587PxOImGJzecepNh3y6UwJJUNRnR0lNj/ZULgSCQSiUQikUjSRgrKOSCkjZWVFRwcHFCyRAmx3gkJaFpSm65SoVFhV5ifPoFy5cuL/V8mBI5EIpFIJHkFKo7OnTsnEoBIBZIks5GSVjbDDEL0uHR3d0fvPn3Euj07d6JvzSAMqlMQ/vnsMLB2EDxu7EfigweoXau22D+jmYckEolEIskL8O3qN998gwIFCqBUqVIoVqwYSpYsiVmzZr3Scnv27Jnq9tmzZ4v00umlX79+In22PgcOHMBXX32VrnPRlPPNN99ERmGSkzVr1uj+Hz16tC65yuuGFJSzEeXJV9EMlytXTixnf/cdPm/XDP7HVuAd+ws4/nVfHP3tJ+1BZs/3p53y06dPU5xLIpFIJJK8DlNAMGkH4xYzWx1TOVOj3K1bN7z99tsYO3bsKymXiUgYMzktgbdJkyaZVuaECRNEyuusRF9QHjx4MMaNG4fXERkeLgflpWdCEfKDrx/wKAxYsFD8X4l/rG1S7MPXTDdu3BDfGbfR19f3pXLcSyQSiUSSW6DGdtWqVTh27BjKli2rW8+kHNQq9+7dG/3794efn1+6hO933nkHZ86cEcqnn3/+GVWrVhWCr62tLW7duoVPPvlEaGovX76MyMhIIZjzXk5FF+tCTe7XX38t0lv36tVLLJkdj1ph3qcXL16M0NBQcRyFbmrFqQGnNtwQLOPhw4fw8tKaY7L8vXv3ivqwrtWqVRP12bp1q9jO8lg3cuXKFZF05Nq1a/jss8/QpUsXTJ48WdSBskL79u0xbNgwLFu2DL/++qtoP7MGMq32pEmTRFru+vXr46effkKlSpVE+ym7vG5yhhSUc0Beek54Ya8cFCQSihiLlaxk5uNEZZQMLhnk/MGDB7qA2RSWo6KixEQ2NZ2mRCKRSCS5CQqX7dq1SyEkK1AIpbA3f/58DB8+3ORzrl69WgiuNH+4evUqunfvjkOHDoltgYGBmDp1aor9p0+fjrp162LkyJFCy0xB2VDmvh49egitMIXQ//77D8WLFxeZ9niP5nL8+PGYOXOmwTqdP38eQaqMvNz/5MmTIhsgZQlFYWYICth8oKCsULlyZSGws547duwQqbF5fHh4uBCEGQ+a/k8UrE+fPo2PPvpI9N+MGTN052M9Lly4gAoVKuB1QgrKOSwvvSkpqikE06aZkTIInzQTb93CjNlzsHbtGjwMDRUXUePGjfHmwDdRpGwZmc1PIpFIJHkG5hRo2LChwW28p9JmmfukBwqBNWvWFN8LFSokhEgFZb0amnp07txZfKdml4KzPrwXBwcH697+Usn1+PFjYUpx7949IQdQaDUVCtUDBgwQbfz0009fSE9NrbACBVqWT0Ua5QQKztSSDx06VDwQUCNtY2OD69ev60xFWDf+L9NeP0cKytkEhV1Fk5wR+GqJT7g8Pi4kBHf69kMrAK0cnQB+yPkLwKef4opMfS2RSCSSPIS/v7/QfBqCmlJqbmvXrp2uc1LTS7tcmjJQo+zq6qrbZmFh8cL+NHOgg1ujRo2EmYIpUJClppZC7KhRo7BhwwZh5mCMEiVKCHth5VgqwNq0aSO03tSaU7N+584dse3+/fspHg5OnDghNNqxsbFim6enpxDK2S80o6BGfvPmzaIdNN1QtNQ818GDB8WxalgP9tHrhhSUs5GXDe+m2AnN/msm6gGwGz0K3pUq8YoWqa/tE55i8rAP0PHGDSRGGTbnkEgkEokkt0H74xYtWggzhPLly6fYtnDhQmGSQBvh9NC2bVusX79eCJI0jZwyZUqq+w8aNAhdu3YVwiYFWlPNHWmCQUfEXbt2oXTp0qnuS8HWw8NDCLpubm6izYSO/BSUqS1u3rw5atSoIeypvb29dcfSPpt2ybRR/u6774TMQdtt2kjzeGq1+Xb6gw8+ENp5PgzQ/GLu3LnCpIU2zp07dxYRN/Lly4f8+fO/dvbJxEyj1tPnUpipzsXFBU+ePNHZ6uZk+MSWmTGQmxUpgp8trRC0Yjnuevhj4eHb+OfMPTQv7YNWngmw7dsNT8d+hwqdOmVamRKJRCKRZHfUCwqpn3/+ubCtpeaUQt7EiROFYDhixIhXXg9qXamJpe3v/v37RRSOzIbnpW0yHRWzi9GjR4s+rlKlCvIC6ZEbpaCcA6JdvOyPRRl7eywPDILt1D8xOzwf5hy8pds+sHoBdJv0Pi527oTWQ4e+dHkSiUQikeQEKKT+8MMP+P3334X5AaFtMp3rqDnNCqVXvXr1hFM9P/PmzRN2yJK8JShL04scEO3iZeDFyVciJNLMCtsuPkqxfdOFUHQpG5zC1koikUgkktwONbnUdDKyBe1naTZAQZX3xayA929Gi5DkbWTCkWyIdkE7oMxMQd2qFd34ANv4WDQq5p5iWx1/O5H6+nUL5yKRSCSS10dgpkMaHdyzSkiWvD5IQTmbUlZnpkG84rAw7bPRaOwcLcwtmPq6Rzl3uJ7aKFJfZ6ZNtEQikUgkEsnrgDS9yOWOfMQ7MBBRtEeOiASGDEQ3Ly9hbmG+/oQQktUZ/SQSiUQikUgkpiHVjFnsyEcDci4zEyWjH6Ne2P3xO+4N6I+zBQvgdt8+iB0zRmwzJZGJRCKRSCS5hfiQEMSeOWP0w+25ndmzZ4sIHpkB01EzfrIhmKabsZlN4f3338fFixfTVXZ6zm8IpitXshDSx4uh/Kh4zAqkRjkXO/KpUQThoNKl4RYRIYKFR8fFIcHGBk/d3CCTWUskEokkr0Ah+EpzbUzh1MjJiqJX8Yb5VXPv3j0RYaRYsWJZWi4FZcaTprMmfbwYN3rt2rUiacqrJneNUC7mVTnyGYI20IyEwdSUXOaG2NISiUQikZhKYrQ2iZbfjz+It6n6H65X72cKO3fuFFn5FOggqGh127dvj44dO6JMmTIi0kVcXByqV68utjMxifL9xx9/FDGVz549K5J4MHwcM/cxfbSi1f3444/RrFkzXL58WQh+TJ5CwY/RO1KDgiFTZXPfMWPGiHVUvDGldZ06ddCgQQORgMVY2aYKwnXr1hXnYl0jIiJSbF+5cqUu3bWhfb/++muReZBQg0xNssKMGTNEchTW6+7du+LtOhOo8H8eTy01U2tzDHhOJn45dOiQaM8///wjNNlMoEJatmyJZcuWISuQGuVclLY6PVSuXFlMWikkSyQSiSSvYl2oEOzSyG6XWfz999/Yt2+fSDm9fPlykTWPWe4oOHt5eYmYvDt27MBff/0lQrIyLTTv93/++af4MJOecn/+6aefxHcKjN988w0KFCgghGemnQ4ODjaoff7oo49EqmzG/6WwSvODvXv3imx8M2fOFPspb62NlZ0WbB8F1O+//17kadCHqcGZeMSUffVh+ms+dPBBYsKECejTp49Q5jGZitLGadOmiQcUCtXMRsiHE7aRAjYFaCUtOTXaxlKYZzZSo5xFKLY0WfmaRRGSmapSIpFIJBKJcVILLVepUiWxpAb40SNtvgJqPSmQMiNg69atsW3bNqG99fX1FbbANAugtvR///sfbt68qTtXzZo1dd99fHx0sZ+ZgvrChQsGy+d5KRBTAOe+1GBzXwqu1B4r8K11amWbEm6W8agZTYsxqp89e5aufdV9qC88s32EWnHWnWFr2a88ftiwYUK5R+F3yZIlQsPcrVs38fCR3UhBORc78ZnC1atXxWsLLiUSiUQikRjGzc1N5+xGzS4z/ykYEgApoE6ePFlogPmdWlIlxTNTWTPF9r///ou33norhdBIYVaBWlOlzCNHjqBo0aIG6+bp6Sn2ffz4sTjXgQMHhIaWpiA0GVEr5VIrOy2okaaGm+YTFM43bdqUYjvLo8mIsX3VfXj06NEUx7J9hFpxaoRpvkItOY9n+5jZsHTp0kLTzDbxc+zYMXEMTVbV40EzDdYlK5CmF7nciS81qEnmRcXJyCX/Z/kSiUQikUhSUrZsWfEmlppYfpjIJDUoFJ8/fx7jx48X5gK02VW0u7Rpfu+997Bo0SLkz5/f6Dmoff7222+FJpWa5ooVKxrcj3ID7Z+bNm0qvtO2t3z58ihZsiTefvttYZJAYZJmIaaWbQgKpzSlYNvp51Q72dRBgeceMmQI3nnnHYP7UmtMkxCaoxQsWDDFsVeuXBHmJdTAs25U4g0dOlQcT1lpzpw58Pf3F7bI1NYrZipsNzX2NB9he6kl37Bhg85e+VVjpknPo0YeyNmdHVCTTCGZkzgzE42YAjXJFJL5uqZQoUJZWrZEIpFIJK8Chn8L6dRZGxbVgI1yWttzChSwFQ1tbuG9994TAm5WR75QoDzVuXNnEQkjo4rH9MiNUqOcx5z49KFwLDXJEolEIsmLxBsxKzS2/nUnLCxMOMipoQaYJhCm8ttvvyE7odJxzZo1WVaeFJSzKE5idsZKVMwtaN+T1qskiSQvxv6USCR5CyXb7J1PUw+pltOz0ma1Npk2xGqbZknaSKkpj5pc6EMv3ejoaDg4OMDd3T1b6yLJveSkOS2RSF5flIy0qcVJppCcU5ONSHIPUlDOIic+/k+PVdrEMLtMVkJNMoVkhm7hknWQmmVJbnJMlUgkEn2kECzJCuRd7hVn4gs/exYT3x2MegUKoE3p0qjr7483GzTAkaVLsywPPYViapIZ75BLKSRLcnp2SYlEIpFIcgLZFvXCzs5OBJ0mvXv3FikY6UXJ2IXUeM6dO1fY0uTmqBehp07jYdeuOSYPvbRRlmQG0kZZIpFIJLmZ9MiN2aYSYmw/JaD0wIEDRaBq2j8y9l7Xrl3xww/aPO25mbnT/ieWrl9/rc0/v2olPNduQNDKlVifHFQ8Mcr0PPQvi9QkSzIDqUmWSCSSnAdDwVLJqMB00Vu2bDHpWMaA/vjjj1+q/CVLluhSaZsK6/jdd99luEwqV3ft2qX7n0pXJeFJZpFtgjIHhQG9GaYkJCREZJBhQGnSpk0b8X9u0a4p6anVS36U8CWuZcvgrmcB/HQ5Ce3/voaJVxLR+MuxYtvZc2dfOE59LiUTjXrby6LObiPJPgzNG2WZkW1ZXW+JRCLJKfDleETss3RloctuMvu3VF9Q7tevH5o0aWLSsUyl/dNPP71U+VOnThUWAlmJvqA8aNCgl25HjnHmo3BMpzZqkqlRLly4MPLlyye2MTlGeHi40WOZaY4ftQo9O1NTE9r/0naTjk50muMF8ODBAyCoIO49fIi5lxIx+4A23/pfe0KgqeaP7l5eIiFI4YgI3XHqc9Hxjuv5XUl5yVcELxNtQEa/yFnRI5TxVS/154Ep27IqCoWMeiGRSHIa1x9FY97+6/jnzD00L+2D3jUCEeie/rBwfMPNdMozZsxIkQyEWk8luQVTJ//5558iAx2VfUwlPWXKFCxYsEB8ZxY5Pz8/VKhQQSTm4G803+YuXrxYpGmuX78+KlWqhP/++08c17hxYzRq1Ehk+KtTp84Lb9MZBIACL3976WPE7HU8D+tGpSJTPBcoUEAIyMzKx7TRLOPTTz8VqaK5X69evcSyQ4cO2LNnjyifGQEpf1HuYtuuX7+ON998E1u3bhUZ75iSmveb8+fPC7mByktmxmMq7xIlSog+UKf1PnfuHLy9vcW9iQ8rPXv2xM2bN0XbmeaaMpGhviUHDx4UbaEm+NdffxX98Mknn2Dv3r3CaZxZALt16yb6a+nSpULZR7mR9WWbIyMjRb05BtWrVxeZCvOERlmJ/MB0hhwg2iPzaYjQZkQRmg0xbtw4YVuifDhJshoOOoV1JvNgOkYOFP+ncMsJzfVKGyLNrLD1QmiK4zdffISkssFwdHQUx/F4nofH8hz8TiGcS/YH1/Gc3DejT6Hq6BeRFy9i89SpeKtxY9TN748mhQvj+zffxLWtW7PMyfB1Iu7aNaz79Vf0rVNH9HeHcuXw+8cf4/r2HYi5ckWMi3r+6M+p1LZxPJXIKlkdyUUikUiyEwplFJJn7LmGW+GxYjn/wPVXoln++++/MW3aNPzyyy8iZbOTkxNCQ0OFyaiXl5e4V+/YsUOksWb6ZgpvFDCZRY6CpQLTMlNIZWa7u3fvCkFy3759QjvKj76806NHD3Ge7t27i/+V+znNVLmePl98g82kIRSCKfC3atUqxXm4P7W9+/fvx7Zt20QqaGpiKezql7ls2TJxjqJFiwrBlX35wQcfiDK4nuWtX78+xTEU/Cn8KklNKNfx/OwP/TTY+vAetnbtWqxcuRIffvihWLdx40bRrzyegjsF8X/++Ueck8I+TTwowLPNFJpZL5r0sj2sX2rK1lyhUY6KihINoSbs1KlTQmjmkxk7iXnEmcOb/xtj1KhRKbLIUKDMamGZT5a8UJRkHoqGj09PitavefPmwP4DsIiJROPifjqNMqmV3xbm608g+I2u4jzq45RzURDR1yhz34zaiCrRLygkx/YfAPaYmJJOTtod9uzF0z17cSWLnQxfByH5aouWKAxgpLq/9+4TnycMAr94EWyCggzOA67Tn1v627IiCoUS9UKJoyxtlSUSSXYT+TRBaJLVbPzvHoY2KgonW6t0nUutIdWHAigJCAgQAhpp0KCBEIapvKBGlAIoNbHU1l66dEnIKZRPKEBXqVJFd66aNWumMHngOQm11BcuXEBwcLBuO/+nZlo5jppppa7cnzAwgv5x+vBeUa5cOfGdAiU13sTf318ItvrKScpZpUqVEpphtolWAO3atdPJcMWLFzdaFnM10ASCgjnfdCqaaGMofRMUFCT6iowfP17YG/M+Q+342bNnxYd9Ttiv1FhnBdkiKLOxVI3zaYyd97///Q9ly5bFunXrhMqd5gVqOxt9KCzyk1NSUxMOphINQNG08bXA4/0H8OeI4Wg/4ReYV/MXmmQKye6nNyHxwQNhZmLj7JziOOU7tymRKtTbXgZO4NN8RcKoHL16oXKH9gDNPCxsYPcsFlM++QTtrl7Ds8hIWL90D0nIPytXoRjNFt5+C6WaNtX1t2VsJCYOeQ89Hz6Es5WV0XlgaG4Z2pbX07FLJBKJPk62lsLcgppkBf7vaJN+8YZvthVHMGpZ1f48akFP0VZTczxs2DA0bdpUfKdQqQh9TPP8xhtvCG3wH3/8IUwkFBTFl2JawTIpsB45cuSF9NIUSKltpraWS0VAZR24P4VkmlhQMUcFhqk+SIbao/D777+Lt5WK9trDwwOFChUSMhrfghNFaaNQpkwZrFixQreN5h40GaG5xeTJk8V3Y31LcxFy48YNIf+xPjRJ4cMHtccUtKl1p3DPMlh3lkGFEeVJ9bl4LN+8pmaVkCsEZT4FHT9+/IX1HJzchlpgUL5zSTMJ9/z5QWOSIfHPgA8HC5vkrmWDhSaZQrKSOUh9nP65lEgV6m08N4WVjApNfH30Ll//dGiPB96BmHfgBv45c038uLQf+xPQo6N4PdO4bNlM7KnXl6XLluJzQAjJD3yCkm3ptP3d8cdfgX49xGuliqVLpzqn0tr2qoXonJCOXSKRSNRQaKJNMuU+apJblPFBr+qBqWowjUGFHQU1vtHmJ61IURSKacNL7ScFWQYpoMBM+HacmuBFixYJDa4xqH3+9ttvcfr0aaExrlixYortI0eORN++fYVtLxUVihKRdaPQOHz4cHH+tm3b6swOOnXqhMGDB2d4olD4Z11o6+zo6CgEZNoCswwKorwHUPhVNNSEphw0I+EbR2qgaSbCBwL+T/ON1PqW7aKpyJ07d8R5Kfi2aNFCJ+9QUKYgTuGZx/K8irlJrVq1xEMJTT+4vHbtmrD5zhNxlDOTnBZHmQ56tLemRtjf3Fyk2IyKjMLde3dF/WjwntH0msq5OUmUJ6b0OnY1K1IEP1tawemvvzDzkTNm7ruu2zawmj+6TR6K7dWq4Z0fc3+IvpxAVQ8PzPHwFOEBGflErfkYWL0Auk16HydatkDXkcIwI1MdSzPL0U868UkkkpwMRZmouAShSc6IkJxdqJ3asuK4V8nixYuFJpo2w9kFzTX44EENfWbJjTKFdSbboh7duxdLFi9B+ONw8bqiV89eKFmqJFx8vOFZXZtgJaPwyYpCsuJAqNiois/Dh7h+/jy2bd2GW7dvCSGdT2RVq1SFheNzgZxPajY0F0lIRKSZJTaf02q2FTZdfIQuZYNha6c1KZG8PIqQSnMLapJT9PeFUNHffPDJDMdS3iy45Pm4Tjnvy5hLPL16DSf37xO+A9QU8EGPr8RKlyqdYm5JJBJJdkHhOL02yZLMpXv37tnepemN42wKUlDOJGKvXkVIy1agjvcdZWXoI+CLL6DEkHhZBzkKOxSAFY2y8hRkdu8ewnr2giuATsrON24Cp06/UDaFar5OwdZtsHkahaYlvVJolOsHOQnTkIbffJPhekpS0rhRY2D/ftjGx7xgS1cvyFH0d42+PV+JY+nLOvrx4e9ay5Zibr2hnluHj2TavJZIJJLXlYxqhXOaNjkvIwXlTOKvKb+hkeKw1aIFnmgs4GKWiAN792LKiBEY6+EpTDBeFhrU69so/7t+PXwAXGnTBg369Ia5lZXQXj6+cRVjB72F4dbWKcqmg0H41m2Y8cWX6PTTbzCrXkBoNhsUcka+ExuF/bSnl+dL11WipWfPN/B0/35M/uADtB03GZrk/uZDievxDaK/GY3kVTmWvoxN8fL580GLuUe9e6Niu7Yws7QUc+vm2dMY/87b+NrFNVPmtUQikUgkOREpKGcCfMW9eMliNHJ2gWuLDph4KRqbzt7RBj5v3x216bi4dRuQhjW4qUKN4uGp7Ltg/nww8WSjfn1TOIs1K+2DPlNnAUPfRnhYOGySz+/q4wtGGOzNEDf9eqCbl5d4/a/vZCjJHPIXKSJC7nW+eQvo1eWV9bcxRz9DkTNMmWc046DHckUzc1Rq307PEbEIev42A/jsEyQ8k5keJRKJRJI3kYJyJsCIBYxDaFG0GOb+F4Y5R+6K9XzFTp+Cjm3aCkE59FGoiF38Ms5SJ0+eFIG06chXvnx5IcwcPnIEyO8vwo4pgdf1MwAyikWjsmW02d3s7eA8fx7M4+Jw6eIlnL9wXphy1PriC3i65UOilTUSvLxkeLhMgn3puXQpnkVGCM9cxn6kCU2d3m/A0ckxQ06dL5sB0BQHP3owM2g8s0s+TUhIMbe4HFDNHyWYXfLaVZQPLv9K6i+RSCQSSXYiBeVMJLFMeWy7os0uqMBwNe1rOokUiMY8cfUznuk7XjEV9urVq0WQc9qdlk4OI8ag3+pX9oacxRi3mSHp4p/FC803nQApXGvc3MS5ihcpgqBGDYWgzP+5zUyjMVgPY1CYoqMXz89wOQwrQztq1pkPEMzuQ8fCtELt5EWUsdX4+uCZqwuCixVDFSsrYV/+qsOsKWUz3iTHnXbM6XHwUwfEiTG3xj9ntA+A+nPLDKZ5mPN8TFXKNK+0o+acoCmRRCKRSCQ5lddPcnkFUHD1cPeAxekTaNSgL+YcidVto/nFv+vngrlk3N3c05XxjILO9++9h6Vz5yKfqytc8+XDtavX4O7hLuIcUgtp5ugoAo7j1m04JMYZdRar2Hqk0QyAaqcvYmrmtcgLFzD28y+wbv06eHt5wcHREdNGjkRpLy8kRMcANtbQeHhgbkgIJuXLJwKGV69f/7Vy/FLGVvmeVVn0jJWdHgc/Pz8/FAwqKL7bJ8W/MLfqBjiIuVXwrQFp1uXavn0YOXQYTv93GoULFxaC+x+ffCKC5H/++edwcHd/reaFRCKRSHIHUlDOBChw0kEuce1aNHGPh2XtIGw6c18IFtXc4vDJ77+jAU0jzNKX8Wz8sGHotH0HOvkXgIWXFxLLBsMiX7Jd67TpuDJtuog4wAw4GD8Bfy9dht6DP9QFXm9c3AMWx9aK/YMCAkzK/EZM0STHh4TgVrv26Augb0Dg8/q5uWvrZ+/wfJ1rcp3HT8CV8RNeuygJ6rHNyix6xso2tQ58A9Knbx9gzlwc2rsPvbv10c2thkXdoDm0SoxrWm8Kws+exdMBA/E1/wkqCAt3D+28OH0CiefO417PXmK/121eSCQSiSTnIwXlTIICxfW1azGhXTPkr1Mbfes1xIFfN2Hhrl34uFs34OChNM9B4UVJWU1zi2Vz56KDrx8sZi3EkvsWIlJCsyYD0aO4E37u1k5k/GPEAZo7MFTX0smTMH/BfNRp0ADt3Lyw/uMFqJecQ145v3ppaJ0iRKs1y4rzIOul1O/S6dPCnOTJgP7waN0Ziy5GifpVr9QBPW4dxoXERFwsWANb7yeKOncv5oiZg3qjz6MwUWf1OZVy8ipqwTQ7stoZy+6XlsDM7W3btEXInLn4beRIWE+bhkrVq6G5gzO2/G85OgQHm1T+miVLUJXpYcd8i8gylbHoQqRuLjf1iMd3LRvhBz8/GT1DIpFIJDkOKShnVkcm5z/nDR9XropPba7gq+tkITmtyAa0QY5OFiKZMlKYRnh7Y9FdM8w6dFPs89eBmzC3Koi6vfsAf/2V4rzjvRkkDsDOf8WitZU1cPeeSWXrZ3fjd9qzEmHTrNHo7JhZP9oktwaQL7gi5l2MwpwD2votDwf8KtRGaAKw8HSYrs5J5gGo3KkLMO1/4iEgKrlMRVCjzW5qaT5zKzk1o11a9VK2m1laPJ/XT5/q5lYnaxvg7Lk05xbPs2XLFiEoIygICy9FY+YB1VyuUxDeTMTD2MwSiUQikeQwpKCcSfCVMV8dKzFl6ZjHLGaKBtY7KCjV18rcj0IyYyTTSY9pFSmY0kFwyyWtwKnAV9+1ihY1WrY+pkRVoPaQZfNDG2aWz8+VK1dErnc6XVHocXJyEsvoKG1ZMVbW2HYhNMW5bpvZ4eCtlHXecu4hahXUard53qcODqKP+FEENU9PzzylWU7LSTO768WA9XS6LFmyZIqHFHW9LXx8UHDDBmhiY8T8PH36tHiA4pymk6Z3oPF5rWQMpD0yicSLmSA5lztUqSEFZYlEIpHkSKSgnInoCwxxyRpiRqawd3dPfSAsLXURLPi9QoUKWPTwobDjbNKoP2Yduq3bl7bPe9cuQcdUyk4vFOAoyFFAirl8GbMnTcLu3bt1jn8F/P3Rs1cv1G3WDNbe3iharChw+DCSHoehUfFCOo0y8dXEoLafDRaHP3dqbFLCEye2rQbFMVcXV0Qmt1WtUc5LQnJqTprZzYGVK/HLuPHCsY6wXnXq1MHHH3+MgGLFxFxS19u2kNahj7EynMzNERcaCltHR3hWrAjbVLTkSsbAokWKAqdPwwkJL2SCbFbKG1tGLkfLLGi3RCKRSCTpxUyjjgGVS6G5gIuLi9BUKmmdcwqKRjm9+3P5RvXq+CYqGhYr1mHptTj8c+YeWpTxQR0fDd6vXx2L8/sjaMVy2CWHi8sMHp0+jQdduur+1znknX6eHIPa69jwcNzp8QZmli6Fd/+chUWHbwntYE0/a3S7th9bIiMRV7oxttxPEHVuGGCFofWrY66nl6izVfHir6WNcnazd9kyuH3xpdGxVTvVGas3rze+ZTC1TadWrYLVyFH4r38/VB04BPMP3hBzhQ98+R6dxuLRH2Gak3Omz2WJRCKRSF5WbswZd+88jCIkUxgkFD4UR7bU9udy7Hffie/j6SB4dBm+DHyEZysm4r261fBWi/Tr4BRHPS7V39VLpiwmzl99CauVG7DkoykYFNAOiz/8FVdGfSW2PX38WCfY3ti3Dx80rImAk6vweUAoXJb/CPuFM/Fs8Wz0mPkFvnO/AbO1v2Jw7croWFVYqurap7Q1rwrJ6ugiOQE+E08a+734bj5zoW5sueTD2J+2NmIbTXhoR04zHH0HT3GsublJbVKOo4kGmTduHL7r1g4lLmzGJ163cPWXYZj90WD89OGHmd5WiUQikUgyA6lRzgJu374tnl74GpoCBs0Z3Nzc4J6GOQZDsF1p3iLVfUwNqaXO0KYfR1mdta13rVr4CWZw+usvzHzknOI1ed/KPuj560c41749WnTskGbdXrbOuZmc6MR39uxZdK5YEauqVceSD38VznQKA2sFovSVbSg5dSpuffgBQp2dxYNMsWLFEBgYqGuHfmZIU9pv+eCBSXPldZgXEolEIsldGmVpo/yKobDAAaF2jvbKFE4pLEdGRopBSs0sIzOc9AxlaKNGmzFyWSc6DNLhikI8tzGTHtzcEWn2ouPVtitP0KNsMB6GPoRlQIDRusXfuYOYR2FIsrGGta8fHBwddFkJX2W65pxCTnXiu3dPGwGFDqIMz6Zm09kHaFSmhPhOJ1QzZ2cxT5jGmg90NLXg/xSSOV+4pNMp16fZftVc0XdypQMnH9Jeh3khkUgkktyHFJRfMdSoKU8rao0yo0eYYrtsSHh4cPIk5k2bhrVr14qQcl5eXmjfvj169OgBZy+vF47Rz9BmLDOfiM7h5U1DaTglPXvB8aphIReRic2vS2ftOY0INrQztcqBGtXX3YkvIDmmNm2SGcNYrVHmWF//bz3y0RnT0hKnDhzAuX934e71ECQmm1BYW1qhdJnSqFizJnzq1TMoJBtrv3quqJ1cHdN4qyKRSCQSSXYiTS+yCEVoUOyD0+Pgp+bO0aN4kpzJLL2vsNWZ2YihbG1zvvoKVZcshe3vv8G8fDWd41Wz0t4oFHoaFcd/gwJLl8CxXLlc5cSWHeTE9veqWROfhYVr7c+vxoqxpbNl52BvfNSoNiam41xpmUqk1v70OrlKJBKJRJJZSGe+HIhao/syAsLk77XOWG7ffougVSvhuXaDWOab+RcmJQvAxkw11JnZjGVr69Chg1h+NXAgdv76I7rY3MEvFc3wbNkPWPbRYLGN2mdTyGlCYlaTE9s/fPhwsZw+4A3UDjuKv+o5oXzIv/i4SR34aZ477e3y9xfLZ336wnXmbPhOnYrwz77ErOQEJCTuyZMMt18KyRKJRCLJDUiVTjagr8U1RdPLJe1CN2/ejAH5/RFVrgqmXY7GpjPXRJit3tXLoenAAcCs2UJ7bWPgXKZg6+oqlqNs7YClS5G4dCloONGDH5plJNsZm3rOnKhVfVXoj1lOpERwMK4A6Bf+GBj7PThLCgP4kRvNntf5JuNpvzEAG0o1w6bdoahdxAN2Lh5I+vRPxFw/ICKb7NmzB01Kl9aF+OPS1Pbn5D6SSCQSiURBCspZjDr6hH7EidSiUXAbs6JxybTW8889xqyD2iQkM/Zcg0aThPaly4j/r127Bh9f3xTnMtVWOMHLC55Ll8LiWbw4NjwsDOHhj5GYlCjsqpmQgvvERESkec6cGPkhq8Y1p7ZZ7SBK582oyCi45nMVY03nzqnffYf2584jNikRawOqYnayHfPiwzfRLtgPB27HwSmgGnp4rcPx48dR+s4dYW/MeUkbfA8PjzTb/zrNC4lEIpHkbqSgnIXoR5+gYKFEnODSWDQKZRu/E5HW+mLYC1EL6hRLBHW+1NRRGFHOpWT8Syv6glI/s/x+MLOwgD1DhMXH4+HZs6IOGhsbISSbEtEhp0Z+yIpx5diRnNpmCssMPZgUHY0dO3Zg9+5diH/2TMQ7tnmmjfFdokJVzLmfmOK4o9fDUcrXBVvuR6Jb2WBonkaJyBdMg825xjlCIdkxIgJnzpzBxg0bcf3GdeH016xZMzRq2AhWzs6Id8v3WswLiUQikeR+pKCchehHn9CPOJFaNApuY0zbkiVLatNaN+6v0ygrUQs2LpyGfoCIgoFkTZ1ao5yWQGIoWgEFGVdXVyEMcaloANOK6JBTIz9k1bjm5Dar43MzBYwuDUzoI90+9U4exe1K7TA7/PlxFQPy4eC1R2jhZyWinzR8+y0hBFNIVjTKTlFRCHujJ9wA9FQOfBQGTJuOW9Omi3/9Vq2EhY9Pju4jiUQikUiIFJSzGAqaihYtvTbKZNjQYUicMAFlHpxE/6rlseVSGJoUdUOBe8ewZssWwNNLxGe2obCcARtldf0UChUqJDTTXG9sH1PP9TqNa04lISpKLBd4eeKTn3+Gjb09oi1s4JAQh+WTJqHy7t0ipXWbG4fwtGQ17LmXgNqF3WFnbYkGflZiPbcHBwfDys8vhY3ylqn/A4PQ3e3eDTW6dKHnpzh3fOg9fDtgIIZpNLBOTISNs3OO7iOJRCKRSIgMD5eNZESgUmsDLby8kFQ2GOanTwjBJSsynOkL8IrG2NTj8iq5qX3bpk2H36RJcJr2PySWroR5+6/jnzP3hFPoGyVdENeqsW5fZY5Z3b2FZ77+KeYa55m5v78QkJW07AMbNMDIh6EIWrEc97wCsODgTXFuhhds4BAB93cHiNCDBerVE8fRRCi9D47KOolEIpFIMoLMzJcLyKhDk+KMRa3giRMnEBoaCp/aNVC2bFnA7NVmvtN3WGMWP9qlMqFK/vz50zwurzpv5bb2nTx1En4A3L288NP+68IZlHBpZlYQhdq1RfDqNXB87z1cCn2IR4/CoMnvBxcnRwT16oWYxATEe3vj3JMnyGduLoRk2mbTBINzEvn9ce/hQ8y9nIRZ+2+Ic/+1JwRJVf3Qw8sLu/7dhQZFi+LBgwfiOPZZUFCQSc6tyjrOudzQ1xKJRCLJ3UjTi2zgZR3dKAhTh1uzjDbKRXY4rFFwod0y680nM6YiNqRZzutOfbmxfUocbJpE/HNGKyQrMAHJe0EMGAd4NKiPAqVLizZyjPlQROH28YMHor2xjx4JIZYPCoojqoW59tyRZlbYcv5hinNvuRQunADjn8WLFO4Md8hzc07xgY828Gk5t3KdYhOeG/paIpFIJLkbeZfJjk5PvtHndKcvQ3WmYMQoGvxQsKFQQ+2eMfOL3NjW9JAb21e7dm2xDAu5Iswt1NBEYuW82QbbyLF2c3MTYQI5/u7u7sKZT1nHT+UqlcUxjppnaFLCM8V56gY4CNONKlWqiH3z5csntMK0qWdYOZ6f51WW3EYBmfuq11FAlkKyRCKRSLICqVHOJnKjo5u+wxoFZVNslHNjW9NDbmtfqVKlEALg4w+GYcyqf4S5hUhTXsoLzveO4+aVq0C+fAbbyDH39vYWml3+r6SiVmyU33rrLeDLr7B+9Wr0HPEVLC0txLkbFnWD+ZG1wr65ePHiwgkwICBA2ihLJBKJJEcjBeVsRBGscpMjmH7KawrJqWUa1N/flAgfuQmlzrmt3qSEoyN6liuG+k2aoFNwRfwzYinioqLw++hRwJ9TodFoDLaRgrGSglq9jpQuXVoI4f8uWIAlS5agdv36aOrlh23/+xutSpXSla3sr9bCG1saW5cb50t6eR3aKJFIJDkZKShnM7nNESw9mQb1M7Sp9zWWhTA39UNuHTs6fJIBTyIwIDAIuHhJfJpzpb2DEJJJ+NOnwg7Z2LgYar9y7jFu7tqdjh0HcBxdrG2Ay1dS7PPo0SOR1U8x43gd+j49vA5tlEgkkpyOFJSzkTt37mDv3r1Cu1a9evVc9frelEyD6gx1RL2vvqMWl1euXMHDhw9FhrgKFSqI7Rnp05MnT4oya9SooSs7s8mNTnxqZ9CCGzYgkk55SYnCAc/B0UH0N7XIzLYXxXa5u+NZZKTBzI7G2s9zuy1ehDNHjoj/GY1FLeQpUVk4/krqazoIHjlyRJRdqVIl3L9/H9evXxcmHvxffx7k5r43BaagZ2ZDtontJ3mtjRKJRJJbkIJyNhB66jTGf/UVNm/eDDNzM3HDp8NS79690b9ff1g4vroQb1mZaVDfwU29r1qjfHTdOvz244+4fPkybG1s8TTuKUqUKIHhw4ejYs2aJvXF/RMnMO7LL7Ft2zZxfvaps5Mz+vbriz69+2R6n+b2zIO2hQoiycfbsMYyJgZJERGpZnY01P4n589j4pgxWLt2rda0RgNY21ija9euGDx4MKzp9Jk8BpwfVg9DMee3KVizZo14UPK1tII1NEJgZrmRfNgKCMAnn3yCmg0b6o7N7X1vjJD9+/HdZ59h37594mGT7aOT41uD3kKXPr1zxW+CRCKR5DVkwpEsJuriRdxs2y5FQofEssEiLXVWJQ3JbEyxUTa0LzmyZg2cRo56qb6IOH8Bt9u3z5Y+ze02pMbqb8iGPLXjn169hmstW5o8BurEOYb2N3S8/vjl9r5Xc+/YMYS/oUv6bVL7JRKJRJIxZMKRHMzGlSvB6McOn3+GZ5VrY+H5CGy6EIpmTQaill04funWHuN9fJAYHY3cQmrOWGk56v0+8SeM5L4zF2LJAwtdX/Qo7oSF7w1Cl9u3RV+k5vy3ZukS8AW105df4GmFGlh0IVJ3nmpWofijd2eM8/IWSVqsM8mhMDc78Smk9iBjyJHOEMq23Vs2w58C3scfQ1OjPpZcjtGNQQOXGExo1ww/+PkhPiJCjMGV//4Tx4X17QOvtt3w19E72HM3Hk3r9Uazgg5Ycfoe9j3UoGnDvih27zjKT5ko5oESXYMaaf3skLlZcJ43fTpaMwnMd2PwuGQFLLkULfqvaeP+qBR1CYXGfonY8HApKEskEkkWI00vspiNGzcKQdmzcmX8dDkGfx24KdZzaVa7IOwYGSAsDHmB1Bz9aHpBW9TDRw7Dolp1LLpvhlkHn/cFLAJRr19fYOz3CAkJQb5kZy995z8u+aqfgrJV0aKYeSkaM1V9qqkZCPPChYHIKERHReuc017GoTAvOFkZakNG28XjVqxYgWEAnri5Yc3FKMw7dFs3BgnV/eFeuTINyIUN+pPbt7F23Tq0AeBVtSrmXYzA4rNPxP4zw2MRY1EA/95LxP2IOMw8HIs+lYJR0csLhw8dBmcBbZZps0thmXbORInxnBvH5OrVq1i3di1aOzoh1MERSy5GYc7BW2LbzIO3kVCpEIp6eWH//v1oXqFCdldXIpFIXityp/olF/Pk8RNVVrR7Kbbx/4r1GiAvoHb0ozBD5z71ksLVvXva9ieWKY8tF1M+HGw6+wCuBbSvmZm1jfvTCZAZ3fTP9eSJtk8jYYnN556/5if8P7hOffGdGeGUsun0x1cv+udkfVlvRdtsrF2KI5mx/XIyhtqQ0XZxP/UYxFnbYcellGO57cIjlKpWU7s9Lk70O9OfkxgLa2zXG/s9l0NRytdF9//2q0+QVDYY9+7fE2PFDyNm0OmQ2f04nswSybE0VneOK/fJaeNF22z2RWRUlPg/ytwS2y4+SrGP0n6ljyUSiUSSdUhBOYspEFBALB0S417MilbKG7vWr0FeQD+Tn6GsawULFtRmtTt9Ak2KuaU4vmlJL4ScOiG+5/fLbzBLm7L09+dLf8AJCeI4NY2Le2D/5o3ie8TVq5g6fDjalS2LblWq4I3q1fG/4SMQffo0LO4/EOdifVNzEMuNmfhMaUNG28X92G/58+cX/9vExaBB0ZRj2aiYOw5u/Ue7PTmTYxDD0vH/+Kdiu5raRTxw9u5zobBekKPI6FeoUCFdBkAlK6CS3Y+JUDg/9Ot+YedOfNqpE6q4u6Omjw/q5M+Pie8OxqPDh4WddHZDzTg14T4+2t+Ck8uXoIpnyr6v528n2l+ggPa3QyKRSCRZhzS9yGI6dugITJiAk8eOoXezdmDkK2Yua1HGBwFx17H2zh3AI2Xq39yKfiY//aWXlxeaNm2KxP/OoHtRR1hYFRRadfZFlwo+GP75dIwD4OvnCxsvrQBs6FzdunUDJv+MG1evom+jVrCwMNf1qV/MFWx+GKrNNDduPHoD6O3pBShdfPo08OlwPEx2lrIMCEhTSMxtmfhMbUNG28XjGFkEo0Yh7MED9O3QELY21roxKG5xHyvPnQP8C8DT0xOO+fOjXbu2eLx2Lfbs3IG+H4xEXEwM9tyKRdNi7qhX2BFPH4fiiIUdmhV3h8OFf4VDG5OZWBUvLspUsgFyacxG+dSmTbAa9gEGMGa0n1aQF+zYgQf85BAHOT4A9GzaDNi8GbV370HFAsXgWqIattxPQBNvS7S+ske0v4x3ygdriUQikbx6cu+dPpdSpUoVsfxx2DAsHPkBmsacw4TScYhePA4/9O6Mse+8i7xEao5+/AwdOlT8P6lzG5S8tBlTqlig+IVN+KBhTXg8fZriPMbOVbtWbbGc8N77WPzZx9o+LRWHyIVjMbl/D4x993mf0lkqaMVyBK1aCc+1G+C7dAmm2mljLdNZLD2a1NyOoTZktF1FixUVyz8+G435w4ehYdR/mFguAUmrf8bXHVvhm0GDxHZqrIlrcorsNX/8gd/f7otmN3dhxo3VeDZmACbVrYTgTVPF/9G/fIiTf07WlaPOCqjO7meo7gwXSHwmjNeNN5cu06djfJx2buUUp1krjdYk5O+YGJwOOYcO5tfxcwVzOO74C2v+nCS2JcbGZHMtJRKJ5PVDhofLYvTDYhkjJ2i6ckp/KJpeYxpl/dBkqUEh+YF3IOYduCG0181Ke6O2VSh8hr0Dj9mzka9yJXFeCl+KxlK9zO2RLtKKdpFRTB0DJjphDOf0jJl6Hpj7++sEZH3U43P27Fl0rlgRK4IKwnrVRiy6HCPGm+ZOvasHYOukcaj5999iPtiULCmON/bmQ9mWmeiX82aZsvg4OaJHzBsDsDagKrbeT0Rjbwu0uXEI9gtn4vE7b6Pa0KG5fv5JJBJJdiPDw+VgKPzyhq9osuhURickJsfw9PJMkb3stesPjdbhLikxSQg9zBpn6eiESCcnPEuOJWso6sUzezs4z58Hi/h4kWWOCUu4H+1haUrAqBnvdeuG3/wL4GlCAubsC8HMfdfF+f7aE4KkKn7o4eWF8xfOw8nWRpyT5gS0vVULyRRq+J0mI7ktssKriHahPmdE8hjYJ0ekUDIvKhpkEm9hgadu+RDNyCNu+WA1fRruXbsm9mVfu8Y/g2VSEmxsrBEXFw9zO1tY+PhotciOTnhoZYXEO3cMprymcx8d+5TxYSQJJq+x8PYWIRiV6DIz9lyDRpOEesnCMR1FrVKbW8mRUWhXnVljrh8Nhs58J+7cBry84TJuHJYhCLMPaqOGzA4HzCo3RA+vdbgQFoaSDK+XCyN7SCQSSW5F2ihnA4oQzJtlPLPIxccj2toaPoUL614jv06oHwpskpLEkx4YfSI2FmZMh50cP1ed8lqdKltsc3cX27lNExcHCzs7mFFYdnaGh5cX7iUmivPHmFtj87m7Kcrfcjkc3coGi+NF2cnCDDPEsTwKJYywoDi78cEmN9ooG0r9TF4mHTTPyT7iBx4egIsLbFxcYGdAYx0XEaFLYf702jWsXLgQu3fvRkx0DLy8vdCqVStUqlgJVj7eMPP0RJJGg0SNBkmWltBYWSHi8WOdNtnFxUX3XUmHzfOy7hw7CtJ8YGJEFcYj1o+oUt5ba6bONifExoqx5vnUadhjk9dzXigPXRkdc745uX35MpYuXYp9+/aLh0DaXLdt2xZ2tnYo6OQk9ovOXwCbd6SMArLlyhMxPzm3FcE9N86/zCD26lVsW7cOq1evxt27d8U4t27dGs2aNYOtq+tro2CQSCSviaB88eJFcbPYsWOHSF/8zTffIDAwUGxbsGCBzpM+r0LBi5oqCmdcvo5CsqlpsfVjHqtTZRvbpkRAoANZjRo1gDt3YZ8YLyJjKBplUsPXGubrTyCgcweEOTun0Cgr8XoVZzF+p8CSG4UUY6mfXyYdNPdnH/F4QoHSmO2zMq6P/vsPmncHoy0gPrCzAyIigUWLxScSgNviRdAkR4JQxpX9z7HhuKjNL/id61gHfufYVatWTfyWMKIKk54oGmXSpKQn/v55LEYw+oyDg7b8NOaWsXal17xI12Zy+j/tB8C3dloNsfXT6BfmZ50C9mJ+1uzyTZpRWfIy0Zcv40brNigM4CNlJR11Z83G7VmzXyuTNYlE8poIymPGjEG9evV0/w8cOBCff/45Xif4MEBBTgrJaUfLMMWO1FiGvffeew8Y/Rn+GD4cLb4aB7PqBYSmsaafDbzObBVRBWj64le8eJ62Uc7MaBf6x5PUzqHs9/mPP2IIzRm++hLOZcshysIKrmZJOHH0KCZ+8AG+c/eAM98G6EU6YQg4ZSz0oWaRWmb1+Hz44YdI/PkXlLh/HP2rlsOWS+FoVNgV+S7twqXLlwB7B3FMahFVMsNGOfIhY6oAW8uWwcCvvoIZE6VYWMMhMR4zp03D1jlz8D0jsQCY/MEH6PjjFN38pJDsenKDmJ8enp7iDUlunn8vw5ypU8Eo85phw1Cwbh16hop49LH3b+Prfv3xiaVljnHOlEgkeYdsE5QPHjwoYoeqbRjnzp2Lf/75Bw0aNBDa5dflhvC6tDM7UITbUhUr4grD8924AQzsiW5eXuhSNlho6iiEKLbhaiFMGRdlHf/n+XJrumRD6alfNhW3+nhTknncvn0bO3fuxJCAQJFufOblaGw6c0vrZNe8PSq33wns3iP2NZRG25gjn1IXZTu/12/eHFd+/gVlJo9HeS8vYb6gjHcTewfdmBsqR3+pbqupD22KUL9+/Xow1k3PESNw3zsQCw7exD9nQkSbe476BuvWr9eV8XZMLDDkTaPzU6lPeh8cczt8k0CzlQb2DkJIvucVkNyP14RDbrdfpgIfvydMcLTvByQSiSSXC8pjx47FrFmz8PHHH4v/27Vrh969GeUW6N+/vzC9UP7XhzaE/CgodqW5EToh8cfdkIPS64qh1NfG0k2ntk2xW6WwwiQVnkuXwuJZvEidfe++VoNcYPBbBh0o9R3c+P/NmzfFvGOii9yWLvlVOfEpxxNTznXixAmtrbe3Nxace4KZyama6WTHmOKNmjQVgnJ6M+hRAFdMmJiERNTFy0u8io8OfYRz58+J+hbu0AYFfH3T7TSrnpOmzEV+54fC8vHjx4Wg/DDsMRbeuoY5eo6FjZo3BzZthuv48bAt4I+oyEhcCwmBo4MjSrw7SOsUqaqrcJ5M/s0z5XrITfPUGA8ePBAfBBVEREwM5u4Lwaz9N3QOuQmVfdGTac4PH0aLqlWzu7oSiSQPkS2CMjUslStXTiEY8uam0L17d2zatMmooDxu3Dihcc7tKE5ISppntYNSXoH2mVGhoeJNwblz52BjbYP6DeoLpy0LxxcFFXXqawq5KRz2UnHm09y5g7jwx9i3fx/OnzsPG1sblCtXDiVLlISZuRmSPDzgVKyYcPArVqECSqSiZdN3eqOgwfFh6mRlHeuQW5yqXpUTn3I8x4Rjo6xL7VwiIsazBOFkt1kvVTMTlNQtoRXozM1MrwvLpOCoLBUBUYydvz/MXF1RvGCQWEdBOr3jpZ+OnQ5+qTn/CcdFOpQmP6wxEguJsbLGNgOOhX1ttNrtJE0SzAoXRn5nZxSoX99oXXhu9rnibGrQuTX5WhE22LlknqaGMmdJlJkltpzXmrMobLvyGD3KBuNZfLxot3p/iUQieRmyRSqjVomvX/ft24fTp0/j/PnzWLJkic6Rb/v27SienIHLEKNGjcJHH+ncOcTNMTemd1WckBSNcl4UkhUnpgrJH8H+/VCSB+s732TEmY8RFCLeHAQzALWSP4Lj2hTYhO8fnJcuhXWRwmkKDPpOb8o4USutaJQNpUt+3Zz41McTU85Vu3Zt2DvYCye7po0H6DTKhK/Q184bg/78h4OZQadYjo967F6mneq2Es4BUxxLKajxIYL71KpdCzh3DnEXzqGxdwkR8k2BcZLrrd8LxmSJGDUajqtWwtzVNdW6KBE40qqDWqOcG+ZpalCRUqFCBSD8MRw1CWhSwlOnUSa1/W2FmUrJNi2kkCyRSDKVbJHMPvvsM/Eh/fr1w5tvvolpdGrZulX80FNIptbYGLxR8JMXUJyQ8pqQTBgOi2wpUxp9Ro+Gjb29cL6JuH0dP7w7GMMY/suA8016nfmuHT8utm0qVRJ9R38GW0cH4SwVeecmhg4ejDIurugTFgZ7czOTX0HrO7jx/6JFi+ZaG+VX6cSnHG/KufiA0bdvXySuXYcaNo9gXlubtpxCsl/0Zfy6YT365/d/aadY/bF7WY2q/pxMj42yZ+PGuDV9BtZOnoSOPd9EQuma2HknDk0Ku6BMwm0sT0xEh+RyrJPDGJpSF1PqkNvmaWrwPoEfJ2Ll0mV448NRsLS0EG8h6hVygebgSmHLHZQLFSYSiSRnIzPz5SDy0k2NTHj7bbT9dxeCli/HA5/n2fDoxNQ0XyycBvbCs/HjUKZtW6M3eFNeo058dzBa7diBwOXL8NAnKEU5zQrZom/FUiJDG7fblymTpvCtrNOPemEoAoKxKBs5Ef06ZrTOaUWCSEtwizt7DiGdO2PUg/uwKlIUFeo1wK4NaxEZFobvBw+G14KFImOeXenSL91GY1Ey0nuelzlWP/ukhZcXnr7zATZbeGNVyNMU2fcsJk9GsRbNM1RueupkbLt6rmf1fE6rzNgzZxDSqTO+Cg/HDU0SKlStCgdvP5zauxsDGjRA+R07xLxJDAwUbxUkEonEGDIzXy7kZR2rciJ79+4VMWMjYmNSZMOjE1Ni1fwiG97m7dsRUL++QSckJhSg3SfDghUqVMhoObRLbkXzisTEF8tJCkClatWA+w8QHRWNWGaFS8UJ0JAzlvJaW4nQomRp03c6zMljZ8g5MSPzTe1IZihbnSmOmHEJ2v/HeXnz1wpYu1qrUXVxBRYsFNvovPaybcyoo+zLXIuGjqVpEeNCD+/YESOtbXAouDz+0/hg8XFtYhGaYmgqNUBPr3XYsWN7pgvKabVH2c6+UsaNfZaV89mUPmdmR/KN4s9y+Yr2Q3bsEIuLN28i/OFDYapRvnz5LKm7RCLJ2+S99/25EEPOVjldO5kWSnIIxflm8zltiCuFLZfCRLguZk9TopionZAonDIlMXn8+HGqmmVFY2kw6965h2hUriKw5R9RVkJEBI4ePYobN27oEpEoSUR0joHJTlJcrwhaLIOCnmLzqti9Kk6H+s59bDvt8G/dugU/Pz80bNgwRSjErIBtob0/I0JQUBRJV1S2yemdb2pHMuU86mNNdsR0c0O+hQtgFhencwKkw5uDo8MLER4yeg0pY5deR9mXuRaNHcv2s803kq+HSt17YurulCZH265GCGe0mNjYDGvBM9IeZTvHiQ9AitZfKT8rfotM6XPuwwQ0fOAwfxon5grnE68xZs0sWLCgCAF5+tEj0Rb+dnC91CxLJJKXRQrKOdjZKjfDNlQIrgAcP475X36GSh0/wS2VE1NtPxvhfFO5Vy8hUBlyQqJWSNEop2Z+IZx8Dh6CfdKLWfcaFnPDv9PWoLuVNf7bsRM/zpqF0EehIrxbWFiYECCHDh2KOk2awiG/n0FnLH2Nsjpbn9JWtdPU1nnzMOHrr3H/3n14eHiI8jw9PPDp8OFo2LJllmQOWzd9On767jttG93cERoaKtJEf/rJp2jQsoUInZbe+abvSKYv0KTLEVOViTIz3qToX0P8ZMRR9mWuRWPHKs6gpUuVAq6FwCnpRWe0+kFO4nqo8ubATPVXSKs96jHjGwJFo8xxzqrfIlP6XFfPoCAxj+b+8ANm/fGHeKigMPzw4UOUKlUK/fv1h7O3N5xLFJdCskQiyRSkjXIOIjfYuaaHo3/8Aftfp4jvMW8MwLqgGthyNx5NfK3ROmS/sMnMP+VXODZq9FI2yueYsOHjT7CjdSu0HPE1Fhy6IZx86CCGi//ixNzp+C5ZC6q2E00sGyyiLygJHRiBwzIg4KVslPcuWwa3L75Ms5xXKSxTUM8/9nuj5avbmh02yvo23Zk573OijbLCkaVL4fDlVzjYtQvqvf8pFh66qZ2npbxgf2YrWs7+X4ZtszNap9xko6zsM+2bb1BvydI057dMZS2RSDLDRjnvSGV5AOVGRRThQn+ZFRgq21h91NuUuivL86dOieWSJ09wgBpFextUK+gGWAEXkl9Dh91NaSqhj6Ltog2j/vmVpRIacMvMWRhSpwqcds5CX7MT2D+yG/ZO/RkT3n9fdz6/H3+A1d/rseSjKRgU0E4sT773idjGCBwcA/2btTozn1q404f1+d8vvzwvZ+WGlOW8/7wcQ31KjVp6+tvQkhrBPydNEv9bzFqYonzLv9djRYC2rzKS6lct8KYm0Cjb1EtD64yd39R1+vPO0D7qTH2moIxBavVLawz0j1XqVzpZAF756xR80KAmnHfORl/NMewd2Q2X501/oQ48LrOuf/W8NXQdqbXf+vtnNfr1Y3/w+ieMZT7z999183vxh7/q5rf58rWYkvzWJy+ksta/FyjzQiKRZC3S9CIHoTgfKc40aoeorHIWy2hWPH3nN2Efu3cvKgJ4o1gxLAyoitlHnmt8+peoicpeG/Hv/gNo17ZtquVcv35dmBDwdTDTnqu1vFzG3n8gnvi+9/LSnnztOrGozT/mFnj244+6csOcnLDgUjRmJWdH++vATfStXAEVvbxE5q/AZGEmNUcwQ33EGzgz/h05ckRkD3vq44OFl6IxM0U5waKcSxcvwSv5nEpb2T4laYQyxunJQqhsCwkJEYldLKpVx6J7Zph18Hn5SeYBqNW9B/DDD7h54ya88uc3eU69KmfT1BwiU8smqM6+yO8cJ9o/GzqXqXVXZ/djuDlj9UxtDPTboJ5HTskOiuN9fCgFAWvXPp+nSh3CwvDsitZBjfObZTB2c2Zc/2wD57giGKuvo9TmeVb+7ijjqdSL/9+7d0+sowkWsxyy/5nZce6NBMw//uD5/DYrgOAO7YHlK4SWyC4P3QuU3wdDc1MikbxapKCcw7L0Kc5PvJHxhqA4RGUkExw1EceOHRNOLVWrVk3zZpfhrHh6zm+6lM8xsZQmgJGjsfVUyviwW+4nCGe+O/ExBp35lHIIbxKsD9ez7bxh8vwsh21LcHKExQ8TYG9mJm4kSqxjRbChQ92YoUPxm38BRJpZGc3qxagY6rEw5AhmqI+4pKBMO2AFQw6M2648EeU8CnsEx5gYXVspDNFhkbBdrLNIpJJG1jVD25Q6MPPdlothKfv83EM0K6e9yYaFhyGfyh47rdfyr8LZVL8v1XOcGMsmqOzPfqNgq4yNkjFPfS5THReVrH6cT3T05P4ByWY4+vVMbQzUbeBxKeaRv78wCdDXdrLOnHtxFuZ4YGGBpOTfAR7POjERk7e3t0ljlVpfs+6sB+vPOtG2l/NNyd5naJ5zPrEORYoUSfP1ZEZhWRTgKRAr6eZZT7aVtsd37twRdaBTLK9lO1s7Mb93hkSmOM+W86H4qGBR8V0Zp9wWn57t5e8d5xc/ylsF/j7wf6KOFy6RSF49uetXJA+jaHUIBUAl85s665apzjVRe/di3m+/Y8vmzYh7lvwq2cwcJUuWxCeffAx7X1841tLlr8uYM1YqmcgUR7cAvua/ew8uHvnQtKRdCie7xkXyCeelYq1bG3XmU8pRHO+4n5eXl+78ypI3RTNnZ3GjV2vibZO1fwFFiuAxBXYAjppnRh2pvPr3TjNjorE+IhRolDFc+eN4VG76dgoHxnr+dqKcwPZtXtAaU/g3plFOLeua/jYmReE5aLPZpHF/zDp4W1c+2335+DpUYoIOPz9xDlPm1KtyNjXUl2llDtTfXzE3UWuU1ecyNTNf7NWrWPz999i4caMQlklwcDDeeust1GzYUDg/KuWmNgbqNvDzwjwyZpseEwOr+HjEh4Xh0q5dWDJ7Ng4fPqy7phrUr493Bw+GfcmSGbK9ZV3YP6yHWqOszjypnuf/bdmC3378UYR4pCBva2OLZs2bYciQIfAKCMg0+1+W8/vEidi9e7cYS9anXt166NmrJ+7cuo1Zy5fj+AltQiHWoWKlisgXGyPmd/26vTA/PFZ3rsbFPfDf+kUomZzYJjcJyQdWrsTUyZNx6NAh8T9/Axo1aoS+ffrCLjBQ9/vAhxUpJEskWYt05sth6DvTpDehBYXkmwPfTHO/An/NMCgsp9cZK7UEHTv++gs+P07Ew5EjENi6M+Yf1DrZMRGI/92jqPbT9yiwdIlIApJWOdR8KTd1/XIUWz5j/Ua+7dsP3Q4fhutfM/C0WLkUjlRWxzei3cKZLzhSpaaRMlQOP+M7dkSni5eeOzAGVBPa8ybelmh942CyA+MUODZq+EJbFWHO1P42tm109+7oe+o0sHQ1VtxIEMlXWpTxQbtSbviocW38YmUl2mpTsmS6hN5X5eCV2hxPbZ2+A1pq50qt7lEXL+Jm23ap1lHt/JjWGBiyUTY1NN357dth9t77adYlo4KqMk8NXUcKx9avh93Hn7yyOiic3LgR1h9+lOHjzecswdKHFth05r6Y340CrfFe3aqY5+X9ypwiXwU7Fy2C9zffptnf8POTQrJEkknIhCO5GH1nmtScnwxx98IFsTzs7o62I0cATs6IcPOCc9gDHNu5Ezv//BM98uVDQljK1/JqUis7tW1K3ZVl9WrVEQJg8kcfo+Q//6Bh02aoEuSEVf+bjBMHDqKau7vQwJlSjtpsRL8cfY2voSU1YaH9+mH4G2+geqdOqFkuGCXcE7Hw2xHw0YuIoV+OqX0kBCWamwBYFfcUfiHn0dzTBfWL+2Pz9D+w/sQJdHFyQtLTWINtVWtLX2Yshg0bhscD38T4ds3QcMAATAiujPOHl2LwWzNQwcsTiNW2N71C76uKgpDaHE9tnb4DWmrnSq3uq5csEbb0NiNHwLdKFYC2zxY2cEiMw+Lx41H9wEE8ffwYzsmCoanjo5Ce0HSTvv8eHwPwmTAetsWL6+oRHxuLLwcMwDuxT1/KUU3tWGno+iETx4zBFwB8J0yATfFiujo8jYrGqD69MSzJcOr59DLxu+8w2kg5X7RqhSH58sFj6FA4Nmyg2xb15Akm9ngD/aytsXBAD5QZMBANSpXAka0z8N6c2ejA8bv+/G1RTocPLQwlOcnMHL4/TIBNsef98CQsDCPe6ImRfFsXHQ07aW4hkWQLuefd1GuOWmtqSJOqrFuyaBE68TX7sKG4Hlwbiw7dxJ6Dd1G7iAd6DByKG/PmimOSkqNOGNLO6oS+dGqU9bFw1JohCCe7Eye1HwBCX5bsOJSRDGwZwcXHG7TeHW1nD2zYKD4+AL5T1zc5sYhi45xe6EC09/BhdPH1RXsbW8QElcBau+LYeiERjbt8ilbVDgELZyIqPh7OBvpU4WU1yu7584MWzyNtbLWZ7hYsRE0ANZ2cdEKy0lZjAqShcl41+ppNQ3MrLS2/oi01tt1QO9asWSMEZQrJt93zY/GRO/jnzDXx5qPTR6OBru2wZ/dutAwOzlC71OWmpnmmLe7+/fuBwCCEFS+PhZejsSm5Hr1rFEPT/gOAP/7Q2kYj81D/jtAR9MSJE8Ih9VHxcinrUL04GvbpA8yeI0xCMjJPlXWXLl0SiX905VyKxqaz2nIaB7ngWmwMkC8fHpWvhqmXE3V16F65OILbtQU2/oPuiUnAdG20kGb8MNNjspCcVb8rL8u+fftw8+ZNICAQj4qVw6LLMbq517tGedTo0kXn9EmUt04SiSTrkIJyLvGAZkQF2goqtnci2gNtc83MdAkwuO7efa0DWRTMhZC8+LA26oGyLFe7tkjOce/uPTy+evUFIVkRNBRPe1OjXhhKZ8xXs4aclxQykoEto+jXhcIGbUcJ22vp6IRIJyeEXrokbAEZASC93uV0SLoZpxVEXcaNwzIEYXayjTDTFJtVaogeXutwIyYWlskxX5U+VUdoUFJEZyTqhdjm5ATPpUth8ey5Exzbm/AsAYlJibq2WkREGIxoYKgOrzrygX6UEUOpstOKRKJEdGCimvREcOC1BXsH3LxzF/MvPsPc5DFTp1q/eetWhtqlLpeklvKcUTd4jTOiw4JzTzDz4C1dPejH1aFYMV19k5M4Z/pvixCSeW16e2P+ucc6G3fWQaNJQpNChcX/TC/vlGy3beo8Va+7ePGirpy5Z8Iw5/BdXTlPn/rAJyAAFu4eWHgnCbOPhui28RxVirAf/oH3+HGwK6p13lPgPE+0skaClxdygzhJIZnzlf2w8HyEiN6hHvN6TMOdLCinFpVFIpG8OqSgnMPhjZ8RFSggUIjljZdCrIj2kOx9z21cx23Ozk5A6CPEevlhz8HnURjInsuhGFy5hhCUY5/GIvrRI91xSgQJ3rwV72p1WufUIi0oTlmGPPJzUtB/pS4iAsDjxyKddcKNG9i/ZYtw4roeEgJfa2u4OzggilEINBp4lCyBrt26ifTPaQn2FM6U7H2xBQKxeZte1ImrT0SkD1s7W9HnSp8qDoDsQyVFtBJJJL1RL3Tn9PWBmZUV7vz3n3AM27Ztm9inUKFCaN++vchmaEcTHEsrHDl6FEuWLMF//52GpZUVqlevjubNm4soA2b29nBKFtBeVTrjmCtXsHPF30Kze/nKZeSn06azCyIiniAyPh72AYHo0rULypcrh8Tk7Gx03Ey4cRObV6/C8hUrcPXqVVE/jlOHDh1gV6EC7AsXNilqB6MIIDoG0RZW2K4fKSQ51TqdqdKrWVeXy77nmPK7oZTnxNfXVywZ0WHzxUcpzkV7+hpFYsE97O3sM0XLb+i3he00FjVl09kHCPaJgwudW8zMUsxhU+bprcOHsWH5Cuzfv0+k6i5obS3K2XZZG/FFYeeVJ2hQriIS8+XD1qvahyWFbRcfoWjyswWFZLUdMtsQFxEBs0yOzvIq4TXGiBbsh00XQl8Y8zJeSeAjHx9yKSQr0Vlk5AuJJOuQgnIOR9Hu8qak1ijroj2oNMpc17pNG2DWbOxdNAe1mw7RaZJJrcLu2P/LAlTgTcbWDrbu7i9EkNDXKKcn6kVOvykpsJ6sb/Tly4h9621UBsQHrsl6Og0A5dXtzVvAxJ+ErXVaTkyMzlGvbl2RptguIe6FdNrVfa1E1Au/nt1odP2Cxpb9qU4RnZGoF+pt57Zvh+voz9ABQAeaYfAT+giY8Reo91Yssz0BvMcvjk7aFcdPiI+S3sB56VJYFyn8SsY3PiQE11u1RilAfOCiFdTA5Aq2dtoPQ+dNm66rr9PiRUhISMS1li1BfeIoUUmX5HSQx8TnumqslAc5Y5EvWrduDSxZioRHoWhYrLBOo0zqJEcqqd9rfIZsutXlapuVMiqH+pz+/v4ijCMjOjRtPECnUSbMMrnkj4n4gO13dsqUsTD028IwdMWLFzccNaWkJ1b8PBYjOFUcHV+Yw6nNxQs7d8Lzq6/RE0BPZVzzQZTTuEpH8cZFXU7IvGOwcHNHk/p9MOvo88gWDYq6Ye3EeSJyS1r9nRt+j+rUqSNiw7MfmjUZqNMoE/5+LBz3Gb7mWFlZCk2yolGW5hcSSdYhBeVcADWV1KCZYqPsWrw47vPV6KrVqNaqG1DZH3uuPELtwu4ol3gLIbSHs7WDj68P3AoVeqU2yjkZatA37NwJ6qOevvMOitSvj8/feRvvVKoG53KlsWbdWtQPKATfdq1x+NpVTBkxAhN8fNN0Ynp/6FAkffgRfv3oI7QaMxGo5i+0gzV9reF9fodIs8uxtFGFG1NrB1kvRVDOqI2yEgni6xEj8LOFpcoxzBoOifHYv3s3fvl0uDbxBZ8FOndCnR49njuxJcRh/PdjcXnnTnzu4Ah7c7NXZnZxePduuNFspecbqNSuHX749FP0KFICrhXKYcuWzaji4QOfNi1xNTIC3w8ejO/cPeBsZYW1y5aiDIC4we+ieKNGyXW3hkV0BH4YPAR9wsJSjJXSr4bmabt27XB3yVJMHT0SnSf+BsvkMavtbwfXUxvFmGU0hrB+ucp3YxrhDz/8EImjRiPw2l70rVxNxN5uWMgFzue2I+r0acDBMc2U7i/72zJq1Cgkfv0NCl8/iL6Vq4g446yD07nt0Fy9ykYYncPG5uK4L78UDmte474XIe44Vnd2bAMmTULBi7vQv0Q9ER1GW84OuD55gsSERJS5fRh9K1cVdWhQyBnO57fD8eFDwMLwrSu1cc6JsJ4jRoxA4qTJKHr7MPpVqYitl8PRoKATbE9tgmtyfHVCcwupSZZIsh4pKOcSqCVRhBVD3urKd2u+RgZEZAsMH4JypUqhf5OWsFz4O+LPnkUFanJU+6UngoShdbnlhmSIFStWCEG5RJPG2P0kDmaDxmFQqAaNvT1RcERDDNp7A40iXdGvY3X4rVgB3LgpXp0bC+NHCpYsCeZV6xsWDgwZiO5eXuhaNlhoJSlwEZpwGOpTQ/9nNAIJTS3u3rnL/N7CSWjx5Vj8cyZE6yTUoQcCV68GLmszwFFIfuAThHn7r+sciXpN+BU9yhQWgpliivMqWLZsGd4GULVjR5yCLZ50GYFBj4B3SgXhinsVTLsYigYRznizYS2Ubd4COHxYdxwFZQrJz+uubV/HiVOAAT1x+fJllFW9mtd3qFOwd6OoDnxC4WvEByhsZMzSi75mU12useumZIUKYv5UnTYFNbyWiAQ1Sj2aOjjq6mLogSm18IL681VdH/3fkeDq1UUdKk39GVW9vFLUoUWykK4/h1Nj+/btIlEICgQgvHh5/Hn5qRirZiWqo+UbA1B14UzU8NoqTFx0fZ7c1lJTf0FZvTq0ThaSjY1JVjqgZgZ1mzbFlUmTUX7KRJG5s7ve3FO3Vd9RNTe1UyLJrUhBORdAT/Tw8HDh9MGkIanB2Mhef/yO+AcPYc5XnhcvIO7OdZTp2hXuDsmCtpub0RjKrxP0vIeXNyJiYrDtehJWXYoR62cfuIF2wX54lpgknIzMraxQsWo1ISjfuH4Dto6OutfMSoITnVOjl5fOaTA8LFxkNnP3cIfb4Ley1IHx1KlTKFS4ECzyuQnHsFmHUjpl1a5bXycoUxtLQZPblH0oG9du0AA4c/bVj0FyHdacfozVl2Ph42yLQ9efYM3JO2LTvPBYWNvZokad2jpB+fKlyzTqNVh3TfUC6OblhfMUlPXKM+TUp3b0pDkTnaZohpD/3bcAs4yNmb7jlanpoNV1oaNd2KMwWLdqBlsmkTG3gL27u3DEfKbnDJpaCnQlLbQyX9VmIIbqQ0c4OoMmREWKbHlsh1uzRrqkLm6M56vqj7TS3jNxSlBQECw8PDH/3BPMPqwd17/230BStaYo0/4RSq1ajZgiQcjfs5tOw534+DEsXF2FsyHr4Nv7DTg6PX9YMDYmWZl6OzNQ9zcdUjmOQX3e0Jq3qNqq367c1k6JJLciBeUcDn8Mn5w/j9iHodh95DD+uH0bFubmqFKlKlq0bCFuXOqbBjUMFhUrwjr5plW7U0epcTAA+0lxqGK66b03VEaSNHW9Ho5Svi64H/FApH7u66y1nY2OiRZOkBSAFG0OhQK1U6MrM5cxExqddZA98MbJh6vEOg2EQ5q+U1ZRhopLhuYW1CTrOxI19gt85YKyuMELRzob/HtVK0CV9HXGMb3xEI5k3s+FATs7W6N1p1NUl7LBwulNTWpOfcr1wzFzqyws1jOM4nClLGnekJ4U4Epd/BlPOSFBhI0TTp4JCbBydcWz5DTUhlKgK6mbuY7bKDizDoqWVdEq81ilP9T1UdZpfH0QH+sCZx8fON66hUe3b2PDhg1CS0+BuV69emjUsBEsLC0Qk6QR+6tTuivpxBW7e+GwVr+xMCtQs+XiIxT0YUuBgBo14V61ygt9E5SOxCFpOW7mNPT727doUTF2/H3RDxmpbpepqdklEsnLI6+sHA7DiLmMGg2/SZPQdtduDL5yFW9fuoyKCxfifq/eCOnUGVeatxBOUUQR1tKT8vp1hP3SgBpTCmsJ8WhU3CPF9ooB+XD27hNdatwNSxaJ7w722tBkFLJ5M1PSAiu2kTnlhsXID9RoC6esolrTArWz1Mp5s3X/m0WGC5MFNQ2LuWHH+lWvvJ6NaV9MrVlMBJqV8hbf2e/sfzV0bFq1cO7z45o0EUu7Z7Ev1L1eoCPMT59A1WpVU6zPqmuD51YcrrjknMhouUp6aQqb+vON3+mMx/8ZrYL/c6nsx23qecql4iwq0pwbqI/SRxTWRLlhYXj21ttw/uZbtNn5Lz68dRtvXbiI4tOm41b37rjeuQsedu0Ks7v3dPVUymUdua5NmzYixrhw3CuSclx5ba1bPF/bVivLlx6T3Pb7p9/fxtLK67dLcb7OLe2USHIzUqOcw4lmlAIAy/398T4zN9nbCy2aZWwkvv78czw6cRKj7e1NdlySPKdv376IP3IUM7/8Eh3H/oRnZfJh1+2naFDQBUFu1jh2wxz9K/kg35XdcAkPA6xtEBAYAEeVE2ROdWpk2CmGVEvcfwB1k27BvHqA0LQ2KZoP7pf3wObuXW3kASaEeett9JgyTZgscB86VFkcXYfmxYuLCB6vkvYdOiBszVr88O5gdJn8B+LKumHnrVhU8LGDk5kn/r0ehSaFXOBz8yDOnv4PSH4t36tXLyQcPoJfP/oYbcdO1NW9fpATXI5vEPadhpzesura0He8eplyFYc7Y/ON3ykgG7NR5jZDNsrG6qOu69Vjx8W6ncHBeGPEcFjb2YnfH01EGD58/324RkZhyLNnWodPd3eD9aPJWLdu3ZC4dx/qJt2GhWoueoTs085Fu+dOrC9Lbvv9U9c3NZtj/XbltnZKJLkVMw3fj71GObtzG4vGjkXwvPnwWTAf4QWKYuGhW/jnzL3kLFV+6FWuGGa5uSNoxfIUMUWJzOKUOtTCUxuvYOHlhSQ60pzWJl1QvqudavTDwxnz8s8JQjTjEzP0mn7b1O1RY2yf1ELivSxPr14TYd4M1YEYqw8xNnbKvmnV+1U5Qulfd5lZTlrZFNPapsRMN5WfBg9Gy+07ELR8OR74Kk6T2t+ftqVc0bNsUSwtEGDw90dN7NWrCGnZKsvnWU53dkst02RubpdEkpfkRqlRzuEcOXIETJwb/TQOc/eFYLZe5qZW7dsDu3a/cJzM4pQ2OsepqGgcO35MJK1wS0xEkV69cPHSJTzVaFD4/fdRslRJgw5EaicmxXmJ39WOU2llL3yVMOEG2/fo1i3s3bdP2Kzmr9gHQYGBsLO3F05ZhDbXdBhltjS+Mq/Z5Rt4JEdFeZXOhyKbnrkZLP43FeZxcbh65QouXrwE18QEFG3TGpevXEFkTAQKdO6Mhg0bvuBYJ9p2+zYOHzqEu/fuwcvLC7WTnaDSqvercoTKqBOfKaR2LlO2Xb9+XTj2meIUrMBkNOIxxvJFp8mkpEDUrFsPuJbSRtwQdoUK6cZr7969Yi4GVRuIYsWKac0O3N0zfZ7ldGe31DJN5uZ2SSR5DSko53DMKB0AiDSzxFYDmZt6BRV5QVBWnIiuXbuGAwcOiJt2zZo1RdayVxnqKzei3JxrlSkNdRyQ4mkcpzjXUAhWHKiUbHq88VNANuTol9WvStk+36AgdK5dW9SDjmGsU7yVFcz9/ERdzFxdUTwoCKVat37BiehVIbIjxsaKbJCJyaYBAQEB8KhWTdz8Hz58iLOPH4vtZjbWQOFCOudLBXN/fzwzN0dpHx8EW1kJcxNTtHOvyuHrZZ34MlpnU7YxAx8fBPfs2SPGv0mTJmjVqpXJ9THkNLn53AM0LVlaCMqmvJjUzcVatUS92EessxmTlGTym0Cl3UzJffDgQTF3mjZtihIlSiAnwPlOIZljwaViWpMXnBXZpvXr14v55uHhITKB5rU3vZLXi5x1hUleoErVKmJpFRspHF/U0PlpjcrBSf06+89PP8WnnTph95w5+HfWLAxq1AhdKlXC5c2bdY5/ksxzwlEcl2gPyptXTnT0UxzDlDrz/+xyfmI57B9qf9k/1HJyyX6b98MPeK9lS+ycOROXNm3C7x9/jHZlyuLQ4sUp5q6h9pha9qtoc2Y68aWnzmlt4/r/ffU1vurVG/vnLxC/AZ9174GWJUrg2LLlqf4eMFMgsU94+oLTZKNi7tixZqX4nt4H8Fc97+4dPy7m0ODmzcXv3/opU9AxOBjvNG2KhwcOZvtvYE6bu5nFlrlz0bhgQXzbtx92zZ4t7kMNAgPx1+jPsr3PJZKMIm2UcziPjx3D3Td64regILw/Yx5WnHwgNMlMaWt78xA2jP8af9jZ62wEDdndJpYNFh7nWWV3+jqRk22U02MXmV02jyxXCVvGev08YgRard+Qrrmb0+w8c5qN8vfvv48OW7Zm6Pfgxo6diH73XSypWgV9Jv6GRYdvid8fRiFJvLADZxfPxrfRMWnaKGekPRkl6tIl3GzTNlf8Bua0ufsyHF69Go4jRqba7zmhzyUSIm2U8xAMt0SiLpxH7/LF0apdO7xRuBjWjpyPuMgoTProI+DPqbqMceeOHwdv0U8G9IdH685YdDFKeJg3azIQXYvYY0zLhvjM3iHNVMwS0zCUaU3/xqcfDzW7MoepM7jpp0DPapS6KB/CV9CLZs5EK28fWMxaiCX3LXRzt0dxJ/zWsxPejonVzV1FyMho/Y1l6nsZWCdFSFbql5njnFqd1Vn4CMtmAotlc+eig6/fC33avZgjfuneHkPinyEhKkr8bqgjZ/BcHp4eYG+f27IFfYJLoFnr1uiWPxBrPp0LW0tLTBk+ArHjxulML0zty1fRNwrb169HUSZf+uJzxFeqhYXnI3Rtbu0HfNW0rknp6F8lhrIipoecJiSTmX/8gaEAfH+YILKBqvs9+PFZFBn/DeIjIsQ8k0hyE9JGOYejpC4daWMLeNoC+/aLj4gATJvNP6eK7aHR0bhy8iRWrlyJbhzYIkUw70Ik5hy8Jbb/deAmzK0Kolq37sDatdnZpNcCQw43+hnMstIZR9+hi2XT9IGvzGkfqWRsy4r6GHNG2rp1q9ZUwNtbCHScs+q5W69vP+DPP1/KEcrUumQEdZ1IZtTP1DorZVMApe034fiuW7dOm6HP2xuL7pph1qHnfQqLQFTr2hWYv0Bk9rt39aouu5+bm5uYp7S5J1+7aBPuaP0hdqOxmTmQmCSEZFGnJA1iHz0yaV5n1tilljKbgrJHpUr46XJMynlUpyCKNG4C/Pcfsou86IzHebN7924MDQiETbFiWKTX7wOqlURxLy+cPXMWVcuVy+7qSiTpQgrKORx1SlsFam8ehYbiWkgIEp49g5m9PdwdHBAeFiacn8gzO0dsO6WNwazAV6YflygtBeVXjCGHG95IDh06JNbRaY22zITbKIycPXtWCBlly5bNdA2v2qFLZOtLTBTfaR+saA+VMl+1HXVqzkhK6LLEMuWFJkp/7tYtUVh857EZcYRKT11exjmLfctz8zp9mfqZWmeuYzmcR3ydqGTto8DM0EdKnxrK0DgqUNunPD5ald2PwjLbonF3h9X0abBgWTY2sLS0Evv8d+Y/3Ll9B/HP4lGxZk2RWS4mOlrncGmsLzPqxJYeFOHeWMbJnhUrv5SgTCfpnTt3iocJJlNJz5zJDc54GYFtUUzMDDp+XnyErmWD8TROOzYSSW5CCsq5AIM2XQyt5eQkhAslIxdvzEWLFAHOnkNC6EM0KlZGp1EmdMbZMeNX5Ay/77yL4nAjbh63bmHK9OlYumQJwpMFETquderUCd0bNcaClX9j7saNQrgiDHHWu3dvvNHjDVg4Zk5oNqU+zJjGsg1plCkYZYVzkLpv9MsrX768iHZBm0a+rlU0Usrc3ffPH6DlqRJ6T9FKvszra2N1yahzliGNcmYKgobqzI9SJstSa5QrVKiARQ8eaDM0NuqPWYdu685FO+PDq+ajEDNO0rHM1VWnUU4R2jA5rbKiLT7w99/46ceJuBaiFYYsLSxRp04dvDv4XdgHFYR1kcJG+1K/n16F2U9xJsq5cRMOCXFi3igh7Qh9OzZ9tRT1M3DeyytWYPyoUSIUocJMS0s0btQY/T8YBsda6rg5r37O5ST40O2fX5uK3CHxxX5vUMgZ5utPoFC3TtlYS4kkY0hBOZdCLRFvgtSe8LsSXss/Ph4P1qzF2tUr8c4fbWBtbSW0KC3K+CDYMRLDN23Cu4HSmSIrxsfs3j2EdO6CphRKXPPBoljx584tW7fhydZtaMh00e4esChZ6vm2FX8jZMXfmer8okTeoDCqaG7VtqxZaTNtLKNYuXLlUCG4gnD8oT09zS2UuVvPzwzvz5uHtr5+L2SrexV1yQj6dXoV2lJjdVaXrR5X/ibMLVNG9CntvC2sC4qEIezT2j4aDF22DN3y+wvtqH2hQi/YKOtn+ds6bx4KjBuPiXxgqVrt+ZxlRIPhI/BQSQiTypzNrLFLLX177JatWDBvLnp//JmIN895ROEtf8xlrGbcZy9tunRTubV+A5599jk+NrcA/PLDulQpxDdpCestGxB/+jRuDnwTBf6aYZKwnBcz6vGBu2u3rsDfK3Ht0mX0rtlA1+/NSnnB5tQmMQdfhamNRPKqyTtX6msIf2gVGzflpqP8H7JnDz5sWAuBJ1fjs4CHiJj3LUa0aIAv+w/I1jq/DlDYIKcPHRLL6EGDYLVyA5Z8NAWDAtqJ5ZVRX+v2T5o+N8W2e7/+D8Pv3hHbMupwpAg4SlQJok59q2xT5o3aSUy9zCxMPd+3Y74Vy/Ftm8Hn8FJ8HhCKhL8nYXCdKujXuLHYFhWpNS/KLNQCYXrR7y+1oGqoT/X3V+aKoW3qdanVWX981U5y/P7dmO/E9/HtmiH/0WWiT5+tmIj361bDW6qsiERxRFQ7qaoFup++055LOAaq5qz58rX4OXkfzllj9c4KB1Jvb60QvPaPP/Flu+Yodm4jRvrdx80/PsGvg3rjpw8/TPc5Z0z6SfuleTPELlmH6W98iUERBcXy5g9/iE3h16+naLd6bPWXeUlIVujevbtYfjGgP6a/PwhlrmzDe06XcPTrvghZOCu7qyeRZBipUc6jzn/fuObjXQmYq42z3I+fgEB6uqTYT5K5KJnZ+Pp61apV6A3ArWIFzLsYhVkq55aupfOjmJcXVTFYeM8M844+32ZWuyDcKlYE7j5/xZseDGUM1M8KaChz46tyNtR3XkrNmalA0aK4AmA4BbbFS8S6QABd/QsAZ86K/4+cOQPb2BgULlw4UxzCMupcZai/aPZAswJ1ZkZ+V4+FYsZABzrF1EEpV9mWVkZH/bLVdSDq9gSVLCH69FPaFy9arOvTbgUKACdPif/vPXkCnzTSW+/fv1/MG4sqVV9wDKT2v/GgQcD06eItVxyjG+j156t24lNQftvG+/gAoaHAjBni/w/4h28kFixMsZ8pnDpxEt08PeHbvgPGX47G4iNakzaxrOyPQaVKYenSpRjYsqVoN30BlN8BxTFSf5zyiiOfgnVyUpHv3D2AY8e1H5pUqfaR9x1JbkQKyq+B858+rzIt8euMkpGNggIFJtrbkhhLW2w5r/2usO9OPAaUDQaDau24GpFiG1+Nd6vfGFg0P911MJQxUD8roH4GOU9PT6HhUx+XllNWRp2XFPtMY85MyvxluLLoqGhRl7v37orzsF8jnyUg3sUZseHhwlGNvMxr/Iw6V+n3M/tLcZJUZ2PkdwpLFIgVJzsle+NjlfMct3Edt/Fcyv6GMjrql62cn8fRT0H5KO3R71M64EU8eQIzc3MhcPP3INHFRZwrtfbfv3/fqGOgiK0crI1mwHpZ6PVnVjjxpeUAzbYnJiXCwtwCTl5e6foNfJasCY9w88Keg3dTbNtz5RH6N2mJRwtmifbxw7nJ9ivjw7mhHieS18wv2J8FN2xA5IMHun52cHTQJaOR9x1JbkUKynkQKQRnU78nZ2QjvCnm98sP3L4D+2exaFLCE7P239DtW8PXWji3kAb1e2PeUa0DluJwtPf7DdAaGqQPRbBSvitaSfVN+eGpU1g4eTK2bd2GyKhIkfq5Y4cOaNuuHaycnOGQ3y9TMn/dOXoU86ZNEyHKKBT6+viiQ8cOaM9ynF1ecPq6sW4d/vj+e5yjM2pSIszNzFE+MABFAgJx4vJlbL95E1bWVsKWuWXLlnDy9YWDiWmr0+tcdW77dlF3hqx7GvsURYsWRZeuXdC2bVtYMlpIUFCKflZrcykIUqCkQKRkUWMd9TXKdMA1plFW9k+8dQt7V6/G8mXLceLkCSF81KxVE926dUOJ4iVgY2sDm6Agsb8hjbLSHlFffomJgRVNAqKjEXr6NNasXoNt27eJ8fHy9ET7Dh3Qo0cPOBsQJGnvzKg6hhwDaf97/ugqVE5uA9NSq8vPCic+UxyglX6xTac215pp1KndD3uA2kU8sPjwc0fT2oXdYbnwd/j5+om2K/NJ0Sir3yyoxykvCckKtoUKIsnHO8+Fv5O83sjMfBJJJqPcJE6tWgWrkaNw68MPUKxTT8w/eEPnnFb8yQWU/na09oClq/H3zQTdtrJ2j/F5m6ZYUqDAS2c807dfvbZvH54OGJjqsdTGWQYEvNSN/Pr+A4jp3z/NchSBJmTVKsSOHJXucjLL2VFtN3po1So4pVEXpVxDCWQMZWY05BinaPcV5zn9bUxFf03PhtgQ1OIJAUVVh7Qy+DHF85OevUxqo1or275cOYx/lgDrlRux6EqMzjGwYzlPDKldBb/b2Yk5a1OypNHwcNmR4EYho/bBE1q3RtvLV/B4QH84vPEWFh66gT2XQlG7qAeqWYSixIghcBszBp6dOurOb8gxMruSDWU1r0MbJbmb9GTmkzNZIslkFK0etZDkj9GjsfSLT9He7Dqm1rCFy645mPfec2F1/+Rx6GBxE39Ut4b91un4rE0TjO7b56XqYMwZa8JXX4mlx9jvELRqJTzXbhBLx6l/Ynxy/Fm+sn7Zm9wP33wjlu7fjUlRjtO0/2FCfJyuHIWJyfWis5Tvjz/Ad+pUxPz4s4gucCA2RmzyHDVKnCdw5d9YW0Qb/5fmBJmBWsD84pNPxHffCRNS1D3u+7H4nDavqrqnlplRf5t6LHSaXpVWWn/bxZMnxfJOt65C+FTX5d82bfD5I21dNMn9o65DauPHbZO//158d/v22xTnzTfzL0xKFtr1zbf4Cv2zzz4T32e93Qf1I07ir3pOKH1lKz5oUAOlXJ7fbFILD5edZHRe92OyG5qYTJqEv/t0RIeHB/BD6QRYzf4cx996Q2yjdj+FGZEBx8iXqUNu4nVoo+T1QZpeSCRpoNYQKnaXhrSG6igSRGNrK5bfe3oBO3ZqPwAa8aMKT1Vj/wFg/wEwlUNzfgoEANt3pNv5RV97rM+tW7ewe88eDAsMQkTpSvjfZWoEr4nX5r1rVEG9Xj2B5SteSEdsimZUve7OnTv4d9e/eC8gEJFlKmOaqpw3qgajQa/ewNKlumNoJxvC8GK+fvBt1Ag3KtTBwoM3sOdyKGr3+AJN34lBzIG9+M2uFLb+fU2YprT/ZgLQszOOHD6C2qVKZdqNmaYWd+lEWaAAHhUvh4WXo7FJ6aO6TVGySRPg+HFdynj9vjFVY2rKfn///bfIslmza1c88A7EvAM3dP3Yc/gXWLRI65RmrC7GoKPZ5s2bMSC/P6LKVcE0dRurl0PTgQOAWbPFXLfRG+vg6tWFY2DPBw+Bb78FtxYH8DMdBeOf6eassRTbyrlym7bTwc8XtMruQSfpO3eByZPFeiEi58snvlu6uen2V+zL1XPiddCyvg5tlLx+SEFZIkkFxVNfiVJAoY6CMhN3qCMb0ImLN0Sup0e/OM7KCg5zZsM8Lk4In8K+09xCOM/Z2tki4c5d4cxn6euDkGsheJbwDPlc8wnbVksrSzi4u5tsVsB68VWSsSgJ5NKlS6IeTGe88HyELqEHEwPQ36ZdjZpCUKbTk2LPqe+tbyh6g36EhsuXL4sbpqFyEhMT0LhkSfE/+4yPAefPn9cJ53ByFkKyYgO6+OhtONcOQnyhmph97L5Y99eeEKC6P7p5eeHS5UsoZyDCQkZgH548eRL5/fOLus8/9xizDt7W1V2jSUL5ypWFoHz3zh3Yu7unsD/lPOH3tKI6mBr9IeR6iFg+TUjAnH0hmLnveorxqtWgAXD4iHAafXL7doq6pNYffCgRDnfe3lhw7glmJiclUtrYvnQZXQY6H1/flGPt5ATPpUvx+N5dRDyJAMyAokWKivmqCMkJXl6I0RsTU+ZnVpDRCCeMj8w4yVePn8CTiCeIiYpGkaJF4O7hoROSlRjKHF8+jFA4Zr8pY5KVaeKzg7yYmlsiIVJQlkhUhJ89i/XLl4sUtYxAEBQYhCZNm4gQTxHPniHe3V3cEITDkpmZ0J7QIUvJrMf1itOSiFzg7KwTMuzMzMQ2MysrxN6+jY3792PHzh2inMDAQDRp0gTWVlawdHaCVeHCsEzDbkqBQinLUlL36kdJiA8Jwb1rIdg2bToKWlsbTRFdrxTgnuy4ZCiqgqHoDZYPH+LAjh3YsnkLwh+Hw8fHB1WrVjVazpbzoajibwbq3hTvfx6jYCiqwKOYZzh4W2uuobDpwiN0KRss2klBJObyFUTHxuCff/7Bvzt3Ii4+HqVLlUanTh3hX6BAmh73ytsCjg8FncTGzbHl4ospn/2jtMLeLyNGCIGQzn0lS5aElYsLIh0dtZrD27fxMDwcq1etwpmzZ+HJ2L6u+RAR8UT0Jx3lqrVqJTLI2QUFwb6w1ozEULYzPHiIGHNrbD5394Xx6u3GMwOzhg7F2dBQWJibC3Ofrl27wdPDA4n588OpTu0XzqukT+f4MLWwfhvrFEsE33dw/nCuK2OtROOwcHdDRMIzmPGBz9YWNoUL68wM2I8UktVRRAiPV+Yn51F2RHx46fTR5csj7Nkz3bXgXbmydoxU8NrgAzHHmQ9/ivNeVqaJzw7yampuiYRIQVkiSebKnj2If3MQKgHiIwgLFxpEQuEuasJ4IXDxBimE3+TIBspNkut5k1BSClOzwv2IIjDfPXoUGPIeKgLi87wcbRQMBj1zWLUS5skCTVrwhqQIH0RfSL7SvIX43pMfv/wiakHjKh0xO/z5OZqV8MTyWV/h7WRBW6MX0UG54aujNzAiQ0TvPqCroc7d8PIV8amUXE6zhv3x1+Hn0REaFffAhpk/Y4jKhpNRN1xdXMR3p0f3X4gq4Gpnicb5bTA7/HlkkHqBjiJqSL1uY6C5fQcPu3YV6ysnfwS7dyNh926EmOD4p0S/aNWqFWaMHq2N7NC4v06jTBp7W6DW+h2gocOQuHjg5i3g9z9A8Y8fvj2gwBCbnNSnbfJHEKoSSJkw5dcp4pjrqdSrefPmwB9/Iu7hXZFuWtEoi34s5IwG64+KuvRITALyJb/2p0nEb7+Bgef4MZQtrmDBgihbpqxoY9PGA3QaZcJyNi6cJuKuM506DETjUEfsoHZYGUd1P+pH3eCcVBJwcK5mhxD1sumjeW3zjRG1xVzqC8mE/cP1vEb0NcpZlSY+O8irqbklEiIFZYkk2aP/kyFDQBcntzHfwrlsWURb2MAhIQ4L58/Dmt//EAkMigUEwKV8+RfsDnnjVGuN1Gl61baZvGkO/OQTfJfsSOVc7nk5SxYtxMpfp4hyrJPtTk1FSYurlKPw4IY2JN2uihXRe/QoHNnwDzyv30QNzV08Le2PPXfi0cTbEgWv78fJPXsAN/cX0uwas1H+dez3aEZt0rChKFi/PmIsbeCQGI8LZ8/ir8FDMJgPAg+OQ1OtotBcNimaD353juAMbbL1TA569uwJrFqNv95+G23mrgA0/iI+be1CbqgWdxvuV0/BolIDbLoagXqBDnA9sVGXElepzzx3d3z6yy+wdXR4Pnbz5mHNn39gvLdPmlkO2eYCBQrgzTffROK69agWcwXm1YsI7XUdPxu0ubYPf9+6iY7+BeA0djxcPfPh9PET+PGDYfg2nxs8HR2F2QlnwIkG9dF+yHv4c8wYtPDwhnXxwli6fTu8/YNQ+9Rx3KhfD1OmTEm1XvXq1cOtP/7E+MGD0fO3GTCrXkBo6BsUdILfiX9E+0m+996DbZkyiMjnBavbN/DRoIEonpSEbi4uSAhLqRVXGDJkCBInTEDpByfQv6o2LnKTom4ocO8Y1mzZAnh6iflrQ2HZgD06BWVFKDI2F9Xz0Nj8zGpeNn00U8BTY2xISFZQrv3XzUY5L6bmlkiIFJQlEgqSu3YJG14EBCKqbBVMVzu6fTQa25nRMPyxTjAwFNlA/wah3kcR5pjdjDa5CAxCZNnKmH45VldO93c/1JYT+siog5YxRzqlfP00uStXrhTxmCkk3/cOxL/Fm2GT5iEam1mgx8PT6HfjvNDMUuiqlCwkCztTVRpmQ3WgxmzZsqVo5poPtg1a4CfhEBaidTSr0wRVOncCtm5DoV9+QFEvL3QtG6wrp3aykKw4fZG6bdrg5qrVaMU+7NdFZDpjEgfLRb8j/qw2I183r3XC3EI5j3KOgxRAAbz59dd4HFgMCw7eVI3dKGzdthV4EpGqk6J6LAcOGYKr69YjcMznKOTllaLMJv3excKAqti6LxbNS7ugd5PWqNPjAPDPJnH+FStWCAe89u+9h0u2rrje5C0MegQ0DvBE4eFt8L/d13Cjcgf0rh6IkpwHp04bvf5skrXsH9IQ+L1BwiZbv/3kXvNOWHzygTBZqV3EF+9vO4CxVUsJQdkY1RvUx5UJE1Bq8niU9fJCN9V5q9P5NLlvDUXSUMdGNuZAaGx+6qNso4lHVtm16ofxMwX1HElNEFTaoz6vfhl5XWCWSPIaUlCWSJgpb98+lChRAhZ0JjPg6NaqbXtgzuyXdnJhObQjtcjnJhyplKQNLIf7VKxaFdiwEdevX4ernrOYMUc6/UQT6v0PHTokBOX7oaGYe0WjS3pCs4uECpXwbM0S9HvwANYjhkOTPz8snZxwi+YDFy4I21RqiHijV4QKLnmjv3r1KsIfP4ZF8RKYf/ZxinYwK1frho2EoPywV09cT0wUNpvF+vVFqVKlRAKPJFsbPGQbkgW+xKAg2Iwbh4TQhzh06DCuXrsGx83rULNkKfjWroVHT+NwLiEBMbExKNSrl9Dgu/nnF3Xlw0d7tl2jwaK91zBHNXZ0TmvYrBmwdJlwxox99Cht50RnZ+GwFv0oFEePHsW1q1ex/cRxTK5QEetKNsTso/dSnL9R9RpCUOaD1vFjx4WgHBETg8VnY7H6stZcZPaBG2gX7IdniUmYfT4WFq4RaN6qdaqCsjrD3IMHD3Ds2DGxvlLnDvihR3cMcc0Hn3ETMOHkg+fOj1yaAaWqVQdu3kzz3FGh2jbSMa9A7RooW7asOD4tm261c57Sb/rOe2mlQ1f24VynTT/HlPbeWUF60mmr28rshMbqmpoz26tKD5+TkM58kryKFJQlkmStD20uE2sYdnT7MFnL9rJOLopjlKE0wNsvheHtZAetq7t24+iyZbC0sBSCdc2aNZCQmIhEa2txjsTIKBw9dhQXLlyAo4Mj6tStI2xPk2gn6OEh7CEVhyISaWb5QhrtnSFRaF6pKrB+LeI8PPHUw0PcvKPCwnQOexQKnJycdBo/vnbmTV5xzDLUji3nHqJxKVtQDIjOlw8FSpcW/UubV0ZNiKaAbWGB2IgInVOkcAwsVRLR0QEoU6UKXG7eFHV4ZG0Nl0KF4OvqKhwHGXouNiEBCXR6pOb78WNdG2OtbLBNb+zonDbMWWu/e2HbNuyfPVuUxz6tUb26rk8t/P1TOKzZeHvBzNUFwYGBsKYpycyZ2rZeffLC+Uub3wEDhMVfuyYc90R/wxK7rqqMwAEcvR6OUr4uuB/xQMyxOsXStkFXhNUCJUvCpUIFnaB1N1nD+djLF3v2pGwzE2EMa9ke+N+UVM8tksq4uqJiwYLinLQ3NkXTqXYeZd9zqdjkK+YVaaVDZzKVRzeuY/OWLTh79qzYp3r16vCJiUlXtJeMkJ502uq2csmHLUI7ZbUWXLnO40JCcP/uXezZswfhYeHw9fVF4yaNRZbJRGsrcW3mxRTW0plPkpeRgrJEkuw4NeuLL2Dh7oFmTQbqNMqEcXtX/fgNSmWCk0vr1q215RhIA9ygsCuq/fqPcNAqsnYtiigb9u9H1Ny5L5w7OPkj2LEDiruY2+JFurTG1alZ3LgRNnFP0aSEd4o02g2K5MP26X+jk6UV7OztYEth1NJS1JMCjlqjzHXKkjfFMmXKCCc8Q+1guu69m6ehDYBAmrIkp3Om5k6JAKAIfIqjoxK9goIzy2EUEUXjRwGb+/F4CuoUWijU0U6WQk+1qtWAPXvx6MplNCpeWadRFnUp7o7yk1aKPvVbshSdlA179yFq9hzdfnbz58E2WWDUd1wMDg6Gh7uHtq31+2KWKt04HfzKzFwlzu84bTo+Tl5PW239tOUVA/Lh4DXtKDWjU+OiaeifwXlUITCI8fWQ9NN4EWuaYfQUaNddcdE20HUu4eFDk89pqtCm7zyq1igbSqSiv40OpkrGwZrJH8Gx47j3x5+ZmnHREOlJp61uKz+ce4pGWa0RFm27exdh3Xvo2qUQtlAb71q5Nq2S05/nFSGZSGc+SV4mWwXlixcvonTp0tixYwcqV66MgQMH4saNGwgICMBff/2l+yGWSF41fOVct25dJN64iZY+STCvU1Bokikkuz06jQtnzgAeir4w404ufF3boH4DJIaEoKWPBpaqcvLfPqKzPX323hAUbdwY0RbWePboIcZ8/RUizp7FZ/Zazd26IkWE3bGLm5vY59a5M5g8bChG2tjC2coKNsnawW7duyF040ZMnvgDhs6YD0tLC1Fek5KeSDy3Ha50SnoaJ2I7OxYqlMLEguibXShLnnvAgAFInL8ANW3CYFG7oEhnTLvgcnbh+HzmLLQpUAAFCxWEWXL4MLUjmNrBiaidnrjkbwBfd9NpSn2ct7e3EOzYp8r+XtWjQNF48sQf8fXKDbC2MtyniUOHonDDBqK/4kPv45svvsTTy5cxknGxbW1FXGRj9sv9B/RH4rLl8L2yC/1LVMSW+wlC2K2VLw5jHzzASADToqPwloPWyevnnyZiwM9TERsVhT23YtGgiBsK5LPBsRvm6F/CCSViLmPMunXoX6BAhuZRs4YNgNVrsODgQbT9whFOdkEIi3kGNzsr+EZfw9z9+9DdxRWauDiTz5mROa2Mnb7drSFnUIWzx47Bhn4BlSqi8wcfwN7JCY+TzHHl+BFM+eRjfO3imqbj5cuidrZNT1sZytCYPfX6ZctFFJuQDu1Rt3dvxFrZwSYuBssWL8Kq337DBB/fFNdmXkM680nyKtl6tY4ZM0Z4dpPZs2cLG9Hdu3eL+KL8XyLJSr77jrEogK+b1sPtqSPQKXo39o3shsWjP8Yfo0ZnWjnfjvlWu2xeH7f+HK4rZ9PXFLe0ODRujZ8uJ6H93yH4K9QJn8xdiudBvIDB475HXPHyun3WmRfGm38tENtu336uXVReiT+7dg1vlCmCsDlfo234dvz7UQecXTIH3739jtiuaHYVwYFL9XdDyw7tO4jlbz074eyEt9E5eg/++34QPm/bDCN79dLVQS2IqR3B9NE/P7XGCurjjaWILpPPFX0rlMSdqSPRKXoX9o7oik3fjHpej/rNdP0185GL6NMryem0qT03dE7Feat7t+7i/6M/jkGPmV9gZJFYJD6NwpcHIuH/5SzEvDEAkcmv1Mmdg4dEf+db8SNm3FiN+K964dAH3TDk4WZx/OIP3sGkjz9CRrlxQ6s1d9JosGvhXESEPcbBa2F4Eh6GsFPH4Gpm+k+7+oEgo45tylLtTKqEg9MXCufNmyeWfUaNRkRQCTEmXdbewk6XYAyYpn1zQq3tq0aZR8pDoZJdU78d+m1VhGT1cXzzMHPmX+L/Yn3fxqSrGrT/+xp+CTFDow9HoVwLrQZdOZdybF4hPfNHIsltZJtG+eDBg+LpXLlB//vvvxg+fLj43qZNG/zwww945x3tTVwf2orxo6A4WkgkLwMTQfBF9Q9+fsCly+LTPDlbHKZPT3dKaWNOLk6enniglJMcd1iU46K1WTWUFY5yXOfu3YE1a8U6cysrzNt/XWxT9kmq5o/uXl4iWYpH1arClEGTpLXf/cTCEvDLr3UeO3UabZhyOCYW+OWXdLdLaU9cgtYJjuHs8DAUWLpIhItj+mf8+6/YFnLvHkqWLm30PKlla9PvN/5/8+ZNce1T08wkMOo29gt/jH5BBZmCUHxEnzq76Pp03vkIzNFzOmzRpg3w7y48efIEz8XcFzlw8gSYFuUD2qqbmeFIpCNmn9faIC8Ij4V1iWpo0P6hbnxGsy38nD0HzdlzIi4xaKCxbrUw0/iOEUaWLktX36v74+iF88IUqFXRolhYuhGWnGXUZGBpeCz6l6iPHkW2CU26RSqRL4z1c0b3VTusCVvy2Fh4eHigUKFCL0SYedPTCxGxMZi7L0RnniKcI6sXQEEvLxw5cgTN6diahZk39eOdp+Z4p3/cf//9h7v37sGiWnXMOxOO2YfvpLh2W3foIOKx0ynT0cfHZEfC3MDr4Kgoeb3JNkF57NixmDVrFj7++GPdDw/tvghfsSpOE4YYN24cvvnmmyyrq+T1IMbVFTdHjURiVJS4WZYvVx6OTs/jpaYVCcBUJxd1NANChyimjV448Uc0/e8M4keMxpbTKec/TQneL1RU9z/jBDMEmhrGKmYYNgooOkcqXx8RwcHe3EynNSWPHz/G2rVrRbQDRo/wdnYWCVVMbQ/PH+fmBpcF8/E0LBwaaISWjOcVzlJRUQh7+hS3jh8HRQY6avHhmEIubX5pQpFaNkH9fuN22icrqcL5oe2osGv29AB+/w3PIiN12RJ5w9YkJWHD9BloeeECYj8Zjm1nX3Q67Fu4uBCU2VfGwoXRRGz7+fM44eAAp/v38EWjpth6P2Wca5piVCxdTgjKHj9NxNkHD5DwLEGY2jjExuLBrZs4uP8AYp/Gws3XF3U7dhJzy9Q5pd8fF5PXWw37CFsvvViXwpWrodKGtbArXz7V8yqRUe7evQt/f3/UrFlTJzCmVQdD48V5wd9yCsOhoVonw4oVK6JOnTq6jICKpjnKgIMpnRwZAk+JRKLAsWd0E5ZdqVIlYSqUWU59SrZJRUBWO3UacrxTH8d6ch4qD3x0+Nx6OfyFa7dlFa0zMK9zTWSkaIcxR0Kei9cK92GWSz4Q5lTU427McVMiye1ki6C8fv16YZOsfprmjwFvsoTandR+HEaNGoWPPvooxQ8LEwVIJC8Db+ROxYoJj3aHfPngWb3aK3NyeUE4iomBf7VqAAXluFg0Khqo036SSu7Ahp8moVzy/zZ3bgp7YEWjTBoVcRWxcMv17ydu+jpHqiKFU2h4Ns2ejZ/HjRNhubgfb3Jb1qwR11WJ4OBUBTelPcp3C2dn2AQ9D7GWFB6Oa/v2Yeb06SKaQYCdHXYmJcEMZkKYfmZmjrvPnolIAB8M+wBWFBb9/V+4ser3m5LxjBE4FI2yOnReUokS4katnw1N9OmFC0hMfIZGxf1TOvqV8MSun1aDSZ55g9cXWCIvXMBPY8di/5q1sNIkiQcaRwpTp0+gVqX2WKKSh2r62eDC/PnCAXPIwIE4Fxkp2sBj6pYshScPHuBO2CNQdGRfVTt4EJ999hkCihXL0DwqU7oMcPgwXAsHoqmlRYqsfbQ/nzVjJSrxLUIq7FqyBBPHjBFJUmxtbPE07qkQ7EeOHIny1aq9MA9Sc9hStv39++/Y8OdUxEY8jw5y2MwMMy2tUKdxI7w5ahTqMKxaRCQcNQkvODw2LOQi5nCp9q3F/7FXr+LPSZOweNFi8ZDBByF+WrZsiU8//RSOHh4ZdvpTnPqMZdBUnDr122rouHLlyok5JLJeNuyH2YefO3zyOj2yc7GYZz6+PtAw8osBR8KYK1fw248/YunSpYhn5keG6bOwEG9Yeb+zd3N7pdFAMsILvwcG+ksiye2YaZTYSlmsTd62bZu4oE6fPi2E3BYtWogfqNGjR+P7778XgrIx0wt9KCjzyZwCttquUSLJCHxgU7RfmYUpSQYiT5zEre7dMS9/fnSq1wzrAqoJ7WCHIDs0TrwHu6k/p0g0YbN+Kxadf6JzXHO9uBONp/2GoOXLYVOqpEFHqs1z5qDAuPHiuwXDtZUNFjd39XlNiThgzOnt9pEjiOrTV7efugxiqLyCGzbAtlBBk/qN/1Ojp0TfUNdBcTJUOwY+oUa7xxuYVrwY3p82F4uO3Bb9ReGlUNItjH+jI5b4F0DQiuWwU5mIxF27hqsqu1KlHdZ3byHe1x/xhUtglUdZbLkbjya+1mgdsh/2C2cabLcuOcpL9Ld+f5xduw5mn36KQ926ov77n2L+wRu6dtnePIgtP43Fz5ZWL7RLYe/y5XD7/IsM1cvYXJ4zfjyqJkcS0e8v/XOT+8M/RWCbLlh46KZ2Dpfygu3pzWg9d7qoN7XtSvr1zOo/QxhyLDWWSCW1474bMABdDhxE3LxlWHffXDi3tijjg8ZBthhavxpmu3voxkP/7YU61fyrbOurwpT+kkhyEumRG7NFo0xNCj+kX79+ImUsX6fRi56v6PgKkGYZEkl2oAjJWf3jb2mlvRyjzp2F/e3bKFHtP9Tq1g9bQhMx5K4LGrw9Hu2v7NEJZH/06ICybdrgHVcPrPhqOFzDw9GY2h2zF53SCJ+Jp/zwA37gjXjWQiy5byFedTMcXo/iTvhf3+4YEBFhUsQBQ05v7Kd506aBLn6e34/FTWcvrL6VKMwUGjcegEBXW/x16DaaNuyLjoXsMKZlQxHhICkm2qjwrQjFihZTnTbZWKY45TtRtIT3jhzBWzUqoHO3bviwUDFs/HU8lu7dJ9JPY8XfukyIigCzb/t2YZO8O6AAKtVugnXF6wN29oiOe4Z9V8PQwNcRpfO7IMI2FpaaWByIiUFDpXN+mYolsflE31av1AE9bh3G2fg4XClSR/QF+7trEXtM7toWw5I0GYrwwGgiIQD+/uVXbFi/Ac3btMZbLu5Y++0o3Lt9C3+MHg1M+c1gNkLy+8SJ+MLAPOhW1BHzBw9Aj/v3Rb0MCY+GrgVq86dOnoyq+dyEY+OaonVh7uCI2PgEkYq8VuWO6HrzEKb/OgHDkqPH/PThh/BZsAB1GzTAQAcnLB89A4Eqvc0VRpqhWV7v3vBu3x2LL0Xp6tnKVyPmz/eeXi8dIUMtsBqa12kdp/TN+++/j3sHDmJMiwao1LkTPqlaA8eWzcWgZcvRo04dICTkhWOV+Xbm6FEwrkb0oEFwbdkBiy5EpmjrN83ri3TnCYxjbuS3SX+dsRTjmY0UjiV5nWyPo6yObrFo0aJsrYtE8iocVEx1llKcut5NdkCrEHIdCx+YY8l57WvseeGxsCxRDT281gkt08CISGCBNkZrJf5RsvNZWBh0TDt16hSuXLkiHI4oHCmxork0tyqIZm+/Dfz4o7CtzWgbN2zYgA7OLghzchZlLE6u++yDt3SZ6WYevgsz60BUoIPT9h1GM+bRxpVmFhT22Hd8Xc317MPChVOakxjqZ9rKRiYLUV/SIZOsXCUWIiY2zbVW/C3+D2X2u6tXdeHpVq9ahbcBnH78GHcCquKfKxGoWtASa07e0Y1FOzMrHLj6CPcj4tC/RANYeG0Xjn4LIxwx+6i2b5eHA34VauPhMw0W/ae11RD9bhGIen37ArNMj+6jbt+z5AcA4UgZFQUsWiz+r8I/bOuU37THJGlS9C3NPugQeeLECTEPFt0zw6yDz+dBklkBVO3WDfj1VxE9xTHZPM5Q9j01mzZtEmNFp8m1AVWx6VoUqha01vUXzVTsS1RDYO06AFN305nV1w+4fQeYr43WUl3vWti8aROaMnJL6dKYdzECc5OdW1nPhOr+yF+rFnDxEvbv24eGRhxGM9K36b3OlWPNk6/f7zw8gJ3/ik9xAD04z5KFZPW1qXYIpL9AF8b6rlkD0y9FYZbq2kStQJRgdskTJw1eK4aycnI/jgc1Zfnz53+pvjGl7eo6SGc+SV4j2wVliSQvO6ikJ2MVX6n6r16Fj9u1x4e01X/3PWy9/qKjlmvlami6YS0cv/gctoWLwMHRQecoxNTQGh8fg1oe3pgVhyND2Qfb1SghvtOZySmD/UXnQEaaiLawEvGDjWamO/sA75etIARl4UwVGfk8K56NjRAg+GqMQquS+Y0mMYogSyGa9srU/tNmlXVQomgoDlJCsPbygt2smfBwcHjupKYBomOiYWFuIexyo1l/JjN5/FgXXePxE62A71GiDLbcT0RJX2ccu2E80x7HpVvZYJ4aW/Wy9902s8PB2ykdCdn+usVLZWgesT/MvL3hNG8uHt64IdY/TE4swjGnKZuwuXZyQqK3F+Kio1NkaqTjHhGZBi/qOTieD0XjUtpX+zynRfIx7M/UrgMKZnTGFs5sRvqLffR+1RpCUHb8bgyikmMTR8fEiOgYDvZam12NrQ2sAgMRFq49Pt7WAdtPpqzntguP0Cm4khCUY2Jjce/ePRFFKauzyqmPtfDxEWZEmtiYFE66CQnP8JTz2tUVj+3sYMsHCgsLMT85lnz1+yhUe21GW9oIJ1P9udKvUjUhKHP/pOTxVJwNWQdeA7wuOMY8t+JUy+uBvkCvIieBuu3KAy0/6e1DiSSnIwVlieQVOqikN2OVU/HigH9+4NZt2DjYonFxD8zWc0DbPH+j0LQJIblc2ecaMJV2x1A5vhoNCjJd8+kTqFqxPW6p5JhmJTxx7tBmlKEGL1nwTm8bSX7WXWSme4Y6BRyxKDzWYGa6piW9cHzxDOGcyJu+nZOTwax4vAGzfUqbLuzciX9WrsTx48fFjZrZATvWrYuo0EfYsW8frsdECy1a27Zt0aVzZ1i5uAgHTWpG6Ri2ZPZsbFmwEI8fPrf7ZFlVKldG49at4ValCqy9veGf3x948BCRIZfRuKEFNt55gmoF3XHLSHvqBNgLJzQxRg37Y9bh546YvpoY1PazwWLVsWz/2X0L4JXBeUTMihYVAj77KPz6ddFfdo6O8KSznAGnNKVPixQpIlKji0yDjfvrwhASzrfrZzaKCCjsW5tk4dhQ9j01POf9+/e1zmxVOhrsL2YxPDFvkxjzxKQk/L1yJTYya2REBBySnTWfRETgaVISbPz9Uc3fXzs+t26gYbGKOo0yqexphmMzF6K5mTn2LV0mElfFP32aIfvdl8kqp3/sC7b2MTEIPXUKC2fNEm9b6CjMvuxQpw68XFyw99BhHL99S1yXDN94e/tWNCnaNEWmS86Vw39uRq3khxS75Ic+tbMhUSK+3DhwEDN//03kJOB4u7q4ol37dsK00cXbO9NsnA3NyYz0oUSS08kWZ77MRjrzSV4FmWmjnJ5z7Jo1G54TJuDJl1/Aq3FrLDp8S2h86RhUIC4Ev73VB3M8PBG4fBnsy5QxqZwn58/jTnKCEEI7UsVZsIm3JVrfOIiJc6biSytrow5gprSR6blrrvgbtr9NQaxnASw7fl9bRilv+DtaYNahOyKjXYMga7xbqxKWFgjQtSMtG2VGacg/9vt014sOUElJGl3aZFP2v3jqFCyGj8C6okXQsEpdrCvTGLC01tko1wlwQClvZ/zv8F3RnnqOEfB8b5A43mrlBiy5GivGrLqPJXpcP4gtkZGIK91Y9AXHsVVxZwypXRkzXPOlq78N2aQqwgm1unSCTs0pTdn2cYcOeOvCRZgvX4tlIfE6x7OO5TzxabN6+DFJI+plkyx0p3Ud8DbSqmRJ/AQzMbdWFq8PKzt7xCYkYs+lUFTxNEevW4fx1U/f4UeaXKQTq7WbsfBMGDZfeKSbr2rnSfXYZVQQfJnr3Nix4WfP4l5HXeJ0k1BfmxyTyq6x+LBRLawIKmj0WlHqcG7bdpi//36q589sh0BDc1IiyenkeGc+iSQ3YIpDT3rPZQpVqlQRjlo/DhuGyu13oEnTZqhf2gHrF4/DxL9X4qePPgSWLU8RFzmtchb9NRPMgRnToT3sV67Czn//QeOBQehQyhGbJ4+F/Z07KMn02Hrxa9Pbxi5duuD2ir/xef/+aNqsGXpcvASXoEI4t+Qk4jUazKhZFwevJ2DowgUY0LQpcO58qlnx1NqyMaNHY6qDI3x/mACbYsVELOm/RnyMtmfPYVlUJLoXKgyn8T/A1c0FUY+f4LN+ffEhzISz1+5du8AAktt9fdDw7j04f/QhzMuUh138U+w+cQqH5s3GG9HaV+bcnzbQHIMr+/ej9aXLSHBYjBLtOiHyzEkM8PDBnuX7UM3OHlXKBuPQjQT8smyZNokIgMVD30LdPn3RrIIf9s2ZBvujR4H4OPQ4+C/aDvsQJ47sxnuD/oc6TMQRFp7uPtb/rvSRElLT0D76yw8/+BDR776LyV3aounbb6Nl5WBcPrYBHwybiiArq1TLMwTH5+uvvga++UYIsM8s56Bgm44wi3kC+ydRMFt1FvbhjzGwVWvg2DFxjN2oUbCzt8eTKVNwo3VbVCpfFqtnzEA1L1/4tm2Na+fPwfbPP8W+S94fBBt7B8zw9cexU4/w7cYN6NOhA0rZOsK7VQuM++YrDHhimiOqKX2bWcfSubUJ37B8/hk8K1SgdylOHT+FfH/+jh1RUagbEwPfX39FrKMzIkcOx6SzZ2D+24/4oERJtB4yFNv+WYlPZ87C8B5vAPv3G71WlO8TvvkazEXpPX4c7EqUENeIQ2IcnoSFYXSfPvjU0irT04ObOkckktyK1ChLJEYwFJosLU1dWpo3Q9v0z/X06jWTtJ+0Z6aphuI5rw6Ppl+vFsWKiXBh+adMwaX9x4XDlYhG4W2BNjcOpdDOUeNkGRCQaluNtU8/zJUppKbhUrSla9aswVe9e2Ohr5/Q2C6+Eiu0oIwv3efO/9m7CvAori56ko27G/EEAoTgBPfgFHeXAhWkhb8USgsttFCgUKBUKG7B3d3dNUASCCGQEHeX/7tv9y2zm02yGxKg7Zzv28xmd+bNs9m5c98999zAU1sbPDD0ZG2iFGk9q9vg7saVqL52HZy3bMb/Jv0PX0REYHpCAqZ8PgkHq7dDvrYEGTl5OB8Sy5byB0dcZ/1g/OefsHNzU9sD/bag9ms7O6scO+V+VjXWHJp489QZJ009j5qOPXmsT4dE4EqCARu3T5p5IjgqGSeexKK1lwX6VbUEenQs0uvK5zCFDbUwTYHNZyNhsuwvuDSnR8LSoTQe0eKOaenmhj8MjVhbo+3dsP5yOJu37Lpz1CKJWuz1bY0TIYkqr0V1xoRfIySM0616deZ51tt9CJtC0tm56HoY3NANp5fMg/+WrSpXojRpZ3HzU/Qoi/inQPQoixDxllAln8zVt5Qlbnk2AeF3xUn8Cr9Tzq7BtlaWcNq9C3qylGWkSkafR7+ORnxCvJRYZWWFYGLM37nDSFRkONFNir4jkpuwXrQsHvHyJeDmjgwLcxyo3k4e97wmAcir2QyD7fbjfu3aaDZiBFJMTZEjy92qqq3FZT/ItbNjSoCJUZHIIQW22FiYGxjIhUAKKB5ZIA5UnDIdZV2gPqdlsWfPnjE1PyZF/SABa69LCWkUZ21VtSF0jfSx5rq0ziTCkpWZCV9tKXnv8uXL7Hjo6sLA0oIZWIcfxsDfw0qelYHKsZRlFAkODoZZrZqw2rwJOcnJyH/9GsjKgpa2NlJTUpDy4gWQnQNzGxvY+vnB0FXanpxXkcjKzgKsbaAtkXrDWVzwq0jkZ2YglcihRkbQ1zdgJCwiXhH5MiI/H/lhYYXGTrmfeZYEGmumSKirCzs7O/n81CTjgII6ZAGQk5sDXZI115KSOfN09dhYapJcjOYNESd1o6Kgk5uH7KwsRtSjsk2MTWDj5AQdJ0d0bdQYix0dkZmbi7Np5tj0KA4OZga4GpYgH4+11zOQr60F5xbN0ez0GRhMnYqx48biF6cKzAP7W7q9fA6vJMGSBs7oa2fHSH0u7zDzRXHH0DhR3DbcPVhb114MkwvD0HWnbeoEI5/GWHstUv6ZpEE75F89gz4hoVKvcMWKxV4r/BqhOP8HDx5IORX29tgYlIRVVyIUZbTr1gW2bGXzTtP8PSp/p5Tm59tkDhEh4kOGGHohQoQSVMonBwfjxaNHTFXy5s2b7DsfHx9069aNEb8KDA2gRYZAEdkBVDHrCcLsGkImu66DA/RlcVNZRHBKSUFsZibSdCSsLD2JBCaydGlkMNFNiurJl2Z5Bgm6WdNn5rKUcyQbfFQp48Wp52kY6FcT+U6OyLG1QdaTJ4h8+pQRrThpjhTbunfvzghehiQ17+lZiNkuz35ha4PkXKmBTn1i4egIPUNDZvCmXbiIjXPn4tSpU8yIIuOsdq1aGDJ0KMxdXWBCKb9k/UIGAN9Se8hQzGvTASdCpQqeHCT6Ud/DRLFNoYnwMZR+Rv3LCIpZ2fCq26DYrAyUucLA0ID1HUl055qZQcvFhfUh9XPKy5eIdXFh7daytoabn598LCmeN5/yUMuMCGMzM7YfF5hIfvWKGdxpublM0TAtOZl9n/rwIeJevMDRo8cQ9CiIfUZKbz169ICriyu07eyg4+rCjGSaJ/TgxIlcZFjzGG5NszYIjS5DwRjSfNMqpiyKu927ZQtLCUdj4+bqhm7du8Hbywt5FAZSqxYMTE2Rn52N9MhI6SqJvj70vbxYvTNNpOOSrq2Hcy+kZEhV43EqOAE97aSZLCx8ffEiT7o6kuvhjSM7FeXbjzyOY9LXpREKovj9PZs3M7IdtYfSqRERtGnTZpCYFP0gV1K2DBofE0FbjwZJDWKOoyEJqO9B4TJv2k3ZaBo7ugAhocxILi52nV8b9GDDjF8jI1YnyjxCcvZCULx8o4r5LDe4phkwlLMACX+nCMLfstJkDhEh4kOHaCiLEFECmzs/IgJxffuBbnl9ZS+GR4+Bn+ciS/av2Yb1MPDwUJkdoChmvXJ2DVWyufSeDCJK88QNY7oB82PoPd2YlD3KPMsBoS3FA1+7Bv3MdMaiF0oeN3TUYxkb6vToAt2YWCQOHwEyN/rLXgwPg9grk9LHUUaE3bugrWSUCGOKyWDhqd7ohkqfp5w/j1ejxzD2fmNjE0qvIT0wLAzJP/wA8te7rFzBjGXanwxr7lHu378/ln39Ncuq0LrlUOZx5Ahw1IVWXqpCXZp7WeDo0q0sv7SNtQ2aNGkCnDgJw/RktsRdVFYG6gevgX1ZvYX9xz3rlMaM2kV9rZx2q7jsCcqyx/x9Tng48v/3FfPwjeQ7k0F46zZ70SMNvcj7a2wqTdrHJbppy6W3S5u1QdMMEJE3biJx4ED4A+zFxw+/LmLzgmC6eRMM7exYf/F5QGPI50a79u2ACxehk5mKNhWtWIaHh5GFx6O5pzkOTd+C9mSMGRqgZcuWQEgIDHMyCsm3N6qgz8bO+bPRGrX39e3biO/Xn+WfZjmoyaVOuZ0XL0HY4iXFhqCU1Ff0cNWpUyfgylXoZRe+7po6G8K6QBoXL2zz5RXHMawE+XECv0YINF89PDzg4e7BrpG2ASPkHmUCKXdu/n0+vihFHLGqLEBF/U6JWS9E/BshGsoiRKgAGTPcK5KSKM2Lu9fTE5/NmQ0dyvMr0YNxXja2btqEHYsXY66DIywNDGBkbV1knJ6wTFWfFRX7x/epUaMG8xxzw4g8SfS5OjHKIz8eidRr17Bo4pfoNncxtBq4MO9VE2cDWN49zARMXBwcmMeIcKiyD0bPnAkJCX3I2rpu9WocWr4cc+zs5WEhRbWRDCT5g4asLj/Nno0eZJzUroWa/fszYYxkKzvkPH6A9RPGo6+ZOXLj3+TLJc+era2t/CZNymd5W7ehTvJjSOpXZV6zFi5G+CjkHIJyszG8clPmFab4Vpvwywh9/AQwN4dfdT9mRMSeOImEu3fRu+ZVZLs3gL6xHvrVdWbKcU3sdfBR+BXWD8SEJm++qthzahcph9J7VZ45VWPMQYY1z/HMy3oRHMy+O1+vLgZMngxtXV1pf+dmY/HChbi+ZzdmWVmzEAlrd3f58coxysWdV1MUV9asad+AciqYfz8DljVryslid27exPzxE5jYhhkZ8CrmAQepsSZfuIh5n32GntNnA5VN2bjVdDCAiZYtzj5PRSt3Exg8OAZfQyOWYo3wySdjgP99hfmfj0WHWfNRwOdwBQNY3ztaSCJbHcz57jsmLGM6/TtY164tn+v379zB3LHjMIseToshv5XU79TW9CtX8cvnY9Hl51/l1x1l7nB/cBzVDAyQUS8AR0IS0NzNGLi2B4Pooe7SZbXqL7xGaE5N+t8k5P2yAJWjbmK4f00cC05g14PFk7MIuncPMNEkQzpK9TslepJF/NsgkvlEiCgBuxcuhM/fy2G9ZjXSvHyx8cqLNySZBq74X7vmmJmWXmyaM4LwM6bkpa0tN5rUJQYKU6a9DXlLYmeHfL+a0L53W25gkOds2/r1qL0xELbr1iLNs6qcfERt7VvbERPbNMG8vPxChCBhnYWf8f+pzr3s7THH1g6O8+chvGYTBF59wYh0Tbxt0NoiA86fD0Pe+PGo9tmnKssQtkFV/VV9xttFUNV+3cgI5Dg6F+qHkkhsFP7Al9WLgqrx4Q83HH99NRnN9+2D67ateG3vhsCrEfL+7l+vAkbU8cVfJqZw2boFJtWryx+K1D3f20I4rk+fPsVHvr7Y7ubOyGKBIWk48uA1q2uf2o7YOm0Sel66JE8rx5fgldtc3Fxk59RwDDUZO2F7IiIi0MHHh6UoVG7PwPou2Prt/9DlzFnWHl3Kby5bGRA+mApl01Vdw7nh4SXWubh5q2kat5KuEU3L1TRFpkjmE/FPgUjmEyGijEAe3Dt37jAp2vSsbKy98ExOIqKl34KCfDQPCAD27C1Sill5+Z72I+EBuvEQGYuW4dUhBlJdSH6YKeeZmrJ0YKUhbxHBiMqhMnw+Hc1Wm4koRKSya1evojbFbaamYcOFZ1hNRClZW8nw8acY4rPnWBvI06dMdKSlYGVyGYFIVrxdGTq6zEjefE3aj2xb1xmjqlbFhVs3meiJKnIQJwpqZWUych55vz379YJZZhYyEhMR8jIC8dracG/XmqV3ExKgKL6ZiGYGBQXIjYrCi5AQpKSkEBMQRoZGcGs8Bha2dtCv6F2iEUHzgcaPSJTk5S9q3igTm8jQJMU08rJ6Umo4FtHykKXtS0hOwbrQMIW5RSS4Bk2bshAMUsnjEts0X8g7XdL53hbKBNaLFy+yUA8ii20ISpQLlTDyZHYWqlb2YSnMqI2xDx6w48lworAAYZs56U87MwvJKcmIuHcPprp6cGvaCC9fvUK2lhZiK3qw68PI0BBN2rSRjwnN4fhXr/A09CkioyJZKIzPwL7M014cMbSo9tD1pao9efl5aFyvPnDmLCJfRSJTS4vF3PNQF24ks+Nlio9C4qv8GjY1ZXM2NzUF0dHRCA4LY4qQbnVqQL+gABn5BXiekw0rSyvotGiK9Ix0mJmaoXKtmqXKdcyv87TYOMaloLHwbNUMlStLVTdL6qPiCHwlzS2RzCfi3wox9EKEiBJILHQDJNCy7HElIhzJyw61tmfvlaWYJdHRuHP5Ms6fP8+MWzc3N7QJaCMl3xTko8DRkd2AyCCgGysnyXACHpduJtBNishcZNzRvrSPptLa/Abp7usL5VslnSvx4UOY5+ay/y+fv4Rj+g0U9jkZHI+eDlKxiOysbHYMDwGhF4HaICSXMbllLa038tFkKFna4/xdxX6k8IfhbTrC8OEdaX2ePkNS5CtcuHCBEQqpfdWqVUOjRo1goG+AanXryVXQmJc9KQlO9JIZ6yQXLPRmcznrbF1dOPn7w1lm7Lx69UqaGYTCBWRkzJI8yWQkMzW8hASVnmVVJC/aktFCx9GWe1n5g0SKlk6huUUyzZ1c3JmhTEZIVmKifD7wEIyizve2nmVG6svKYvUkA5G2NIbUV6qkr4l4V9VURhhNTUVSQQHyIiKQFBmJu3fvIep1FMta0qZWLVgYGOLG/Xu4/vw59PX0UbNWTVRpUB86evqo5u+PuPg4hB0+jGvXrrE+Pnf+PHr27MkefgqoL52dpfHhaWms77MNDKBbwtjRfHpw7Soj41L/Ozo4wNnFBa7a2qqlvINiULeC9PpKTUtlMuDUJ/RwRuek8eAPuDTnaY7T+YVS4Vz6W9/eDtkW5rAl/kLFimwuplGfysiYVWVE19u3b0uvf319ZNvYaJRxRAhK7ZhnYgIHQwPY5eezuVJS/5RE4Cvpt6Y85qAIER8KRENZhIgSSCzNmjUDzl9AQlgoAnz8FCWlq9hi34z1aKIkxUxyyWnDR4BMOQ8h+e/IUZZhgF5ZCxfA2tNTTnZTJuAJPcrck0g3Vu5R5seVxQ2JbmxGSUno94xkNoB6x48geERjlrJKSHa7tXAnI1fp6euxY6he3BAkcBKcsrQt3azNZcQj0/jXaOLtJPcoExp7WkFn0+9o1r8/Wz7mOYyJ8y/n/d+4idS165AqILiR8U/tp/Py5X3lmzTvOzJQaMsNhqI+Lw5kJJEnmXuUVYVfqCJ58Xhd7lHmdW3RogUjSeYnxSPAx0lhbrX0tsTx5dvRTUeHefIMLSzkdRbWtSRSWWmg3Kc0F5s3b45f9fRVSl9TXU+v2IuaNL40Rykzx/c/MIlueYKzp89Y7C1JwdaWvRju3UPKuvVIkY0roZbsxRAdwwhx0pkJlrYPVlasTqr6Qxk8Lzkn4zI8kcaG13ZwlLan1VCsvpahIBV/Yv2fIB84SUCnGhsreJT5NanKo6zqGub70tiTUS0si+pPn5c0rzQZO04YpYdBded2SQS+4uZWecxBESI+FIiGsggRxYBuOLVr1wZx1Wf98D1m7DgAXV0Plm6JjGTdsEtIS0ggWj4LheBkvh/nzWdZDPInjIdHixZI19GHflYG/v7zD5zftBmz7ezg7ewMkwoV1I5RprpUrFixVDHK6mDHhg2MbEfYBaBrZQuY21hhx4MYNLLVZmII24nsJ9GRtlW2DMtJPLzOws/4//S+V+/ewKHDmD/9OwzYcoCFfJC8cWMva9TIjUD2w4fQN9BHlow8udbKEuPnzoOlrQ0jjRUkx+Pbr6cgMzQEU/QNFEhWqupQFJFOnc+LA4VblBSjrIrYRKEHyvG6ZHxG/PEnln/zDQb9sRISTvaqaAmjR6dQ1diIpbUjwpaJp2eRMcrlQaRS7lOab0OHDkHewUNolhcB7QaurK7tfKzhHv8A969eAWztWH9Szm/Cxfr+6Pr55yxVXmxUDDKmf4vNoaHobWrK8iHnenghJy4GX038EiaJiZiQT2Y0ENS+Hep16wYbBwc29s/u3MSCceMww9yckQW5h7S4mG2ONX/+ycJb4oYMRu3u3dm1aJSbhf179uDk/F8wgTJQ5L+CpIkniw+nDBEV0kKx4/AhjHJ2ga2dLZwqVSpVjLLyZ2QQk2dduSx155UmY+fq6irPhFNWBD519xch4t8E0VAWIaIE8NzEDZ1d8LF/ddRr2BDtatXDyeU7YWZgiD+mTUP+goXy/Sj+9/CRwxjp6gaDlh2wgJGEwhhJaND3c9kSK+Li5TcU5a1ylgACv1Epe3qE36ki1KkL8nTu2L4DPRwdmepZhqs/xp2JY6nXljglwGT5EkYIGsLTVsmWYvmNXtU5levXqlUrRB46DJMXLzCjljeq1K+PEe0649bi7UgWGL0nT54EmSVf/PILMir6YQEjTz5j/Tdh1UYMr+ML6Bswr5xy3xQH5frwupfGkFAuS9PjOLRkDxtj6AFk+AAmmkH5gCnVmZCApSfzxvO60hxR7nd16vQ2pCz6f+TYcXh28BAcvv2qUF3r2trJ42A3bd6EIQAGfDUZ0Y7u+OvScxx+kIOAETMZcTP97j0sTrXFsZ3S62Lqpt0YUM0LEyo4szI6jBqFaAd3LGDH0dhXwdC/VgNff4HMjEwYClYFiqs/PZhs2LgBzc3M4dhjABYEp+HIQ+k5B4z4DJHXrgEPHmL7ZyMQ7eGOjs1b4dyU/UiOjcWSyZOBwE2Fxk35elXuo5L2F9aZv+dzka/OCB+ES/tATMdQiAgZ3pqWoXxNlXSsutegCBH/RIiGsggRJYBu/IS+kZHo6+4BREYBkfvQi5TMSBFvwUKF/Y4fPw5rKyuVJCEi/3Xp3gNYsQJpqWlyQhwHEb5iY2PZsiyJe5Skhick3PDlXk6o0wQUR12AAlbn/b6tsUauFpaB7BoVUKmaL+qfjEbGp58g09kZKXFxsJHFZaoilynXjy1VW5G4AtDf0pK98CICWPEXGgr2T8zPx7nz55ihnJmTW4g8SaSxJpRP9+491n+cPKku0Yj3JYtZzssrtu5FISgoiC2R07EUd66uCqNQaZDSerH/KSb896VIjIrCk8dP8Dz8Ocy0C1Bz2FD4VvWFjq4OjK2tFQhYdBzNETKqXFxcFM5dHKFKXbJVcXOK4sIp5CU6PBy7d+1GQmICPAJao0uXLtIwAxlZjIhyQ4xNkJmXi/WXnstzHlMoj1kTZyS7G2PN1TfXBRlaLSnX94OH0kpIJArHsX3qO8PLzo6R1FrXraNW/emhlIinkoqVsOZeLNbfeC0vLy8vFw39/dk5x9EcSE4B9u1Bd9rBwlJuJCdTDHsxSpVvc90pKy7S/KAyKfyCVm3UJdIVRzolQ9nb21vtMjQl5YkkPhH/doiGsggRmsj9FgEhm5xueBKJjkqSEJH/aleQEuKIWS8kvjBCXWIiI8/Q5xQjSsvYyipYQs+hkHDDc+vSDU7TJVAqizzirM4hisp3Z8PT0ahhU+DkKSQaGSHHxAQ6lDFCJixCUBW+oEzwMWvYkAmK8FzJ+Xl5SEhIRHZONrIysxjpKaNSJeTKDA9V5EkijXWvWIUZyplZmShIS1ObaMT7iYwdMkh4fTUJvSCjgJP5qEwysrngi/K4CIlN3Agi8iARysgQIiObjk/W0UG6lRVs6vvDpUVzRlpjqxOGhtCiOFyZN5lA5SUlJbG5Qu0hA0u4PF4UoUpdspWwr6hspq6opSWPV2bzy90ddk5OaG1rKzeoDLy85CsdVAZf3SBFusMPFBXpXqYX4EqkdIw5jgZFo1tlX7mhTOEW5ElW2OdJHPr41WTzpSgPqfJYh4SEsM9pXp96Ks14wXHsUSz8XaXXbNKIEYg3MmRtppAFIo5SGMSNhw9x8MQJZrQSkZTmGifdCol7yn2kLu7fv88erAl+fn5sHlJZPFsIjZempF1l0in1Bc0ZmucllaEpKU8k8Yn4L0A0lEWIUAOapGoi8t/iCRNUkp5Inev0xmWMJERpooTEF0744hktyIgqSgWLoByGwT1bpYkT9Pf3R25ObpF1vrpjLSjhmoWFJdLpoUBPj6XmKo5MpYrgwyWqOQpk3jR9QbqtmrVqAcEh0M1IRYCPnQLBrYW3BU79sAtE9aPsF9rGxmoTjfh72p9J/co8ypqEXpCHjZOu6FgyktVRYSRC2d9TpuDE8RMwNJKSuOihqEH9Bvjk00+gp6uLDAsLecy00JMoLJv+p+9prGmcqQ7C5fGiCFXqkq2EfUWkPD6nyGhTrodQOVEYKkT7sbR5T5/BKD+7kIqenV4+C+mh1QqOAB8bHPtmOzrJ/icRE+XjmrubsDAP317dS6w/yWzPnzkTZ86cgae+lIDoX7sbIoTkVB8b3D6yjWWA+fXXhXiSns6uP0rjVt3RCTp5eYhKTEC2mRkzNFeZmuLTTz9F2y5dYVzBqRBxT7mPisOLq1cxY/JkXL58mY05PSjSAwApaPbu3RuWTk4KaSM1JcgJSaf0nuaMOmVoSsoTSXwi/gsQBUdEiCgHfNyqFSa9ikT+pp3Y9bJALiJRVS8W07u1xzZXt0KiHRw87ZoyEaikuNO3iVEmfN27N4bdu4/s9duw77U2q3OHag6oa57ORFVImIHEF7S8vOSxveqQqUqKj1QmR8Vfv47XgwZjeWUffPbXGmy58YqRJ6n/zKNvY+OUL7DayrqQwEtJUO5LdepenGeZjGZ1xiXr2TM87SDN4sGFIPL8ajLjTRiHTLLg5pUrqzXmqmKUlc9bXJ1KgrpzSlU8PeFyYCDMZ87C7cGD0OiTL7Dh8nMpAdZeB6bBZ9FcXx8Hq7djZEAaV4OIqzgwZwb+ICU+AK8mToR3zwFvjqtsA+0b+9Fr63o2Bw195blQCoEyzoR17FSov7O9KmO3lS9TAaR6tHDTw+zu7bHIwbHYcVH1Oa0wURq20lx3ZMRH9ehZbPkEj4MHWajL25B2OTmwtDHK5bW/CBHvG6LgiAgR7xjKLPdZM2ci8eNRmN62GWp064ZPqtfGycVzsPnCBcwaPQY4fLhQGfJlbEFWBHXINKr2KYl9r+oG//XXXzMD9ft2zeH3UWd8WrcBzv2xABtPnMCUgYOACxfk+wtTrAnPV1z9ioJyWXKRkuvXMaJONXTp1RMfu3th3w9fIyIsDL9N/hpYuVLt8ovar7RGMkE5w0ZR5DfCnctXQMLBuWPHQtI0AFueZUmzRbQZia4uEsxo2wyzbe2gK8thrc6YC41kodoj9R3PilJUH6iTZaW4OSW80fAMDcplVq9enWWK2TR/PrZs2YLW7drjExNz+K86ig1PHsPIwhJOL0MwolIV7Jn+PyS8jsbv30wFflvKylv0v//BbPUqNGzaFH2NzbF70hrUd5Bmi1A+H8/swNt/6uBBlpLRYOoU5NVrisCgRBwNSURDCy3USAuG2f3z6HTgKb68fQs+xrIME4v/wpYMSzYujev3Qp+wy7i6KxD+3QfggG9rdjyNV9XXt1D115+Rl5oGbRVjXlImDNru3rQJlKHccuYPSKpaG1tC0uXzoZlJMhb06oy5Do7IT09Tm6RZFIoi/v7XjWR1fxdVffdPa6uIt4cYeiFCxFtCWfGLlkqNbGxAkb4/WtsA586zF6MfubrJjeR0SoUl80wqE73etj7KZCx1SEivk6Rp2Sh1HeWtpRflup1ABEaZkRyTmoq00FCFepYlmYeITSmyWPDvTExlgd1H2aY+/aH+lBnJwv7TtG/epq7KZZREoDt48CDL35tibY2DIWnYICNKrqSQEokbqnToAFy/oaB2qO75CfSejuVx0zwsQtU8UiY1FqcEWVybr1+/zgiFZChXqVKl0NwKDQlhDwdk8CE7B9i3j5WTR2ROIsoBaHTmLFO+Y2ROU1O5kUyY5+QEJCQCe6XHBdBDTWycnFynLyO9kQAPGae8DYRdu3ZhIoAcpwrYFJyG1bL+3pYAmFSuiP7P1zHP7S9O0v4hAuumFFOsvi4N8dmSkAGjyvXh3zsX+5z85cRWGq+hdavBz84O165fg7uZqUIeZaoP7wNVan2cREox6mQox5uaYXNwKtbJwpyofK0mHjDx8wNiYhXIvqWZt8q/KeqU8V8g8qn6vS7uehB+V1pipYh/NkRDWYSIMlYwo9hCXQcHtnRakJFe6Bja73VyMp5lZcIhLo55KOiHm244tKWcuUV5BNWpjzLBj6v8ccVAZQVAMnho/yeUSeGLCbA3M4OPj4+CZ5uQp6eHF7m5CvXknryyUOTiCnpZVlZImz8P2bJ8ygaGBrCxtmHkRzoP1ZnSqhU4Omh0zrIgHimXIVQhLIpAR8vfrH1Gpjj9KLGwsmP12sxQJrVDGpfi6iU8P1c95CRQmldkOJJhRFCeR8pzQ3kehIeHsy2RDIsjAgoNc/qM5g/F9vK5RXGxCYaGSPh6MiQ5OSyWnYwTEu4wy85CVnIK9ExNkGtpCQMmUKMLYxNj+cNPbm4OMhISWN2Tk5IQ8fIlqyMZLh5Vq7L5gaws1gZqL9WPtlRn/hlXOzz2KEah/yjswqtVG9TZvBGvBwzAksWL8VPrtjgWqjguLDyjRh0cv0+m/RucCE1Cf7+a7IHOPiNDrsxHfU/9ytULqS5CtT7qG6o/xTpTX1AS8VRtHZxUIvtSuFNnIs7u3SUn+xY3x4oC7UfjSWND2XMoDrqkMv5JRD6aD5SGk/qUHgJ4as6SQHXmSqJ8JUIVOVOuqij4rihStYh/P0RDWYSIt4AqBTPudeASy0IEnTyJ33/5hZGM6AZD+7dp0wb9+vVjacDMKlcutZFcHMFPWSEMkZG4cOAAjm7ciOiICIUy6Mbac8AANO/ZUyGbB8FM4KXi5ykrRS5ODGT19fWVp8qysLSEmSxVlirvpyahF29bV+UylFUIVRHoPDzcKacctFMS0cLbERsECnBElLyw6ABTdiS1w5IIYcrnJ5CRwA1VXh9lgp3wWP6ez4dTGwOxadUqBD0KYt9ZWligR48e+HjUKBhaWrLxF56TvGmUBYJ7lMkQFs4tMtDJcE+SZfi4cP4Ck4EmUEjGkCFD4F+nDrRkhDgFD53MQ6kr894ZkCH+8KFUPdHcHNZVqsg9e8IcxLxdPGUf7t2HSX4u2lS2x+pL4fI+IDGRPTP3sdUd5wb18Wh2qpTA2no4VsvS1XEVymdnjyCgSkcFdUpOKPRq05IZTao8ylQHVWp9nETq6uLCUiMa5+WiVSUHuUeZz4dTU3ajq4DsW9wcU4U7hw7hjwULcf7CeWbw0Zzq0KEDRo4cCXN7B+h5e6ks459A5EsPDcXq33/H1q1bERMrzYhDIkwjR4xAm7ZtC/1eqaqzUElUeXyKU1UsilQt4t8PkcwnQkQZoCg1PSEeHj8OrbHjii2HyzKXRX2Kirfjkr7qQrlOxQmilAWE5D4qV1l8Qbk9mqIs6qpcRnFlRp4/z+LVT3XuhNZfTMH2O9GMoEZEST+DBEztHIDtbu5FkjtLOr9yjHJRBDvlY2m7c+nv8P3jD7XGv6gYZVUxnIlBQYikfOEllMsJcUXVj2/JK0/Gv6rvlGOUH9FKzsRJuDt0CPw/HovAqy/k/e2Z/xLzBvVCoKMTIwWOGzsWkyKjoL19H7aFZTOPbjMXI/QMOYd5fy7E5E8nykmH7arawfDeUXRat5wdq+vjUygeWZ0Y5fPr1sF69hxE/m8SXDv3UiCr2iYGYcPX4/G3qVmh+aDOvL2+bx+Mv5qs1nj+02KU1f3dUuc3VIxRFpGcnMyywdAqD1+FKwqiR1mEiDKAsidRFRbOno1JABzm/gwDHx+WK5bSYGVnZGD6iBH4JCOz2FzNpamPqnolvY5i24se7mj0LAxaH4+CeaPGMMzORGRKOtZNm4Ih2dlYmhCPsZZWheqkyggryxulMrmvpPZoirKoa1HEPVUgjzgt7B9ZsZIJYHTr1RuNKznixNa5+GbbNnw/8mNSqVF7+Vj5fPy90MOvzrG0/Dx/1kyssbaB0/x50KtYUT4nX714gSmDBmGmYPyV2yi8uSiPz55Nm+FPAo7fTIV9nTpMQISXvf7HH9H0+g1kJSVBTw11O9ryc6n6Trn95FEOA7Bx7lxcuHABnbp0RUNvWxxe9zdm79+H+eMnUCAz2/ebb6Yha9w4/NKzE1oOH4Gfff0QfHAbjE6dRhVowShwFVoaSeBnZ4NNs6fBLD4enbS0FeansF9UfaZc5zp16rD6kfJf5SNHEdC+PfzdzbH770XYeeYslk6dAqxZW2g+qDNvKSXe9wAc582FfqVK8j7PSE3F1MGD8UUBSvyN0fT6eFfe1QvHj4My0OeOGwvvFi0U5tSenTux5ZcFjF+hzm9oceOj7nci/jsQDWURIsoZ5L0goQlSK5vk7oF4nxoIZLLWUlnmgfW90W7ECOD3P6SxxOVcn6NHj6Iu5XLNymJy1Qe9A5AfK0FGjiHOh+Sh0eQ/kP70IpJX/q7yeKqjcvwyb2dZ3EhUeUuLO8fbepY19S5RjCmPURR6EIvycmvJUp797OAARLwEFi1i/w+gF5E7ZYITXNlR3brzeinXQV3s2bNHLgMeW9EPm0LS5VLhgxs0RLX27Rmhk+/Dz1PU+CuUvXcPM5TJSCYpalLZ42X3nPwd0KcbyyHc0tdXo+wj6mQh4P3IiIQhocBCqXLmcHq5uMqNZNrPuaI3QgFMJON3zRr2Oddp7GtuLv1/xXL2GRmgkBnJJY1VcWPBj51jZw/cuyd9ARhLL0dHZiQL91O1wlKUYuQ9KsvdA3GVqiuOZ8MqaDl4MLBuvXw8NalzWeyvKQplC9mzG58BzEiOtnfD+svh8vYNHDUOfy/7mx2nLG1fFqtQynUS8d+CaCiLEPEOGNakwEVQJWtNpJ1usqVCiu2U5gQoP7yOksr45unoYp+rPw4/jIG/hxX23nnFPt+akAHjyvXh7H0YeCn9TCixTXWkmFhPT88yZ7+ryuhQXHaJ0p5X08wg/Lvnz5+z8aRzOTg4yPdVFodQqJ+VJaw2b4J2ZhaTpFZlZJYUW1kUa1+YaYHqoEk/EBmKVOgkpmYIfJQszcIhkFqvWLkqM5SJuJfw8iU7DxH1WNy40vgr4/Xr14C5hUop6oIGzuhrZ8dU83xevVJbRlxVxg5VWQg0UdKkMm23bkVuagqLCebjk0M50DMzIDEwhI6To8pjS6pnUWORa2fHzinJkRLg6MGDxH5iY2OQKlNadPXxYecQylvTEjG12dHRUWVGk4iICGnMtL19ofEk53TbSj7sfxpDow8824WqsSZnAyE5PR1rL4Zh1cXnChLofrVrAUGPFKTt1c3qokmdxKwX/z2IhrIIEWUEEpY4c/gwtm7bhsePH8PQwBCNmzRGu3btYCFjS6uStT4WFIMGrplwpWV6Mi7KGUS2InjUa4BVr/NQxdEMN8MTCrH+O7h5KRjKPLsCkcZoyz2LZcV+F5ZD5+Dsc2Xmf3pIKO4/eIBNmzfh5o0bxGZDvbr1MGjwIJatgwyZ3Lw8HNi+naUKI/Y/xaJ17NABvXr3ZoQmMl7VzQyS//IlLhw7jkOHDyEsLIy1r26duujarStsXV1R4OAgJ04KWfEEnmWCMjUYyiSp9c3MSu2VErL2eVo07injnll1+59Im2Rc5fXuz2JwC2Xj0JYS0jLS05GbnMzGgowsGgvh+KsCEfyQk6tSivrI4zj09qvJjBXqY3VkxIvK2FFUFgJ1Hjp4mSx7Soa5wvgUJ2iiTpl8nt66c5vlkb5z+zaTtScZbJo3LkToMzFlcc5ZqanITktDfF4uk4fP1tVFpqUlDLOzmZHMMnk8eYLHt28zuWt6wCCDj9Q0BwwYIJ/zZECzB6dqNQqNJ8VA16yQA8oazUmFwlWbDynbhaqxpi37bcyIQqqWDpM8F4L+b2RDebYfMYVDekhSlcWitFkr3meGDxHvH6KhLEJEGYCrr7kALA4ZprL4TVk+YkLrGjVUSkSTlO7OZfPxhSwVWnmjbds2SNy6FXnRrxBQUYJDr5JQ38MaEUJJYXsJgtecVziOS2xzj7JQdKMs2O+qMjooZ5cg4yOmTx+Wo3c07cBzLQcFAd9MY7GfHESDYlQoM3OAVmMPHkI8vWQqeLoCA7coljux7FNHjWZhBPSClfWb8wUFsWKN166BoaMjq58yK145y8TbMuaVWftCjzIZBpqU361bN7nUOoldcA8kobWPDXZ9u4Zl4zA0MoKWmZncO8c9ysWFX3T5qAuwcydy46MLSVE3dTZkmSOafPctdPX11ZIRLypjx9v0qaoyy2J8hPPUCsCnwnl66xZ78cdSMyKeUd5ymlpWVvLVCpIPp3Kob+hBLf+rySyneW3hb8v9BwpzvuKhg9Kc1irGs11Ve2xdOAtTVEhta3r9ltX1XlL5ymPdvkN7YPUaJEWEo20VL7lHmdDUwwxXV5zAcIkO9HT15NL2qrJYlKbO5d1mER82RENZhIgyIprQAm3C0KGo1eUjOdHEIDsdv37xBXq9iMDIgYOQ98cfcH92EUPr1mc5WVt5msMi+AyCKTSDq4SVMzi57Oau3fjYpRIyXOrByFgP/eo643xoHJrYS/BR+FWE16oF3LypcCwtt6vyJNLNvSy8LMrlCN/Td6+ipOIPD9q2QacxY2T9rAfjvGz8/eefOBsYKBV5IXwxAe5Nm8rHQpKWhJkjRmJ0ejr0KP+tzLNbXIzyqZUrQb7FzE8+gU9Aa2jp6CCxQBsG2RmY//nnGBwbB1sTE4WyhH0gbE9ZxTfyMt82RpkyVkyaNAl569ajavRtDK/nh2MhCWjhbgrdWwdRhbxvKanMgDOqUIGdh0I11IlRpvRyUTt34rshQ9B74R/Ir++Mo0/i0MTZEBZ3DzHBDxcnJ+g6Oakdo6yqL9+2T8trfJ6GPQP545927YJWQ4a8IZ7lZmHRwgW4vX8/vje3YJ5PXgd6+BDK1xMoJCWJhEfIxm7RHB998il0DPTlJLY1K1fi2OrV+MnGFvnp6fjqq6+QN3MWPMIuYWjdejgRmoiWnmYwfnAcWs+fUw5ClWOn6fVbVte7JuNCKe5erF6DhePGod/iZSjwr4BjwfFo5moEXN2NYUTwO3ee5eQ2srYu8xjl8m6ziA8XYno4ESLKAJ+0bYsJ4S9Y2qgXlk7YejOSpZoib9pH9vnQG9wbcaNHwfrv5Wx/iZ0d8v1qQvvebWY0lHV6uOJAXtLnnTrL/+d10Y2MQI6jc6E6kXAK5YRW9ybDDTdNoQ5xb8Fnn6HjyVNw374d0Y6cJCbt5761HfFx/er4S/bAQWPxhvQTxXLotjROgfWnw2Gw9De4tWqlYGiqQj9/f8xITpGW5aB4vvbWWTAePgDZc2bDr2vXQgRETVLIaYri6qwJOTE3PByh7TuoNSe5N02ddmSHhcnLLaps5bleFFFPWGd1oU5Z5UnMmjlsGHpfvsLmTZSdKzZeeSGfN31qO2BIzcpYbWXNvi8qzIOP8aJx49Hu2DG4bN3C5mDg1Qh5WYPqu2Kkvx+W6huwsigEQ53xpLR8vB80GVdCecs5F1WuOnPqXf2GlhVhmH8m4t1DTA8nQsQ7xoMHD9iS6PnLV3DWohbWX5PG9tKSc05dBwy0s8Ol4GBMkJGMiKQTHxcP0x5dYGlswkhEJDhS3j/wjBykqysNF6C4gdhYxL16xWL5kj1doauji2w3Z6Tl50HX0RGVatRAppUl0mTkmJKILJx8pC5BS1NZ6MdPnoAyqWbm5RYiieXk5qBeo0bAnbsqST8rz4cht64jG4tTp0+jR926rK5cJEJVfSkeFJSdQCUpzYWR0h4+fAi3li0VwkWUiWZlLfNdVB9rLM9ragqzDeuRn5bGQmoIzsOHyEOAOHGNyyHTsj15mEtqByesJUZFIjkpGSmpKSxm37RDG2RkZDJlxYj8fHiWQNRTJbVeEtQp622JXSXhyZMnbBuXmIR1IWFy0ROaN2QA12/cmBHPioKQxPfg4QO0o3zcMTHY8BRYq0TSa9W2LZMCVyYy3rhxA1FRUXBt0hB+1f3Y9yx+384O8TLDkvqKx+SrM67KfVvW/VfcdSJsG+3DlfmcPx0lT6WnCSm2vFESYVjTeS3i/UEMvRAh4i1BCmVkYLILytIap4ITVMreFuRlsZsU/Sg6U5xsfr5cfU6L4ulKSHpeWu/x6UOHcPLkSbas61zBGS1btYSZqSl0HB1h1KQxKsnOS3WJvXcPh3fuwvUb15nx7O3tzWJZiZxFKm3w9Cxy+ZFLUNMNgLZE0MqPiEBWYhJOnTqJM2fPshtHNV9fdOnalS01042NvFvqyEKTB4Zu6Kxd2no4/CBSsZ8fx6Gtk4vcUFZF+qGlaBqLsPMX8LxOHejRjcvUFPDwUEkoM5KldlNNSotlpLSCiAj89uWXeBkRAVMzM7Rs2RJVKleGIUkte3qWSoK4KKjqY17n0sjzss+sraFlYwPn6tVZeVQ3irm/efEiU9ajrBdmpmZo1qwpHJ2coOfqCpOKFYtsh5yMZWuD5NwcaNvZwVpWx7TMTEYINElJQcyRI9h2+zZehIfDwMAQzVs0h29VXxhYWSLX1lahzmQIcQVMdYhmyqS/siR2lQSqA0lzFyWjffxxLFo7k1rjI5Wp2vgYU31pSzG3hHSJHk6oIOn1tFfMysGzeWgnJcHG1RW5enoo8PBgvztMvEVGxOTy6lQHOldJ/aHct2XRf+Qljnz2DLt37UJwcDB09fTQrFkzNGzYENoOjoXUTbkRTGc2p9CwDxTCvqIxVHndaTCvRbxfiIayCBFvCTIi6/nXY7K5mTGv0dLbFesFMsVNXY0YeanpmNEKnoPyJohE3riJxIEDQbeakfzDp8+Ac+fY2yQiou3eBW0LaaaNzGfPkDNqNFoTmYvvf+s2e2XS9zISHN+/KAlq7u0kI5kvlVaUvRhCnyJx7z4WJy1fKrWzK1EWmratW7dmx2fFRhUiiTX3ssDJv3eht8ywMM7PQVsfG6wSkJqIpEhj0Z88alO/YZ/lEcFp8yb5crQQrQNaMzKmYU5G4fPJxrVWdDQUbtkPHir0l45MlrwsZb55HyuLspRGnpd/xkleqcHBePFRF9AoDxSeXJbvN4X4ZMXMAyEZi0trmwkexrSiomD0zTRWPpFf5QgKAuXAoBel09N3d1dZv9KS/sqK2FUSqLyWrVoBGwOBlES0qeyoIKNN8/T0sj3op6evUmRGQcpdVxfNmjcDwsKQGROF1j4+co8yoU1lW+ybtAHtZQ/qHPQ7Y2lpyR5KaMt/d4RzhLZ0Lv4gQYZvcf1R1uRHYShFW9mL4fETJCxfwQiPH1IYhSYQ9hURM9W57kR8uBANZREiygATxk9A0qhR2LVtK0Yubg0DA33m7WnhZQHt6/tYDF3NmjXfKUFkyhcTGMvd+NtpsKUwA4k+jHIzsfLvv3Fi7VomeECkNo6l8+Yzw0jryy9hU7cOYGYJ49xsHNi3F+tmz2YCDsL9VYFCAbiXMyNSqgC43MQYk5csgbmVFasDGZ1//PYbLm3bxkhIQkKTkLinql8CAgLw4u/l+GXcOAz9czULfyDPbmsvc+jdO4qG9g5AvDT9XuBPs9F1wmQUVDZl6e5auBjB9ekF5PnVhH2nDliyORAPjhxh6nNmuoqGBsegQYOQfeUqFn3xJbrMWSg/HxHenG9LSWmvWrZEg88+hbauLmtf3LNQzB49ClMMDOT9VZbjLOzjkoh+6sToKsdK/j5/PrqQZ3PsWHgHtJYTx04cPYoV339faN6ogpCgJsxiQqkJL1++wvL4BnfuhDbDhgM6UqJbYvhT/DR6NCbr6rHxUEW2fFvS37uKUe7cuTNebQzEsilT0H/JMmjL5g2Rd3XvHkYrD49COcqLGmObDh3wcu06rJ4+A4P/XAUd4Zy/cwh1KPwmSRpuIwRlwCDPsvKyvvIc0SRGuSzJj3evXgU9DtwLaM1IinwepEW+wOwxY9RSEfyQodxXBDFG+Z8J0VAWIaIMYGllyTy0+jExGF7HFzXr1YO/tw+urDqHniTh+45BUsnXrl1jKl05dZtggUCla+A3M3Hp0iUgUSpgQIiMjMS+/fswsIIzdJu3xZ+kHHg8TKrqNeIzaVn3pKIpJf3o85vntevXQBmbP5s9G1mVqmOBQElr8I+/MHlhZOfIl5+LWu4VnkdHlmZrXG4eMGoIixGm8Afy7AoJPYQOjx8Dn41Efzs79PWriSzdytjlXBerdGuhXY4thi/8A6MbSB9eilIrq+DlDfIh9wgPBwb2Unk+/x49EOvkKVefa+fryAwafPkZ86BypcWyMC54xoniyJLC8oXe+JK+I9BS/PYdO9DF1g5GAZ0U5s3gASNQl1YYaO4UoaCoPB8IQiU5qveGjRvwJXlDhw9XUu1zxNA/1wDjR7MYXWc1ZYOVDT1hvdRpf3mAhSkBGJORUew8LSgme4g8L7bMcz+B5ugnw4ssS5VaYEly5sJ9lMdSCFXXt6b9x8vlJMWNGzeyFI8fffqpgPAonWvD/loDjBmGiBcvULGUOa3LG+o8hKl73Yn4sCEayiJElAH4TeqzrGx85u4BxMRKXyR5e/OWwj7vQu3p1KlTLJWbxNaukEoXKQG2CGgDbN+O8OfhMDAxwenTp6XLqfb2WP8gAWsEZERSaWtIadbu3WcCFaYyApkqYgr/jOJaqQ59yLNiaorlF59h9cU3hCZace7asyewaTNT0oKS56soUlqKthYky/5CXkoKIl6+RGhIKMwtzOHf7VvYWlkxhbN8A32mspaTnIQ/v/0O/aOiEOXihHMejbDmSgQrc+WlcGjrSNC1Vy9g956i62BkyMhu6XFxuHPnDqKjo5mwQ+PB/TGiXTvMd3SCjouzAtGPSIMF9Z3Rz84ON65fR8eGDctkrItSRSxL3Lp1i4V1SKoVVnejeRBAstaXLiEhPgFGyckqCYxFEZV4+69evQo4VUDw0zDsfaalkiB55/YdODdrVmJ9lUmG5UUy0xRC4lloaCiuXL8OLWihwdQpcJeF+CTn5CCWiLVxccUSX4VlkXjOuXPnWf96DujPrg16yHP08CgUolAU6VN4bSkTyYpSvyxqf3XBy+XkWTKWaR6MNrdAVEwM1oXkKxAe+Ty4cfMmKtKc+8CgijD6roiiIt49RENZhIgyQEmyucpsbIrPexkaihMnTiAzIxM+lX2YahczVsuIuV2QX6BSpYuUAD+xkxKA0tLTWEYLroRH+x8PSSik0lbTgaQTgJSUFBQkJ7ObgVDJTqhuR9+RQUefsWO0dNk5haCwlAlEvKMY4fzCpD0qk8qiOvHzMIWylBREZWfj6JkzrPzq1aujx4AB7JzsZk4qeDISV46FOcxIhTAqCrCxZ3l8C9XBXNquA38vg3WNGmjRogXzdmkZGiHTwlxKejIzQ6q2NrzatIGvgQG8vLyYB/6ZLBb4YQSlAlT0SNO5+vjVRF5+vtzT9DaEvqJUEcsLquYNzYPqdlkstpgyjFBbqB407jQWQvIc/c/jNIUqhRQzy5Guo4fDd6NUEiRVhO4WApVHY0514OemOpUXSU9T8Gu4apUqzOiXC8OYmUnn+KtXKkmZxZXl5eMD/SpVmELfzuvXYZWVBS9HJ1y5cgVnDh9h10OtWrXYNZWSloawrCycO3eOGWyNGzdGvXr15IRPgpBIRnWiB4/9+/czQ7Bu3bqME1DU/poS22he0HjRsexala3ipKAw4VE+D6DGRChn0BgdOnSIkQ3pgaNLly6sDcrKge+CKCri/UA0lEWIKCOoa9xyshShMf/w0CGE/7pIvs/bklgolnf51KkqVbqIAHRy6RxQQIixkTEMrK2Zkf5XQQHbP6DVMKwRkBHbVrHDhS0r4S3zKJnIiFmqiCn8M/J61q5dG7hxE2mRL9Gmiqfco0ygnMb7F8xiynnk/VUm7fEbsrBMwuKvp+DE/v3Mi0wkmeN//43t8+Zhzpw5cKtcWa62R/sXvHqFTjICWoV1qxEwYibWCJ4BiNhXY9UBRuarf/EScPESIv78S/49EfFo2VtIeqL300aMwKGdO1FR5i1aPPZT1J/yNyIEZTd3M2FL4zV7d5e3620IfUWpIpY16tSpw/qV5kHbVsOwSjAP/O0l2D7nR3yjpY3UR49gbG0DQ28v9h0Zy0LyHJ8PQkOB2k3EMspsgcREGOVmob2vpwJBsqWHmbTf+vUusa5UHicJ0nwhz6nQo/yhGCiqSLv0KoqUWRxuHTyIb778Eq9fv0Z1JydMkMmMy7Fvn4I65ayXERTwDCNjY6ycNg2+vr744fsfYO7oAImzs5xIRv02e+xYbFu/nklF0zhtmT0HThWcMGPGDLiSTLZg/9K0n0DjReeia7p6jRrA83CYIJf9JgkJjxTLTfOgbrdv8T5xauNG/DB1KpKSkuDu7o7o16+x5IsvMHz4cPQbPhzGFSq8U6KoiH+AoUzLjkeOHGFLkPwHu0aNGmjTpg0cHBzKr5YiRPyL8PP0GYw0Fzt4EOr26Ik0HT2kRUZgzqxZSHv8BN8YGb01icXPzw+NGjZEXmQUurpIoK3rwTyoFP9XISMUu65cYcvfrm6uMPH0ZB7A7t27I+/qNXRyLIBOEw+5qEFVvVhM37ULQ13dUKFCBejLJHeLi8+j3wab1q3xcvkKzPlxJr7fcQA6Eom8DnbJj7D79m3A3kGqpFUC4YjK/H70aIy+cwejXVyY2ACR8sigY3GaU6bilZI4CqWcqi8rL9DYGH0buMPMLhU7771GI1ttpj4YGBqCAV7eMJ0zFwUSYMnChQg9c4YR/IiwZipoKxk6U4YOxahbtzHC1U1eh2/v3UZK+BWYVa7PSIOtK1pC++YBVi8b8mgrtam0N8+iVBHLElTHPn36IO/ESXR6cBwFsjZ1dzdEQF4UDO0dWLu0Fy9BzOIl8gc6VeQ5grCtvP2fff4Z8NNs3L5xHYPHtmDeY5oXJOUuubmflU8x/+qA5iMRBIuKUf5QoGrsiyNlqkLI2bMwmfw1llBWF2fFa4BA7w1at8CyJYsxNOo1+2xpBec3+1nbSK+Vr75CMr9WZPftuaQeeuo0egnLtZJdW7N+LLR/adtPvws8RnnkyJHA9Bk4cuAABn/1HXR0pL8PbSrbQPf2G/XG94VbBw7CYdaP+NPIGDAyhoSUFJu0kP7mHDqM2EOH5eIt75IoKuLdQ62RDAoKQq9evRiLdv369ezJiQxj2tL/9JRK31PifREi/gvgP4rCrarPlL979uwZdu3exd479RyIBaH56LYzDOuTbTB54w5E6b7dIg9PDUbn+/Gnn9j77wKaIHnDLAwtuIlbPwzF0tFDsOh//2PfcU8t3bgmTpzI3s9s3xKxq77FUNxE0NwxmNG9A34YNUp+DlUkFVWfkWeFYJ+TgwF+FZEaOBuD82/g+ozBWDF+NH6b/LXKPuUhG0KQcMLuTZuldV4diC0Tf8Mo165sq7PzALgvviAjXV7GihUr2Pv0ASOQ1vdrjNoTitcJyfiiYg4KFo6FUeAqdPh5EQJHzETv8+lYFWuGoQt+h8TNTaGtHGFhYTiye7f081WB2DzhV1aH5cO+xyUUIHvxBKwI34OnU/tB+/IZ+XG8PcrkN03A91eHnPU2oPOMIWlwMm4CV8Fo7QxMrZiD11m5+PyFOdaOnsP6cyWR1Gi+yWJXOYojyzElwNxc6UoDgB2LF2NMo9rQ2rcE3ZJP4/Sk7sg5e7TE+ilvuaFZliQpTcdH1fHKdVVVL2EObL4VzhfhdsNy6Xx2nDsXWeu34K+h37P5F/jlElya9Td7v17LA91nzZeXr7Vyo8K1gq17MCs1ReFaIT7BtnXrVF5b2tv34Xc96XWcKzuO10+4Vb52+e8QbYW/ScJ+qFq1KtseXbUKo+rXAPYuRo/Uszg9qQeSDkmvs/eJ1X/+wbaO8+ZCb/chhX55Om0m+45yxBf3Gyji3wG17srDhg1jGvLEUuUJ/4WgJcm9e/eyJ0TGphch4l8MdYgcRX23bds29pBJpLmNQUlYJSOXcYJb30GDgC1bS1UvZWJTqiyjxc+UMk2WD7kJfUD/B24qRDDk7Pp55MV5GMRebH8XV+DI0SIJiUWB7/t5dg4+r+AM3LjBXoyiZWMLrF3Lvo9KSoK5TPmPk33oPTfiqd+2b9/Owi2o3zZHaWPVFWkoCYWUkLe8yeBBwPoN8nNfvHiRrXpJKlbCPld/bHuUyj7fkpABo8qmGGVlTfECOJRnhzWy72gM6LesSYsWwN590hhpAQlpw4YNjMhHddgUpYXVMsLjtgRgeOUGGGp6AHknjrLQBERIxzUmNRV49Yq1hZbYheQ3dck+5a2GpnyeZJkRTOiaX4DAZANsfSQ1iDcmZECvcn1U6vQMOHkKMTExSHr5Ut62olQI6TNSUmOxrpGR0OPzknBa+lDRiTylMk9occTXt1Ht06QfStvPqoioxZUlbBfF4JOxSTGuwlAS2pJoUF9TU2Q5OWLz00zsDJYaukRQ7VrTCTl5+Vh15SUya1hjGK2EaGkhMApYc+3NtQKJG2oTiVZ2PRMOHz7MvL3yeS24tvK1XFC1Y0dGeCVSoqmJCTPuuVeYG8n0ntpK9aRrhUBt4rG75Emm9vDrgMe3E2bbSldtuLpgB8oJLVOJ1OT3pixBbSKC86fOLtCvVAmbQtLl4WusX/wroqKdHe7eu4vGNWu8lzqK+MAMZSIKFAe6Mffu3Zu9RIj4N6Mo5S8hmY0T3FR9RzdQExMTRpZSRS6bWrFKqeqlTGyiG1KCgQFSp38H7awsFnPo4e7BpLI5lEmDnJCYm5rKskDk5uYgk+Jy9fWho6PLwhA0iZtOMDRE1PTvYKytDRcXFxZXSf1hamIKbYk2q6c2hZmYmwNJSazfONmH+pkbGdQmMiDYDbaIfpvu7VPI+KCbNyMnvlbM+UuhBFbePggwNCz03amQBIx1l8bdMk9YVpa8b4V1OBYcX6jMGl17wGf5X9D56n/QcXeHrpkZUkxMoJ2RITcmOOGHXuqQ+spDDa2489D4pJmZYW/VKujyMAixH4/B8VeF+2+oK2XdOIWc7BxkJifLPaNkEFIZjx49YgYTheZRiAG9p/6j77L19WH2y3w2L2mMKTuDrY0tPCi3sJZqGWJV1115qJvx85SWdKmKiMrFQ1SVJWwX9Q/NW/qM/ueEMd5WZliamjLFyfNhioTbG88TUNXRHK+To3E2PB1DSDGSVABDuKzPG0LmWJ+qzFCm3yXKcnL//n0mL87m9ROlef0oFmPdPOWpA7Pj4lgMO8/PTJ/xzBtkSFO/0UM6GcYU18u9yEx9VEuL7UftYuRha2vor1wBE4mE/SYS6HeHiIjEW9D096YsQX3DveOqVDnp+qeUk0TEFvHvh0jmEyGilMQUVeSlktTQiJG+99dFkFjeRoO6PbBdcL9rXMEA93ZsQWkSfykTmyj2kadhIli7usK0QoWSy3F3Z94+cK+awItpoKZ3LeLaNSz48UecOH4CtlqAAeU/lnmfMvPzkairizYBbTBo8CDoGxlD18RESiCTSNiNVZVHmcRaAn/8UUoyCxgh98QTKOb5/La16K8Uo03no/3bBAzH6isv5d+18LbA1VVn0M7eAY3r9cAWwRg0cNDFs12HQD4iajP1Jd3gqW8po8CJ5ctVjl2jCvq4s+koyFw3rFgRhr6+rP5aAg85laXsUS7JCFM138pLTU5IuHIiotXDIKRkpKClZyWsvyEg9dlo4cmva9hqQ+BXX6FR3z6w7doNet5eOLp2Lf5YsIClsuNjRxyWzz/7jBlEuiTrTUZXbCzW//03Ll68hNw86Rz18fHB2M/HomnbNmr1Q3mom6ki3ml6vCoialFlCdvF5cO5R5kr5fG2enp5AskpMCnIZep+G6+/GZParpa48ixOPj5EhCO0bjoQaxPe7FfHGri6aCmb3z906YpbcbGIzM2FB52HrpUWQ7BaMNYUN3576wq2PxmzlBqSK2fSVic6God27cKOHTsYh4lAbW/VqhWLdYeBAfLs7ZnhTIY1tYW3i42dlxcjB8u97QJvvrq/N+UBOj97cCsAE9tRVuVs6SklnXr36vbe6ijiAzaUicj35ZdfMkEDepok8Kd6HotUEsg70759ezYZ6cmUGOt0AfXv35/9WBIWLFjAGNgiRHxoKEr5i6D8mfJ3Xbt2xQYLc0ZU6f/iKkyrNsSxyGy0cdRD56cXYBT0iO2b+yoS0DDRvjKxiW5Ozs7OpYptLa0CV9StW0gZPIQJCSiT7ghyAh5lo5j8NchEciGSkLW1vM58WVfYb/R78beXt7TfKplCoiclJ3ao5oCGNrmYsH07+lOIiAzkwW7erDnywsLQx8sIEl0pOZH2b+2mh79iY5GnpY0+4VdhV6sJXmkZwqkgAy0en4fRo8esDAnlChaQkAYMGIA930wrYuwuwihUahyaZmbBvIj28H7UxFNZlmpo6pyH6kzKclGbNuPS7t3o1iAJOjJSH2ur1mtYVPJBtqMzBtBYbgxEzMZAhAwaCO8NG0ERshL/+m/G+mEQMseOY+fw2reX3Tf0vpuOCSSioUzMJDLlwoUqs76UdN2VdT+Utsyi1BHVOR+t/PDVB+XfEZp/+GsZQh8/xsftuiIzNQVXXuehtbspvG0NcDNcG+NqWTHSJYHmaZcnZ6CtNHamlG86OhojDQ0hqV1HgRTbOegkINufrpVGdnn4Yt8+DK3gzNIicuIv1S89NBTPR49BABnURHZTGnN8/wOrh8u+vTCpWLHQdVAc4fNDiPFlhv6WrQh+9AiDm7aRk07bVbWD4f2jrL/sZGRfEf9uaGwokzHbs2dPLFmyRL4MqCnoyfTs2bPsoiHPQ9++fTF//nx06tRJTsARIeJDhjqKX6q+Y/F7mVmAKRBCnjBjA9T3MIGOViaOp6YgMyUZfUzNkCsj2qgrQcy3yipbb0P+Ur5ZqTJgleu1ccUKdARgNWsmom1csOV5FgtvCAgYATcLfay8+gptWw3FR846+KlzAGZZW8tJQkWdl0AP4vRATYz9ed07sJjkbzwr4dLWtcxIHt+jB0kByhX2qD7fTPsGyaNGY3bnNmz/76rVxK0D2/HZxkB0kS2HP8/PQ3yeFq68iEdTZwOcSEtFVloaehkbIz8zQ54PmMAcA9lZ7L2qsctITkJfM3PkymI0ldW5aOmce86EpD5NjILyMiCUPajc0Iu9eRNGT5/ByfEQ/hg1DgckjthvWBnp/b/DhafxaFKnG3pHXGfEv83LluFbYxNGCKM4cgqRodSEPdx0Ma9HR0zRN2DhFsI5kupXjwmbUN5c2tc35i6qLPgJOSkp0ClG9bE40mBZoLTjozzm6tavOEIY39IqTNhfyzBv/Hh4Nd+BOm5uGJVTwDyb5zIysGT819ieo4/PX5qzVIiU1YXGpb/dfrSZ+gNOpupgwlNL+XcPsjLxtGIz6fXZYjA+CjqFPb8vwCAfHzQZPBTndmzAhC1bMaZzJ+DO3UL1iQ2XxuyGdvkIlYaOwZbgNPk4dnLIx0+d2+BHGxtIZA604kiXqtQU3xf4fKMEBeFbtuKHj0fBJ6A16jdqDG8zA2z5YTJs/8HS2iLegaFM7POZM2eyG1dpIfwxIO8yLWkSKPVc06ZN2TLrvHnzijTEKb6JXhycOCFCxIeOnTt3AqQcZ2+PIFd/rLkmJS8RhlcNQH+vM8xTkZKVhXwZwU1d0mB5EL2UFbWUQyKU60Wk3o7GJoC7OwJD8rBJRpRTIBxdi0SBjgt8OrQHrl5DSEgIbK2tC5GXlNtq7eIMiqCcSL8dGwPZdx4ABpAn+dp19n8CxWjL+k3HVCp3Ten2sGMne5HPuaujVGyFxuCue0NsvCtdst6UkIHhVVqjv8dpNgYxSUmIDQtjN3gKDSEyn5aM9KRq7AZ4S8fuZVwsooOCFMhLz58/Z31IHkPKHiTs25LGrLzUG5VJoBRyQasSCkRMC2matub5+QjMtsLhV2nw99DH3jtSIuPmBMCwcn1mjKXefw2Jpxc2RhRg7Y0IBUJYre7dgYOHEBUZJZ8jeipIUsP9fVHNzo6JZDRwcSmWsFfe/aJp+eVdH4mJdEzm2NkDtPIU9IjFIVMEeVN7ewTm2SDwkTQmmfKFa8nGhVyhR19rYc2jOPl3ZrWaIDIjF9tkJM01NzLY/mQk0xx2WjAffQH0dXFhRrLytUVzedeunWhLK1mNGmPDkxSsk4U30TjmNnBG1U4dgStX33u/lZaIqSUjQ5Oxj9t3pC8AUmsF75VsKOIDN5SHDh2KwMBADBxImWDf7seZPMlPnjzBqlWrWJgFKd+whP7TpuGXX37Bd999p/JY8iz98IN0WUeEiH8S6EFT19GxSJJZ3Z594PnnUuRYWDByT3HEQOXvypropayoxQ1YIclOWZmPpI1hbMIIR+fCU4okHBFJaESN2sxQppsTKbYJyUsq22plBd3lfyM3JYXtT9/Ry97eXqoqSLGl1tbMG8n3twzcCO3sbDl5LjY2lhlhF7duw4zWbVWOQeNBQ1Bh4S9INTSEVmqq3Iv+6tUrwMamyLGr3b0XvJf9gUxjE6TEvyFFUZuovlQH2lJ7aYzUIY29LbmsJHCiIt/y0J1cOzskzv4JK6dOxSQtbRxw82BtruJohpvhCYXaTsQmo9AQ1jcnnioSyGisv6zqxwxlUoLkcyRdWw+HH0Qq7hucwMrixM+iCHvl3S+all/e9SFQKArlMk6JjmZE26TkZKyb/DUG5+YiZfAwlXOyLyf1KX33UssQV14XJqR6tW6LOps2IH3MaBh4e7OHEyJsFhgasOuJ8rtzFcyYWKlyY7aBMU7eUSzrxOM4jK5Vt0RD+V30m7qgunAVQhb+YmUF840bkJWYKCc0U8537iQsKwVVEf9CQ3nKlClo2LAhZs+ezW5QQlD6GnVBnovz58+z3KQkG0tbDjLCp06dWuSx9B3P+Uqgi5ZiEkWI+NDh5uaGXWFhkBgZo23AcJbOSaiAd2PfJkbmI6PAUEZwK4oYqPxdWRO9lAleRXmUhfWyd5D+JhDhqJmrMQITVBOOiCQUtOkSGsriEsnTqkxeUtVWvYoV2WcFCQnyLBAW9OChwgPN+sTMTIFAlxMfD8v0dDwgUh6Rl1oPx+qrimMQdO4wyK9KXmTI0mHReyL3nHr5Unpcq+FYfU3xuJt7NjL1QgNDAxYHKvQoU/u4R5l7zdQhjb0tuUxdEij3KGc/f46N69Yxchb9Jnvp6QMODoi9f4cpNh56lYT6HtaIEIwrKRzS8j+1j/qmdYuhWCsghLX2tsCNP+eAsuZ+M2QoPGT5tfMePUC7yj5YKVBko32pLBciejLjRDVhr7z7RdPyy7s+HExMx8FeTrSNd3IEwl9A194GbWwV1e3q2+vISX2tWgzBOsGY2Btqwd9eR0FNktTxLq64zBQ7yUi2qF1bvsoTdOIEts+di/MXLiA7K5sRC2uTZ5vm0KsXaFWpltyjTGhdyRr3N19AvRLao6rfssPCcPboUZaO9ubNm+wzsjkGDx7MVpvLy0Cl8/AHWPnviJkZ9MhIC60AAKNFSURBVMs5LaOIf6GhTHE7dMMgFa/SxihzLxiBfpzpJkSpZIj1yw1uTupTBTpWVT5nESI+dHTr1o1JoNLy5oDK5pDo6clJae29jTFqyDb0dnBkKZaMZIQwTWKUy/oGrUpRq7gYZfpdwP4DyMvMwmBfO+hnZUmJRFXs4GKmy7yRIxu4oK23EUYfPIgRFZzh7e0NkwoV1G4rgXJRc5U6dfqGwNvh5OTEMmjQGAyqYsHGgBP9uvla4dNPAxFgasoe5nXd3eWhYvQAv+rbb9lxA6uaQ8fgzdi18zLCqO3b0cfRiaXhM61SRaG/KE0aT6ml3LcljVl5E5w4CZSMZJJWb0DZP+gL1zfCK4PSM5AefhXavgEo0NVDP38XnA+ORT1bLRbvSn1iLVN+G1LNCjqG+jjy4DXa+lij092jMJLllZ4nC3shpH33HToOGAGtRu1xOChGqhr58horo2HDRtA3MyuWsFfe/aJp+e+KiCY8z5DBQ4CffkJGagqGBLjL1e1oTjpH3pQq65HzqYo59I0Mpcp39jqwfHEDyc+fs1AjTtxr4lCAT48dwzh3D/ZAz6/JC9u2w2bGDJAMzRiZcYzsHHmucIN58zB47xHoC37LWrnoYMyB/Rju7KJRe8hIDm3fgT2oTqYvKf86Iew5Uwjk7jRVZM+y7FtCef+2ivgXG8qU7YLyXr4NSYjyNlLmDHpKo5vJokWL2NMjhWDQRLWxsWHvRYj4t4Hm9ze0WrLsb+z6ajzajxiBHk0r4MbpPRj/8RJ0rlmTiS7w5b3SkgbLErxcZTKOqnP369cPr/cfwLfDh6HzRx+h/42bMHfzxLNdQcjMyMCKJi1wP1YfX4xZi94NGzJvGPdQa9JWgvCGps7+QoOZwrswew7Wfz4C7UZ/gl7NPPDg0lGMH7sYte3tgHSp900oL0wP9Gyla/kK7JpMYzcSPZo64fqpXRg/4jd0pSw9ryLluaqV+0uVN0rdMSvvmzT9nm9Yu5Z5+CX/mwQXGhuJBIlxSUiZOhkHQ0PRLnAVbKz3wKVXX0QGB0EvKRXGL57DSGaMMUnideuwcdzHaDt6DHo3c0fg95Nh9DwcJ/X10MbcAqY/z4MkLgZxX32FLUlJ6Bu4Cn08HNG2hgN2rJ2F/ceOowHFhGqpN6/Lu180Lf9dGVP8PJRukozH+RMmoGn/y+jeoSM+amCME7uXY8fq1fB3kD6YXF08Dz1790bniukwXLQQCx7cZw+oXS+dRq+vvsaFS5vw5dLf8EmnzsCDB/JrkgzE6ZO/wh+GRkyhjsQ3KK8wpUx7eOgQjJb9zfbbO3k8Ogwbjh5NHXDl+HZ8Mew39G3cGHgerlF7Qu/fZ9sXPXui6YD+bA7y8wWuW4/9y/5iAiUUAlJeKOl3RMR/D1oFnCauJjp27MjCLmgJ5EMBLRuSN5q80jyXrAgRHyq416Q4lJfHpCxQnHdFnbYV1VZNvTdv4+Up7Rhocpyq9nAvs6ZtKG+PFtWrq58ffikA3HdsR7S9G9ZfDmeedgqt4BkUioPLyhV4MfJjld+R7DUpJFKsbLvKtuh453Cx5ak7/5X7s7xQUv+XNjuGpitG/Lu3ud7UAe9/Il7OGDwYgY5O0N11EJtDM9icIO//gCrmyOoUoHZZ6uDH4SPQ89KlQnOQzjewvgs+rueHpQaGcNu+DUbVqpXa41vS6pOIfz+SNbAbNf6FobCLtm3bsiVW5RhlyoYhQoSI4sEV8PIEamUUasF/pD9kkkhJDHUigdlu3cpSvhXk5yP1WRhMDaQkLKb2J9GGbdWqhQgxmso0vy1TPobiZH9fCmNtCV5FvmIkP8qJytULja2tVY4Btc9sw3ombZ2flw8tbS2VY6eqPRRTTXG8FPdJanUfStYLWiGk1HeUmYPCLZLT07H2YhhWXXwuz5KgXbc1+tntR4i3N6q2bIHUlFR2jLa2FkytbWBbpw6SrK1guHoVDAoKmAF77949LJ06Fb/Wqo0Dvq2x5pqUuMdikhu0Qw9nW2jPm4uEYUPh07q1vG3qzn+qt7A/ywsl9X9ps2MoZ6wpKauNquwfwt8SYu3FxUuzUlCIUdDDIKQ9D5OmjaxQARnp6bCxtYV1QQGM6eGiAEjNzYGWrS2sLK2YF1+5/x8/fgxPT09IzMwR+ChJzqkg8Q0tLQ9UHzgQ3hs3wnH+PHZNJaekwMnRERaWlgh+Eoyk7GxkJyUxwRJ1+iU4JJi9V56DdD5qR/0mTYDrN9hvCc/AoWnGH1US4+UtDy/inw2NDWWaZJTvmC70Fy+kaX1EiBChGfiNqHRR/u8HJTHU+fcFjg7IzjBnHAbbatXYjZ32sygjmea3ZcrLMz3Y2IBoO+kFUoZ7EmXyqODEQix0VHgYuDxxjo0N8l++RFpCAo4eOYK7d+9BoiNB40aN8VGXj2CSmor0/ALWD9QeREbi3NGjOH78ODMuXV1dWYiKu5s78g30WSq995H1IvPpM5w9egQ7d+xAQWwsmhpJU10d2bgFRx0p0/EbHA1NRB+/mjCuWxPO/fuz/PfpERHMIM42MoKRuRnSScqawiZ0dVkfOpmb4xnVnWTHlaWUH8eiuY8NbAHY1qoFyzp1NGoXnZeMZJoztCXPUHl4lqn/00NCEfcyAocPHcKt27dZFg7K0kTOIvbAk18ArQpOCuOT8PAhDmzfjtOnT7M5U7VqVfTq2RMVnJ0V5gbP8CKU5KYXtUXVd6rkuoUPFbKIXsTfv4/X0a9x/sYNPHjwgB3LuUWmrq6wdHeHkZdXkdckBxncsTExyGvUDEeV5K0pHtnbRuos03Fzg76FBSxycpCjq4ssMzPEx8Sw+uclJLB5z2Wqi+pnYZ5xyppzNEga0sNB/7e1dWDvs3Oy2cOBphl/CmW2EPRzecnDi/jnQ+NfltWrV5dPTUSIEPFBoyRmvzBLBr1XNwuHpse9bYYB5UwPBErbxiR6TU2LlRumm6pubCySR37MfjzJnJSblDt3Io5esn/Js56VkIDcMWNQm7J+8P0oB+6M7yFNrgU47d4FbQuLd5pNITU4mBH3iGpFCnkMZOQSke/mNTwd8RHzJCtntqg9egQzLshATExMZPWi99xQJYOePLxkdBAhjKTEKRMGiVDwfMk8S8jBLXMwlJ3WRuN20bnoPNyjXF7hF7nh4YghhTaqs+zFcPgIUuklGGuS8KZ2hJw7h5xRo1n2CLm27LnzyD13Hs8F+xtXcNIoq426ct0UjvG6V2+Q+azgl38SDMydh0wS2lEzJILIx0snTpRJxytm6WlX1R5bZn7N8grz7C58PMjApgwvdF3RtjgjWZhxgqSvsXoNMqOj0LaKi9yjTGjpbYkTy3ait54+9HT1oC3LKqNJxh+VmS3KKWuQiH8PNP51IU+CMuLj41lO5NDQ0LKqlwgRIj5AlMTsL63csqbHvW2GAaHcN73nHi915IZfJ0q9oxfr+2PAV5MBHSnhSD8rHdOmfI2Uh0GYTEu42lqYOX8ePgVg/O002NatixQtXZgW5ODsyVP4Y9o3+NnegaX5Ks+2qsKyRYukBv4XE2BsbYO00+fwOCYKPnfv4nRaGrrrxcOssQd2PoxHIztteWYLbpBy45g8uzzziDAzCoE+HzduHPJmz0Hl17cw3L8GjgXHo01FK7hG3cKeQ4cBOzs5KVNTCA308kJanPSxZ6+XJz6fM4dlSKGxNsrNxML583HnwAHMtLRiY03jRJ7br8aOxWyq36xZMPWrJiWj5WZhy6ZA7FryG352cJDuX4qsNvy74kB5xAmbHOzxyawfYWlrg8QCWtHJx8q//8aJtWsx2049QhxdI6SdkHf8BOpnPIVWAy8ceRyH1l4WMH54HFZJSYC2ROV4UKaXkjzJQlD/kVR9xOo1+PWLCRi0dCW0Griw1YeWHqbQuXUAbby9GQGY8hmr6j91zyNmthChCTT+hSGmLC3/CDmA9H/v3r01LUqECBH/QJR0Ey8tU1z5uPIm3HAvNl+C5e9LMlxIXZGMTDKSox044egZIxx99tcaDPD1BhwdmQodpbr81NUNOXWb4JeQNBx58Irt169Hf1Q5fQq4e4+Vz6WyWYosmfe4vEhjtOy8fft2dLS0gl6L9vjzZhTOuXZF21aWcOgXi1fJevj8RR4CHFOwxCkBJsuXyNOMUfyqcppAAg874KB9CP7NmiF09hxU+/Vn1LCzYwIY5Jmm8urb2cnLLC3K2/tHarEUXzt65kzEOXkqjPWAnxfhxIkTbD8ec3/27FkmnEWx3il+dfF3SLp8/8HjJ+PYsWNAQmK5ZrW5cOECWyn49McfkV2lFhZceo7Dsnk36JuZOHHyBJAl9aiqg88nTcLT4yfgOnMaPOzs0Fswhh1kRjIfQ+WHFnUePoXQl6WInUTljh+Nvkrn49CRGd/CvtGEIClmthBRroay8MeRQIzBX3/9lS2xiBAh4t8PVWSkomSG3+YcxRFuCGVBcKPz0EoYjxelZWK+jKyKXEVLy1evXmOGclxSEtY+LUw4ata6FfAwCNeuX2OGAklebwwiIlSEfD8q15ukrO/ew72792AlE9fgcdBCOWlNiY4ljRPFrNLvtqRyFWwISsQmmYT3wccFSK9kh82PpPVck5CB7BrO0DU2Qj8yYmbMQAQ9VLx6xfqBCJCMKKanx/qOzkH9R0Yy9ScZg+RhpDCDnOQk3Ll7lxHwXP1HoG6duow89jbE1XchfXznzh0pEU1HpxC5rKAgH206dABOn5GqR9Iqw8WLqFy5MiSmZgh8lCwPN+H7t27XHti8Wb5/eeDunbvMULawsWFGMp1bWIcAqvPuPWrXIc/eXj6G9x88YPPT56MOcJeJfBU3hpqOkZCcSPPr3t270JZIUGtQP3mYlKrzaUKQFAl7IjTFW69Z0Q/h9OnTWQaMxYsXv21xIkSI+IChTLwTyk3zeNq3DRPgxiLdyGnlSiiVTVv6nowwXpfSno+Op6wjZDRychjdTKlsKo/aKJTRprbSvhxJBdoqCUcfWRPBKQiSyEgmnMDIbE945LIUJ57E4RO2H5CUnATtxER2bt6PfNmbjGdNiI7qjBP39lK9jgkIWiRPfT5UsZ5nw9PQ1scXeBaGLDNTZJCcr4EBM3jpQYYTzOiBgJPQyGjhY0SgpX861qdCBbnxTJ7Dt50j70L6mOcTTo5PwtEgab9xHHkYjdF20jzFuTm58pUJRmBrWIOFDCjv/6m1ncL+5VJnHWmdKeSDvNnKdRipVGd15hGRFQ1dXdC6USO161zaMeJGMJnhLs2bq30e5bmuiiApEvZElAZlcpWSzCSxgEWIEPHvBjeGyagjryvdjGjL4/7KwmDhpDkqi25sRLDj56Hz0ufcg/k25Bs6jsomw43qT2neyOAjzxWdl7eL14G2tG+dutLfOsPcTEZKE4JIb90fP2TvfY8ew49W1lIilLelwn6tKlnh3KH97L25mTmL76WyySNL7aM68LYJ+5u2mhAkVY1TtWrV4OjgIJXirmQlP+ZhZBKaeEsJfRzNPc1xev9uBWVD6iMi4HFVVeo32lLdaUuxqrQPvahNwv7jY1cWc4TLnZcnAau5ry/bZs34jo2tEPR/g9Mnpf/ExbI6UIwtrVAwAqOPYl8yAuPWQPaeUhCWV50p+wohMfwpC7dQrIMtDmzeqHYd3qaf39UYFTXXacvnHc17Ta4fESLeyqPctGlTuaeAQE9slC+T0t80a9ZM/jnFaokQIeLfB1XEO3WJRpqeoyRJ6rc9H53H19dX7vESxt+qim8kQ3Hw4MFIPH0GC+fNw+fL1iIzLY15Xlu6GsEu5i6O1fFHmxtXccnbG5f27mFZJdrox0G7iYdcPME58yl2nz2LL1xc4FfdT0EqWzlGuSwJkrw9w0eMQF7gJjTSj4d2fWcceRKHRk56aF5BgsxEQ1yPBSPd5Tw5DQuKB83MYh5uE09PeR9RPak8OgeXE+ffca91UX1ZFngXktG1qlZFDIDNT0PRziYHEn8nHAlOQICnOcxuH8TG4CfoZ24BXVnbKMtHs6ZNkfciAh2NEgEZGa2djzWcI2/gPsUvW0gfhsoLVAdS65s04Qv8sPsQy3dMqdzaVbWDceRNRIaHa1SHt+nn9yHrrU6MsggR5Woof/yxauUlESJE/HdQWqJRac6hfB5+syNGfWmUOLlRx7cEbpiqkulWBhnLlPci7fFj9Pf1Qk1nZ6xo2QZHs5zx1K0BLjt4I2ZEZwyq74qw8OdAxEusHdoP2bVroWfDJjj13W7sfv4cCydNBLZuK9QuIbGQDE6hB0wdomNxxEq+7dmjJ8ICN+G3AT1Q0c8PK6rXxpoNp7D0eRia1ayFFX41MWf1UaQZGeLXiZOQPnt2IalxIXFLuV6q+lJYt7JCeRs/9x4/Bvlke5uYIv3mLRj6NEZ9DyuY5Kejub4BjMylaf20Dd5E+/60cCGie/eB0fgxhchoDSws35rAWCJkfqxKRkYY6FcRLdu0Qc+atXFo8hbkpKfjD5Jv//0PBUJ+UaAwGjJC/wnGZVFzXdXviAgR5Sph/SFClLAWIeK/AU7aCQoKYoYyLffXrVtXo/SWlP+XxzDSsiyVoYqIqIpQSEarTnR0IdlgIuwFDv8Bax7xzLrAyAYu8H98CK6r1xRbJ93lf0PHxYUZxTzkg+I6icxE9aRQBk7sK6pemhIrSys1TsqEPO6Un4fqQ/UUesKpDcqKeeVBvitvQt/0QYPQ//oNOCxejIXJVlh/47X8uyF1HGC8ZQ663H/AJJcNZWEahMSgINy5fJmR+6ivqlSpgoCAAGkoQjkrb6o7tqQwaVm1apH9RtcYz4NM9f9QCZciRHwQEtZLlizBmDFj2I2lKNAP5bJlyzB+/HjNayxChAgRxYDklSnEi8K+KlasyG7g5EmkrVA4pDiQB5mMZCrr7t277CZOP5SVKlViHAshEVGVgpecCOTqCo+DB5ESHY1Lly9hxfffY27rtjj+WjEfMi25N/SsxN4njxyBVHML5OXlglwTlAeWDGNTSpFmZASdpCR2XvodpS2FtFG76LVhwwb229u1a1fUrl27SKKjusRK6oMrjx9D99tp8PXygraWNrIjX0E7Kxt6+vrs+1wdCfItLWFmbs7aHxIRgacPHsBbJrdOxEc6P52LExzpwYWMYzKgeXgez6tbHuQ7KoeU7+j8ZMhVr169zD2GXJgiz7MiTu1UJMadfJqEDu5ewP0HTA6ag3nNHR1RrUsX1OjeXa5M+a6gIGutBIqffkox1KamqGptLV9VUa4fXRt0bVH7acs9yx8i4VKEiPKGWoZyVFQUy5/csWNHNG/eHD4+PixInhjjT548YT9Whw4dwpAhQ8q9wiJEiPjv4MXVq/jp229x7tw55j0lI8zayhqdOnWEf/PmMPXxUTv8IunRIyyb/DVCr16BgSAX/AWS47W3R//hw9FswABmaBSl4MXDIAw8PZDvYI8q1lYI+/ZbKTEuYDhWC5TLiLx189gulvnCukYN5JmYMMOEyjIyNmaGBG05uY17lOlFxuX8QYPwQiY/TLi5eDGsLK0wadIkWHl6QK9u3WIV3JQNk9QnT/DrnDnYtWsXy3jACV1dPuqCUaNHwcjWFuaVKwNxcVJD+OUrbN6wHtu2bWNGMJVfkF+AFi1bMIeIoZUVDJ2d2edkoHOiFIGTp4ThF2WpMLhp4UL8vXgxoqOjWXl0/kYNG+Kbb6bBuaJ3mXlsifhIKfx0M1NZbDlPtUaoYw08Xr2HxTpM6tcPg6Z8jbpNmrBzl4eaoiZQbv+dw4cxZ/p09oBooG+AzKxMuDg7Y8KECQj46KNC+9P4CZX1SuMNLusxFyHigw+9oGXANWvWMIOYPDvkdaALiJ7iyYAmI1m4zPYuIYZeiBDx70PM3buI7dNX/r+E1MT8ajKjlIsPqCPDy43kV926FypLLzIC2Y7ORZZZEhGIPvu6d2+MePAQuYE7sOcVGGGvQzUHNHPSwoSWDbHRwZEtzev6+DCjgYwO7snjRgSVwz3XtB3btCnGxUlTt+lVrYrsNh2hd+wgsh9KM2oQnJcvh2nTJmopuGU9e4anHToW25fCtqeHhuJ5p84l7k+edXpo4O3gW6FCn3J/va3BtGH+fNRZuUqtdrwt4q5dQ/TgIdhUtw5GLvoLq84E40RIAtrY66Bz+BWYHt9f5Jz8UIhjj06dQsGnn5XqOiqNJ1kZH0o/iBBRrqEXBEoH9L///Y+9RIgQIaK8sXXtWrQCYDVzJlKr12MCDhTO0DZgBOqnh8B11rdIjY2FlRoG0f5t21CbwiGsrdG0XVccqNwSR58lo0lLaxjq6SC1TjT6RVyHUeAq5KWmFavgJQR9NnnyZMQOHYaZHVqibu/e+F/teri6aRU+3bkTH5PARFAQ25cMR6G8s7BMoTrg48eP8fzePcCpAtJWbMbaKLD8xk0GTEc3V10c/KgV+ltaIjtWMU9vccTKmxcvgmhneePHwbBVR3lftmszEu1sczCrYyvMc3SSL9dHPn3Ktq/69oF7/+EK+3dz1cGsDq3wg6UlspISQS1R9QChbCyXhcFEDxh/LliAFRaWkKwOxJbXEnm9+ngb4ZeenTBRS1steWZ1wI3ER8eOY0yj2qhsY4sVtepi76E7ONmgJVI+mYuTL9LRttVQeL64hjp/LWLn/pCMwxVLfsNIAA5zf0ZcperY9DiF9VmbVsNRNfo2qi2ey+a8KhSlEKkJeD8UpzgpQsS/WnBEhAgRIsoDhw8fZoayWXU/LA9Jl6uckcJdfj1PJqdLEsK91SDzHTxwkBnKdxISkOjqjzU3paSszdcj0LWmEy5H5cHEtT762+3Hvfv3UMm5gtoEJHN7e5DJOtPSCjh+gr18AAx2dZMbyaqyHMTJQhy4QUmhChR2MWPGDBY3rFetGjOSqY68rtBygXGTxsCDh3j27BmSnj5lMcMl1ZVWAvuT57BVKywQ9CXbNnaDZ6tWQNAjeb12797N1Aerd+mCv4LTFPeXuKFal4+Ac+fx8OFDGGlrs9VFaguBiz9Qm1xcXNhKY1mRukgCOj0jAxKfysxIFtZLW9cDLYePANYUT57UBHzc6KGAIT4eBSeOohuRNyu3wDqZquGqaxkYUqcu/O3s8OzpMzhVUH/+lCeoz48dP4aRFZwBd3cEBqdhlazPVl97iUG1qjJp8fsP7qNetTdkROH8VCZllgYvX76UcwmExFQRIv4JEA1lESJEfJBISkwCTE1VKowdD0lAP7+aiI+PL+S9IyIcGQh0U+YKfhQqRnCuWacQ6e7G8wRUdTTHsdcp6OtXE7ExMfAoIs5XU/IUQVWWA64ESB5SToLjIRMxMTGw1NVBduv2hZTyzofEYlLHrsxQzsrKZMYMJxlSjDA3bOh9ob4sRq1tSP3GzFAm4hWVwfsrBTo48vB1of1HV6vBDGWqf0ZcHOsj4qzQeWlL7aP2kOgI8VnKitRF403p+UhVUFn5jnIF/+zrh7IEjZvT7l14dOsWXrx4gdU//ohfnCrAdM5cHD+XVojcN8CvJmJiY2CrwfwpT9BYyrOTaOvhaFCkwvenw1IxyK+mnBzL68rnJx1LW07KLA1ozMlI5lvKxy16lkX8k/BhrA2JECFChBLIG0kwzssqpDDWytMc2vduw83NTSrSERaGC+vX4+OWLVHH0hIN7e3RwccHa6ZPR8aDB/BzlB4f/fBuIYW12q6WTJWOPmdlurtrrOBFBhWlB1P1UhX7yT3IXO1OqF5H4k1Z5H09dhBNvBQ9eaScd33nVvZeX9+Aefoynj7F0i8nopmzMxo5OMDfxgZTevdByNGjrF8Irq6yvswt3JdEOrxw5AB7T8Q8qpeDLGfyj0MHMtKawv4+Nrhz/gx7T/WnOnBVwaibN7H+hx8wqXt3TOzWDSNbtsTfX09BVlAQIwe+LamLSOX0IKFK+Y7adedC2QtdEcHRrGZNmNeqBU7VtLAyL9SPzd1N2PxxcXb5YBTg6GHR0kKa69koP7uQkmRTVyNWZ1dXV4W68vnJ1e5KayQTqB+40iTfihDxT4LoURYhQsQHiR49egCrVuFZcAgGN2oJyjjGFMZ87eEadYsRkUgplOeNJTHmSfRy93hTyNZtCN+6DUNl/7o6OKB9+FVo12+Lo0/i0KSiDQx1JGjkoIOPwq+yMj09PaH/DlJ6cQOTK9lxY+Snn37CoA0bGHGvj7cJoO2C88GxrK6tXHSx+NxZDHKqAA8PD+SnpiJ25MfoSSIiFPpBL8K9e8gZPwGhMqJW127dkHPyFA4fPIDBwz6R9yWRDmsYJWHL5cuAm9Sgj75zB62uXmPvv8rNQ/qrG7CqXB/HXucyElunu0fw9ZEjLIaajHrzGjVY/a/s2gXvXxdhMh3o4vqmoYcOIf7QIfaW6kIhAKVFo0aN4O7uzsapv48pC7fg7ejkY4Yxw1eilbWiAV0WoPRz9FBGEtWUBSM9JQWDG1ZVmJMGd4+werk4Ob6T+aMO6MGnW/fuwKnTyExJwdBGNSGRaLM6t6lsA8vgc6zO7m5uxc7PtwWFW4ieZBH/VKh9Jf/44494/VpxCU6Izz57w6oVIUKEiLdF+w7t2faH0aOw8/spaJf5CLN90hG3ejr2TvmSfUfGSFqcNDzhSqOGLLuE++5dsN13kG2zZv+EqdFvfrei7txhhL2COaMxNvcKbHfNR/7WubBZOY19zvGujBxuhAiNEfIwk3Ie4Ui3ANS5uQ3zfHNhtf1nLG5dHy3tpZ5MiY4EK39byt6bfz9Doe0uO7ZjvY3UFUwhITwudM2sH7Hs85FomXIPC2vkQ3v/b5jSqTW+GzZcfv65338vf79WRwd3c9LQPusRfnGJQd5vE1k/DWjShH3PvYPUXzO/+Ya9d5w3V2EM9H/7DT/Ici2/LcmOQmm+l9Vv2bB+qPvyAhbX0YbDta34vEldBFB6u3ICxRuPHyfVCZg6eDDO/b4A7bMeY5pLDB7P+xSP1/wl3/dDMJI5hg+Xju3UIUNw/Nc5rM7feyQi/Pf/4eqSucUeWxZGMofoSRbxr08PRxe+g4MDtmzZwrw4yqAlFa4W9a4hpocTIeLfB3UUxshDuWvTJlRfuw42a9YgxaMyAq+9ZCnaaGl8gL8zfh8zFB/LiGrqoKxSi6kDYUo3YXq49EuX8GLkx8Uea/v7Unw0YABWWVoxIznSxlne9nZV7RFgngaL0UOh99sSOHp6KqR7KwqSZX+hW7t22OHugfQBI7DP1Z/FdFNYCnnchQ8TwvRwp06dwvjOnbHVxRV6uw9hU0i6fAwGN3DFlm//h49OnymkYFee86I0Y6ic3o6Pjzz9XTmeu7ygbp11BOEXmmbtUJWikG+5DDv/jKecE6YxLCqdYFHnESHig0wPR3FKs2bNYjmTiZWtnCbuX6CELUKEiA8InCQXev8+klNS2A2WC4E4OjjCyNoaMbq6CAkJQXUAYS9fYu8rfay/Ko0kJXEIUsLzqFhRmtFh6hRYVqyIgugYICsTBoaGyEzPQAEK2E3awNwCBmUoVlESeCYIIrlxAhyXsI60skLChPGQpKay1JwUv0yqeRwxWVm4L5FIVfEsrXDr7j0cMcjF2ivSDBkrL4Qhr64jBtjZ4c6dOyyHM0llp8bEMGODYk85CZDEOrSgBT0Lc1yLiJBLcu+t3BJrZdlB1iQAkgbt0KOCNbTnz4fhN1OhW7UqEo0MYZaezjJw2NnZSaW8HyXLs1HQGBQU5KNmNT/g9BmpkuBb9puQPBkRESHP6c+95qWViOaZGQg0BjxemwiE1EcsY4OQuFkApKSmsP2pP2lelrc8dWmgTDYlsRlmlErFE1mdSZo8PTlZ7vXVJEOJcB4ry6mT/gKNOc1fys5CqpiccGpvb8+Op/3oVVJ2DVEOW8T7go4mS14jR45kEqq9e/dmGvYkQMItcS5ZKkKECBFlBbqBJ5Bksr6+PKtCBhl51laQWFsxw4YbfNn6hjj1QCrSwXHsUSz6Gkl/o9KNjKBrZwfzihVZOZSRQSs1VX5jN3mHcaVc3peyCqQ8ecIeBo4cPoIHDx+wOpBMd8MGDWFrawMDR0e4tGolN2LI8Eh5+BC58fFyL1yuoQlOPFbMkHE8NJFlBqF9yMhIMTBAho0Nc2owFT9ra3l6Ovr9pvPyvqSsEieeKa4QUpYJ/dDr+AjAliW/ISwzAznZ2bB2dIJDdT+YJ6eozEZBWTK8TWX1zJFmw3jbfibjj/UDSXbTaqa+Ppy9vOT5qTUFz8jAsnhkZLD+oH7iGVP4/Y3F2QrEaLKSk9n80ZJIPpi4ZO5Ffh0Whh07djJVy5zcHKYy2LdvXybZLjTo2QqGrB2pwcGICA5m6o23b99m86RevXpoX7cuHty8iQvXruNVTjZT5+3Tpw8rMz2/AAWODqzfuIw6bWnOUZ/S/KJXTng4Tu/ciXPnz7MsG/QA2Kl+fVjoG+DC9eu4GxXJDOqAgAB079Yd5g72CnWkMcoKC8PD+/exf/9+3L9/H7o6umjStAl69ewJG1vbD/JBRcQ/HxoHINWqVQs3btzA4MGDUadOHezYsYOp84kQIUJEWYNL6RLI4CPjhWdaIA8UoWXLlix38YPLF9Cydi+5R5l9V9EKB77bhACZl5DK4lLUVN77ktjl8r654S+QNfJjOANMFAJa2sxTiSfB0heHgATHM2UQ6lIO6ajX0E5NQutKLnKPMqGRkz60D9xGlS4doW9kxM5HHmgmnS2TmCaDhhuGVC55hYm0RlklWrccirXXM+TlUfhFtwMPQMn1uqSmyhoiAYi7cuw12pOhQtkoWg3HymtvxqBNZVvsmvMNasoks8uqn3k/kCFL29IayQSekYGXS/3DPcr0MMM9ysI42w9VolkYatFO9mK4fYe9wpRCRHg70kNCEde3H/P4D5C9kJcPXLjIXvUA9mJ4GAR8/wOey/613boVxhWcCsmpU9/Qw4c+pXH89DO0pawpdIC+AbnjpXnHAVTkc5+ET3bvQSy9lOqoFRWF+H79Qb8Gg3k9cvOAY8eRSi+ldokQUVYoVaQ+xXXs3bsXP//8M4tXXrRoUZlVSIQIESKUMw7wuEbaciOXDD4ykMhDTAv9h/78E4N+rwPd+p4so0VLTzMY3T+KyhSykJ7BUmBRuIbQo0llvq9ct3Tu+MQE9v6ivz/6TJoIHX19pEn0YJybjYW/zMetffswy8q6EAmOMnOQATJ16lTkTvgCh5b9hY6z5kOngQvz6DZxNoCVLAuDu7MzdJ2c5Nk1qP3COFzaEvj7KVOmIG/uPKbaNqRWNZwMS0WLCgZwi7qFPSnJ6Ny6LQwr2GPvg4fQN7VAy4f3kNStK1b//DPGUbq96FvI96+FY8HxLI2fSdAJmMXHM6P6bYxZVeD9UBblCjMzCGOUaY4VpSr3PudPUciSESf3eHpg7M8/Q6Knx/JnU5rFnVu3YcvCBZjr4Kgwp6gdibLjzteriwGTJ0Ob8nJL9DF/9AgMi4zCtpQU9PPygunP81h6vONHjmD5jBmsLCNtLYVri2/pwZT6klIEtqbCv/wCDnXrwsDYGHdu3oXVX79jR3g4ulE41ZIlyPXwhiQtGT9/8gmGJSYq1PFVSAjbPmzXFh1Hj6aUHqx+BtnpmDljBqKuX8dUA8MyU2UUIUJjQ1lVDDL9oDZo0AD9+/eXqzKJECFCRFmDx0oKYya5caIn8wTOtrUDvv8GfnZ26ONXk3lTyVDk0DExUTjuQ8C+ffvQAkC/r/6HWEcPrL8cjsMPwhgJbuDPi3CU0rDJQgPI0yc0bslAc/PxYSngBsXEAp8MR187O/RWajuLQZUdR21XzrQhJFHR9w1btkTo3HmovmQ+atnZMRENKi8loDP2TViEUUTuq2QDrxb9sezcM0Q26I1B9V1RiVLK3b4Nz8XzUNHOjom38Hp0JM8zOQ0NpeOnivTFz69MqBMa8kIiGD+urLIpcNKZsE/kc0zFOVTJnH8IOHPmDLxohWL6DMQ5ecrm1DMpsfKzL7F3317mzeX3dN6Offv2ohmAXl98IZiLz1Bn4HcsRaB5bg4CPRszoZX2vqYYOGAEHPftB2Rx7cVh27ataG1iCvcmTRBt74bfqewXNggYMRNNDJOQ/vgxlqTZ4ejOZyzVXp9FfwLD+uPRo0fw8/Fh47Fl61b0BZiRTGUI2zVy0V/oX80bcDBkKyRvGwcvQkSpDOVly5ap/LxFixa4efMmVqxYoW5RIkSIEFEuZCUydoIeBiE7JxteA/rIQxSKil18nwQhOve9e/eYoZydn4+1F8Ow6uJzOQmOwmLbduoEnDmLp0+fKnjouCCEtaDtREZ79eoV+86x+0fIy8wEDA1xNzYW2vHxLP7Y0dGxyLbyvogno/X3pchOTsaSyZPxv+hoJI8fh11WdbHxdgzbd82VF0z6OycvH2seZUBinoyGAW2YoWzy7be4GR2NpOQkmHfrBnMLc3ZOWxdXRGlrwTQurhDpS64el57OwhwI1D5qK3mMyajjiov0OYWHCI+jsIi3GT9N5Zo/ZGIZyYqToaxjaFBoThGxskXrAGD3bkZSJFVFGgNq+63bt5mhHBkdg60vdLFGRsiMSADcajVBdE4BNt9PeEOUzc9DfUoTuHkzoiKjYO7oqHJcaV7GxMYCJqZITk9XqBORRFGnAkx8bJg0PWHl+TDk+zuhv50dLl64AOt69dg8IFIqGcpxiUlYG6rYLqpLw6bNgOBg1n5TXV3UqFHjPY2AiP+soTxgAItYUgn68f3uu+/Kqk4iRIgQoRGERrC/mjdIThAqC2llTeJHk6OjceDAAXZDz376lIUkJMUl4miQorQ2iUL0sndi78l4zExIYCREMhx5fDaFwfG2uxobsxjk3bt3IzkpGVbWVghwdUVsWBiu3rqNiLRUWFpYokvXLqhVuzZ0ra1h0rixQl+QMUoxv/nm5kjR1kYckfuyc6BTxQ9nrvIoUEXp79fJ0TjyJA51nKV1Sre2grW7G4wyMhgBM1HmddU3MYZeijRLBBntnPRF56Tznz17FocPH2bGFRHOevXqJU+bl//yJZKionD9+nVEvHgBSysr1K9fn5HJtLW0IbG3gwG9L2b8qO/zUtNw7fo15nWl8/v6+jLyGMmI55Hst7t7iSIb72PeFIWsZ89w7dw5nCZBkaxMFqZkKVvdTUnOwNGg9ELEymHWUnU+mkf5aWlsThHpTiLz+mfpG+H4XUVC5kstQ1x5qUSUDYrBSHPpg2ha+HMmqX7x0iX2oKqnr8eI/8xYTU6Go6w/U7V0cDTozSoP4fjTJNT3IKGchDdlByewFYn8ggIpETUlhRnfrF1akkJlUF1akdBQcDCys7IYWZDGlAi7IkS8LURlPhEiRPwn8a7JWEKSlb/sxchw9N3309kyNPOwydCmii32TdqAdhIdZlAaWlqyGz8ZZtyjzA06ylbw4qMuIN+m3KVBIZ1XrjLFwkqcQJWRAWzegqjNW9guLitXMGOZ9wWBvPBkRJIBRRkPiMhlmJOFAB87uZeRS39feSbNtNGmkhWOrPsNn8iM92xKZycIV6A6cwOUMhsISV+JQUH4dtIktsxOxHBjfQOc+Hs5Tq9axWKwve3soDVzFsgkk+vHvYgA7tyF1J8MkA/avBgSl7DvbSm8gH9x8xZi12+Q72e6eRPLJ1wcPhQSX+zde4jp0wfk/+4paA9H5rSv0Xbib1glGDM2p75fj8ayMTGUpcEj479R40ZAWBiyYl8jgOTfBcc5FqSjgb0E24Xzs7ItjszdigZkSMz/hX3WSPZiuH0HFDRDc3Kps1RC3aQgl8loc28woamzIawLFA365m4mLGyn4djPmcee+rlB/QbAqVPQz0wrVEZLb0ucWbYP/fX0WRpFU9m1IkJEWUA0lEWIEPGfxbskYz0LCmLb07VqYuDXX0PXwADxMfFImzYVgSHBTNBDUi8AR0IS0KaiJYzvH4OvkTG5kxlpjUtFK0teE36dPZsZf5mffILK7dshRUsXR77/FnVv3cbFtDQ0MjaG3cyZSKvoixu7t+DWX8vQn8I4iGSn1BdC8prtsOFIunARC+b9jLHL1iI7IwNnw9PQ0ssCblb6uBmujeGVTVEt+g42nD0L2Noxg9iuShW5t5W8lRQaQXXmMb08Ljbj6VPkf/IpZlIFXFwh0dVDnm91SPLzpTHWf70J+TtWzRd9Jk6EOaULlOgh+WU4xn/2GapbWWFwbFyxJC7+3W8SCf63aBEcXZwZEUwnIwW/zp+Ph0ePYqalFczIq6wGPgQS3zcTvwTpU0r+NwkuTZqw9uhmpmLdzFkIuHeP9V8bq0xImkplvslI1gu7hJS4eBaSQ3mNOQGPxrxz5854tTEQgT/9hKHL1kDCiaFOemj5+AKCCwpgWrkBkzJvW8kaDhFX8eh5GGAq5QgcqFgRw6d/ByNTUzY+6a9f4cux4+Cuo4OPZVlSjq9Ygb7jvoJWvrRskkR3f3Ac1Sh1oWzuEwHU4s4hVn/y+HMi6qDBg5Bw6hRWzpiBPgv/hJasfq29LKB/7wiaOjsD0TFMVt1KDLsQ8T6U+T5kiMp8IkSIeBu8C8WvH4YORZ8rV+G+fTuiHd2x/tJzpl4nVL2T2Nkhn0hw9xSJiMWlvKJY09YeHgh0dGKqeIEhaTjy4DXq22phQMR1nD+2F/W/nI7dBfY4HxKLJt42aKQXh4pffQa7OXOg3yaA/YY6OTnJU61xQzz9/n0879Ubi7W1cOH5c3Rs3BjDK1Zh9WP9pkZdi8oYQbhOacWmz4DWl19Cp1kbbHqcwoyfdj426F/JBPN6dMSXMmUM5X4jElcbDwMMr1OVKQk6b94M05o1FIiBfPn9xrZtMPpuOvLmzYVpo1YyIpi0jIH1XTCueX3Mzy+A2/ZtMKpWrViyobJqn1B9riyhqg5cvfHWrVsY2LAha7fOjgPY8ixT3p5+XobI6d6RlfG/Vy9hXbs2KtXxx8k9O2Gsr4/5EyagYOGvhdqaHhqqoN6oai4WNT8Jrtu2CkiA0rp0qmSKQTUqYbub4txVt2zhXFJWGCzpWhFV/ES8c2U+ESJEiPg34l0Rs0ikqY9EB9CRMGOPSEgECrfQrtsa/ez2Y01+Puy0C+A/ehSLNyWBDlLMKy4vLAlKUB5kUsXbGJQkJ0URCcuscn207S7B7jxbbL4hXUrffO0FUNcZvlWrsmwE5plvciXTjYPih728vNiSfEqMlLw3Ib8AE1xcgfAXKAh/wXIpM5w4yt7b/7oQhq6uhUiTXO2OqdrJlPOEuHTpEstxbd+gPn4LTpOHCTBlP4kbanTrxvLqEjLzchX6Taq86IIalEs6Ng4RES+gb2YqH0NS7eOG8tkzZ0AmlpWtLZZffIbVF8MVCG6du3YFdikS3FSRDbmKHM+xLFSfIwENVW0sDVSp3XH1RjJqSb+A0h3SmG8ISsTa65Fv2pPrwrKfkPH4i1MFlmcbB/ahp44uy4tMRjIhgcRVBGQ+itE2XrsGabGxLH4+JDgY+toFqDlsKDxNTRH9IgJ3goKQiFx4d+uG+g3qs3JmfP45vsjIRGpmZiHyYH6+Gxo1awY8D4flzz8jSV+PzdeIFxHQz05Hw86dYG1igifPn+NhdDQM8rPRcuznzJOsPJfkpF1ZnPm9u3eho6uLpl99BQ9PD7YPP+ZDJluK+OdBNJRFiBDxn8W7JGYV5BcAErAlckprJcTR0ESW0s5eBxjw7bdS4hKp5eXno0AWQ1pUveTGVLUaLH+0ELRM/lHDxjh/SZGIdT40DsPbdETuKWn6OQ4yxqgfiAzFQiOMjaE192eYSCRwdnZhgiHKKCqjCFe741ueo1gI7qlN19bD0SCpsScknn1aQR6VjDRtPRx+EFlIebF59drAyWPIjHiJlNRUhIWFMeOVSH5e3l5I1dWFTmKitAwdfUb8Uj7PZ85uCgQ3ocIckQ1p4ZUbzEIvL+1PbaP/yTOlqo1vo9rI1e7IkCXjj+fBpvPKFRRDExXb8zgWVbv3QNVlfyF3/DgYV6wEfQN9ueGYlZmFAkMDZFlZsZAUOZlPIkGWkREy7exQwdoaHq1bM5lpqkdeQQGs6tRBm1495X2jJeubGNmitCqiHv3fvloNZijnWFog384OjdzcEBkZKVVB1NZGkqkpfJo1g2NyMiubib14eansRz7PmlXzZRk6yuqapvG9du0ai5Onh8U2bdqIBrYIOURDWYQIEf9ZvEtiVq3atYB795nwAy1Lc88ogeIsibxU5+ORzHDhRoI69aJc9mR0kCpe24ARco8ygcI6nu7dhib1B2HzjTdqeY08raCz6Xd4eHtDKFRNRDvyKHMFQ/LIZhkYwMzaGqYaeku52h33KKsyfEjpFUeOIiP6FdpWsVcgaBFh6/iS2agt+984P7tQvxGJ6+yy/Rikpw+DRYtAsiN+KurSRrZNj3qJNlXc5R5lfp6TS39GLSWCm1BhTpVHmfqJzx3qf5aBpAzCL4TESnrP68DDPmjbuHFjHFy6VKWCIrXn6J+HUZX6rGIlmNeuxcowkNWbtrw9NNc4mY/aRV5yNuZZWcwTz73myvsL+6a6X3Xg2jUY5+cUItm19rHGqeW70FNHBwb6BtA2M2PlkfedHsboeK6yybNaFDVXyuuavnf0KGZMnsyMZHowoAee2bq6GDNmDAaOHAl9D6m3WsR/F6KhLEKEiP803hUxq1+/fsC9b7ElMBCDJ3zN8iQTyapdVTsYPTjOlsrr1KkDfTMzeV3UqRfFFrdr2w55QUHo6iKBtq4HixFt4qiHj8IuYfnqNRjWqB1Qz0Uao+xljep5Ech++BCNhw+DTsuWRcYov238rVDtThXq1a3HJJVnff89vtm8GxKJNusTMojdsp9jx5UrQAUS+Aa2btyIwV/PUOi3/CdnYEcS52nSrAlnatdCl/HjoWdth5y4GPz95x+4SSqy9g7s+wVz52La5j3QkUjk53HPfYHtFy8Czi4KBDd1Y5R5buuyjFEWzknheXiMsouLCzb7+bE509vLEHqGHvL2eBe8xPaz5/CFiwscHB1KbA8n86ka86L2F24HDhqI3GvXsGn9egyePls+hiQcoh1yHoZ6ukB+AYxNjGFboQIrm8JG6OFCLuUuO3dx8eyl7b/i8PTCBeiMn4Cf6B93Dxb3nOdXkz2A5G3fgafbd4iS2CLwYUkKiRAhQsS/FJUrV2bbXUt+Y+Qx09OrMTj/Bs5/3Qch65fL9+M3d26clATab8rUKez9922bI3v7PHxq9Bj2639gBMF6RkYw/2Y8PLbOxicGj5G2eCxeTvtCfjx5Dh0cpIYkT6nF6yD0bpIRown4/sXlJJbx9KATFYXBNXygvf83jDEIwsO5Y7BgWF8s/HKifNdDK1bg08Z1YHpqFYZq3cLFqf1wZflvmPPZ5/J92kyfjZWxpui2M4xt+89ZhEqtWsm/14+OUTjPo3mfYP7gXljwJeWPoGgXrULtF26F7VHVR3zMuJqg8DPhVtVnyt+pMvL4ucmzO2/ePPb+h/YtgL2L8YnhIzye/ylm9++OeRPGl9ge5c+E7VLVxqL6xJmyTVCs/KZN+KRRbZicXInh2ndweWo/nP5tHhZOnKhQF1429ZmyEiL3BJcFeP2ovKL6ecNy6XVn//Mc6O46iC0Tf8Mo165sG/btLPZdenx8sWPHx7qs6i3iw4OY9UKECBH/abwr4o8ya18VOGOf6kRe3pJU53jds8LCEN+vv8Z1ojzK2rVqsTIYoUtAVBP2R0mkPGXw/SnmlLy0RfWtOn2iLhiZcexCrL3xJo55sL8TaoadQdW/VSvLKqOo7CLqzBG+D+9H6kMKz1Am5SmHMaj6jo+5MqlPeH5N5lN5Xg/qjqGwLkWdQ9N5VhKoPIpXJ+8yhXso93PPWrWwwtwCVuvXYVmkoULYyHD/Cui/aAIeduuKFiNGqBw7Pta0JZRVvUWUP8SsFyJEiBDxgZH5hFLbRB5KSyXJ7RxkZmXBQF8fumbmTOyCk7U4YYuMTVX1EpK+iJhlGbgRkuwctsTNvXcZt+8gLzkJWvoGkNhYIzM9A3kF+ZBoaUPPzhaRdnYoiIhg8bXcMCfjgpb5KXcznZc8ZiWR8oTg+1GcK5G9yFgkqGoDtdd261bkpqYwZThh3YVkweycHLx4/Bg5ObnQ1dVhxEItbS3ExMTg8ePHmD95Mpa2bosTTxWJbaeCE9DYVapuGD5gAKx8mPQKM854bmfqex0dXZja2ak0KouaIxTLSuen/qDYbvbAkpXF2s49pDTOXH5bSAykF+2jijRIoHJ5rDidX1U/CucTPxfNKZJzpr4sqj1lfT0o10MVaAzh5MSk2KmtPPZZeA51yJ+agMqhMaLrSGiUC8eAGbjmFiqJiMeC45k6IMVS87ksHDtOgiTQPtQOQlkQOkV8WBBjlEWIEPGfxbtWWVMwXLhXTeAtFMYm86VcMixU1asQ6UtGghJ66Ax9fRWOIU9ezJ27WPnXn0xGm4hbhBa+1eBqb4cb9x/gQfRr9pmHuweGDR/GhCiMaT8zM7WIVkISH1MUlJHeimqDkbdXiR5MOqOZkZHc28iJhVlxcXBzckK8RCIltrUYirU33hDb6lgDW3+aia8A2JmbQ9/aGgWOjiwmlxtrvO8Niji38hyhuNal8+fj5ImTyM3LhY5EB61atcTHo0bBwd0DZtZWhTzKQlJeUcS4glevcGD7dmzdsgUvIqSETEcHB/Ts1Qvdu3WDlpk59Ly9FPqxkCEs8NQW1Z7yuB6KM8hTHj/GH/PmYefOnUiQZR8hUZAhgwejeYcO0LawUJv8qQnoeHoApP6m64nKVB4DNzc3ICdXpWJga09zRrCtNOpjNo9VjR0nQXKURb1FfHgQQy9EiBDxn8f7EidQJkYpf0coqV7FlaGMpEeP8Kpb91LV1WXfXphUrKj2/tzYUqde6va/KrIXeYVJzGXAjZsInzkXl9MtWFo8Un3rHH6FxWkL4XZgP4y8vDTqN17Hp+fPI2f0mGL3I++qtrOz3KtcEpGOpZl7+gzPOkpFQkoquyQvcVnM5bK6HtJCQhDe+aNi99FEoKY0oPJ41hDlMdgyZw5qrt8gF6LZcCVcTkS0CjmHVn8thvuO7dCvUqXIsStrIqKIdwMx9EKECBEiNMD7kiJWRRZT/u5tylDG9vXr0YhCD6Z9A7vatQGJBI/uP4Lxkl9xpSAfdWNi4fDrr8jz9mFp7I4dPowV33+PuQ6OkGhIVhJ6u9Vtg7plCkFGyrhx4xA3bDh2fTYSE6tWRccBgxH5/CWOvYyCbgUndHz5CstSUjDG1BRaspAWTfqN77dk3jx8SuSvOXNgWKki6z/Ki03iGTNHjMCIpGQWgqAnIDAWRwzk7yNCgtn2ZZ/eaNy3r7xcGoO7t27hxzGfYJ6TU7HhDcplfgjXw+Gdu1iaOp2v/gfnBg0U2rVj4ULUOXsOabFxisIiZWxsCstTHoMuXbogfP0G/DBqFGp06oSGTZuhZgV9bFv4Ex4FP0Er48LkVuWyhEREEf9OiFkvRIgQIUIGdTNNlBVKYsorM+uFW/5emYVfHPbu3cu2ZCRHO7hjQUg+xoWaIXDETNT68RekDxiBhak26LbzGfuuxuBRyHNw1LhdwroUVy91+1uYRUJVGRayrB0TbGxYyjTt6ATcdGuB/V69kTJ4OmuXR4vmpTo3B8UNnzp1ir0nIzna3o31EfXVomdA558WsO94XKwm5R/Yv59tG/fpKx8XPgYObbvAlnJwy+KQhXVXlYWhLFBWZfH5RkaycrvqjZ/Mvjt56qTaY13W0DU1ZduZllboefESnObOheePM/H1q1f4VmYks/jqD/T3Q8S7gRijLEKECBHvMPuFugx/5SwKfImXtmSIkdGkKta2uKwMUVFRgLUN8+wpy2ib2Vgg2b0B1t+QxijTd8Srq1PfH7hytVT9SCiqT9Xt77i4ONYH1E4Sp1BVRp6pKY736I77u3Zhkp099ldtjTUyWWdqm06j9qhhZQTcuKnRuYV1uHfvnjweNTk9XUGueeX5MOTVc8IAOzvcvXMHFjo6cilwdcqPei3tc2V5cz4GNevVA/btZ2Q9ocS2csxsWczdsrwOXlO8u7ak0HxjUts5zkxqOzo6Wq2xLg+UREQsSnVSFUTZ7H8vRENZhAgR/3m8y+wXhJIY/rw+PIsC1YUMCDJcaKsspUz/F5ddgpdnQ0YyxY5KSA6apD7e4GV6Aa5ESg0vDorXbGVmWap+JGOeMljwz4T1Ure/6aGAt5e2RM4Sxv4qSD27u+PG69fIa9UWx5RknQ8HxcDDSFo+PWBoMta8DpTZgu+nKkvC8ZAE9POriVMLFyIiOwfZ2VkwtbFF81490a1rN+hbmBdpdNH4E1TJm9MYdNeTGqyUJSVHJrGtnIWhuPF/X9cBpWRDfILKdh15EofefjXlBnFxY12e0DQzyIfw+yHi3eK9jCT98Ddq1AgtWrSAv78/Tpw4wS52ijNr2rQpY1nHx8e/j6qJECHiPwjO9lfOPlFe4Ax/4VZVfcggou/JCCLvMRnKlDKMPiOvG+Uopu/oPZe+Li5DRvsO7dn/uQmxTMVNCCutLAQ46ip81sLbAmcP7itVP5KxQPVX1afq9jcZSrxttBUaTrwM/t1HH33EymNS3pUUvZFtqthiywppLmUy3jUZa14HkjduUL8++8woNxttfaQPHUK5cO17tzFEooNvDA3xvbkFJuXkoO6mzYjo14/lGqacw6rQuVNntn14+UKhcWldyRr7Nm+Q1UXaVupXLjdOc6Kk8X9f1wGNCSH99ctC7WrqasT6q3Xr1iWO9YeOd/37IeLd4r3MRFJ/Onv2LLsQKK9i3759MWvWLLZ0ce7cOaxbt46pDv3888/vo3oiRIj4D+JdSVmrK+/M6yOUFxZuCUIp5ZIyFVB5/fv3R8yhw5g+ZAh6LfgD+fWdcfRJHMsQ4XzrKKoZGECrbiscC01CM1djFFzZjYGNGgHXrpe6H4vqU3X7mzyORXkXlaWev/rqK+StWo2q0bcxrF515uVt4W4K3ZsH4CWRaHxu5Tr876uvUDBxEpZMmog2X0xBQWVzlmGjiaMufF/dYPLHRs6OuPg6CjGJqWj/NBiS4cPwPUl0GxoVucTv4urCpLwXf/klBiz9G8P9PVge3+Zu0jHo4FMZePqU5ZlWlqQmaJK9411eBx07dETE2nWYMWQo+iz6Uz7fmroYweL2QRZPLgzvKG6sP3S8698PEf+h9HC3b9/Gb7/9Bjs7O+Zd7t69O0ve3bFjR1y6dKnM03yIECFCxIeSJk54vuLSiJW2TOXPlFXUJHZ2yPeryTx7ZLQU9RnBfvs2WFWrVuy5uSGvbn3epk0E5ZRcwvYV1Q7ldGTFGZ2FUoAV0X8ZnpWwx7oajr/OQ0AlG3g7muGvM0+Zl3lQfVecC1yFBtu2w2XrFhhVq1aoLeqMi6q6f+jXgDrtEqbTo3NTX//TM0homnpQxLuHJnbjezOUichCnuQnT55g1apVjB07YMAAFo5BVapSpQoePXqk8liK26OXsMEuLi6ioSxChIhS412TcVSR3oqTM9a0TH6M8mdkvKTFxbHfy+fPn7NlfBcK3yBDRUcXkbnS+GdyXiQlJjHDJSYtFenm5izso27duirPrYqIpU59StOmosiQd+7cQfyDBzDW1kZUZCQSk5Lg7uaOev71VJKzhBLRRUlLCyWpqV3Uf+QZ/vGTTzAoJhZmP/2EvwvcsVZGHiR0remEy0/j8Do5CyPrO6MTwmA4dQry589DhaZNVbadjwvd24h0qaerxzzNZEBSvHeerh4TZynPuVke1wDvL2oDjRnNN+cKzsjMkrYpSybQQn1NAji0H8U2/1OloIuTHRfx4eAfkUeZLoLz588jLCyMGcf9+vVDoky1hypOP8hFYc6cOfjhhx/eYW1FiBDxb8a7JuOoIr2RQaosdUyfFyVhrarM9JBQpMbG4MyZM7h16xb7rGqVqghoEwBzM3NoM1ljN2hZWMAwKwt2jo7MEMvT14eJkxN7byUri1b20iMjWV3icrKBDKniHTdOhVAmYpGBsHnzZhw9epSV1axZM4wcOVIu9axuPxc1LqrIkPSeuC1k0GcQidDAAKYFBUglmegKFVgIi6qyM0Kf4sqZ0zh9+jRSklNQwbkCOnXqxB4UdM3MkGJiIveS042VG9pZRMCLiYV+9Vo4sVORqHbjeQKqOprjdXI0I601rQgQ1Y7GlBvkym0nOW8aF928PLhXrcr6mHsls5KToVXOc7O8rgHeX9R+yzp15OeiNuURWTU+Xk5IJSOT+ohsgH+iFLQywbQsCJYi3j/ei6HMte0JTI7U1BTNmzfHrl270K1bNxw8eJD9XxSmTp2KiRMnFvIoixAhQsQ/Qcpa+XwEMopVSR0XJWGtjNzwcMT06cPe+8teDCGhyNm3D7EAe7Hlezs7+e8v95YqE+XoJk98Ejo/GfP04kRCZXAiFhnJ4ZcvY9rEicjOyUGTJk1QoK2N7XPnYdeCBViyZAk8fX0hcXBQq5+LGhdVcsf0InIjtYcb5CkpKazOykYyLzv7+XMkDhwIH4C9GCiF3vUbIFkSehmvXQM4Ohbqo4CAAOBhEDJfv2JKbpQijqO2qyWuPItj79tWssLh7SsxVJYFoijSXVFtfVdz811eA/xcwjlIc436huYZeyD5hxnJyu3i17JI7vvn472EXty4cQNffvklm0TkiSCiQ8uWLVnWi7t377ILhwh96uZRFGOURYgQ8V+PUU65cwcRfftho50tJi5cCEMTE6lqXFY65vw4C0/PnMUMc3MmyWvo61so/rao+tGLvlflSVZG/P37eN2rt0JMKhHcJEqxth4HD8LA00OtdmkSo0yg5Xta6qb9aZVSlZHMQdLXfa5cRcGECXBv0RzpOvowzs3GkUMHsXrmLPzs4MD6S9fHp1Afpd69ixd9+uJrHQmmBu7EwUdJOPUsBS08zeFubYg116IYSbJadhjWT/kCc+zsFeSQNW3ru5qb7/IaUJ6DYoyyiHeFDz70ok6dOizrhTJ+//3391EdESJEiHgv4MQloXGiqbQyB4UOeAMYP28eUtwr44/L4Sx3LaXlGvXbcgyv4ys3LmlBmJ+zuAwD9D2vB7+ZFEfYO7Z3H6pT9oJZs5DiVxeBj5Jx5HEs2rUZiT7eRvi+XXNMNzVDfnrJUszK9RCepzgIPXjKdRY+fFBM9Z7de9DH0RH6LdtjQUgajjwIY/01eMhoXKdMH7dusf3Jy0keT1V1qmltg5H+1dGsVi2sqO0P7QO32edNiLR2QPqAQEYyj5FWSRKUGfxc0Y8MfeUHp/I2Xt/VeYRQloEWemT/yVC+hlU90In45+Cfl4NFhAgRIv5FynwU2kAhA2973hvXbzBDWdfQEH8JVOO4ulvXnj2BQ4dZSk66gVNIgqYKaCUR9q7fuM4MZVO/avg7JB0rL79g+7CtxA1VOnYEzp1nCnNIT9eovcrjo4rMJ/yM2idUNmQ5lmUp4miJnx4scvNyIbG3x4agRKy+8lLeXwUF+WjRpg0zlEmRLz0mhpVXo0YNeV3S86WLsf1fv0Z/dw8gIREFJ45Cqt0HQPbeYfEiGDg7y4mEyoqLtCXQlmKs6TMnJye4ubm9M0KYqCr3/hQ4RXz4EA1lESJE/OfxvpT5iK9RZqQfLekmXVsPR4PeZGDg6m4jnN3YezpnZkKC3MOlbt5aTtijLAaJ8fE4+uABiwG2t7NH3Xp1kaOrB7OsbLavSiW2h9EY4O7FDOW8fM36WXl86BghmY+M9nNbt+LqmTOIfPUK1jY28PHxQYP6DZCVlQktY2Pk29uzhxKKBRfGgOdVq4FjT+IL1bWRl5RQnpqSghxLS0Zu5GEddF6tCk6w2boF+WlpjIAm0ZbA0MiQPUyQHkBiQiKcK1WEZ4sWck6OsuIi1YXKpfowImJ6OvssNjZWTmgvb0KYqCqH96bAKeKfAdFQFiFCxH8e75rMJySjkRFFxtDbnpfy0OPqNeQmxqJtFTu5R5lAZLN9MzagoYwcaCjzJmuigEb76ZFHefQYkH5fTcF3yX//zba9ZP9rpyayEAbyzgrV8Q5M24iWFIKgrRnJSXl8yGjk/Rd54wZmd+uGb7S04cwPeBbGRFKyNmxk/5Lv12TtGuhZWck9yg0bNpSmgrt3G20Chss9ygTqv/N7NoKokRYWlkjW12eGKw+/4HUx9PZWWFrftngxlv7yC6uvg4MDItasxvyZMzFt2jQEdO7MPMrKJDZOE6JjuEeZSH/8+/ImhL3ruf9fgirSqYh/HkRDWYQIESLeszJfWRCoKAXbi6W/4/tvv8XXG3dAItFmnmQyks2ibiH6ZQRgYQlPT0+Y16hRLImvKOzdsgVNATzt2gXNhgxBlp4R8hJj8fvixXhw+Ah+tJHKOk+bMgUTV29mIR+8DgYvriItKQkwMpYqzGkYSqA8PtR/GaGhcPzxJ2Ykc/JgQePm7Lw4f4bFB8+LicZkWzvYUgYPWbYPHnrSo0cP5F24iPa2eZA08cDhB1HMwPcziMe0TZvQx9UNVapWQZ6bm0KMsir1wZ1Lf4f/2nVYZ2tXmMS49HeELv2dZRwxcncvpLioToxyeUJUlXt/CpwiPnyIj44iRIgQ8Z4gJDG9LXj8rU5kFAZU80bm1rkYmHcNV77pj23TJ2Pp1Knse/KiCs+tLihEZPXq1ex95eGfYtFToNvOZ1j+2hgjFy+DSZXKb/YNDsYAP29kbZuHAblXcGlKXxz8+Xss+OJL9n1erjSSl0INhNk1+HvlLX/PwSW8t6/fwLZbJBKkDxiBwC+XYKRFC/xZowcuzVrOPqvckPzoUlAWDCHRavy48ez9jx1bIWbFNAwpuInH8z7Ft13bYfqIEfLjhEYyP7dwzKh+K5b+Jh2H1YHYMvE3jHLtyra6uw5it4c0lzAJbwjbokxmIwOaP0CUltSpKVS1R0TZgoxk3s8i/nkQPcoiRIgQ8Z6V+crifEQWI0wkg8fBEbhylb1a0Idm5sCff7Hvo5KS4KAhkY5AmYqYmEjlKlj3IB5rr0UqkAV79e0HLF3KPvtaTx+wtQMuX2EvCreAoREgC9GIiItF4qVLLOyAwj/s7e1VquKpUswTkvNI0KSroSFC83Kxz70B1lyJkJaf8BL5NZ0Q69MEti9DWC7pw4cPQ6dSJebJbdqU/OKAvoU5285zcgJICfbRI+Yxh4srcPwE+y4mNRWuJZAZSdwlPDwckvoNsDlKG6uuKJIYm/brT0pZjNhlIjtOua3vQ8FNVXtEiP0sQhGioSxChIj/PN6nMl9ZnS9GVxeR306DfkEBi4/Vghb0DfRZ+eSxJNW5XD1d5FtYMO+wpuckg5Dim4n8diJEqqLKQeEVjStKI4R1v/sWWhQCQQQ3mQGYnJSEiJcvmdFbQF5TbW3cvXqVlUehILSl/aie9J6LUnGFQnpxKWcySimmm7JC0P8wNIR7bX8cj5Qa1EJ1PB0PK7i6eZGZj+SkZKSGh+PRo0csy4ivry+LGaaczolRkcxo5OqIJB+dnpEOIzIezcxYH9J3ly9fZm2oWrUqI0FylUCeuYL65ugTqdCIkBjYroYTe085WyWyNgnb+j4U3JTVFEsidQqlqJ89fQZtiTa8vLzkxyjLg4tQ7GcigpJOBCk+1qxZUwzF+AdBNJRFiBDxn8f7VuZ7m/OFnD2LX378kWVa4MQwMuTGjBmDWg0bwaCCEzNYtdPSmBFIhg0ZZpqek1KjMY/yvdto3WIw1t6QSloT6lgDa6dPw2S6qeTnQ9fSEhJnZ7nX1CAvD7EPHyI/JITlWibvdGpaKjuWYoV79eqFXj17Qs/CAvru7qyOQoXClMdP8PfSpTh67KjUOAZQ3ckJ/rIwksy7NxHQfhTWJGQoqOM5FqQjPvQx+//itq0490xKLlwzfTqaNG6CiZMmwqNKFZjVrInM6GhpXmuZB1vCvf2JSVg5bRoCAwOZMU0gYlafPn0wevRoaOnpsQwbZPRS37QNGIFVMs82Jwbeu7wdjQA4OjhCW2YU877hbX3XRDqhmmJJpE4ykkPbd5D/L20B8KaVUjDVR9FYVuy758+x8eefsWfPHkbqI9CD2oABAzBs2DDomJiIffaB470o85U1RGU+ESJE/NOV+UqDZxcvInPEyGKV8Mh40XF1lQtcvI2oxOiAAHwZ8ZLF/u53rY9jr3PR3d0QAXlRMPxrkUr1Pd7GjKdPEdaxU7F1VXVc8qPHeNmtW7HH0Wcpo8Zjn74bjj9Lhr+7FWrZ6qPq+f1Y9fcSjJXFGBd1Tt5HXIWQP8CkBgfjxUdd1KrzzG+mYvDtO8jftBO7XhYwYmCHag7oWNEU41rUx3Izc7kyH0FZhfF9xQirQ+rMuP8AYb164ce0VHz06acIaNcOadr6OH94PxbOm4uR7dqh5e07ctVHEVJkPXuGpx06yrujuPknPmC8W3zwynwiRIgQ8V9GWamgLV+yBIMB2M2ZjcQqtQRKeCPgHXENNZcuYMvl2irOVxqp7O++/Rapn3wKo8BVcPW7ip/GfIHDr4HPI8zR9OOf0CvsElb8Ng/jrW0Kqe9dO3MWtmSYjRsLw1Ydselxily1r5lxEn7p2ZnFCuempijUb//2bahFXsxvpiK3XlP5cQH1eqBJ/ANYpqZhu3M9nHuVjw6uWfiuYhbizq5H3ZvXmTHiwCuw+C9sybBUUAr8a2hfjE5LZ32ko4Jc9+TOHeY9jR08CPbd+mFLcJr8+DbWWfipcwDmOTohJzkZX375JWKHDsNPndug0cABmF67Hu4e2YNRg9ejvW81ICamUD+/K8JecQayULVQeT7wzy5dvgRHAN/88QdMGrbEX0z1MQrt/bpg3qH2GNeiAVq6e8hXNIorq6Tvitv/n0Y4vHXpEigKPvuzz2DS9iMFpcqW5mmY27U9m/M0/0R8uBANZREiRIh4h2S+sjoPhSQcPnQYgx0dYVSlCv5UUMKLwJA6tVDHzg7Xr1+Hm6lpIWU6ZbIceVVKqo+9uzukARNA4+gYBEbkYtMj6SebEjJgULk+XFq1Au7cZTmBM+Li5OfZuWsnxpBR7++PZcFpWCVQ7ctr4ALL2rWAqNeIiYlB9NOnciNu165dzFDW8fLGOsFxaxIovqIeTApysOkW/QMsT8hAbmVT9JcZyYReJiZMfS8w2Rhrbrw5Z762KxoNGAgsX46IiAiYKpHsIiMjsWXLFgyjc3tXxPrHKVh/9eWb4xu5wqVZMyA4BPfu30Ouri57EPjO1BTYu4+9XAB0IvlqmZHMCZfvG5zER2InNDYUiuPo6KiSPEmf0Rh8BsDGwQHLlFQf8xu5oW6DBmzsSHFROOaqyiruu+L2f1+Ex7fB/v37MRBApbZtsEBJqVK7qQecmjQGnioK84j48CAayiJEiPjP412R+cryPEQOyszKLFIJ7+TTJAzwq8kMPruMDHZOoTKdkCxHn9H/JdWHlof3+1VD53v3YTpnLo6fU/SEUSjG6EZNmaHMcgKnpcnPw+N7U7V0cDTozbIz4fjjWHRr3AzYsY0dl5GYyAwiUv4jgxv6BkjRkhQ+7lkK6nuQiEiCQh2qNmqKart34EVAayxetw6/tG6L40+l8aHy/YJi0MKnIntPxjnFcPO+oT4gI5LXOc/IFKcexhc6vm/dBsxQJvW+VHt7pE/+CgYAqlWrxuJ+hfhQyG6cXMYNZU6SNDU1Zd8JyZN87OLj4oscO/q/Z7MWwNYtyM7JZt5RVUTM4kiaJe3/vgiPbws2d4u4PokAO6RZK+DpyvdUOxHq4p8x20SIECHiHZDr3pUKWlmchwwbehFO//0n/O2k3mKOFq5G0L53G66urszIoHg8Mt7IAKUtGSB0PH1Hxgf9r059TGTGnrmlGRPnEIL+v3n2FHtPZQrPQ5k42PEFuYzgJkRrHxtcO3VcfhylcKN6UsoynjrONF/FcZ5mjLCn8Fklaxy8fpm9t2jcBM+ys1lMaIC3hcJ+bSrb4sXD++w9nUPYN5Q3mUiGDvbSOkvSUtCyolWh4+9cOCNtk6kp21/i4gKT6tVh4+/PYnWFr3dlJEdcu4Y5o0ahaYUKqGZkhPaVKmHZ118j8eZNRsrjJD56UZ2pzVx1kM8H5Tni4Fj02JHi4uXjR9l7yhaiPLeEZRX3XXH705a8zP805UA+543zsgpdKyTCc/HoofdUMxGaQPQoixAhQsQ7VCcrq/OQwdOnZUvg7j347tsHD1NbmFeWEuza2Ougc/A5Fn7ga2sHQycneRxqcXGh6qBz585I3bcfB/buxeCPx8rV94i41ryCNkYfOIAx7h6M2U/p1fh5+vbtC0yfgeCgIAzt2EOuHEjH1TBKwo7btwFXN6ZiZuLpKY+d7dunL8u/nJKYgKGNasiPozZ6Rd5ElcQkZDRoiyOP41hZ9a2zMf78ecDdA1V9q6Jhg4bIi4rCoCoW0NE3kJPsetW0x1fTNqIOACcnJwXVPqozGesDBw0Ebt3CqxfPMXxIOxjo68nr3NA2F2PPnsUkdw/4VfODac0acqni94XQ8+eR/fEoEPWxm6kZQC/Cnr2I3LNXThyzdndnD070EEXeZJqPxcUJU4YP/DAToY8fY2j7bgpj52eYiO137rDc00xxUTDm//UY5W5du7E84lcuXsTgrn0VrpU6ZmnYfOki4Pb+VxlEFI9/1qwTIUKEiHLEu7oRl9V5DGUxxwcL8hGVFotBxjFYUlcXJqdWYu8fC9l3eZnSlHD8vMoEMk1JhTb/b+8+wJsq2z6A/9t00hY6oJRSSgERCpQhCAgiIBtBQbaCCri3iIC+uAevgK/zc1JARUBFhrxsXgVUliioYNmUPcsqpYO2+a77aU9MQ9pmNift/3dd6cnqyclzTpI7T577uasWlKmeNenf+GLso+ibvx+ftK+E6E1z8UTnG3B/YZa/DGMwfxyZt1i8/fTTmP/ys+jnewgftg1A6A/JeK5PN0wYPrxohcHCbe7aratavvrAg1gx9TUM9D+GD+qnY9j057H79RdUYmH/M7/hk3bBiPr5SzzToyMev/1207qefvppdf6Te4bhxrQtSO4YhhaHf8K4Hp1QLTvb9LystU1CYS/wF2+8ga8njsWtxgMFj/PLLDzdrQMeLZyNw8+/YFs9GSSLf7/4olpWe/11JCxcgGqLl6plyEcf4Y3Mgp53LXHMvBpgcceDtmzatKla/uepMVj4ynPobzis9l3I6mn4V99ueHbECKv7vLjjraTbSrq/t6l/bcHQnvfGjcO8559BP59D+KhtICqvmYlxvTrjmWHDPL2JZANOD0dEVMjdvVauXL+sa1B8bbxWOPWZTNm2OL41Vp/MQ9fqBvQ9tFkFkUEvv4Q60ptrx/aV1MOXtf8ADvT+Z8qr4lhOeWU5F6+r/88ambbN19en1P+Xx/SNi1PP0Xx+6/Rdu3BEegXt3GZr7eZuqamp6N2wIb5LqIOAhcswe28GVuw4qX7yH9E2Hivfeh03LliIhHnzYKxbx1TgxRaO7jtX87beZb20G12N08MREels1gtXr1/m/0w5cxoIDUXVqVPx4ZWamLnpqGlGCJ+WN2NY9H9x4OJF1LFj+0qbmcAQGYHIuXNw7tixgop1V3LVT+7Sm+pn8FO9qyFRUVd98MtlCQhUj6YROHvurAp2wquEAz7FJ7xp/5eRlqaSuiTBLjgoGIGX0pF7KQMIDEBmaCh8fXwRVjlMtYtslwwByIqMUNtc7Ztv1LRzkpR2Mf0iKgVXgn9hL3BwVBSO5Ofj4vbtariHNhZWkt1k+4xTp8D/Si78A/xVe8h9ZOy0rMPac5V21ApLaO1WFrM17NmzR22vzPDxVcoFU9ETmZnCaMxHu2sbqMu//vorck+dVGN/GzZsaFPp6mL3XXh4mSUrWh6f3jADhtV28/FBUFAwMgqnTwyLjmaQrHMco0xEFZ67Z71w1fov79uHNcuWYenSpSqjvm5goLo+MyQMqzZbzMqw/wKGJDVXH8ql9cBp2yeBoMw+UNosBOmhoUivVk09HwlYQqtXx5W8PPgFB8PH3x9+xQxBMA+katrxvKUYiE94OAxXriAsLu6q7atUuH0S3KYHBBQ8Hwmmdu1ScyGvXLlS9bhKu7dt21YNJQiOjER2ZCSMVarg0pkz6rlpsz5I8pgEu7LOLAnIwsNNgVloQAAu5+UhKDISPoGBRZ6rPK6M+VUzfhQWLymr2RokaJXHLK6MdlJ0wWNLu+UUlq4+c+ZMqaWrnd13zpJCNT8uXYrFixerY15KQPft0wfNW7SAb3R1VZxGzyzbTfbR+fPnkVv4ZSq/ShWv6SGvqBgoE1GF5+4S1q5Y//mUFBzvf7vqHX5Eu7JGrFpkvfg8uo56pWBu4ULtawbBd8k2JI68q9TH07ZPO29ePtpauWVZSpAswaXMliCBpXlPn7vaz5btk+tkuypduICM++5XwclIbUXSA/3fJQUnSaz8vw8QEhenglgJjM17lFXZb19fFRzLdXIfea7a85Qg2vK5ynm5n+xn8+0qi9kaWrZsiVq1ahVbRnvZR1Mhfcoyw8WlwtkkZLy5rcMvPEGryijH/OPalemXgHffg3wVSPPCYQuWx4its82Q5+j3FUJEVI5mvXB2/W+99hrukOBr3DOo2a6dmpv1zPqfYJw0CV/t3o1bD22G4fquWLH3HDrUqoTwP5aqWS+CgoPs3j5bZiGQgEsCSwkCy2LsqK3bp23X2hkzEAfg2JDBuGHQIPj4+SHDEIDsU8fx+v0P4LG8PCTExMC/cEYQ+R/LMcrajBByWZtf2bKSXXHbabld7iaP8fhjjyPvww/R9OwOjGrTWPUsd6sfgZjDm7D9998lSkZS0yQY69g3RtlT3vn3JAySQOWZsYhr317tv5C8HGz9dQv+M2YMXo2K8sqqdpbHCOkbk/mIiAq5M6hxZt3yk3OXOnUwu0ZskUStHg2rofcfy1XSnjBERyM/qbmaP1mrTOdtPW6uMqpTJzxz4iQSvpuH49VqYfbmI2pqOJm/tnNIOqIeGonA999HfOdOVwW+1qZ5s9x/9u5PZ48tW/7fPHnM2rFgnrhYVkFycdO8lTY9nAxPkGN+VvUYq8mJ814Yh94//KiSEwMbJV61Lm9irYy4tz0Hb8NkPiIiHSXzObvubdu2qf+XRK1ZKecxozBpL3nDIeS36Y6bR/uganIyUq5vhahmzdDiwXsLhijopBqcJ/whc/tWj8HhY8cxe08eZmrlg39OhbFNHIZGR+PnX35GpwbXquERMnxE9s/ff/+tKtZJz3SrVq2s7j9796ez+9/W/8+NjlaJi8jKREpKigo2a3bugMSGiSphUo6H9LAwZBw7pp6vLYl8zrCWIGprCevNmzer8dSWx7yWnNjxhnbADz9i/4H9iKpatPy4NyT6WZYT145Bb0pWrCj0/bsLEZGXJ/O5Yt1q9gWjUSVqrdptkbS3Ow03FBYtaNWvH2q0b1/he6Okh87gWzAfc4bBX5XINidDEgYnNVf3kwTJUwcP4vfffsf5C+dVgJKUlIRLYWE4K1UCGzUqsv/k9hMnTmDevHmqPHjdunUx6MYbEWQ04n//+x8O7D+gZgHp2rUr4uLi4BNcCTmFs284sv9tPX60+/nUjFWBVvtWra66nypffeyYCkglOLM1kc8R1hJE7SlhLUth7ZiX5MT2kQVB9X8//hi+S5eiQ4cOqsJicEQEULeuV5S61sqJa4mksr3SXq5MAJVfGXb98QfWrlmL7OwsJCYmosNNNxXkG1TgL9L2YKBMRBWeO5P5XLHuNm3aqKBGErW6dR1p6l3TSimvm/857iwc+6j34KAsSBDQuvX1wIFUhORdQdcG0aYeZdExIVQlOra6awSMDz2MalJS2HwFP/+iFielbLMMXYmONu2/mW+8gQ+mTkWVypWRkFAHR+fPR9f/+1Ddv1HhSeQu/i9SC8/HLlwAQ0yMQ/vf1uPHlvtp5aslOJOlO4dfFJeAWVoipnad9OarsuBWjnmZJzxu+kzkAbh1335ATj+uQZYktha2t6/Z1HV6pe0PFL52JUB2VYl78wRg2ctdtCt/+BFHCo/Xijw0yx4MlImI3JzM5+y65QN0+J13Im/pMtzscxK+bWthxa4z6NGgKpJyUjF90SLcGVPDlCBEwKjRo4GJz2PZ4u9x54SX1bzJUj64y7VR8NnyvRq3u3XDBrQGcGLYULQeNAiZ/sHwy0xH8scfY93sOfh3TIxKFtP238KPPkL72XPQPrZggjSDry/y+vRTwZw2DrjmJ58gJ7YW9vz+K94b8xReCKuMgLw8BFau7PD+t/X4seV+MtzCnT3JxW2PIyWs77rrLuQt+h6djcdNx3yXhDD03bUGs3btwrCICNR47z1cSaiHP35ag48nTFAJftLe3sJ8f7h6jPJL48bhAQDZDz+EBt27qwTg/AtpmDJpEg6v34AXq1TxymTIssZkPiKiQu5IonHFOtXP2KkHTRXxSkrUYu9QgcwdO5A6YCBeOHcWx3x9cWOnTgipXhP/+34+eicmqp7Ily6cx0tVwq9KFrvj+pr4z8hheGT/AZUMGNy4sRoKcFtSEt7MzUPslMk4fU0TzNmVroI36eFslbEPNdLSsLRpj4IvMY2ro63PScQ9/QgiZ0xHtTZtTLNmaKWabQ0eS/o/y/vbejxp/+cOrgr4sg8cwP5exR/zUo1yabOeWLHztGrvZtmpqP+vsag5dw4qNWmi+1k9XJkEaXnbzp07cXvz5qpSo/+CpZi7L1Mls6rju3UcHr2pNd6CD2rP+1a1VUVz8eJF9QVFChSVVnree48iIiKdJ/O5Yp2mdcRUV4HwwV27sGjhIqSdOYFara/HgAED1Bs9xxsWJe0hXomILLhi6zZJi8SggMCCn+plNpHLl2G4tsFVleyu5F5Blx49gY8+Mo2VPXToEPbu3Qsk1EFWTAxm78nA9MLhHGr+6pbNEFo1G8lmSYP5rWtiWHQ0fvzxR/RMTFRDHmR/ytCCsLAwmxLcZFnc/1ne35bjzLxyoBw37kpcdUVSWmCdOuqYP7xnD5YvW4a0s2exadtWTI2tqXqS38+MUQmtWnuPbF0TDaOjsW7dOjSNjCyThEU9JEFau23+/PmoFRdnqtQ4Y3PRZMhbb78dmL9AzaiDy5eZOFgCBspEVOG5I5nPFeu8ah3x8agTF4fBiYnqQ1E+EKMK5wGmEsoHW/HTli04/dhjVivZ/W9XGm6Ij1Hnpe2FJJtpLvn4YWXKPz35YvX+C2hTR4Lyf6q+rNpzVlVHlEBX/l96r6RnWOZn1obUlJTgJrfJPrb2f5b3tyUBzLxyoJDHsHZ/SQCTdjt27Bj279+PkEohaNqsqQrISvpCZpnA54qkNLUfExLwSLduap0t585V1+fWuQYr5h8ocl+tvS9duqTaTpTVMBNPJUEWd5sE24FBQQXJkHuuToZ8Ir6uOp+TnaPW4Q3Jj57iPUcPEZEXJfO5Yp3W1iGnskrI8nYlDUNpGhWF/Lx8q5XsZBzz1pXfonZhwpWQ2S0iChPEQo25qtrd9PUHTf/TMb4SIoyXizxG57qVVdJg00ceVkGjBEGWPcOlJbjJsrj/s9ajXNJxZktVOPO5mIUUbRH/pEIWP8THWgKfK5NjpQ2vueYaIDcPIXnZahiB9JBqOiWEqfZu1O0p9dy88fXhSBKktdskAXjhf/4DQ2QUunUZaepRFnLsrkt+FzLgIiAwgNUBS+FdRxARkRcl87lindbWUZYJWeVVTEwMunfvjryUFNyeEABf/zpqDGevJjFoF52Pp2fPQb8aNUz3l+Bl0KDBwKpVOHvqFO5u1xEGg69KEOxW3Q+hf61Cp6AgZLYtHKPcKBqVdqxW42mbNGmikvnCw8MdGqNc0v9Z3t/ZqnBpRwt/og8LxZAxTyOpeXOcuZKP1Qu+xcJ33sG/qxckOJa2fncVzhg2bBjw5Sz8uXUrRnS/FT4+UPtAgr+AbQXVKOvXr2+quOiNHEmCtLytd+/emFa3nmqPodeGwi+wjmonOb4bB57FxFWr8HB8bURGRnLYRSnYz05EVEj7oHEFVyRMFbcOud5bgwA9GT9+vFq+3LMTAlZ8hLHVDiN99ut4rGNr3NO161X3Hy0zaQB47q678P79dyF+63w8mLUBw6Y/jwvJ/6cqJCb+Mgv3B+7A5ol3Ys/nn5r+V9uH5vtNu858ae26km6zvM7W40m7v3adtvx67tdqOfGjj1G9Wx+8tS8fw5adwJGWAzHy0y/VbfJTvfn/Wa7Dnm2yV7/b+qnlGw89jCnDB6p9MNLwJ9Y/OwQnFxZsu/ljm2+fN7H3OLC8TXqZp0yZos6/1rsLqqydiTFVD+HYxxPwr77d8PJ996nbfOSbhovf+8obznpBRGRWIcsVCUAuTeKzWIc7KwhWNJbDDKwxH2Zgy/1LW4cj+89dx5O1pLGhrVvjPf8ARH75BT45HlxkeIkkyw175wn8cUtvdHvgAYcTCp1hyz6QeZSNMrWf2fa5I3GxvBzfUtGxor2nXOSsF0RE9lfIkg8LeQOV8Y2hoaH6SeIz+xnWXRUEKyLLhD9p19OnT6vjQXp+qyckFBmLa3l/SZzKuJSBnOPH4Judg0pRkQiIjS3yGObJb47sP3cdT8IyaUxLOETValYTFrVkubQzaapX2ZGEQncnaUolxKzICFP1Qdk26TUtLnHREfIFQ9pS3iO0Hlk9Kq2t5Nj0i4/H5YsX+Z5SAv52R0QVXnZqKua/+x4Wfb8IJ0+eVB+mUhJXfmpv2rq1XXMTuyuJz1XrpqIs92222S8Llaz8snDVsSBJdg0b2NQb58j+c+fxZC1pTMpuIyvbasJil2vCVbJcnaFDVeDpSEKhK5T2esy/XJBUKYmP2vZZS1y0t3f251WrMPPzz7FlyxZ1Xb169XDHHXeo4SCGUH2Wg7Zlm/ieUjIOvSCiCu3yvn04eEufEu/jSCEPVxUasbYOdyRJ0T+0HmVb2bs/HNl/7jqeLBPCvnr1VVz31Wz4PPUU/G7qZiqqIlUg6x/5Fc0+mIqEefMQ2CjRqaIn7mYtwc1Rtg658eaCP3rad2WBQy+IiGy09Lvv0Fh6DZ56CrVvbC9ZMKrUa0huNqa/9CJu/uNP5Fy8iIK+N9u5aoo5d62bimdvoqS9+8PRXmFnWVuHZUJY/zvuwMGvZsP49tu48vbbGBIdjUFSEW/JPxXxpPfUWsKeno5LVyYUnj12TC23d+2KPg89+M97RF42tm7ZgkmPPILJNWK9uhy0nvad3rBliKhCW7BggVpKkHwqJgFv7c1Hv/kHVLZ/pwkvqdvWr19v8/pclT1ubT3MTC9b1mZ2sOX+9vRc27stzihpHdptQXXqoNb3i7D+9tsxxpiPfps3YeiXM/CpzDs9ZTLqLF2qek0tZ7rQK1ds37Jly9Sy57334lT12v+8R+zNR82e/RDTqhXKC73vT0/gGGUiqtCOyryxlUJUL9GXGw6aChioUq9t4lSPmrqPDVw1I0VJMxRUpMx0TzKfEcKWmRPs3T/2zLLizllUrD7XypXR7+kxGDDuGVPCnvQ4yjjkLOlNTUsrUj5Zr8ekq14zR48UvP7TMy9j5voDmLH+UJFy0C3btFHloL0d32OsY6BMRBVaREQEkJ2jfkpdvqNoSdwVu9PUz85S3KM0rpqRoqQZCjjbRdmXEbZl5gR7972Mi/999WosXrwYe/fuRXBQMDp26ogBAwaoAhDOzpRR3POxtg5rz9WyRHJxZZNlWRYzXTjClTPESMEXkeEXiFUpp68qBz0sOAzejjPqFI+BMhFVaFLBCgsWwnjx7FUlcTvEV1JjMzuNHFHqelw1I0VJMxRwtouyLyNsy8wJ9ux7SQyT5FEpDf2QusYHyMoClq/ARTlZJIa5c9aLkp6reYnkksoml9VMF/Zy5QwxvXr3Qs6yZdi9ZTO6JbY39SiLLg2qYuH4mbjZR1/P316cUad4DJSJqELr378/Ti9YiJfuuQeD//MhjG1rqSz/m+IrIXzbMpXApPWalVUZbGvrcUeJbbJtH9gyc4Kt++fv339HIIB9ffui04jhMAQEqF8zAnMu4/kJE5CeshNj/fyKJIa5qxR6ac/V1rLJej0mXfWaiY2NRSqAGS+8gLs+ngHfNnHq16bOdcLgv3UJrouMBM6dh7fje4x1DJSJqEKrHB0N+TH10Su5wGP3W8/yDwkp8ym8zNejTVem14CkvLI2c0JJgaL5cIbi9tW3336L4dITec/dKnlUxsXLkB/5NePe9z7DnU3rAzXj1FAH83W5a99brt/aLBYlXaf34NmR7bF8HlLERLwqY8n/NRYNrbxHWHuf0GN7lMZbtrMsMVAmogrNvHrV2bNnsWvnTvj5++OaoYPUT80B4VVsmhvVXQlXriytTc6xVvLZMpmttOPg77//LjhjJXlUvhBdf8MNwKHDquJfZmHSnCuS5dyVIGpLm3iSvc/R6vOJjFBlsQMKkx1TUlLUvrp2xB0IDQtFVlYW8vwDVCnogGLWo5f2IPsxUCaiCk8LhGvk5yMkKclU1tc/OBhGf/9Se4TclXAl10mQrCVaSVKhvXP8kmuYJ71pJZ+1ZLbcQ4dxIf0ili5Zit17dqvrbr75ZrRq1Qp+oaFFy2DLeOBikkdXy5CfuteqQDnnSo768uaKZDl3JYiW1iZ5xnxs2LBBTa8o923evDm6du1aMNbZLGHRXex9XZb0fPxjYhBYuTKCfX3RpnnzIv+TffEifEooD67XhEeyDd9xiYisJDZpZX1tSQRyV8KVnKQnWetRZpCsr2ND9ofx6DGcHjxYXd+u8KRs/hUHrVRs69ypM7B4MQKyM65KHu1Ytwp+/mQpRgQEIsA/AL4hIS5JlnNXgqgtbVILwBDtH7b8hqPTksuskp29r8vink9J+6CktjVfjx4THknHgfLWrVvx6KOPmg7CadOmYd26dXj55ZdRu3ZtdZ+vvvoKNWvW9MTmEVEFZpnYZOuHm7sSrmS4BXuS9Xts/Lp6NUIlBuxwI/o/9lhhcl4ATu7ZhTcffgjPBgUXSczr178fzi1ejPFPP41HP/kcPj7Asu0n0OXaKKRvXYJmjRoBe/chJDQElaTIh4vGt7orQdRam1wqnHd8Wmgoxrz9H0RWq6Z60H0vnccrL7yAM9v+wL9CQsqkkp29z9Ha8yltH5TWtt40Rpmu5pE9V6NGDSxfvlwFx2PHjsWLL76orh89ejTWrFmjTgySichTLBOVyoL0SJk/tnnlNvYk64dlMtvs2bPVcuCTTyIttm5h1bZUzM+Px8hPv1C3ydh37TiSoiUi/+AhDG1cD4c+GIvOhxZhzdP9kb91Aybec4+6XeZtNn8cZ1ibtcOWmTwcbZNNGzep5RNTpiA3sYWpkt2HRwPxePJXOFTG1d/Mkyw1lpUFzZfWEhZteQzLdTE4Lh880qMcExNjOi9jgLQPgS+++EIF0J07d1a9y8UdZDJmSE6aixe1mSeJiDyTCORMYpRU/pP3MQmitE4CJvF5BxmDe39kFC5evozP16di+vqCARfJP6civ3VNDIuOxtq1a9E7KUmNlZXEL/GknGrFAwcOqNMdAYHAnr1Im/i8XTOt6LHKo7TJAAkwggLxmUUlO4n/+w0aqOaNLkvmz1lYS0B0JvGuuOQ9Vrvzfh4doyzj7iZOnIjk5GTVyzxiRMGk/iNHjlRDL7TLliZNmqQCaSIiPSQCOZPMJ/eXIFlbVqtWTf0vk/j0T/a77HNxyccPK1P+mSpMrNpzFkOSmqvgWDp3VDnoqCgEJk9DqMGA0NBQU8+xOWcS3aSgSdb589i0aZP6Anbq1CnVOdWkcRM0atkSAQm13V7lMTev4JeQy35BV1Wyk2EmD0rCIsouUDZ/fcq+kDaXX2vME/acqTRomQSorUMbu+yqtpage9WqVTh//jwaNmyI1q1bWz1+qJwEynJADRkyBOPHj0cjGZNlZujQoVixYkWxgfKzzz6LMWPGmC7Lh0utWpIyQERU9olAziTzyf2lJ1nrUdZ6vJjEp3+yn5s1awYcO45QYy66J0abepRF54QwNdfudU8+Yfr1VFW5q1cPoZUru7w3V4LkfT17qfNxhad/fA1JGwx57VVUadIEhpgYtyWYXXfddSqZ0XghDd0SqxepZNejcXUsfmMiWqLsWL4+hQSYlgl7jlYaLC4JWNbniuqAMqd28quvYtoHH6h1Sc7CyZMn0aBBA9Vp2LB5c7fPIFKReSRQlm9fw4cPR79+/dRJyDckrZ76Dz/8oA6A4sgbjpyIiPSSCORMYpQMt5CeZO3DVjCJzzvcNeIu4M038du873DHPQ/AJ7+gsmO3+pGoumOVKkghn2cytZhllTtXW/Ldd2hYeN4QHY28pOYIOH4EOTXiYPiroDhGxsTnISl0dZYuRVDdOnAHmdnjyMef4O2pUzFm5lz4GQyqJ1lm+Yi+uBOLdu4EoqujLFm+PotL2HM08a645D1XJExOf/11tJ89B+0jo0z7VdufmPAs9pXBDCIVmUcC5fnz52PJkiXqG9GsWbOQlJSkelJWr16tvoHJm4oMryAiqgjkZ2DzIFmY936RfrXt3An73nwTdRYtwpVFi4qt7GhrlT/tPrbepl0nPdUffvgh3vMPwOU7RmFRg474IfUSbry5KoL9Dbjc+iwGH9yILz95Fw+EhcGYedltbeLnXxBaXNq5E3c3b4jbBg3C/fUa4L+vPYf9u3fjvWfGAZ9/jrKmtb35a8uRxL3S1m+5Dmv7U17z2hSQJQXnMlQk+f0P0C4iAoYZs/H1SYP6Itaj22gMuzYU7w27HQ9lZ5fJDCIVlUcC5YEDB6qTpddff90Tm0NE5LFkPmtJe9aS+0jflR337diBBQsWYP/+/Qg9tB/dBw1E6zZtgKDgIhXbSqoAp4ZlAAUFOSySzKzdZn6dTLsqx42hTVssjm+NL7YWjA2e++th3NY8FhuPZqNSfBvU79oF2LRZBWAFI2ldT0tElKnx5Plj1Wp1ul6ulJ7kwiA5x2Bw2zYUxxOvLct9La93uU72W1hYWIkJhPIL++XMyzA0bKiC5OSNh9X1svT1r4POo0YBH31UJs+jomLBESIiDyXzSa+SlrSXnp6Oc+fOqfGIsg65TUvuY8+y/oPlRDndckuRY0L2n7VjwloFOJXoZzSqk/yyap5kZu02y+tkCjpZf16TZlh9siDBUPPbwXNoVKMKVp1Mx5OJSSpQzr2S67b5fc3LwmtkO6Usd27uFWRJ0lxEBIwxMWU6x7C1xFl3v7Ys97UExxcuXFCvb20GFPmSLKy9b8h2StKn7FfpSTYnw1lubqINtiF3YaBMROShZD6V7JOWhoWff45Fixbh+PHj6vrY2Fj07dMH/fr3BySDnmMPvU5Jx0RxFeAse43Nk8ys3WZ+nSTFSzAqY1e7Xn87Zp77Z1uui4/ApgNp6BXrjx3f/ojGhcMj3BmgWh0vq/3qYjaFWlnONVxc4qw7WdvXEjxb61G21hayX+VLkOxXGW6h9SgLGfP929qZ6OL2Z1GxMVAmIvJQMp/MUnBu2B3oBqBbYBCQYJZctXIVLq9cxUQdL1bSMVFcBThHxyhHRESgQ4cOyDt0GH0PbUZ20w746fBl3Fi/KoL9DGhfw09d/8JPP2FwbE312GVND9XqrCXOlvXzlokLbB2j3LRpU3WS8e5D64eq4RbSk9yrSQx61KuEh++eji7VqpXZc6mIGCgTEZXA3mmi7JGydasau3runrvRom9fQMYvGgIRkpeN9et+wjtjx2JybCwTdbxYab9EWFvae5t2fsKECch8+BFUmj0dRr8vMLBzF/jtzcDZnHxUSdmOShcv4u4ePYG//oKnuCJpzlmeGMpk+bzNq22W1hYvvfQSjGOexluD+uDme0ahY6NG+O2HZDx010z0bdECOFJQMpzcg4EyEZENSur1cbR3bPH3i1UFs6SevXAqJgFfbjiI5TsOqJ9URwy4A4EffwRczuT+KQfKogc1tm5d9QuEuFvKn6+6uqhHUmGQ7KrKf87wVK+ypx63NMX9elC3USO1X5/INwLTk9Vt3eVULdoUJOthf5ZXDJSJiEpR0owWzpSoPXHyhFoeP30acw75XlXqt6XMmvDjGu4fL1dWZYy1JLrsPXuRl1XwBStHpg7LzYPBz4CgKuHwj63hVOU/V/FUaWe9lpQ2nxnjqhlOwsJQ7ZtvkHspHQZfgxpfbj50Rg/7szxjoExEVIKSZrRwpnS1UNPB7T+AnKAQrPr96lK/vUIqc994OWePEXtJwKQFTeYzb0jAJdUA9dCTWtZt4unHtXW7JECWWXCszn5SPRo54VVUeWwff39TARtyP7YyEZENWevWMtNLus0Wt916m1oe3P4HuiUWTcjpXD8SK+d/y33j5Zw9Rrz1sfW4XXpvD20WDAmGpbdbpo2TQNl8KffR07ZXBOxRJiIqha2zF9grsVEiUgHMfOlF3PH+ZxjZOh6r9pzFTfEhMG5agIEtWwJ/bef+8XKuKGPsjY+tx+3yhvYobfYTvW17ecdAmYjIBubDLVz1QaUl4LwSEQm8MB6No6MxxKL8sfn9yHu54/gpb20iU6aZzwZR0dg7+wmVjYp7RBIRuSARyJnkIBlLGrtwAdJPnVJBghQWCA4KQuwDo9XPw4KJOuWHJxLJ9Jq8Zrl9MjZXxg6bl3KviO1B+sNAmYjIwUQg4UxykKwzv3p15BauK6F5c1WMgL1G5Y8nEsn0mrxmuX2SrCZJh1pvcpUqVdzSs+yO9sjafwDr/7caK1euwqWMS6hTpw769+uPGjqZXYScx0CZiMiJksSOlK42X6ck6WhBt94CGXIdR8uce9tjOlreWUpKaz3K7hp+4er2OLtjB04OGIgaMm+1duX+A8j+3w8q90DIdH0Mlr0bA2UiIicSgZxNDtL+X+gtkCHvTyTTa/Ka5fZpZZ3dPUbZle3xxsTnMVoCqWfGIq59+4KqmrnZWDj/O8yZMgVvxtRgVc1yQJ+vHCIinTLPSjfPTneEjEkWEiDoNZAh9x0/ZaWsH89eZZ2opiUOOkJ6o0VqaiqWr1hesL72XTB1bx76zT+At/blo90DT6DOjR2KDrGyeM8o7jpHbtO2idyDPcpERA5W0NLmY3UkKeinn37C+fPn1byotWvXVj8916xZk/uinCvrZLK0tDSVKOfuJDlvahdH2+To0aNqLLX44Ycf1P8bqlfHrJTzmLHpqKmqptGYj5u7dwf27sWFCxeAwhlsTJX2rFXfK3w/sfc2+bItY7z5/uE+DJSJiByooJWZmakKAwh7f8qVDzcJkvOOHEF6Whr+XLhQVeJq2bIl2rVrBx8fHyYClUNlnVwnvaYSEGoV39yVJOeonNRU5F66hI0bNiAlJQWBQUG48cYbER8fD7/QULeM7XW0TWR/SZCclZWlXvsSnBrzjchr0gyrdhf8MqRZ8fcpXFezoIDQ5YzL8MnMLFJpT/7favU9O2+TQPnEiRNYt26dek9JSkrCgAEDOJuHi+nnFUNEpHPmyUdy3tEKX5GRkQi/nImq776nLrfQbli7Dgf/87bpfkwEKl/KOrlOginp9dR6T/UWJO/r2Uudr1F4Esb5C3DQjce/o20i+0t6bYV8wenQoQNmZmXB8Nc2dOs60tSjLLonRmPtV5+iroyJDqkEFH6h1nqB5TEte4a1wNee25YmJ+ODKVNU8C+/Rq2ZPh0fjBmDp59+Gv2GDmUSoYvo51VDROQFLCtoORrs/LJ6NaSA9bEhg9Fq4EBcCQpF9qljmDp5Mo5v/hUvVqnCRKByqKyT62Rogd56ksXRvXvVcn7teNz13HOoWr060n388OcvP+HT557Fy+ERbjv+HW0TCUarVaumgmYJTnvf0ht5f/6FPjUAw411sHzHCfRsHIMGvifw8uLvMTK+tnqcwOho9f+WFfasXWfrbau//BKtps/AzKiq6rIhMgp5HbuowD1v5ufYN/NzftF2EWaPEBE5UVHMEadOncKcuXPU+YRhI/HeQV+VCDTjXAQenzYLWdUKPvyofHL2+LGXFhDqKalvzty5avnk1KnIb9IKb+3Nx+0LD2FjdBvclzxb3abG97qJI19UpP20X5SkTcePH6/Ov9SjI9JmvoC7jb9jx6T78OrgWzHpkUeKPJa1CnvFVd2z5bbk9z9Ql2OnTEbAwmX4esz7uC/+NrXc8dQEdVveJfd80ahoGCgTETmYEHTs2DG1tDdpaf78+QgtTAT6KuUCkn9OxZFzmSoRaPbmwxg2fAT3STknx4GMeZVleXy80kgynPD198eXGw6qY197DWy8UhWG6Gj88ssvumkLa/8TUpgIOLlGLO7fvgM3zkzGC2ln8XVcLVyz+L9uKz9//Phx/LX9L3U+oH59zNl7GckbD6v2k+X2qk1V+x099s9wEHKcvn6LISLyAjLGdMuWLWqc47XXXmvzz7haMlfB+MhQlQi0cnfRQHvZ9hN45Zr6btx6qmhJfe5+PFnv9u3bVdJZYmIiwsLCSv0fSYpDQKCae3j5jgNFblux6wwGJTUvuI8O2qK4/5Hx0zKOurghIu6qzGcerFtrv9V7z2FoUnNcyc52+WNXRAyUiYjsSEBaOHcuPvvsMzVVlJAPzT59+uDJJ59EaNWqJX4waslczZo1Q/LRI2o8YfeuozB90xHTfWSM48+L5mAQ90q5VdZJfe56vOwDBzDvy1mYPj0Zx0+cMI3Bvu222/Doo4+qHtfiXg8Nrm0AnDiBkLxsdcxLT7Km6zUR8F2yDQ07PQo9tEVJ/+OJqntxcXHqy7mw1n4dE0JV+1UfeVeZb1t5xECZiMiOLP0kAO/5B8DQug3ykpoXJM9s+Q0nh4/ASRsy9SWQ6Ny5s+p5yzt1CkOvDYOvf0EiUK8mMWhfPR+Pz5mDQXG1uF/KsbJO6nP148nrYX+v3rgOwHVBwUVfDxs24sSGjep+xb0eBg8eDLz3Hn7duBEj+g6Cj0/Bryk9GldHxJ516rXRKLER9NIWeqpwKFPF9e/fH1izFieOHMGIG24wtZ/MuOH7239V+wUFF1T8JOd4fo8TEXmB84U9Zrt697oqeebKV/Pw4rlz6vaSMvW1ZCqZ6umNN95Q59/s1wM1f/sWz8enIfvbyXi8Y1s81LdvmTwnqrhJhM4m9p06dEgtD/S7Df4LlhZ5PWR/+TUmnjmjbpd5krXHNF/e2OFGtXzrqafw9j1D0WjvajwRcQA73rgfm999s+BBfOA29oxPdrYCpzvcf//9ajl++HB8OfYxNN63Gg8EpWDzxDtwbsl3pvuxap/z2KNMRGSD1atXq/mOu4wejXcLk2eELKVHuM2wocDyFTZXHoupUwfHAIw1+MkUAOo+8QCG1aoFbN3mtkQgqpgV+swfV6suJ/MCO/rYK1euxA0A2g4Zgg/2ZGC62esB7Wuj6W23Ab/8ogphZKalXVVhLqtw/Oy/q8cAe/YWnAA0kT9BBfMO5xgMKDjnWn/88QfOnTuHiIgINQxKj/upNJUiI9VSptHDhg0FJwCt5E9OwVzLv6ekINLXl1X7nMRAmYjIBmfTCqpvZQdUuip5Rn7yfLZlm2IDZctkIPnQNcbEIHLuHPhmZSMkNERV4yuLRCCqeMl85o8rCXJakpz8hO/oY2uvh0y/IKxMOX5VZbqHr2ulAmV5rPyMjKsrzEVFwf+zT2HIyVGJsOkX05Gbl6teByGVQlApKlK9RpyZq9yaS5cuqSBZtkWWcjk0NFRX+8kWlomEUq0v41IGLl1Kx8FDh9SXjOzAQPinp6vbtfmfyX4MlImIbBBTI6bgTTMz/arkGbm8bfHXqhKXLclAEhioD62EBN31VFH5S+Yzf1wJ9rSf4yVodfSxtddDYM5lNS52+vqDRSrT/fX1dPULjDxesEyFaK3CXP36pupzvhkZqvdWLsusGY5WvSyNBMWX9uzBwjlzsG3bNhUwy8w1gwcNRt9b+xYpne2p/WSrq75IS/vl5CAtPFx9AQg2GFRbyi8HDJId52OUryFeTn5GkgxQmZxcKzFJRORK57b8hhPDh+PHPrfglmdfxqyNB1VPsiTg9bwmBPe2borZNWKR8N08BDdubHUdlr1jru4tI+/iqf3vijG3pzduwpl77sGGgQPQ5ckJmLXpkOn10LV2AO5r21zNJ1x73reo1KSJTdXnpNqdVlDDXW2zYf58hD/3rxLvY5mA6E2vU21btZ5yLcgnx+NG79jzREQepmWQL582DR89NBI9s3fhsw6hiN+2AI/d1Ab9WqnRgSWy/LD1lg9fcg9P7X/zym+OCg0rGK6w8IMP8Nnj96PXlT34rEMIav42D493vgFDbyxI1tOGFNlSfU56mi2vcyUZQvHCM8+o8zUmv4mEhQtQbfFStcx87VX868xpqwm53vQ61bZVG07CINl5HHpBRGQDLbHuzZgawJ9/FZwKk2eSIyKAo8dKTMAz75Xyph4qcj9PHg+29PRau84nuNI/r4fftxacALSRU1RVIPWg3Qmp1trBlW2zatUqnDx5EoirhbRrm6qKdpJvIEOnRnTqiYZduwLb/lABtasf25NknLgMgdGDfCvHm97bmIEyEZEDyTNHjhxRP9/ViKmBiMiIEhPwzDPnhR6z6MkzPDmrgvbY5rNRqLHDgGnscHHXGSIjTMmofv5+aj1yioqKMvUi25OQaq0dXN02u3btQkJCAgxRVTF750XTzDWSb2A05qNJ8xYqUD548CDCo6IQItvv5a/T/fv34/z58wgPD0fdusVlUXjueDMUjkXXcxszUCYispH2oS9jKQPDwhB+5Qpy/f3hHxtbbAlr88x56dmRIEK7Tk9Z9FT2PDmrgvbYEgTLLBSm2SiMRnWS47m467TZK7IjIxEcHAwff39Uq1zZ4W231g7CnraRAiipKTsx77t5SElJQWBAADp17ozevXurbZSgXYLFtDNnkNexiyqTbTlTx72Bwf/MsXz+vOk17a2vU3m/kSBZ9pcsPdmznG/leJPtkn2j9zZmoExEZO8bp5+f6m3KyMhQy+KCZGuZ80KvWfRUtjw5q4L22Nr5IrNRmPUeF3ed+dLZbS+uHWxtG61qpuhfeFJmz8HJ2XNM9+v9zdd4NzNLVQ/s0W20qUdZdGtYDYtf+1INHZHeTQmqJZjz5tepBJ/yPLQeZU8Ov/At5nhz1+wmrsRAmYjIAfITs2RNlxQkF1f+Vs+9J1S2PFka2fyx7R2j7Ooxptbawda22bl1G/wBbO/WFX0eeBDwMyDDEAhDxgU89fjjCD1/Ho/kXEGowYBRo0Yhb9kytM7YA7S9Bit2paFLvXBU2bUGVaS6pp8/ateujdCaNb1i/GxpZLiFXsYoVyrmeNN7G3N6OCIiB8kQjNICZSbxkbcl9ZUUKJfFNhR3m7XtkuVzQ4dixLY/1NSMp6rXxpcbD2H5jhMqSa9Pw8q4M6k+5tVOUFPVyRCM/b16q3UZoqORn9Qcvn9tQ96pU8VOD1delNXxlV9Cgqgnt8vR6eHYo0xE5IC0tDTT0AvpXbaGSXzkbUl9JSXzOVPy2pnnb152u0hCYeFSCoeMgA8uXr6Mz9enmoqfSJJefn5tXN+unZqVRirXhdStqwLhy2fP4rctvyEzKxP1+/REQnx8ua6IWVbH1+USEkStHT96LRFujoEyEZEDPckSJMsHgCytDcFgEh+5M6lPpjmbO3cuTpw4gfj4eAwdOhQRMk2hE0lWciwXl8wnSajOlLx29Pmbl92W85YJhbJ9apYNI3DJxw8rU/7pGRZyuWODRipQzs29UrD++HiEJySgy3XXoSIwb18p2y3HzZ49exAZGYnBgweroSaOyklNxZnDR7Bi5QqcPn1aHYMdb+oI/wB/BIaHIycqqtjjR88lws0xUCYickMyH5P4yB1JfRJ0vP/cc5j2/vuoVrUq4mvXxi9ffInPJjyLsc+MxcDhw+3qETVPspJyxyUl8zlT8trR529ZdttaQmGbNm2AjZtQKTfnqnLana+JwLpPlmB4QCD8/Px1nzjmDlr7Lp2WjMmvvKwuJyYmYtuJE/j8xRcxdMhQjH3+eQTVrWPXenPMkijbml2ft2AhZCbqLEBNIWiMibF6/Oi9RLiGY5SJiBzEMcrkSraM1Zw1ZQpaJk83jbHNS2quZnFwdoytN49RPrB6NbIefQxLG1yL3q9Owbz9WWr6t67XRCBg+0pk/bgMw06cNJXTroh+/f57hI4bb7ps7dix97j5etIkNP38C+y7tS8633MPMv2DEZhzGfO/+QbfvfuuKkYj48YDExPV/TlGmYiIig2ivSG7mzyrpFklZCk/Uc/86CO0DAiEYcZsfH3SoAJCmepsWIMwLJk4Ft13/K2K4pQ2U4XlbdZKR7uznLS9Stqumtdcg30y/duu3cDg2zAkOhqDJElvSdEvEH6FZZ0r4mvx848/xiMAYqdMxqm6jTF3zyXTsdM2az/iXnoWl86cQaQNgXJ+fr46TU9Oxjt+/kgc9TD+szcDK7Qqh4+PU0VbpJdflNbWet8XHHpBROTiZD7tNvlpWG73lgpUBF1WLtMSoqSQxrFjx2Bo0xZzTvhgxqaCeYDVfMCG2rh54CBgx8umynLFJb9ZDq/Qw3HpTFKXVjUz89w5rF69WrVTUP4VdHr0ETRu3LhIkp43JI+5mgzX+emnn/BIzTikR0bhqz2XMHOj2bHTto76crFt61bc3KpVieu6XJhYKVUODx85oo7FWSnnMWPTUVMCpQwZ7zdgoAqU5b0wDt6NgTIRkQuT+bTbJNlIzktvidzPGypQkecUV7nMPKFOm/khr0kzrNp99qrKcj2bVVXn5X6Bhf9jLfnNPGFPD8elK5K6JAiW04AWLdz6ON5I9rW8F4l0Hz+stqxKuCtN9cBfuVJwn+LkmyVWpqenF3ssLtt+AgM7Vof8bqF9KfNm5f8IISJyUzKf9MhZJvNpt0lQItMhSSCi3VfPCSvkWVpik3ZMyfGjLSXJTo6jpKQk1Qsq40q7XRtZ5P8liW3rz2vV+biacer+ct/i1qXdpofjUnvu7q7SVlaPozfyPJs0LhibHZZ/BV0bFHyh0nSuW1nNJd0wsWGp6wkKClKnRo0aITQk1OqxKMMvNv+wSp2vVq0avJ1HepS3bt2KRx991JSxOm3aNMTGxmL06NE4dOiQmuomOTlZF5VkiIjsrcxnfps3VaAi/VYu08YV9+/fH3m/rMdtcb4w+NdRhTV6NYlB14QgPHHvJ+gQGYWIyAgERkfbNUa5olQo9GQlRE8aOmwo8Nk0pO7fh7t69oO/v5/q+ZUvWIF/LldjuaMLjxlb2k/cfvvtyPvpJ9xa0xeGG/85FrvXDcbjo9/F9IhIFed5O48cKTVq1MDy5cuxbt06jB07Fi+++CJmzpyJhg0bqnE0DRo0UJeJiLyN9hOnFkDrKSGK9M/yeDFfyumRRyQlC3i1Vxf4LH4XY6sdRs68KbivTVP0bf7PsANrCXqW6zK/riIx/7KgLcu7nj16quXkxx/H5OEDEb91Pkb7/4WNzw3FkW+/NN1Pm4ZPS9gTlkvt+Hno4YfU5Vd732w6Fq98NxWjr09C76SmKC880qMcUzinnpCfguQDZe3atRg3bpy6rm/fvpg8eTIefPBBq/8vY63kpNHGbREReTKZz5ZqfUTOqBRZ8DP3a1WrAmvXqVMD6TGMqwUcOmRKXPM2ZZlkZ5k0WRES+wyhBceETNmGQ4eBWV/9M/9xrsx6DOw+fBgBvr4qLtPaw98iGdS8rYILC9y8XrVakWNxiByLR4547bGoq2Q++UCZOHGiGmbx5JNPmqoKhYeH4+zZooPDzU2aNAkvv/xyGW4pEVHJyXyitGp9RM7SZniQKeCs8cYSzGWZZGeZNKmHZEZPHDeS4CclvbOys3DmzBnkBwYiPSgIoRkZ6ouEFhj7mSWDWrZVeTwWrfHYu7gcpEOGDMH48ePVoHAppXj+/Hl124ULF9Tl4jz77LMYM2ZMkR7lWrVqlcl2ExEVV5mvtGp9RK5QHoIPc2VZoc28EqGcr0iJfVcdN5cvw1++NJw9qwJhv8L2t9aj7FdYCdGyrcrbsWiNR97J5Rvd8OHD0a9fP3USHTt2xNKlS9G8eXO1lMvFkZ0oJyIiPSXzlZTgR0T6SLKzljRZEWntIL/ia19StGVJBWsqGo+8m8+fPx9LlizByZMnMWvWLDXljYxJHjVqFDp06IC4uDjMmDHDE5tGRGQzawExg2Qix5RlEFaRkxnNac9f62U37223vI9vBW0rH6MMVPFyMvRCenFkyIbMW0pE5Iky1ZaXich2nuyxLGnqPD1Pq0fujxv5jk5E5ADLGS444wWR4zxZWtp8FgzL8t56L/1N7sdAmYjIyVkvtCQ+znhBZD9PlpY2nwVDXsPm5b31XvqbygYDZSIiJ2e9kA9LznhBpP9ZL4p7bCHlvS17jbXZHmRprUeZQXL5x0CZiMgBljNccMYLIu8sLW05C4bgGGXS8PcCIiIXl60mIu9SUnnvkm6rKCWwKzK+qxMROUBL3tNmumDZaiLvTOarSNtM9mOgTERko5zUVORdysDmXzdj2bJlyMrMRK34eHTp0gV5VaogOCEBlerVY3sSeUkyX0XaZnIMA2UiIhuD5H09e6nz0QDu1m7Ysxf43w/IAnAQQL3lyypEWVei8pDMV5G2mRzDQJmIyAZ5GRlq+a6vD555913E1qqFdB9/BGRn4J0pU7F9xXK8Ghlluh8ReUcyX0XaZrIf9y4RkQ12796tlg+/8Qb8rmuHt/bm4/aFB/HBIT+MfPtDXImuznYkckFSrDdhUl/5x0CZiMgGGzdsUMv6DRviyw0HMe3nAzhyLlMtZ206hNuHDGY7Ejno6NGj2Ldvn1p6G0nqk5LIsqTyh4EyEZEN8gqngcowBGL5jhNFblu2/QTC4zgumcgRMs5XAk3zpbewTOrjdHHlDwNlIiIbtGjRQi0vHj2Ino1jitwml5fNm8t2JHKAJMNVrly5yNJbaEl9rNRXfjFQJiKyQfNmzdXyw3HjMCDeD6Pb1kJcRLBaNrq0B8fXr2c7EjmoZs2aqFevnlp6G0nqkwCfcymXT5z1gojIBobQELUcfTEdGHwbhkRHY1BSc/gu2Ya8U6fw7+oFvcyGkIL7EZGdAYkXV7bkzBfll/celUREZUjmRpY5kjPPncOqVauwZs0aZO/cjkbNmqJ///6oXr26CpI5hzKR/VjljvTKx2g0GuHlZPB/lSpVcOHCBfXzBxEREXkHSYCTz3FJiJOxvvI5zh5a0kvcyDHKRERE5DFMiCM949ALIiIi8ihWuSO9Yo8yEREReRyHW5AeMVAmIiIij2OxDtIjDr0gIiIij+KsF6RX7FEmIiIij2EZaNIzBspERETkMZz1gvSMQy+IiIjIozjrBekVe5SJiIjI45jMR3rEHmUiIiLyqLS0NGRkZCAkJARRUVHcG6Qb7FEmIiIij8nNzVVB8pUrV9RSLhPpBQNlIiIi8hg/Pz/Vk+zv76+WcplIL3g0EhERkUfJcIsqVaowSCbdYY8yEREReRxLWJMesUeZiIiIPIqV+Uiv2KNMREREHsPKfKRnDJSJiIjIY1iZj/SMQy+IiIjIo1iZj/SKPcpERERERFawR5mIiIg8isl8pFfsUSYiIiKPYTIf6RkDZSIiIvIYJvORnnHoBREREXkUk/lIr9ijTERERERkBXuUiYiIyKOYzEd6xR5lIiIi8hgm85GeMVAmIiKiMpOTmop1M2fi/q5d0bxyZVwXHo6nbrsNm+bMgXHfPuQeOsS9QbrhYzQajZ544B49euD333/HE088gYkTJ2LNmjUYNmwYGjRooG5/66230LJlS5vWdfHiRVSpUgUXLlxA5cqV3bzlRERE5GiQvK9nr1LvV2/5MgQkJLCRyS3siRs9NkY5OTkZq1evxpEjR0zX3XLLLZg2bZqnNomIiIjc6PiBA2q5s1dP9Lz3XsBgQIYhECF52fh+wQJ89eabeDOmBvIyMrgfqGIPvYiLi7vquhUrVqBDhw547LHHkJmZ6ZHtIiIiIvdYuHChWvYcfS+OV43DW3vz0W/+AbVsc+9jEhyw6UlXdDNGWYZZ7NmzBz/99JPqBp86dWqx983Ozlbd5uYnIiIi0reDBw+q5Ykzp/H5+lRM+/kAjpzLVMsvN6ai/U0dPb2JRPoMlMPCwhAUFKTO33nnndiyZUux9500aZIaW6KdatWqVYZbSkRERI5+1ot0H3/8b3dakdtW/H0KhoiqbFjSFd0EyjKgWvPDDz+YkvqsefbZZ9X9tdPhw4fLaCuJiIjImUR+cfHIQXS5NqrIbXJ5yddfsXFJVzyWzHffffdh/fr1ahiF9B53794d06dPV2Usq1atqs4XJzAwUJ2IiIjIe7Ro3gKpAJ5/7lmMnzUP/jfWwfIdJ9D5mgikb12CevHxwLHjnt5MIs8Hyp999tlV1z388MMe2RYiIiIqAz4Fi74tWmB875sRU6sWrruuNTYkr0fr667DhIcfRtrE57krSDdYwpqIiIjKhCEkRC177dyFXjXjgHwjsGUT4GsAtv2BtG1/FLkfkacxUCYiIqIyIUVEpJhISfMkS5DMYiOkFwyUiYiIqMwwCCZvoptZL4iIiIiI9ISBMhERERGRFQyUiYiIiIisYKBMRERERGQFA2UiIiIiIisYKBMRERERWcFAmYiIiIjICgbKRERERERWMFAmIiIiIrKCgTIRERERkRUMlImIiIiIrGCgTERERERkhR/KAaPRqJYXL1709KYQERERkY5p8aIWP5b7QDk9PV0ta9Wq5elNISIiIiIviR+rVKlS4n18jLaE0zqXn5+PY8eOISwsDD4+Pp7eHN1+e5IvEocPH0blypU9vTnlCtuW7epteMyybb0Nj1m2rStJ6CtBcmxsLHx9fct/j7I8ybi4OE9vhleQIJmBMtvWm/CYZdt6Ix63bFdvU9GO2Sql9CRrmMxHRERERGQFA2UiIiIiIisYKFcQgYGBePHFF9WS2LbegMcs29Yb8bhlu3obHrMo/8l8RERERESuxh5lIiIiIiIrGCgTEREREVnBQJmIiIiIyAoGyuVIjx49UK1aNbz22mvqsgw/f+yxx9ChQwf06dMHZ8+eVdfLUi7L9XI7h6nb37ZffPEFWrdujZtuuglDhw5Fdna2uj41NRU333wz2rdvjzfeeMONe7v8tq1mxowZ8Pf3N11m2zrfrnLcdunSBZ07d8bs2bPVdXw/cP6YPXfuHLp3746OHTuq1/6ff/7JtnXA1q1bVfvJ+6q8j+7fvx9ZWVm488471eeVLOWy4PuB8207efJktGnTRl1vHgv8/vvv6rp27dph5syZjuzK8kWS+ah8OHz4sHHGjBnGV199VV1etmyZcdSoUer8559/bhw/frw6L8svvvhCnR85cqS6H9nXtvv27TPm5uaq888884xx2rRp6vyQIUOM69atU+e7dOliTElJYdPa2bYiMzPTeMsttxjr1q1ruo5t61y7bt++3ThixAhjfn5+kfvx/cD5tn3//feNL730kjr/448/GgcPHsy2dcDx48eNFy9eVOeXLFliHD58uPGjjz4yvvLKK+q6l19+WV0WfD9wvm13795tun3QoEHG1atXq/Pt2rUz7t+/35idnW1s0aKF8ezZs8aKjD3K5YhldcK1a9eqnmPRt29fdbmk68n2tq1bty4MBoNpah0/v4Iil9u2bVM9H+KWW25h2zpw3Ir33nsPDz74YJGS9Gxb59p13rx5qFSpkur57N+/P44cOaKu5/uB822bmJioSixrvcvR0dFsWwfExMQgLCysyPtqcccn3w+cb9v69eubbteuk19HMzIyUKdOHQQEBKjPs82bN6MiY6BcjqWlpSEiIkKdDw8PV2/g2k+tclm7XhuSQfbbuXMnli9fjiFDhqjL+fn5ptvYto6R43TdunWmD0cN29Y5x44dU+8JK1euxOjRozF27Fh1Pd8PnNeyZUts3LgRTZo0UT9hP/3002xbJ0igNnHiRDzzzDNXfY5pn1d8P3C+bTXy5eP48eNqWIa0txYfWLZ5RcVAuRyLjIzE+fPn1fkLFy6Y3mxkKZe16+V+ZD/pkbv77rsxd+5cBAUFqet8ff95SbFtHTNp0iSMGzfuquvZts6R17mMrZVeeln+9ddf6nq+HzhPxnoOGDAA27dvx7fffotHHnmEbeugK1euqI6H8ePHo1GjRld9jmmfV3w/cL5thYynnzBhgvock/cG8/a2bPOKioFyOSaJJUuXLlXnZSmXS7qebHfmzBn1wfjxxx+jXr16puubNWuG9evXq/PLli1T39DJPrt371aJkD179lS9HFpvPdvWOZ06dcKWLVvU+d9++8103PL9wHmSBFW1alV1XoZdaD1wbFv7SC/x8OHD0a9fP3UqqQ35fuB82+7duxejRo1SQbJ2/EqnT0hICA4dOqQC659//lklrldkrMxXjtx3330qSJMxRvIT4Pz589XPgPKNsXLlyirjPSoqSv20ctddd6kxdU2bNsX7779f5Ns5ld62MkZx4cKFuOaaa9TtI0aMUD9nSyaxLHNyctCrVy/1ExfZd9xKu2qkfeXNXLBtnXs/WLBgAcaMGaOy3+VD89NPP0XDhg35fuCCtv3www/Ve0BeXh4yMzPx5ptvqi8mfK+1j4yjv+eee9CqVSt1OSkpSfXWSzAnv+DJ+67MhiPBHN8PnG/bAwcOqOGD2ph7GY4huTXyhfqJJ55QXwDvvfde1f4VGQNlIiIiIiIr2I1IRERERGQFA2UiIiIiIisYKBMRERERWcFAmYiIiIjICgbKRERERERWMFAmIiIiIrKCgTIRUTnwySef4Mknn3TLuqW4jhTQISKqaBgoExHpyKVLl5CQkICvvvrKdF16ejri4+NV0QBrpMDNa6+9pgoGuIOUvGXxHCKqiBgoExHpSGhoqKl3+PTp0+q6cePGqYpaAwcOtPo/ixYtUlX2atas6ZZtkhK2UslTK4FNRFRRMFAmItKZHj16qFKyjz/+ONasWYNvvvlGlUkujgyL6Nixo+my/I9WllYjvdSrV69W51966SUMGjQIw4cPR1hYmCpnu3v3bkyaNAnR0dGoVasWVq5cWeT/pSTzkiVLXP5ciYj0jIEyEZEOvf322yrglV7kqVOnIiYmptj7/vXXX2jQoIFd61+8eDFGjBiBc+fOoUWLFio4z8/Px9GjR/HCCy/ggQceKHL/xMRE/PHHHw4/HyIib8RAmYhIhyIiItC4cWNcvnwZt99+e4n3PX/+vOoZtkeHDh1UcOzn56d6l2WYx4QJE+Dv74+hQ4ciNTVVrVcj6ze/TERUETBQJiLSoVmzZqlgtWvXriqZrrSgWhL+7FG9enXT+eDgYFStWhUGg8F0WUss1Mj6w8PD7XwWRETezc/TG0BEREWdOnUKTz31lBqbLEl60rN85513ql5ga5o2barGGJvLzMwscvnChQtONXNKSgqaNWvGXUVEFQp7lImIdObRRx9Fv3790LlzZ9SoUQOTJ0/Gfffdh+zsbKv37927N9auXVvkurNnz2LhwoVq3PH06dPVsAkJlvPy8hzaJll/r169HPpfIiJvxUCZiEhHJLj9+eefMWXKFNN19957L2JjY/HKK69Y/Z++ffti586dOHbsmOk6Sf6THulq1aphxYoVagaNBx980KGe5V9//VVNWyfTxBERVSQ+RqPR6OmNICIi53z66af4+++/8c4776jZMmTqtyNHjrisMt/o0aNVzzURUUXCMcpEROXA/fff77Z1f/fdd25bNxGRnnHoBRERERGRFRx6QURERERkBXuUiYiIiIisYKBMRERERGQFA2UiIiIiIisYKBMRERERWcFAmYiIiIjICgbKRERERERWMFAmIiIiIrKCgTIRERERkRUMlImIiIiIcLX/B1/WnbaDNUjoAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 720x520 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -424,10 +434,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "2304b538",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Annotation local_ls error (mean / p95 / max): 0.0389 / 0.1822 / 1.0539\n",
+      "Annotation optimize error (mean / p95 / max): 1.7260e-12 / 6.7212e-12 / 1.0847e-10\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x520 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# unwarp demo (step 2): annotated coordinates not on skeleton\n",
     "# --------------------------------------------------------------------------- #\n",
@@ -520,7 +549,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "48ec81d6",
    "metadata": {},
    "outputs": [
@@ -528,7 +557,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Last updated: 2026-02-12 13:48:25 CET\n",
+      "Last updated: 2026-02-12 14:12:05 CET\n",
       "\n",
       "Python implementation: CPython\n",
       "Python version       : 3.13.11\n",

From 6d446df1c4fb62551b9d17c3f7fbb298deab025d Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Thu, 12 Feb 2026 15:08:15 +0100
Subject: [PATCH 6/8] change: improve unwarper api

---
 notebooks/example.api.low.ipynb |  46 ++++--------
 pywarper/unwarper.py            |  95 ++++++++++++++----------
 tests/test_unwarper.py          | 124 +++++++++++++++++++++++++-------
 3 files changed, 170 insertions(+), 95 deletions(-)

diff --git a/notebooks/example.api.low.ipynb b/notebooks/example.api.low.ipynb
index 298f688..fea216e 100644
--- a/notebooks/example.api.low.ipynb
+++ b/notebooks/example.api.low.ipynb
@@ -70,9 +70,9 @@
      "output_type": "stream",
      "text": [
       "↳ mapping ON (min) surface …\n",
-      "    done in 0.01 seconds.\n",
+      "    done in 0.02 seconds.\n",
       "↳ mapping OFF (max) surface …\n",
-      "    done in 0.01 seconds.\n"
+      "    done in 0.02 seconds.\n"
      ]
     }
    ],
@@ -93,7 +93,7 @@
      "output_type": "stream",
      "text": [
       "[pywarper] Warping skeleton...\n",
-      "    done in 0.31 seconds.\n",
+      "    done in 0.39 seconds.\n",
       "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
      ]
     }
@@ -269,7 +269,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x1174a9450>"
+       "<matplotlib.legend.Legend at 0x1190dd310>"
       ]
      },
      "execution_count": 8,
@@ -331,7 +331,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "5bfbb928",
    "metadata": {},
    "outputs": [
@@ -368,12 +368,9 @@
     "unwarped_skel_local = unwarp_nodes(\n",
     "    warped_nodes_norm,\n",
     "    surface_mapping,\n",
-    "    med_z_on=med_z_on,\n",
-    "    med_z_off=med_z_off,\n",
-    "    on_sac_pos=0.0,\n",
-    "    off_sac_pos=12.0,\n",
+    "    on_sac_pos=0,\n",
+    "    off_sac_pos=12,\n",
     "    conformal_jump=2,\n",
-    "    method=\"local_ls\",\n",
     ")\n",
     "\n",
     "# option 2: inverse-by-optimization (iterative; use subset for notebook speed)\n",
@@ -381,15 +378,11 @@
     "unwarped_skel_opt = unwarp_nodes(\n",
     "    warped_nodes_norm[opt_idx],\n",
     "    surface_mapping,\n",
-    "    med_z_on=med_z_on,\n",
-    "    med_z_off=med_z_off,\n",
-    "    on_sac_pos=0.0,\n",
-    "    off_sac_pos=12.0,\n",
     "    conformal_jump=2,\n",
     "    method=\"optimize\",\n",
-    "    optimize_max_evals_per_point=100,\n",
-    "    optimize_convergence_tol=1e-9,\n",
-    "    optimize_bound_xy_to_map=True,\n",
+    "    max_evals_per_point=100,\n",
+    "    convergence_tol=1e-9,\n",
+    "    bound_xy_to_map=True,\n",
     ")\n",
     "\n",
     "err_skel_local = np.linalg.norm(unwarped_skel_local - skel.nodes, axis=1)\n",
@@ -485,32 +478,21 @@
     "    annot_prenorm,\n",
     "    med_z_on=med_z_on,\n",
     "    med_z_off=med_z_off,\n",
-    "    on_sac_pos=0.0,\n",
-    "    off_sac_pos=12.0,\n",
     ")\n",
     "\n",
     "annot_unwarped_local = unwarp_nodes(\n",
     "    annot_warped,\n",
     "    surface_mapping,\n",
-    "    med_z_on=med_z_on,\n",
-    "    med_z_off=med_z_off,\n",
-    "    on_sac_pos=0.0,\n",
-    "    off_sac_pos=12.0,\n",
     "    conformal_jump=2,\n",
-    "    method=\"local_ls\",\n",
     ")\n",
     "annot_unwarped_opt = unwarp_nodes(\n",
     "    annot_warped,\n",
     "    surface_mapping,\n",
-    "    med_z_on=med_z_on,\n",
-    "    med_z_off=med_z_off,\n",
-    "    on_sac_pos=0.0,\n",
-    "    off_sac_pos=12.0,\n",
     "    conformal_jump=2,\n",
     "    method=\"optimize\",\n",
-    "    optimize_max_evals_per_point=100,\n",
-    "    optimize_convergence_tol=1e-9,\n",
-    "    optimize_bound_xy_to_map=True,\n",
+    "    max_evals_per_point=100,\n",
+    "    convergence_tol=1e-9,\n",
+    "    bound_xy_to_map=True,\n",
     ")\n",
     "\n",
     "err_ann_local = np.linalg.norm(annot_unwarped_local - annot_orig, axis=1)\n",
@@ -557,7 +539,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Last updated: 2026-02-12 14:12:05 CET\n",
+      "Last updated: 2026-02-12 14:55:39 CET\n",
       "\n",
       "Python implementation: CPython\n",
       "Python version       : 3.13.11\n",
diff --git a/pywarper/unwarper.py b/pywarper/unwarper.py
index f9d8c1c..90433fa 100644
--- a/pywarper/unwarper.py
+++ b/pywarper/unwarper.py
@@ -53,50 +53,69 @@ def denormalize_nodes(
     return denormalized_nodes
 
 
+def _prepare_unwarp_inputs(
+    nodes: np.ndarray,
+    surface_mapping: dict,
+    *,
+    on_sac_pos: float,
+    off_sac_pos: float,
+    conformal_jump: int | None,
+    backward_compatible: bool,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    points = np.asarray(nodes, dtype=float)
+    if points.ndim != 2 or points.shape[1] != 3:
+        raise ValueError("nodes must be an (N, 3) array.")
+
+    resolved_jump = resolve_conformal_jump(surface_mapping, conformal_jump)
+    on_input_pts, off_input_pts, on_output_pts, off_output_pts, map_med_z_on, map_med_z_off = (
+        build_surface_correspondences(
+            surface_mapping,
+            conformal_jump=resolved_jump,
+            backward_compatible=backward_compatible,
+        )
+    )
+
+    prenormed_nodes = denormalize_nodes(
+        points,
+        med_z_on=map_med_z_on,
+        med_z_off=map_med_z_off,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+    )
+
+    return prenormed_nodes, on_input_pts, off_input_pts, on_output_pts, off_output_pts
+
+
 def unwarp_nodes(
     nodes: np.ndarray,
     surface_mapping: dict,
-    med_z_on: float,
-    med_z_off: float,
     *,
     on_sac_pos: float = 0.0,
     off_sac_pos: float = 12.0,
     conformal_jump: int | None = None,
-    prenormalized: bool = False,
     backward_compatible: bool = False,
     method: str = "local_ls",
-    optimize_max_evals_per_point: int = 80,
-    optimize_convergence_tol: float = 1e-9,
-    optimize_bound_xy_to_map: bool = True,
+    max_evals_per_point: int = 80,
+    convergence_tol: float = 1e-9,
+    bound_xy_to_map: bool = True,
 ) -> np.ndarray:
     """
     Inverse of `warp_nodes` for point coordinates.
 
-    `method="local_ls"` uses the original approximate inverse by swapping
-    local LS correspondences.
-    `method="optimize"` refines per-point coordinates by minimizing forward
-    warp residuals, i.e. solving `warp_nodes(x) ~= target`.
+    `method="local_ls"` mirrors the forward local least-squares model with
+    swapped correspondences (flattened -> curved frame).
+    `method="optimize"` refines per-point inverse coordinates by minimizing
+    forward residuals (`warp_nodes(x) ~= target`).
+    Input nodes are assumed to be normalized warped coordinates and are
+    denormalized using the provided ON/OFF SAC reference positions.
     """
-    points = np.asarray(nodes, dtype=float)
-    if points.ndim != 2 or points.shape[1] != 3:
-        raise ValueError("nodes must be an (N, 3) array.")
-
-    if prenormalized:
-        prenormed_nodes = points
-    else:
-        prenormed_nodes = denormalize_nodes(
-            points,
-            med_z_on=med_z_on,
-            med_z_off=med_z_off,
+    prenormed_nodes, on_input_pts, off_input_pts, on_output_pts, off_output_pts = (
+        _prepare_unwarp_inputs(
+            nodes,
+            surface_mapping,
             on_sac_pos=on_sac_pos,
             off_sac_pos=off_sac_pos,
-        )
-
-    resolved_jump = resolve_conformal_jump(surface_mapping, conformal_jump)
-    on_input_pts, off_input_pts, on_output_pts, off_output_pts, _, _ = (
-        build_surface_correspondences(
-            surface_mapping,
-            conformal_jump=resolved_jump,
+            conformal_jump=conformal_jump,
             backward_compatible=backward_compatible,
         )
     )
@@ -114,10 +133,10 @@ def unwarp_nodes(
     if method != "optimize":
         raise ValueError("method must be one of {'local_ls', 'optimize'}")
 
-    if optimize_max_evals_per_point <= 0:
-        raise ValueError("optimize_max_evals_per_point must be a positive integer.")
-    if optimize_convergence_tol <= 0:
-        raise ValueError("optimize_convergence_tol must be a positive float.")
+    if max_evals_per_point <= 0:
+        raise ValueError("max_evals_per_point must be a positive integer.")
+    if convergence_tol <= 0:
+        raise ValueError("convergence_tol must be a positive float.")
 
     # Start from the fast approximate inverse and refine against the forward model.
     inverse_state = _build_local_ls_state(
@@ -139,7 +158,7 @@ def unwarp_nodes(
         max_order=2,
     )
 
-    if optimize_bound_xy_to_map:
+    if bound_xy_to_map:
         x_min = float(min(on_input_pts[:, 0].min(), off_input_pts[:, 0].min()))
         x_max = float(max(on_input_pts[:, 0].max(), off_input_pts[:, 0].max()))
         y_min = float(min(on_input_pts[:, 1].min(), off_input_pts[:, 1].min()))
@@ -153,7 +172,7 @@ def unwarp_nodes(
     recovered = np.empty_like(prenormed_nodes)
     for i, target in enumerate(prenormed_nodes):
         x0 = initial[i].astype(float, copy=True)
-        if optimize_bound_xy_to_map:
+        if bound_xy_to_map:
             x0[:2] = np.clip(x0[:2], lower_bounds[:2], upper_bounds[:2])
 
         def _residual(x: np.ndarray) -> np.ndarray:
@@ -165,10 +184,10 @@ def _residual(x: np.ndarray) -> np.ndarray:
             x0=x0,
             bounds=(lower_bounds, upper_bounds),
             method="trf",
-            max_nfev=int(optimize_max_evals_per_point),
-            ftol=float(optimize_convergence_tol),
-            xtol=float(optimize_convergence_tol),
-            gtol=float(optimize_convergence_tol),
+            max_nfev=int(max_evals_per_point),
+            ftol=float(convergence_tol),
+            xtol=float(convergence_tol),
+            gtol=float(convergence_tol),
         )
         recovered[i] = sol.x
 
diff --git a/tests/test_unwarper.py b/tests/test_unwarper.py
index 8fa2a98..42149db 100644
--- a/tests/test_unwarper.py
+++ b/tests/test_unwarper.py
@@ -104,21 +104,75 @@ def test_unwarp_nodes_roundtrip_with_identity_surface_mapping():
     recovered = unwarp_nodes(
         normalized,
         mapping,
+    )
+
+    assert np.allclose(recovered, nodes, rtol=1e-6, atol=1e-6)
+
+
+def test_unwarp_nodes_can_infer_median_depths_from_mapping():
+    rng = np.random.default_rng(3)
+    mapping = _identity_surface_mapping()
+
+    nodes = np.empty((80, 3), dtype=float)
+    nodes[:, 0] = rng.uniform(6.0, 18.0, size=80)
+    nodes[:, 1] = rng.uniform(6.0, 18.0, size=80)
+    nodes[:, 2] = rng.uniform(0.0, 10.0, size=80)
+
+    warped, med_z_on, med_z_off = warp_nodes(nodes, mapping)
+    normalized = normalize_nodes(
+        warped,
         med_z_on=med_z_on,
         med_z_off=med_z_off,
         on_sac_pos=0.0,
         off_sac_pos=12.0,
     )
-    recovered_from_prenormed = unwarp_nodes(
-        warped,
+
+    # med_z_on / med_z_off omitted: inferred from surface_mapping.
+    recovered = unwarp_nodes(
+        normalized,
         mapping,
+    )
+
+    assert np.allclose(recovered, nodes, rtol=1e-6, atol=1e-6)
+
+
+def test_unwarp_nodes_supports_custom_sac_positions():
+    rng = np.random.default_rng(4)
+    mapping = _identity_surface_mapping()
+
+    nodes = np.empty((120, 3), dtype=float)
+    nodes[:, 0] = rng.uniform(6.0, 18.0, size=120)
+    nodes[:, 1] = rng.uniform(6.0, 18.0, size=120)
+    nodes[:, 2] = rng.uniform(0.0, 10.0, size=120)
+
+    warped, med_z_on, med_z_off = warp_nodes(nodes, mapping)
+    on_sac_pos, off_sac_pos = -3.0, 21.5
+    normalized = normalize_nodes(
+        warped,
         med_z_on=med_z_on,
         med_z_off=med_z_off,
-        prenormalized=True,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
     )
 
-    assert np.allclose(recovered, nodes, rtol=1e-6, atol=1e-6)
-    assert np.allclose(recovered_from_prenormed, nodes, rtol=1e-6, atol=1e-6)
+    recovered_local = unwarp_nodes(
+        normalized,
+        mapping,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+    )
+    recovered_opt = unwarp_nodes(
+        normalized,
+        mapping,
+        method="optimize",
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+        max_evals_per_point=60,
+        convergence_tol=1e-9,
+    )
+
+    assert np.allclose(recovered_local, nodes, rtol=1e-6, atol=1e-6)
+    assert np.allclose(recovered_opt, nodes, rtol=1e-6, atol=1e-6)
 
 
 def test_unwarp_nodes_optimize_refines_nontrivial_mapping():
@@ -132,25 +186,25 @@ def test_unwarp_nodes_optimize_refines_nontrivial_mapping():
     nodes[:, 2] = rng.uniform(-120.0, 180.0, size=80)
 
     warped, med_z_on, med_z_off = warp_nodes(nodes, mapping)
-
-    recovered_local = unwarp_nodes(
+    normalized = normalize_nodes(
         warped,
-        mapping,
         med_z_on=med_z_on,
         med_z_off=med_z_off,
-        prenormalized=True,
-        method="local_ls",
+        on_sac_pos=0.0,
+        off_sac_pos=12.0,
+    )
+
+    recovered_local = unwarp_nodes(
+        normalized,
+        mapping,
     )
     recovered_opt = unwarp_nodes(
-        warped,
+        normalized,
         mapping,
-        med_z_on=med_z_on,
-        med_z_off=med_z_off,
-        prenormalized=True,
         method="optimize",
-        optimize_max_evals_per_point=80,
-        optimize_convergence_tol=1e-9,
-        optimize_bound_xy_to_map=True,
+        max_evals_per_point=80,
+        convergence_tol=1e-9,
+        bound_xy_to_map=True,
     )
 
     local_err = np.linalg.norm(recovered_local - nodes, axis=1)
@@ -160,20 +214,40 @@ def test_unwarp_nodes_optimize_refines_nontrivial_mapping():
     assert np.quantile(opt_err, 0.95) < 1e-6
 
     rewarped_opt, _, _ = warp_nodes(recovered_opt, mapping)
-    assert np.allclose(rewarped_opt, warped, rtol=1e-8, atol=1e-8)
+    renorm_opt = normalize_nodes(
+        rewarped_opt,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        on_sac_pos=0.0,
+        off_sac_pos=12.0,
+    )
+    assert np.allclose(renorm_opt, normalized, rtol=1e-8, atol=1e-8)
 
 
-def test_unwarp_nodes_invalid_method_raises():
+def test_unwarp_nodes_optimize_invalid_params_raise():
     mapping = _identity_surface_mapping()
     nodes = np.array([[10.0, 10.0, 5.0]], dtype=float)
     warped, med_z_on, med_z_off = warp_nodes(nodes, mapping)
+    normalized = normalize_nodes(
+        warped,
+        med_z_on=med_z_on,
+        med_z_off=med_z_off,
+        on_sac_pos=0.0,
+        off_sac_pos=12.0,
+    )
+
+    with pytest.raises(ValueError, match="max_evals_per_point"):
+        unwarp_nodes(
+            normalized,
+            mapping,
+            method="optimize",
+            max_evals_per_point=0,
+        )
 
-    with pytest.raises(ValueError, match="method"):
+    with pytest.raises(ValueError, match="convergence_tol"):
         unwarp_nodes(
-            warped,
+            normalized,
             mapping,
-            med_z_on=med_z_on,
-            med_z_off=med_z_off,
-            prenormalized=True,
-            method="unknown",
+            method="optimize",
+            convergence_tol=0.0,
         )

From 795d79787f0214bee6f7fac01ee73dcb2e305f28 Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Mon, 16 Feb 2026 16:07:29 +0100
Subject: [PATCH 7/8] add: unwarp_skeleton

---
 notebooks/example.api.high.ipynb |  16 +--
 notebooks/example.api.low.ipynb  | 215 +------------------------------
 notebooks/example.unwarp.ipynb   |  88 +++++++++++++
 pywarper/unwarper.py             | 102 +++++++++++++++
 tests/test_unwarper.py           | 130 ++++++++++++++++++-
 5 files changed, 333 insertions(+), 218 deletions(-)
 create mode 100644 notebooks/example.unwarp.ipynb

diff --git a/notebooks/example.api.high.ipynb b/notebooks/example.api.high.ipynb
index f8d4307..98d7ada 100644
--- a/notebooks/example.api.high.ipynb
+++ b/notebooks/example.api.high.ipynb
@@ -83,7 +83,7 @@
     {
      "data": {
       "text/plain": [
-       "<pywarper.warpers.Warper at 0x117b80ad0>"
+       "<pywarper.warpers.Warper at 0x116e40ad0>"
       ]
      },
      "execution_count": 4,
@@ -115,15 +115,15 @@
      "text": [
       "[pywarper] Building mapping …\n",
       "↳ mapping ON (min) surface …\n",
-      "    done in 0.06 seconds.\n",
+      "    done in 0.08 seconds.\n",
       "↳ mapping OFF (max) surface …\n",
-      "    done in 0.05 seconds.\n"
+      "    done in 0.07 seconds.\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "<pywarper.warpers.Warper at 0x117b80ad0>"
+       "<pywarper.warpers.Warper at 0x116e40ad0>"
       ]
      },
      "execution_count": 5,
@@ -152,14 +152,14 @@
      "output_type": "stream",
      "text": [
       "[pywarper] Warping skeleton...\n",
-      "    done in 0.32 seconds.\n",
+      "    done in 0.38 seconds.\n",
       "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "<pywarper.warpers.Warper at 0x117b80ad0>"
+       "<pywarper.warpers.Warper at 0x116e40ad0>"
       ]
      },
      "execution_count": 6,
@@ -335,7 +335,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x117c191d0>"
+       "<matplotlib.legend.Legend at 0x1170d11d0>"
       ]
      },
      "execution_count": 9,
@@ -405,7 +405,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Last updated: 2026-02-12 13:43:42 CET\n",
+      "Last updated: 2026-02-16 16:06:41 CET\n",
       "\n",
       "Python implementation: CPython\n",
       "Python version       : 3.13.11\n",
diff --git a/notebooks/example.api.low.ipynb b/notebooks/example.api.low.ipynb
index fea216e..5c3b9cb 100644
--- a/notebooks/example.api.low.ipynb
+++ b/notebooks/example.api.low.ipynb
@@ -17,8 +17,7 @@
     "from pywarper.warpers import warp_nodes, normalize_nodes, warp_skeleton\n",
     "from pywarper.stats import get_convex_hull, get_hull_centroid, get_xy_center_of_mass\n",
     "from pywarper.utils import read_sumbul_et_al_chat_bands\n",
-    "\n",
-    "from pywarper.unwarper import unwarp_nodes"
+    "\n"
    ]
   },
   {
@@ -70,9 +69,9 @@
      "output_type": "stream",
      "text": [
       "↳ mapping ON (min) surface …\n",
-      "    done in 0.02 seconds.\n",
+      "    done in 0.01 seconds.\n",
       "↳ mapping OFF (max) surface …\n",
-      "    done in 0.02 seconds.\n"
+      "    done in 0.01 seconds.\n"
      ]
     }
    ],
@@ -93,7 +92,7 @@
      "output_type": "stream",
      "text": [
       "[pywarper] Warping skeleton...\n",
-      "    done in 0.39 seconds.\n",
+      "    done in 0.36 seconds.\n",
       "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
      ]
     }
@@ -269,7 +268,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x1190dd310>"
+       "<matplotlib.legend.Legend at 0x117041310>"
       ]
      },
      "execution_count": 8,
@@ -331,207 +330,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "5bfbb928",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Skeleton local_ls error (mean / p95 / max): 0.0060 / 0.0257 / 0.0664\n",
-      "Skeleton optimize error on subset (mean / p95 / max): 5.2062e-04 / 1.9949e-03 / 2.6957e-02\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 720x520 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# unwarp demo (step 1): warped skeleton -> original space\n",
-    "# --------------------------------------------------------------------------- #\n",
-    "# Unwarp warped skeleton nodes back to the original coordinate frame.\n",
-    "# Compare the recovered nodes to the original skeleton nodes in XZ.\n",
-    "\n",
-    "warped_nodes_norm = warped_skeleton.nodes\n",
-    "med_z_on = warped_skeleton.extra[\"med_z_on\"]\n",
-    "med_z_off = warped_skeleton.extra[\"med_z_off\"]\n",
-    "\n",
-    "# option 1: fast approximate inverse (all nodes)\n",
-    "unwarped_skel_local = unwarp_nodes(\n",
-    "    warped_nodes_norm,\n",
-    "    surface_mapping,\n",
-    "    on_sac_pos=0,\n",
-    "    off_sac_pos=12,\n",
-    "    conformal_jump=2,\n",
-    ")\n",
-    "\n",
-    "# option 2: inverse-by-optimization (iterative; use subset for notebook speed)\n",
-    "opt_idx = np.arange(0, len(warped_nodes_norm), 20)\n",
-    "unwarped_skel_opt = unwarp_nodes(\n",
-    "    warped_nodes_norm[opt_idx],\n",
-    "    surface_mapping,\n",
-    "    conformal_jump=2,\n",
-    "    method=\"optimize\",\n",
-    "    max_evals_per_point=100,\n",
-    "    convergence_tol=1e-9,\n",
-    "    bound_xy_to_map=True,\n",
-    ")\n",
-    "\n",
-    "err_skel_local = np.linalg.norm(unwarped_skel_local - skel.nodes, axis=1)\n",
-    "err_skel_opt = np.linalg.norm(unwarped_skel_opt - skel.nodes[opt_idx], axis=1)\n",
-    "\n",
-    "print(\"Skeleton local_ls error (mean / p95 / max):\", \n",
-    "      f\"{err_skel_local.mean():.4f} / {np.quantile(err_skel_local, 0.95):.4f} / {err_skel_local.max():.4f}\")\n",
-    "print(\"Skeleton optimize error on subset (mean / p95 / max):\", \n",
-    "      f\"{err_skel_opt.mean():.4e} / {np.quantile(err_skel_opt, 0.95):.4e} / {err_skel_opt.max():.4e}\")\n",
-    "\n",
-    "fig, ax = plt.subplots(figsize=(7.2, 5.2))\n",
-    "\n",
-    "# background context: all original nodes\n",
-    "ax.scatter(\n",
-    "    skel.nodes[:, 0], skel.nodes[:, 2],\n",
-    "    s=2, alpha=0.12, c='0.65', label='original (all)', zorder=1,\n",
-    ")\n",
-    "\n",
-    "# compare all methods on the same subset so marker overlap is readable\n",
-    "ax.scatter(\n",
-    "    skel.nodes[opt_idx, 0], skel.nodes[opt_idx, 2],\n",
-    "    s=34, facecolors='none', edgecolors='black', linewidths=0.9,\n",
-    "    label='original (subset)', zorder=2,\n",
-    ")\n",
-    "ax.scatter(\n",
-    "    unwarped_skel_local[opt_idx, 0], unwarped_skel_local[opt_idx, 2],\n",
-    "    s=28, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n",
-    "    label='unwarp local_ls (subset)', zorder=3,\n",
-    ")\n",
-    "ax.scatter(\n",
-    "    unwarped_skel_opt[:, 0], unwarped_skel_opt[:, 2],\n",
-    "    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n",
-    "    label='unwarp optimize (subset)', zorder=4,\n",
-    ")\n",
-    "\n",
-    "ax.set_title('Step 1 (XZ): original vs unwrapped skeleton')\n",
-    "ax.set_xlabel('X (μm)')\n",
-    "ax.set_ylabel('Z (μm)')\n",
-    "ax.legend(frameon=False, loc='best')\n",
-    "fig.tight_layout()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "2304b538",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Annotation local_ls error (mean / p95 / max): 0.0389 / 0.1822 / 1.0539\n",
-      "Annotation optimize error (mean / p95 / max): 1.7260e-12 / 6.7212e-12 / 1.0847e-10\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 720x520 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# unwarp demo (step 2): annotated coordinates not on skeleton\n",
-    "# --------------------------------------------------------------------------- #\n",
-    "# Simulate annotations in warped space from arbitrary coordinates that are\n",
-    "# within mapping XY bounds but not constrained to skeleton nodes.\n",
-    "# Compare recovered coordinates in XZ.\n",
-    "\n",
-    "rng = np.random.default_rng(7)\n",
-    "n_annotations = 220\n",
-    "\n",
-    "x_min = float(surface_mapping[\"sampled_x_idx\"].min())\n",
-    "x_max = float(surface_mapping[\"sampled_x_idx\"].max())\n",
-    "y_min = float(surface_mapping[\"sampled_y_idx\"].min())\n",
-    "y_max = float(surface_mapping[\"sampled_y_idx\"].max())\n",
-    "\n",
-    "# synthetic ground truth coordinates (not on original skeleton)\n",
-    "annot_orig = np.column_stack([\n",
-    "    rng.uniform(x_min + 2, x_max - 2, size=n_annotations),\n",
-    "    rng.uniform(y_min + 2, y_max - 2, size=n_annotations),\n",
-    "    rng.uniform(skel.nodes[:, 2].min() - 30, skel.nodes[:, 2].max() + 30, size=n_annotations),\n",
-    "])\n",
-    "\n",
-    "# these are the coordinates that would be annotated in warped space\n",
-    "annot_prenorm, _, _ = warp_nodes(annot_orig, surface_mapping, conformal_jump=2)\n",
-    "annot_warped = normalize_nodes(\n",
-    "    annot_prenorm,\n",
-    "    med_z_on=med_z_on,\n",
-    "    med_z_off=med_z_off,\n",
-    ")\n",
-    "\n",
-    "annot_unwarped_local = unwarp_nodes(\n",
-    "    annot_warped,\n",
-    "    surface_mapping,\n",
-    "    conformal_jump=2,\n",
-    ")\n",
-    "annot_unwarped_opt = unwarp_nodes(\n",
-    "    annot_warped,\n",
-    "    surface_mapping,\n",
-    "    conformal_jump=2,\n",
-    "    method=\"optimize\",\n",
-    "    max_evals_per_point=100,\n",
-    "    convergence_tol=1e-9,\n",
-    "    bound_xy_to_map=True,\n",
-    ")\n",
-    "\n",
-    "err_ann_local = np.linalg.norm(annot_unwarped_local - annot_orig, axis=1)\n",
-    "err_ann_opt = np.linalg.norm(annot_unwarped_opt - annot_orig, axis=1)\n",
-    "\n",
-    "print(\"Annotation local_ls error (mean / p95 / max):\", \n",
-    "      f\"{err_ann_local.mean():.4f} / {np.quantile(err_ann_local, 0.95):.4f} / {err_ann_local.max():.4f}\")\n",
-    "print(\"Annotation optimize error (mean / p95 / max):\", \n",
-    "      f\"{err_ann_opt.mean():.4e} / {np.quantile(err_ann_opt, 0.95):.4e} / {err_ann_opt.max():.4e}\")\n",
-    "\n",
-    "fig, ax = plt.subplots(figsize=(7.2, 5.2))\n",
-    "\n",
-    "# marker stacking for readability at overlapping coordinates\n",
-    "ax.scatter(\n",
-    "    annot_orig[:, 0], annot_orig[:, 2],\n",
-    "    s=40, facecolors='none', edgecolors='black', linewidths=0.9,\n",
-    "    alpha=0.7, label='original annotations (demo GT)', zorder=2,\n",
-    ")\n",
-    "ax.scatter(\n",
-    "    annot_unwarped_local[:, 0], annot_unwarped_local[:, 2],\n",
-    "    s=32, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n",
-    "    alpha=0.8, label='unwarp local_ls', zorder=3,\n",
-    ")\n",
-    "ax.scatter(\n",
-    "    annot_unwarped_opt[:, 0], annot_unwarped_opt[:, 2],\n",
-    "    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n",
-    "    alpha=0.95, label='unwarp optimize', zorder=4,\n",
-    ")\n",
-    "\n",
-    "ax.set_title('Step 2 (XZ): annotation points')\n",
-    "ax.set_xlabel('X (μm)')\n",
-    "ax.set_ylabel('Z (μm)')\n",
-    "ax.legend(frameon=False, loc='best')\n",
-    "fig.tight_layout()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 9,
    "id": "48ec81d6",
    "metadata": {},
    "outputs": [
@@ -539,7 +338,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Last updated: 2026-02-12 14:55:39 CET\n",
+      "Last updated: 2026-02-16 16:06:33 CET\n",
       "\n",
       "Python implementation: CPython\n",
       "Python version       : 3.13.11\n",
diff --git a/notebooks/example.unwarp.ipynb b/notebooks/example.unwarp.ipynb
new file mode 100644
index 0000000..dc8fcfa
--- /dev/null
+++ b/notebooks/example.unwarp.ipynb
@@ -0,0 +1,88 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "import numpy as np\nimport skeliner as sk\nimport matplotlib.pyplot as plt\n\nfrom pywarper.surface import fit_sac_surface, build_mapping\nfrom pywarper.warpers import warp_nodes, normalize_nodes, warp_skeleton\nfrom pywarper.utils import read_sumbul_et_al_chat_bands\nfrom pywarper.unwarper import unwarp_nodes, unwarp_skeleton\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "# data from Sümbül et al. 2014\n# https://github.com/uygarsumbul/rgc\nchat_top = read_sumbul_et_al_chat_bands(\"../tests/data/Image013-009_01_ChAT-TopBand-Mike.txt\", unit=\"physical\") # should be the off sac layer\nchat_bottom = read_sumbul_et_al_chat_bands(\"../tests/data/Image013-009_01_ChAT-BottomBand-Mike.txt\", unit=\"physical\") # should be the on sac layer\n# but the image can be flipped\nif chat_top[\"z\"].mean() > chat_bottom[\"z\"].mean():\n    off_sac = chat_top\n    on_sac = chat_bottom\nelse:\n    off_sac = chat_bottom\n    on_sac = chat_top\n\nskel = sk.io.load_swc(\"../tests/data/Image013-009_01_raw_latest_Uygar.swc\")\n# in the original matlab code, all data were in voxel space and converted to microns at the end\n# but it makes more sense to work in microns from the beginning, so that there will be fewer unit conversion in between\nvoxel_resolution = np.array([0.4, 0.4, 0.5])  # in microns\nskel.nodes *= voxel_resolution\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "# Fit surfaces with pygridfit under the hood\noff_sac_surface, xgridmax, ygridmax = fit_sac_surface(x=off_sac['x'], y=off_sac['y'], z=off_sac['z'], smoothness=15)\non_sac_surface,  xgridmin, ygridmin = fit_sac_surface(x=on_sac['x'], y=on_sac['y'], z=on_sac['z'], smoothness=15)\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "# fit quasi-conformally mapping\narbor_boundaries = np.array([skel.nodes[:, 0].min(), skel.nodes[:, 0].max(), skel.nodes[:, 1].min(), skel.nodes[:, 1].max()])\nsurface_mapping = build_mapping(on_sac_surface, off_sac_surface, arbor_boundaries, conformal_jump=2, n_anchors=16, verbose=True)\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "# warp the arbor\nwarped_skeleton = warp_skeleton(\n    skel,\n    surface_mapping,\n    conformal_jump=2,\n    z_profile_extent=[-25, 25], # the limits of the z profile, if None, it will be inferred.\n    z_profile_bin_size=1., #  bin size (μm) in the z profile.\n    z_profile_hdr_mass=0.95, # the mass of the histogram to be used for the z profile.\n    xy_profile_extents=None, # the limits of the xy profile, if None, it will be inferred.\n    xy_profile_bin_size=20., # bin size (μm) in the xy profile.\n    verbose=True,\n)\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "# unwarp demo (step 1): unwarp_nodes on warped skeleton nodes\n# --------------------------------------------------------------------------- #\n# Unwarp warped skeleton nodes back to the original coordinate frame.\n# Compare the recovered nodes to the original skeleton nodes in XZ.\n\nwarped_nodes_norm = warped_skeleton.nodes\nmed_z_on = warped_skeleton.extra[\"med_z_on\"]\nmed_z_off = warped_skeleton.extra[\"med_z_off\"]\n\n# option 1: fast approximate inverse (all nodes)\nunwarped_skel_local = unwarp_nodes(\n    warped_nodes_norm,\n    surface_mapping,\n    on_sac_pos=0,\n    off_sac_pos=12,\n    conformal_jump=2,\n)\n\n# option 2: inverse-by-optimization (iterative; use subset for notebook speed)\nopt_idx = np.arange(0, len(warped_nodes_norm), 20)\nunwarped_skel_opt = unwarp_nodes(\n    warped_nodes_norm[opt_idx],\n    surface_mapping,\n    on_sac_pos=0,\n    off_sac_pos=12,\n    conformal_jump=2,\n    method=\"optimize\",\n    max_evals_per_point=100,\n    convergence_tol=1e-9,\n    bound_xy_to_map=True,\n)\n\nerr_skel_local = np.linalg.norm(unwarped_skel_local - skel.nodes, axis=1)\nerr_skel_opt = np.linalg.norm(unwarped_skel_opt - skel.nodes[opt_idx], axis=1)\n\nprint(\"Skeleton local_ls error (mean / p95 / max):\", \n      f\"{err_skel_local.mean():.4f} / {np.quantile(err_skel_local, 0.95):.4f} / {err_skel_local.max():.4f}\")\nprint(\"Skeleton optimize error on subset (mean / p95 / max):\", \n      f\"{err_skel_opt.mean():.4e} / {np.quantile(err_skel_opt, 0.95):.4e} / {err_skel_opt.max():.4e}\")\n\nfig, ax = plt.subplots(figsize=(7.2, 5.2))\n\n# background context: all original nodes\nax.scatter(\n    skel.nodes[:, 0], skel.nodes[:, 2],\n    s=2, alpha=0.12, c='0.65', label='original (all)', zorder=1,\n)\n\n# compare all methods on the same subset so marker overlap is readable\nax.scatter(\n    skel.nodes[opt_idx, 0], skel.nodes[opt_idx, 2],\n    s=34, facecolors='none', edgecolors='black', linewidths=0.9,\n    label='original (subset)', zorder=2,\n)\nax.scatter(\n    unwarped_skel_local[opt_idx, 0], unwarped_skel_local[opt_idx, 2],\n    s=28, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n    label='unwarp_nodes local_ls (subset)', zorder=3,\n)\nax.scatter(\n    unwarped_skel_opt[:, 0], unwarped_skel_opt[:, 2],\n    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n    label='unwarp_nodes optimize (subset)', zorder=4,\n)\n\nax.set_title('Step 1 (XZ): original vs unwrapped nodes')\nax.set_xlabel('X (μm)')\nax.set_ylabel('Z (μm)')\nax.legend(frameon=False, loc='best')\nfig.tight_layout()\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "# unwarp demo (step 2): unwarp_nodes on annotation-like coordinates\n# --------------------------------------------------------------------------- #\n# Simulate annotations in warped space from arbitrary coordinates that are\n# within mapping XY bounds but not constrained to skeleton nodes.\n# Compare recovered coordinates in XZ.\n\nrng = np.random.default_rng(7)\nn_annotations = 220\n\nx_min = float(surface_mapping[\"sampled_x_idx\"].min())\nx_max = float(surface_mapping[\"sampled_x_idx\"].max())\ny_min = float(surface_mapping[\"sampled_y_idx\"].min())\ny_max = float(surface_mapping[\"sampled_y_idx\"].max())\n\n# synthetic ground truth coordinates (not on original skeleton)\nannot_orig = np.column_stack([\n    rng.uniform(x_min + 2, x_max - 2, size=n_annotations),\n    rng.uniform(y_min + 2, y_max - 2, size=n_annotations),\n    rng.uniform(skel.nodes[:, 2].min() - 30, skel.nodes[:, 2].max() + 30, size=n_annotations),\n])\n\n# these are the coordinates that would be annotated in warped space\nannot_prenorm, _, _ = warp_nodes(annot_orig, surface_mapping, conformal_jump=2)\nannot_warped = normalize_nodes(\n    annot_prenorm,\n    med_z_on=med_z_on,\n    med_z_off=med_z_off,\n)\n\nannot_unwarped_local = unwarp_nodes(\n    annot_warped,\n    surface_mapping,\n    conformal_jump=2,\n)\nannot_unwarped_opt = unwarp_nodes(\n    annot_warped,\n    surface_mapping,\n    conformal_jump=2,\n    method=\"optimize\",\n    max_evals_per_point=100,\n    convergence_tol=1e-9,\n    bound_xy_to_map=True,\n)\n\nerr_ann_local = np.linalg.norm(annot_unwarped_local - annot_orig, axis=1)\nerr_ann_opt = np.linalg.norm(annot_unwarped_opt - annot_orig, axis=1)\n\nprint(\"Annotation local_ls error (mean / p95 / max):\", \n      f\"{err_ann_local.mean():.4f} / {np.quantile(err_ann_local, 0.95):.4f} / {err_ann_local.max():.4f}\")\nprint(\"Annotation optimize error (mean / p95 / max):\", \n      f\"{err_ann_opt.mean():.4e} / {np.quantile(err_ann_opt, 0.95):.4e} / {err_ann_opt.max():.4e}\")\n\nfig, ax = plt.subplots(figsize=(7.2, 5.2))\n\n# marker stacking for readability at overlapping coordinates\nax.scatter(\n    annot_orig[:, 0], annot_orig[:, 2],\n    s=40, facecolors='none', edgecolors='black', linewidths=0.9,\n    alpha=0.7, label='original annotations (demo GT)', zorder=2,\n)\nax.scatter(\n    annot_unwarped_local[:, 0], annot_unwarped_local[:, 2],\n    s=32, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n    alpha=0.8, label='unwarp_nodes local_ls', zorder=3,\n)\nax.scatter(\n    annot_unwarped_opt[:, 0], annot_unwarped_opt[:, 2],\n    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n    alpha=0.95, label='unwarp_nodes optimize', zorder=4,\n)\n\nax.set_title('Step 2 (XZ): annotation points')\nax.set_xlabel('X (μm)')\nax.set_ylabel('Z (μm)')\nax.legend(frameon=False, loc='best')\nfig.tight_layout()\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "# unwarp demo (step 3): unwarp_skeleton (object-level API)\n# --------------------------------------------------------------------------- #\n# `unwarp_skeleton` inverts `warp_skeleton` directly on Skeleton objects.\n# If `warp_skeleton` used voxel_resolution/skeleton_nodes_scale, pass the same values here.\n\nunwarped_skeleton = unwarp_skeleton(\n    warped_skeleton,\n    surface_mapping,\n    on_sac_pos=0,\n    off_sac_pos=12,\n    conformal_jump=2,\n    method=\"local_ls\",\n)\n\nerr_obj = np.linalg.norm(unwarped_skeleton.nodes - skel.nodes, axis=1)\nprint(\"unwarp_skeleton local_ls error (mean / p95 / max):\", \n      f\"{err_obj.mean():.4f} / {np.quantile(err_obj, 0.95):.4f} / {err_obj.max():.4f}\")\n\nfig, ax = plt.subplots(figsize=(7.2, 5.2))\nax.scatter(\n    skel.nodes[:, 0], skel.nodes[:, 2],\n    s=2, alpha=0.20, c='black', label='original skeleton',\n)\nax.scatter(\n    unwarped_skeleton.nodes[:, 0], unwarped_skeleton.nodes[:, 2],\n    s=2, alpha=0.20, c='C3', label='unwarp_skeleton local_ls',\n)\nax.set_title('Step 3 (XZ): object-level unwarping')\nax.set_xlabel('X (μm)')\nax.set_ylabel('Z (μm)')\nax.legend(frameon=False, markerscale=4)\nfig.tight_layout()\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "%load_ext watermark\n%watermark --time --date --timezone --updated --python --iversions --watermark\n"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pywarper",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pywarper/unwarper.py b/pywarper/unwarper.py
index 90433fa..2da50fb 100644
--- a/pywarper/unwarper.py
+++ b/pywarper/unwarper.py
@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+from copy import deepcopy
+
 import numpy as np
 from scipy.optimize import least_squares
+from skeliner.dataclass import Skeleton
 
 from .utils import build_surface_correspondences, resolve_conformal_jump
 from .warpers import (
@@ -192,3 +195,102 @@ def _residual(x: np.ndarray) -> np.ndarray:
         recovered[i] = sol.x
 
     return recovered
+
+
+def _coerce_voxel_resolution(
+    voxel_resolution: float
+    | list[float | int]
+    | tuple[float | int, float | int, float | int]
+) -> np.ndarray:
+    voxel_res = np.asarray(voxel_resolution, dtype=float)
+    if voxel_res.ndim == 0:
+        voxel_res = np.repeat(voxel_res, 3)
+    if voxel_res.shape != (3,):
+        raise ValueError("voxel_resolution must be a scalar or a length-3 sequence.")
+    if np.any(np.isclose(voxel_res, 0.0)):
+        raise ValueError("voxel_resolution entries must be non-zero.")
+    return voxel_res
+
+
+def unwarp_skeleton(
+    skel: Skeleton,
+    surface_mapping: dict,
+    *,
+    voxel_resolution: float
+    | list[float | int]
+    | tuple[float | int, float | int, float | int] = (1.0, 1.0, 1.0),
+    on_sac_pos: float = 0.0,
+    off_sac_pos: float = 12.0,
+    skeleton_nodes_scale: float = 1.0,
+    conformal_jump: int | None = None,
+    backward_compatible: bool = False,
+    method: str = "local_ls",
+    max_evals_per_point: int = 80,
+    convergence_tol: float = 1e-9,
+    bound_xy_to_map: bool = True,
+) -> Skeleton:
+    """
+    Inverse of `warp_skeleton` for Skeleton objects.
+
+    Parameters
+    ----------
+    skel : Skeleton
+        Warped skeleton, typically produced by `warp_skeleton`.
+    surface_mapping : dict
+        Surface mapping used for the forward warp.
+    voxel_resolution : float or length-3 sequence, default=(1.0, 1.0, 1.0)
+        Resolution that was used in `warp_skeleton` to convert warped nodes
+        to physical units. It is undone before node-level inversion.
+    on_sac_pos, off_sac_pos : float
+        SAC reference positions used during normalization in the forward pass.
+    skeleton_nodes_scale : float, default=1.0
+        Scale factor that was used in `warp_skeleton` before warping.
+    conformal_jump, backward_compatible
+        Mapping options forwarded to `unwarp_nodes`.
+    method, max_evals_per_point, convergence_tol, bound_xy_to_map
+        Inversion options forwarded to `unwarp_nodes`.
+
+    Returns
+    -------
+    Skeleton
+        Skeleton with recovered nodes in the original (pre-warp) node units.
+    """
+    scale = float(skeleton_nodes_scale)
+    if np.isclose(scale, 0.0):
+        raise ValueError("skeleton_nodes_scale must be non-zero.")
+
+    voxel_res = _coerce_voxel_resolution(voxel_resolution)
+
+    # `warp_skeleton` stores nodes in physical units, so undo that first.
+    normalized_nodes = np.asarray(skel.nodes, dtype=float) / voxel_res
+    # `warp_skeleton` divides by this scale before returning the skeleton.
+    normalized_nodes *= scale
+
+    recovered_nodes = unwarp_nodes(
+        normalized_nodes,
+        surface_mapping,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+        conformal_jump=conformal_jump,
+        backward_compatible=backward_compatible,
+        method=method,
+        max_evals_per_point=max_evals_per_point,
+        convergence_tol=convergence_tol,
+        bound_xy_to_map=bound_xy_to_map,
+    )
+    recovered_nodes /= scale
+
+    recovered_soma = deepcopy(skel.soma)
+    recovered_soma.center = recovered_nodes[0].copy()
+
+    return Skeleton(
+        soma=recovered_soma,
+        nodes=recovered_nodes,
+        edges=skel.edges,
+        radii=skel.radii,
+        ntype=skel.ntype,
+        node2verts=skel.node2verts,
+        vert2node=skel.vert2node,
+        meta=skel.meta.copy(),
+        extra=skel.extra.copy(),
+    )
diff --git a/tests/test_unwarper.py b/tests/test_unwarper.py
index 42149db..4ab6fb1 100644
--- a/tests/test_unwarper.py
+++ b/tests/test_unwarper.py
@@ -1,8 +1,9 @@
 import numpy as np
 import pytest
+from skeliner.dataclass import Skeleton, Soma
 
-from pywarper.unwarper import denormalize_nodes, unwarp_nodes
-from pywarper.warpers import normalize_nodes, warp_nodes
+from pywarper.unwarper import denormalize_nodes, unwarp_nodes, unwarp_skeleton
+from pywarper.warpers import normalize_nodes, warp_nodes, warp_skeleton
 
 
 def _identity_surface_mapping(nx: int = 25, ny: int = 25) -> dict:
@@ -59,6 +60,45 @@ def _nontrivial_surface_mapping(nx: int = 35, ny: int = 35) -> dict:
     }
 
 
+def _test_skeleton(n_nodes: int = 60, seed: int = 11) -> Skeleton:
+    rng = np.random.default_rng(seed)
+    nodes = np.empty((n_nodes, 3), dtype=float)
+    nodes[:, 0] = rng.uniform(6.0, 18.0, size=n_nodes)
+    nodes[:, 1] = rng.uniform(6.0, 18.0, size=n_nodes)
+    nodes[:, 2] = rng.uniform(0.0, 10.0, size=n_nodes)
+
+    edges = np.column_stack(
+        [np.arange(0, n_nodes - 1, dtype=int), np.arange(1, n_nodes, dtype=int)]
+    )
+    radii_values = rng.uniform(0.1, 1.2, size=n_nodes).astype(float)
+    radii = {
+        "median": radii_values.copy(),
+        "mean": radii_values.copy(),
+        "trim": radii_values.copy(),
+    }
+    ntype = np.ones(n_nodes, dtype=int)
+    soma = Soma(
+        center=nodes[0].copy(),
+        axes=np.array([1.0, 1.0, 1.0], dtype=float),
+        R=np.eye(3, dtype=float),
+        verts=None,
+    )
+    node2verts = [np.array([i], dtype=int) for i in range(n_nodes)]
+    vert2node = {int(i): int(i) for i in range(n_nodes)}
+
+    return Skeleton(
+        soma=soma,
+        nodes=nodes,
+        radii=radii,
+        edges=edges,
+        ntype=ntype,
+        node2verts=node2verts,
+        vert2node=vert2node,
+        meta={"source": "toy_skeleton"},
+        extra={"tag": "toy"},
+    )
+
+
 def test_denormalize_nodes_inverts_normalize_nodes():
     rng = np.random.default_rng(0)
     nodes = rng.uniform(-10.0, 10.0, size=(100, 3))
@@ -251,3 +291,89 @@ def test_unwarp_nodes_optimize_invalid_params_raise():
             method="optimize",
             convergence_tol=0.0,
         )
+
+
+def test_unwarp_skeleton_roundtrip_with_identity_surface_mapping():
+    mapping = _identity_surface_mapping()
+    skel = _test_skeleton(seed=7)
+    voxel_resolution = np.array([0.4, 0.4, 0.5], dtype=float)
+
+    warped = warp_skeleton(
+        skel,
+        mapping,
+        voxel_resolution=voxel_resolution,
+        on_sac_pos=0.0,
+        off_sac_pos=12.0,
+    )
+    recovered = unwarp_skeleton(
+        warped,
+        mapping,
+        voxel_resolution=voxel_resolution,
+        on_sac_pos=0.0,
+        off_sac_pos=12.0,
+    )
+
+    assert np.allclose(recovered.nodes, skel.nodes, rtol=1e-6, atol=1e-6)
+    assert np.allclose(recovered.soma.center, skel.nodes[0], rtol=1e-6, atol=1e-6)
+    assert np.array_equal(recovered.edges, skel.edges)
+    assert np.array_equal(recovered.ntype, skel.ntype)
+    assert recovered.vert2node == skel.vert2node
+    assert recovered.meta == warped.meta
+    assert recovered.extra.keys() == warped.extra.keys()
+    assert np.allclose(
+        recovered.extra["prenormed_nodes"], warped.extra["prenormed_nodes"]
+    )
+    assert recovered.extra["med_z_on"] == warped.extra["med_z_on"]
+    assert recovered.extra["med_z_off"] == warped.extra["med_z_off"]
+    for key in ("median", "mean", "trim"):
+        assert np.array_equal(recovered.radii[key], skel.radii[key])
+    for i in range(len(skel.node2verts)):
+        assert np.array_equal(recovered.node2verts[i], skel.node2verts[i])
+
+
+def test_unwarp_skeleton_optimize_roundtrip_with_scaling():
+    rng = np.random.default_rng(17)
+    mapping = _nontrivial_surface_mapping()
+    skel = _test_skeleton(n_nodes=50, seed=13)
+    skel.nodes[:, 0] = rng.uniform(5.0, 12.0, size=len(skel.nodes))
+    skel.nodes[:, 1] = rng.uniform(5.0, 12.0, size=len(skel.nodes))
+    skel.nodes[:, 2] = rng.uniform(-120.0, 180.0, size=len(skel.nodes))
+    skel.soma.center = skel.nodes[0].copy()
+
+    voxel_resolution = np.array([0.4, 0.4, 0.5], dtype=float)
+    on_sac_pos, off_sac_pos = -3.0, 21.5
+    skeleton_nodes_scale = 2.0
+
+    warped = warp_skeleton(
+        skel,
+        mapping,
+        voxel_resolution=voxel_resolution,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+        skeleton_nodes_scale=skeleton_nodes_scale,
+    )
+    recovered = unwarp_skeleton(
+        warped,
+        mapping,
+        voxel_resolution=voxel_resolution,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+        skeleton_nodes_scale=skeleton_nodes_scale,
+        method="optimize",
+        max_evals_per_point=80,
+        convergence_tol=1e-9,
+        bound_xy_to_map=True,
+    )
+
+    err = np.linalg.norm(recovered.nodes - skel.nodes, axis=1)
+    assert np.quantile(err, 0.95) < 1e-6
+
+    rewarped = warp_skeleton(
+        recovered,
+        mapping,
+        voxel_resolution=voxel_resolution,
+        on_sac_pos=on_sac_pos,
+        off_sac_pos=off_sac_pos,
+        skeleton_nodes_scale=skeleton_nodes_scale,
+    )
+    assert np.allclose(rewarped.nodes, warped.nodes, rtol=1e-8, atol=1e-8)

From bea7fc05817235a542eb78bbbb9888c18b0d129c Mon Sep 17 00:00:00 2001
From: Ziwei Huang <huang-ziwei@outlook.com>
Date: Mon, 16 Feb 2026 16:26:24 +0100
Subject: [PATCH 8/8] update: example.unwarp.ipynb

---
 notebooks/example.unwarp.ipynb | 377 ++++++++++++++++++++++++++++++---
 1 file changed, 353 insertions(+), 24 deletions(-)

diff --git a/notebooks/example.unwarp.ipynb b/notebooks/example.unwarp.ipynb
index dc8fcfa..762cde0 100644
--- a/notebooks/example.unwarp.ipynb
+++ b/notebooks/example.unwarp.ipynb
@@ -2,66 +2,395 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
-   "source": "import numpy as np\nimport skeliner as sk\nimport matplotlib.pyplot as plt\n\nfrom pywarper.surface import fit_sac_surface, build_mapping\nfrom pywarper.warpers import warp_nodes, normalize_nodes, warp_skeleton\nfrom pywarper.utils import read_sumbul_et_al_chat_bands\nfrom pywarper.unwarper import unwarp_nodes, unwarp_skeleton\n"
+   "source": [
+    "import numpy as np\n",
+    "import skeliner as sk\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from pywarper.surface import fit_sac_surface, build_mapping\n",
+    "from pywarper.warpers import warp_nodes, normalize_nodes, warp_skeleton\n",
+    "from pywarper.utils import read_sumbul_et_al_chat_bands\n",
+    "from pywarper.unwarper import unwarp_nodes, unwarp_skeleton\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
-   "source": "# data from Sümbül et al. 2014\n# https://github.com/uygarsumbul/rgc\nchat_top = read_sumbul_et_al_chat_bands(\"../tests/data/Image013-009_01_ChAT-TopBand-Mike.txt\", unit=\"physical\") # should be the off sac layer\nchat_bottom = read_sumbul_et_al_chat_bands(\"../tests/data/Image013-009_01_ChAT-BottomBand-Mike.txt\", unit=\"physical\") # should be the on sac layer\n# but the image can be flipped\nif chat_top[\"z\"].mean() > chat_bottom[\"z\"].mean():\n    off_sac = chat_top\n    on_sac = chat_bottom\nelse:\n    off_sac = chat_bottom\n    on_sac = chat_top\n\nskel = sk.io.load_swc(\"../tests/data/Image013-009_01_raw_latest_Uygar.swc\")\n# in the original matlab code, all data were in voxel space and converted to microns at the end\n# but it makes more sense to work in microns from the beginning, so that there will be fewer unit conversion in between\nvoxel_resolution = np.array([0.4, 0.4, 0.5])  # in microns\nskel.nodes *= voxel_resolution\n"
+   "source": [
+    "# data from Sümbül et al. 2014\n",
+    "# https://github.com/uygarsumbul/rgc\n",
+    "chat_top = read_sumbul_et_al_chat_bands(\"../tests/data/Image013-009_01_ChAT-TopBand-Mike.txt\", unit=\"physical\") # should be the off sac layer\n",
+    "chat_bottom = read_sumbul_et_al_chat_bands(\"../tests/data/Image013-009_01_ChAT-BottomBand-Mike.txt\", unit=\"physical\") # should be the on sac layer\n",
+    "# but the image can be flipped\n",
+    "if chat_top[\"z\"].mean() > chat_bottom[\"z\"].mean():\n",
+    "    off_sac = chat_top\n",
+    "    on_sac = chat_bottom\n",
+    "else:\n",
+    "    off_sac = chat_bottom\n",
+    "    on_sac = chat_top\n",
+    "\n",
+    "skel = sk.io.load_swc(\"../tests/data/Image013-009_01_raw_latest_Uygar.swc\")\n",
+    "# in the original matlab code, all data were in voxel space and converted to microns at the end\n",
+    "# but it makes more sense to work in microns from the beginning, so that there will be fewer unit conversion in between\n",
+    "voxel_resolution = np.array([0.4, 0.4, 0.5])  # in microns\n",
+    "skel.nodes *= voxel_resolution\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
-   "source": "# Fit surfaces with pygridfit under the hood\noff_sac_surface, xgridmax, ygridmax = fit_sac_surface(x=off_sac['x'], y=off_sac['y'], z=off_sac['z'], smoothness=15)\non_sac_surface,  xgridmin, ygridmin = fit_sac_surface(x=on_sac['x'], y=on_sac['y'], z=on_sac['z'], smoothness=15)\n"
+   "source": [
+    "# Fit surfaces with pygridfit under the hood\n",
+    "off_sac_surface, xgridmax, ygridmax = fit_sac_surface(x=off_sac['x'], y=off_sac['y'], z=off_sac['z'], smoothness=15)\n",
+    "on_sac_surface,  xgridmin, ygridmin = fit_sac_surface(x=on_sac['x'], y=on_sac['y'], z=on_sac['z'], smoothness=15)\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
-   "source": "# fit quasi-conformally mapping\narbor_boundaries = np.array([skel.nodes[:, 0].min(), skel.nodes[:, 0].max(), skel.nodes[:, 1].min(), skel.nodes[:, 1].max()])\nsurface_mapping = build_mapping(on_sac_surface, off_sac_surface, arbor_boundaries, conformal_jump=2, n_anchors=16, verbose=True)\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "↳ mapping ON (min) surface …\n",
+      "    done in 0.02 seconds.\n",
+      "↳ mapping OFF (max) surface …\n",
+      "    done in 0.02 seconds.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# fit quasi-conformally mapping\n",
+    "arbor_boundaries = np.array([skel.nodes[:, 0].min(), skel.nodes[:, 0].max(), skel.nodes[:, 1].min(), skel.nodes[:, 1].max()])\n",
+    "surface_mapping = build_mapping(on_sac_surface, off_sac_surface, arbor_boundaries, conformal_jump=2, n_anchors=16, verbose=True)\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
-   "source": "# warp the arbor\nwarped_skeleton = warp_skeleton(\n    skel,\n    surface_mapping,\n    conformal_jump=2,\n    z_profile_extent=[-25, 25], # the limits of the z profile, if None, it will be inferred.\n    z_profile_bin_size=1., #  bin size (μm) in the z profile.\n    z_profile_hdr_mass=0.95, # the mass of the histogram to be used for the z profile.\n    xy_profile_extents=None, # the limits of the xy profile, if None, it will be inferred.\n    xy_profile_bin_size=20., # bin size (μm) in the xy profile.\n    verbose=True,\n)\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[pywarper] Warping skeleton...\n",
+      "    done in 0.40 seconds.\n",
+      "[skeliner] Warning: 58 nodes have zero radius; they were ignored when picking the estimator.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# warp the arbor\n",
+    "warped_skeleton = warp_skeleton(\n",
+    "    skel,\n",
+    "    surface_mapping,\n",
+    "    conformal_jump=2,\n",
+    "    z_profile_extent=[-25, 25], # the limits of the z profile, if None, it will be inferred.\n",
+    "    z_profile_bin_size=1., #  bin size (μm) in the z profile.\n",
+    "    z_profile_hdr_mass=0.95, # the mass of the histogram to be used for the z profile.\n",
+    "    xy_profile_extents=None, # the limits of the xy profile, if None, it will be inferred.\n",
+    "    xy_profile_bin_size=20., # bin size (μm) in the xy profile.\n",
+    "    verbose=True,\n",
+    ")\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
-   "source": "# unwarp demo (step 1): unwarp_nodes on warped skeleton nodes\n# --------------------------------------------------------------------------- #\n# Unwarp warped skeleton nodes back to the original coordinate frame.\n# Compare the recovered nodes to the original skeleton nodes in XZ.\n\nwarped_nodes_norm = warped_skeleton.nodes\nmed_z_on = warped_skeleton.extra[\"med_z_on\"]\nmed_z_off = warped_skeleton.extra[\"med_z_off\"]\n\n# option 1: fast approximate inverse (all nodes)\nunwarped_skel_local = unwarp_nodes(\n    warped_nodes_norm,\n    surface_mapping,\n    on_sac_pos=0,\n    off_sac_pos=12,\n    conformal_jump=2,\n)\n\n# option 2: inverse-by-optimization (iterative; use subset for notebook speed)\nopt_idx = np.arange(0, len(warped_nodes_norm), 20)\nunwarped_skel_opt = unwarp_nodes(\n    warped_nodes_norm[opt_idx],\n    surface_mapping,\n    on_sac_pos=0,\n    off_sac_pos=12,\n    conformal_jump=2,\n    method=\"optimize\",\n    max_evals_per_point=100,\n    convergence_tol=1e-9,\n    bound_xy_to_map=True,\n)\n\nerr_skel_local = np.linalg.norm(unwarped_skel_local - skel.nodes, axis=1)\nerr_skel_opt = np.linalg.norm(unwarped_skel_opt - skel.nodes[opt_idx], axis=1)\n\nprint(\"Skeleton local_ls error (mean / p95 / max):\", \n      f\"{err_skel_local.mean():.4f} / {np.quantile(err_skel_local, 0.95):.4f} / {err_skel_local.max():.4f}\")\nprint(\"Skeleton optimize error on subset (mean / p95 / max):\", \n      f\"{err_skel_opt.mean():.4e} / {np.quantile(err_skel_opt, 0.95):.4e} / {err_skel_opt.max():.4e}\")\n\nfig, ax = plt.subplots(figsize=(7.2, 5.2))\n\n# background context: all original nodes\nax.scatter(\n    skel.nodes[:, 0], skel.nodes[:, 2],\n    s=2, alpha=0.12, c='0.65', label='original (all)', zorder=1,\n)\n\n# compare all methods on the same subset so marker overlap is readable\nax.scatter(\n    skel.nodes[opt_idx, 0], skel.nodes[opt_idx, 2],\n    s=34, facecolors='none', edgecolors='black', linewidths=0.9,\n    label='original (subset)', zorder=2,\n)\nax.scatter(\n    unwarped_skel_local[opt_idx, 0], unwarped_skel_local[opt_idx, 2],\n    s=28, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n    label='unwarp_nodes local_ls (subset)', zorder=3,\n)\nax.scatter(\n    unwarped_skel_opt[:, 0], unwarped_skel_opt[:, 2],\n    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n    label='unwarp_nodes optimize (subset)', zorder=4,\n)\n\nax.set_title('Step 1 (XZ): original vs unwrapped nodes')\nax.set_xlabel('X (μm)')\nax.set_ylabel('Z (μm)')\nax.legend(frameon=False, loc='best')\nfig.tight_layout()\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Skeleton local_ls error (mean / p95 / max): 0.0060 / 0.0257 / 0.0664\n",
+      "Skeleton optimize error on subset (mean / p95 / max): 5.2062e-04 / 1.9949e-03 / 2.6957e-02\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x520 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# unwarp demo (step 1): unwarp_nodes on warped skeleton nodes\n",
+    "# --------------------------------------------------------------------------- #\n",
+    "# Unwarp warped skeleton nodes back to the original coordinate frame.\n",
+    "# Compare the recovered nodes to the original skeleton nodes in XZ.\n",
+    "\n",
+    "warped_nodes_norm = warped_skeleton.nodes\n",
+    "med_z_on = warped_skeleton.extra[\"med_z_on\"]\n",
+    "med_z_off = warped_skeleton.extra[\"med_z_off\"]\n",
+    "\n",
+    "# option 1: fast approximate inverse (all nodes)\n",
+    "unwarped_skel_local = unwarp_nodes(\n",
+    "    warped_nodes_norm,\n",
+    "    surface_mapping,\n",
+    "    on_sac_pos=0,\n",
+    "    off_sac_pos=12,\n",
+    "    conformal_jump=2,\n",
+    ")\n",
+    "\n",
+    "# option 2: inverse-by-optimization (iterative; use subset for notebook speed)\n",
+    "opt_idx = np.arange(0, len(warped_nodes_norm), 20)\n",
+    "unwarped_skel_opt = unwarp_nodes(\n",
+    "    warped_nodes_norm[opt_idx],\n",
+    "    surface_mapping,\n",
+    "    on_sac_pos=0,\n",
+    "    off_sac_pos=12,\n",
+    "    conformal_jump=2,\n",
+    "    method=\"optimize\",\n",
+    "    max_evals_per_point=100,\n",
+    "    convergence_tol=1e-9,\n",
+    "    bound_xy_to_map=True,\n",
+    ")\n",
+    "\n",
+    "err_skel_local = np.linalg.norm(unwarped_skel_local - skel.nodes, axis=1)\n",
+    "err_skel_opt = np.linalg.norm(unwarped_skel_opt - skel.nodes[opt_idx], axis=1)\n",
+    "\n",
+    "print(\"Skeleton local_ls error (mean / p95 / max):\", \n",
+    "      f\"{err_skel_local.mean():.4f} / {np.quantile(err_skel_local, 0.95):.4f} / {err_skel_local.max():.4f}\")\n",
+    "print(\"Skeleton optimize error on subset (mean / p95 / max):\", \n",
+    "      f\"{err_skel_opt.mean():.4e} / {np.quantile(err_skel_opt, 0.95):.4e} / {err_skel_opt.max():.4e}\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7.2, 5.2))\n",
+    "\n",
+    "# background context: all original nodes\n",
+    "ax.scatter(\n",
+    "    skel.nodes[:, 0], skel.nodes[:, 2],\n",
+    "    s=2, alpha=0.12, c='0.65', label='original (all)', zorder=1,\n",
+    ")\n",
+    "\n",
+    "# compare all methods on the same subset so marker overlap is readable\n",
+    "ax.scatter(\n",
+    "    skel.nodes[opt_idx, 0], skel.nodes[opt_idx, 2],\n",
+    "    s=34, facecolors='none', edgecolors='black', linewidths=0.9,\n",
+    "    label='original (subset)', zorder=2,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    unwarped_skel_local[opt_idx, 0], unwarped_skel_local[opt_idx, 2],\n",
+    "    s=28, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n",
+    "    label='unwarp_nodes local_ls (subset)', zorder=3,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    unwarped_skel_opt[:, 0], unwarped_skel_opt[:, 2],\n",
+    "    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n",
+    "    label='unwarp_nodes optimize (subset)', zorder=4,\n",
+    ")\n",
+    "\n",
+    "ax.set_title('Step 1 (XZ): original vs unwrapped nodes')\n",
+    "ax.set_xlabel('X (μm)')\n",
+    "ax.set_ylabel('Z (μm)')\n",
+    "ax.legend(frameon=False, loc='best')\n",
+    "fig.tight_layout()\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
-   "source": "# unwarp demo (step 2): unwarp_nodes on annotation-like coordinates\n# --------------------------------------------------------------------------- #\n# Simulate annotations in warped space from arbitrary coordinates that are\n# within mapping XY bounds but not constrained to skeleton nodes.\n# Compare recovered coordinates in XZ.\n\nrng = np.random.default_rng(7)\nn_annotations = 220\n\nx_min = float(surface_mapping[\"sampled_x_idx\"].min())\nx_max = float(surface_mapping[\"sampled_x_idx\"].max())\ny_min = float(surface_mapping[\"sampled_y_idx\"].min())\ny_max = float(surface_mapping[\"sampled_y_idx\"].max())\n\n# synthetic ground truth coordinates (not on original skeleton)\nannot_orig = np.column_stack([\n    rng.uniform(x_min + 2, x_max - 2, size=n_annotations),\n    rng.uniform(y_min + 2, y_max - 2, size=n_annotations),\n    rng.uniform(skel.nodes[:, 2].min() - 30, skel.nodes[:, 2].max() + 30, size=n_annotations),\n])\n\n# these are the coordinates that would be annotated in warped space\nannot_prenorm, _, _ = warp_nodes(annot_orig, surface_mapping, conformal_jump=2)\nannot_warped = normalize_nodes(\n    annot_prenorm,\n    med_z_on=med_z_on,\n    med_z_off=med_z_off,\n)\n\nannot_unwarped_local = unwarp_nodes(\n    annot_warped,\n    surface_mapping,\n    conformal_jump=2,\n)\nannot_unwarped_opt = unwarp_nodes(\n    annot_warped,\n    surface_mapping,\n    conformal_jump=2,\n    method=\"optimize\",\n    max_evals_per_point=100,\n    convergence_tol=1e-9,\n    bound_xy_to_map=True,\n)\n\nerr_ann_local = np.linalg.norm(annot_unwarped_local - annot_orig, axis=1)\nerr_ann_opt = np.linalg.norm(annot_unwarped_opt - annot_orig, axis=1)\n\nprint(\"Annotation local_ls error (mean / p95 / max):\", \n      f\"{err_ann_local.mean():.4f} / {np.quantile(err_ann_local, 0.95):.4f} / {err_ann_local.max():.4f}\")\nprint(\"Annotation optimize error (mean / p95 / max):\", \n      f\"{err_ann_opt.mean():.4e} / {np.quantile(err_ann_opt, 0.95):.4e} / {err_ann_opt.max():.4e}\")\n\nfig, ax = plt.subplots(figsize=(7.2, 5.2))\n\n# marker stacking for readability at overlapping coordinates\nax.scatter(\n    annot_orig[:, 0], annot_orig[:, 2],\n    s=40, facecolors='none', edgecolors='black', linewidths=0.9,\n    alpha=0.7, label='original annotations (demo GT)', zorder=2,\n)\nax.scatter(\n    annot_unwarped_local[:, 0], annot_unwarped_local[:, 2],\n    s=32, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n    alpha=0.8, label='unwarp_nodes local_ls', zorder=3,\n)\nax.scatter(\n    annot_unwarped_opt[:, 0], annot_unwarped_opt[:, 2],\n    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n    alpha=0.95, label='unwarp_nodes optimize', zorder=4,\n)\n\nax.set_title('Step 2 (XZ): annotation points')\nax.set_xlabel('X (μm)')\nax.set_ylabel('Z (μm)')\nax.legend(frameon=False, loc='best')\nfig.tight_layout()\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Annotation local_ls error (mean / p95 / max): 0.0389 / 0.1822 / 1.0539\n",
+      "Annotation optimize error (mean / p95 / max): 1.7260e-12 / 6.7212e-12 / 1.0847e-10\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x520 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# unwarp demo (step 2): unwarp_nodes on annotation-like coordinates\n",
+    "# --------------------------------------------------------------------------- #\n",
+    "# Simulate annotations in warped space from arbitrary coordinates that are\n",
+    "# within mapping XY bounds but not constrained to skeleton nodes.\n",
+    "# Compare recovered coordinates in XZ.\n",
+    "\n",
+    "rng = np.random.default_rng(7)\n",
+    "n_annotations = 220\n",
+    "\n",
+    "x_min = float(surface_mapping[\"sampled_x_idx\"].min())\n",
+    "x_max = float(surface_mapping[\"sampled_x_idx\"].max())\n",
+    "y_min = float(surface_mapping[\"sampled_y_idx\"].min())\n",
+    "y_max = float(surface_mapping[\"sampled_y_idx\"].max())\n",
+    "\n",
+    "# synthetic ground truth coordinates (not on original skeleton)\n",
+    "annot_orig = np.column_stack([\n",
+    "    rng.uniform(x_min + 2, x_max - 2, size=n_annotations),\n",
+    "    rng.uniform(y_min + 2, y_max - 2, size=n_annotations),\n",
+    "    rng.uniform(skel.nodes[:, 2].min() - 30, skel.nodes[:, 2].max() + 30, size=n_annotations),\n",
+    "])\n",
+    "\n",
+    "# these are the coordinates that would be annotated in warped space\n",
+    "annot_prenorm, _, _ = warp_nodes(annot_orig, surface_mapping, conformal_jump=2)\n",
+    "annot_warped = normalize_nodes(\n",
+    "    annot_prenorm,\n",
+    "    med_z_on=med_z_on,\n",
+    "    med_z_off=med_z_off,\n",
+    ")\n",
+    "\n",
+    "annot_unwarped_local = unwarp_nodes(\n",
+    "    annot_warped,\n",
+    "    surface_mapping,\n",
+    "    conformal_jump=2,\n",
+    ")\n",
+    "annot_unwarped_opt = unwarp_nodes(\n",
+    "    annot_warped,\n",
+    "    surface_mapping,\n",
+    "    conformal_jump=2,\n",
+    "    method=\"optimize\",\n",
+    "    max_evals_per_point=100,\n",
+    "    convergence_tol=1e-9,\n",
+    "    bound_xy_to_map=True,\n",
+    ")\n",
+    "\n",
+    "err_ann_local = np.linalg.norm(annot_unwarped_local - annot_orig, axis=1)\n",
+    "err_ann_opt = np.linalg.norm(annot_unwarped_opt - annot_orig, axis=1)\n",
+    "\n",
+    "print(\"Annotation local_ls error (mean / p95 / max):\", \n",
+    "      f\"{err_ann_local.mean():.4f} / {np.quantile(err_ann_local, 0.95):.4f} / {err_ann_local.max():.4f}\")\n",
+    "print(\"Annotation optimize error (mean / p95 / max):\", \n",
+    "      f\"{err_ann_opt.mean():.4e} / {np.quantile(err_ann_opt, 0.95):.4e} / {err_ann_opt.max():.4e}\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7.2, 5.2))\n",
+    "\n",
+    "# marker stacking for readability at overlapping coordinates\n",
+    "ax.scatter(\n",
+    "    annot_orig[:, 0], annot_orig[:, 2],\n",
+    "    s=40, facecolors='none', edgecolors='black', linewidths=0.9,\n",
+    "    alpha=0.7, label='original annotations (demo GT)', zorder=2,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    annot_unwarped_local[:, 0], annot_unwarped_local[:, 2],\n",
+    "    s=32, marker='s', facecolors='none', edgecolors='C3', linewidths=1.0,\n",
+    "    alpha=0.8, label='unwarp_nodes local_ls', zorder=3,\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    annot_unwarped_opt[:, 0], annot_unwarped_opt[:, 2],\n",
+    "    s=14, marker='o', c='C0', edgecolors='white', linewidths=0.3,\n",
+    "    alpha=0.95, label='unwarp_nodes optimize', zorder=4,\n",
+    ")\n",
+    "\n",
+    "ax.set_title('Step 2 (XZ): annotation points')\n",
+    "ax.set_xlabel('X (μm)')\n",
+    "ax.set_ylabel('Z (μm)')\n",
+    "ax.legend(frameon=False, loc='best')\n",
+    "fig.tight_layout()\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
-   "source": "# unwarp demo (step 3): unwarp_skeleton (object-level API)\n# --------------------------------------------------------------------------- #\n# `unwarp_skeleton` inverts `warp_skeleton` directly on Skeleton objects.\n# If `warp_skeleton` used voxel_resolution/skeleton_nodes_scale, pass the same values here.\n\nunwarped_skeleton = unwarp_skeleton(\n    warped_skeleton,\n    surface_mapping,\n    on_sac_pos=0,\n    off_sac_pos=12,\n    conformal_jump=2,\n    method=\"local_ls\",\n)\n\nerr_obj = np.linalg.norm(unwarped_skeleton.nodes - skel.nodes, axis=1)\nprint(\"unwarp_skeleton local_ls error (mean / p95 / max):\", \n      f\"{err_obj.mean():.4f} / {np.quantile(err_obj, 0.95):.4f} / {err_obj.max():.4f}\")\n\nfig, ax = plt.subplots(figsize=(7.2, 5.2))\nax.scatter(\n    skel.nodes[:, 0], skel.nodes[:, 2],\n    s=2, alpha=0.20, c='black', label='original skeleton',\n)\nax.scatter(\n    unwarped_skeleton.nodes[:, 0], unwarped_skeleton.nodes[:, 2],\n    s=2, alpha=0.20, c='C3', label='unwarp_skeleton local_ls',\n)\nax.set_title('Step 3 (XZ): object-level unwarping')\nax.set_xlabel('X (μm)')\nax.set_ylabel('Z (μm)')\nax.legend(frameon=False, markerscale=4)\nfig.tight_layout()\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "unwarp_skeleton local_ls error (mean / p95 / max): 0.0060 / 0.0257 / 0.0664\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x520 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# unwarp demo (step 3): unwarp_skeleton (object-level API)\n",
+    "# --------------------------------------------------------------------------- #\n",
+    "# `unwarp_skeleton` inverts `warp_skeleton` directly on Skeleton objects.\n",
+    "# If `warp_skeleton` used voxel_resolution/skeleton_nodes_scale, pass the same values here.\n",
+    "\n",
+    "unwarped_skeleton = unwarp_skeleton(\n",
+    "    warped_skeleton,\n",
+    "    surface_mapping,\n",
+    "    on_sac_pos=0,\n",
+    "    off_sac_pos=12,\n",
+    "    conformal_jump=2,\n",
+    "    method=\"local_ls\",\n",
+    ")\n",
+    "\n",
+    "err_obj = np.linalg.norm(unwarped_skeleton.nodes - skel.nodes, axis=1)\n",
+    "print(\"unwarp_skeleton local_ls error (mean / p95 / max):\", \n",
+    "      f\"{err_obj.mean():.4f} / {np.quantile(err_obj, 0.95):.4f} / {err_obj.max():.4f}\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7.2, 5.2))\n",
+    "ax.scatter(\n",
+    "    skel.nodes[:, 0], skel.nodes[:, 2],\n",
+    "    s=2, alpha=0.20, c='black', label='original skeleton',\n",
+    ")\n",
+    "ax.scatter(\n",
+    "    unwarped_skeleton.nodes[:, 0], unwarped_skeleton.nodes[:, 2],\n",
+    "    s=2, alpha=0.20, c='C3', label='unwarp_skeleton local_ls',\n",
+    ")\n",
+    "ax.set_title('Step 3 (XZ): object-level unwarping')\n",
+    "ax.set_xlabel('X (μm)')\n",
+    "ax.set_ylabel('Z (μm)')\n",
+    "ax.legend(frameon=False, markerscale=4)\n",
+    "fig.tight_layout()\n"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
-   "outputs": [],
-   "source": "%load_ext watermark\n%watermark --time --date --timezone --updated --python --iversions --watermark\n"
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Last updated: 2026-02-16 16:06:53 CET\n",
+      "\n",
+      "Python implementation: CPython\n",
+      "Python version       : 3.13.11\n",
+      "IPython version      : 9.10.0\n",
+      "\n",
+      "matplotlib: 3.10.8\n",
+      "numpy     : 2.4.2\n",
+      "pywarper  : 0.2.5\n",
+      "skeliner  : 0.2.6\n",
+      "\n",
+      "Watermark: 2.6.0\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext watermark\n",
+    "%watermark --time --date --timezone --updated --python --iversions --watermark\n"
+   ]
   }
  ],
  "metadata": {