diff --git a/.github/workflows/test_meep_local.yml b/.github/workflows/test_meep_local.yml
new file mode 100644
index 0000000..47c19d8
--- /dev/null
+++ b/.github/workflows/test_meep_local.yml
@@ -0,0 +1,28 @@
+name: MEEP Local Tests
+on:
+  workflow_dispatch:
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+jobs:
+  meep_local_test:
+    if: >-
+      github.event_name == 'workflow_dispatch' || (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'meep_tests'))
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash -el {0}
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v6
+    - name: Setup Miniconda
+      uses: conda-incubator/setup-miniconda@v3
+      with:
+        python-version: "3.12"
+        auto-update-conda: true
+        channels: conda-forge,defaults
+    - name: Install MEEP and dependencies
+      run: |
+        conda install -c conda-forge pymeep pymeep-extras
+        pip install -e ".[dev]"
+    - name: Run MEEP local tests
+      run: pytest -m meep_local
diff --git a/.gitignore b/.gitignore
index 8981d4a..0996bd1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,6 +50,7 @@ pip-log.txt
 .DS_Store
 
 # folders
+.kilo/
 .cursor/
 .eggs/
 .hypothesis/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3012ecb..fac0da1 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -56,6 +56,7 @@ repos:
     entry: python scripts/check_cp1252.py
     language: system
     types: [python]
+    exclude: ^nbs/_meep_mode_solver_(rib|tfln)\.py$
 - repo: https://github.com/mwouts/jupytext
   rev: v1.19.2
   hooks:
diff --git a/nbs/_meep_mode_solver_rib.ipynb b/nbs/_meep_mode_solver_rib.ipynb
new file mode 100644
index 0000000..0cefdad
--- /dev/null
+++ b/nbs/_meep_mode_solver_rib.ipynb
@@ -0,0 +1,275 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "be2f7c0d",
+   "metadata": {},
+   "source": [
+    "# MEEP Mode Solver - Rib Waveguide\n",
+    "\n",
+    "Compute the fundamental TE mode of a **silicon rib waveguide** at a\n",
+    "single wavelength, returning `n_eff` and the full 2D (Y, Z) mode\n",
+    "profile.\n",
+    "\n",
+    "**Rib cross-section:**\n",
+    " - SiO2 box (2 um)\n",
+    " - Si slab (70 nm, partially etched)\n",
+    " - Si rib (150 nm on top of slab -> total 220 nm)\n",
+    "\n",
+    "The rib provides lateral confinement via effective-index contrast\n",
+    "between the ridge and the thinner side slabs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d571fbf",
+   "metadata": {},
+   "source": [
+    "### Imports & MEEP check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8d8de59",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gdsfactory as gf\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "import gsim.meep as gm\n",
+    "from gsim.common.stack.extractor import Layer, LayerStack\n",
+    "\n",
+    "try:\n",
+    "    import meep as mp\n",
+    "\n",
+    "    print(f\"MEEP {mp.__version__} ready\")\n",
+    "except ImportError as err:\n",
+    "    raise SystemExit(\n",
+    "        \"MEEP not found. Install it via conda-forge:\\n\"\n",
+    "        \"    conda install -c conda-forge pymeep\"\n",
+    "    ) from err\n",
+    "\n",
+    "plt.close()\n",
+    "\n",
+    "gf.gpdk.PDK.activate()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c92ae427",
+   "metadata": {},
+   "source": [
+    "### Build the GDS component\n",
+    "\n",
+    "We manually create a component with **two Si layers** - a wide slab and\n",
+    "a narrow rib on top.  The mode solver later slices through both layers\n",
+    "at the port Y-position to reconstruct the 2D (X,Z) geometry."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5581cf67",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SLAB_WIDTH = 3.0  # um\n",
+    "RIB_WIDTH = 0.5  # um\n",
+    "LENGTH = 10.0  # um\n",
+    "\n",
+    "c = gf.Component()\n",
+    "\n",
+    "# Si rib layer (layer 2) - narrow ridge on top\n",
+    "c.add_polygon(\n",
+    "    [\n",
+    "        (-LENGTH / 2, -RIB_WIDTH / 2),\n",
+    "        (LENGTH / 2, -RIB_WIDTH / 2),\n",
+    "        (LENGTH / 2, RIB_WIDTH / 2),\n",
+    "        (-LENGTH / 2, RIB_WIDTH / 2),\n",
+    "    ],\n",
+    "    layer=(2, 0),\n",
+    ")\n",
+    "\n",
+    "# Ports at both ends\n",
+    "c.add_port(\n",
+    "    name=\"o1\", center=(-LENGTH / 2, 0), width=RIB_WIDTH, orientation=180, layer=(1, 0)\n",
+    ")\n",
+    "c.add_port(\n",
+    "    name=\"o2\", center=(LENGTH / 2, 0), width=RIB_WIDTH, orientation=0, layer=(1, 0)\n",
+    ")\n",
+    "\n",
+    "print(f\"Component: {c.name}\")\n",
+    "print(f\"  Ports:  {[p.name for p in c.ports]}\")\n",
+    "print(f\"  Layers: {list(c.layers)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c296bbf1",
+   "metadata": {},
+   "source": [
+    "### Layer stack\n",
+    "\n",
+    "Define the vertical material profile.  Each non-air layer maps a GDS\n",
+    "layer to a Z-range."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb95c942",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "layers = {\n",
+    "    \"ox\": Layer(\n",
+    "        name=\"box\",\n",
+    "        gds_layer=(0, 0),\n",
+    "        zmin=-1,\n",
+    "        zmax=0.0,\n",
+    "        thickness=1.0,\n",
+    "        material=\"sio2\",\n",
+    "        layer_type=\"dielectric\",\n",
+    "    ),\n",
+    "    \"slab\": Layer(\n",
+    "        name=\"slab\",\n",
+    "        gds_layer=(1, 0),\n",
+    "        zmin=0.0,\n",
+    "        zmax=0.07,\n",
+    "        thickness=0.07,\n",
+    "        material=\"si\",\n",
+    "        layer_type=\"dielectric\",\n",
+    "    ),\n",
+    "    \"rib\": Layer(\n",
+    "        name=\"rib\",\n",
+    "        gds_layer=(2, 0),\n",
+    "        zmin=0.07,\n",
+    "        zmax=0.22,\n",
+    "        thickness=0.15,\n",
+    "        material=\"si\",\n",
+    "        layer_type=\"dielectric\",\n",
+    "    ),\n",
+    "}\n",
+    "stack = LayerStack(layers=layers)\n",
+    "\n",
+    "print(\"Layer stack:\")\n",
+    "for name, l in stack.layers.items():\n",
+    "    print(\n",
+    "        f\"  {name:6s}  z=[{l.zmin:+.3f}, {l.zmax:+.3f}]  t={l.thickness:.3f}  material={l.material}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22362b7c",
+   "metadata": {},
+   "source": [
+    "### Solve the fundamental mode\n",
+    "\n",
+    "Use the declarative :class:`Simulation` + :class:`ModeSolver` API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21d0926d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "WAVELENGTH = 1.55  # um\n",
+    "RESOLUTION = 32\n",
+    "PML_THICKNESS = 1 * WAVELENGTH\n",
+    "\n",
+    "\n",
+    "sim = gm.Simulation(\n",
+    "    geometry=gm.Geometry(component=c, stack=stack),\n",
+    "    domain=gm.Domain(\n",
+    "        pml=PML_THICKNESS,\n",
+    "        margin_z=(0.0, 0.5),\n",
+    "    ),\n",
+    ")\n",
+    "sim.mode_solver.wavelengths = [WAVELENGTH]\n",
+    "sim.mode_solver.fundamental().at_port(\"o1\")\n",
+    "sim.mode_solver.y_span = SLAB_WIDTH\n",
+    "sim.mode_solver.n_field_y = 100\n",
+    "sim.mode_solver.n_field_z = 100\n",
+    "\n",
+    "sweep = sim.solve_modes()\n",
+    "mode = sweep.at(WAVELENGTH).band(1)\n",
+    "\n",
+    "print(f\"n_eff    = {mode.n_eff:.6f}\")\n",
+    "print(f\"n_group  = {mode.n_group}\")\n",
+    "print(f\"kdom     = {[f'{k:.6f}' for k in mode.kdom]}\")\n",
+    "print(f\"band     = {mode.band_num}, parity = {mode.parity}\")\n",
+    "print(f\"fields   = {list(mode.fields.keys())}\")\n",
+    "for comp, arr in mode.fields.items():\n",
+    "    print(f\"  {comp}: shape={arr.shape}  |max|={np.abs(arr).max():.6f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5fd2ea63",
+   "metadata": {},
+   "source": [
+    "### Refractive index profile\n",
+    "\n",
+    "Use ``ModeResult.plot_index()`` which auto-computes ``n`` from the\n",
+    "stored :class:`LayerStack` and grid arrays."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f9cb1a5",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [],
+   "source": [
+    "mode.plot_index(show=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e47994b5",
+   "metadata": {},
+   "source": [
+    "### 2D mode profile — all field components\n",
+    "\n",
+    "Use ``ModeResult.plot_mode()`` with ``components=\"all\"`` and\n",
+    "``geometry=True`` to overlay structural geometry boundaries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed98159c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mode.plot_mode(\n",
+    "    components=\"all\",\n",
+    "    norm=\"abs\",\n",
+    "    geometry=True,\n",
+    "    suptitle=(\n",
+    "        f\"Rib waveguide fundamental TE mode\\n\"\n",
+    "        f\"(λ={WAVELENGTH:.2f} µm, slab={SLAB_WIDTH:.1f} µm, rib={RIB_WIDTH:.1f} µm)\"\n",
+    "    ),\n",
+    "    show=True,\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/nbs/_meep_mode_solver_rib.py b/nbs/_meep_mode_solver_rib.py
new file mode 100644
index 0000000..0353b0b
--- /dev/null
+++ b/nbs/_meep_mode_solver_rib.py
@@ -0,0 +1,197 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.2
+#   kernelspec:
+#     display_name: Python 3 (ipykernel)
+#     language: python
+#     name: python3
+# ---
+
+# %% [markdown]
+# # MEEP Mode Solver - Rib Waveguide
+#
+# Compute the fundamental TE mode of a **silicon rib waveguide** at a
+# single wavelength, returning `n_eff` and the full 2D (Y, Z) mode
+# profile.
+#
+# **Rib cross-section:**
+#  - SiO2 box (2 um)
+#  - Si slab (70 nm, partially etched)
+#  - Si rib (150 nm on top of slab -> total 220 nm)
+#
+# The rib provides lateral confinement via effective-index contrast
+# between the ridge and the thinner side slabs.
+
+# %% [markdown]
+# ### Imports & MEEP check
+
+# %%
+import gdsfactory as gf
+import matplotlib.pyplot as plt
+import numpy as np
+
+import gsim.meep as gm
+from gsim.common.stack.extractor import Layer, LayerStack
+
+try:
+    import meep as mp
+
+    print(f"MEEP {mp.__version__} ready")
+except ImportError as err:
+    raise SystemExit(
+        "MEEP not found. Install it via conda-forge:\n"
+        "    conda install -c conda-forge pymeep"
+    ) from err
+
+plt.close()
+
+gf.gpdk.PDK.activate()
+
+# %% [markdown]
+# ### Build the GDS component
+#
+# We manually create a component with **two Si layers** - a wide slab and
+# a narrow rib on top.  The mode solver later slices through both layers
+# at the port Y-position to reconstruct the 2D (X,Z) geometry.
+
+# %%
+SLAB_WIDTH = 3.0  # um
+RIB_WIDTH = 0.5  # um
+LENGTH = 10.0  # um
+
+c = gf.Component()
+
+# Si rib layer (layer 2) - narrow ridge on top
+c.add_polygon(
+    [
+        (-LENGTH / 2, -RIB_WIDTH / 2),
+        (LENGTH / 2, -RIB_WIDTH / 2),
+        (LENGTH / 2, RIB_WIDTH / 2),
+        (-LENGTH / 2, RIB_WIDTH / 2),
+    ],
+    layer=(2, 0),
+)
+
+# Ports at both ends
+c.add_port(
+    name="o1", center=(-LENGTH / 2, 0), width=RIB_WIDTH, orientation=180, layer=(1, 0)
+)
+c.add_port(
+    name="o2", center=(LENGTH / 2, 0), width=RIB_WIDTH, orientation=0, layer=(1, 0)
+)
+
+print(f"Component: {c.name}")
+print(f"  Ports:  {[p.name for p in c.ports]}")
+print(f"  Layers: {list(c.layers)}")
+
+# %% [markdown]
+# ### Layer stack
+#
+# Define the vertical material profile.  Each non-air layer maps a GDS
+# layer to a Z-range.
+
+# %%
+layers = {
+    "ox": Layer(
+        name="box",
+        gds_layer=(0, 0),
+        zmin=-1,
+        zmax=0.0,
+        thickness=1.0,
+        material="sio2",
+        layer_type="dielectric",
+    ),
+    "slab": Layer(
+        name="slab",
+        gds_layer=(1, 0),
+        zmin=0.0,
+        zmax=0.07,
+        thickness=0.07,
+        material="si",
+        layer_type="dielectric",
+    ),
+    "rib": Layer(
+        name="rib",
+        gds_layer=(2, 0),
+        zmin=0.07,
+        zmax=0.22,
+        thickness=0.15,
+        material="si",
+        layer_type="dielectric",
+    ),
+}
+stack = LayerStack(layers=layers)
+
+print("Layer stack:")
+for name, l in stack.layers.items():
+    print(
+        f"  {name:6s}  z=[{l.zmin:+.3f}, {l.zmax:+.3f}]  t={l.thickness:.3f}  material={l.material}"
+    )
+
+# %% [markdown]
+# ### Solve the fundamental mode
+#
+# Use the declarative :class:`Simulation` + :class:`ModeSolver` API.
+
+# %%
+WAVELENGTH = 1.55  # um
+RESOLUTION = 32
+PML_THICKNESS = 1 * WAVELENGTH
+
+
+sim = gm.Simulation(
+    geometry=gm.Geometry(component=c, stack=stack),
+    domain=gm.Domain(
+        pml=PML_THICKNESS,
+        margin_z=(0.0, 0.5),
+    ),
+)
+sim.mode_solver.wavelengths = [WAVELENGTH]
+sim.mode_solver.fundamental().at_port("o1")
+sim.mode_solver.y_span = SLAB_WIDTH
+sim.mode_solver.n_field_y = 100
+sim.mode_solver.n_field_z = 100
+
+sweep = sim.solve_modes()
+mode = sweep.at(WAVELENGTH).band(1)
+
+print(f"n_eff    = {mode.n_eff:.6f}")
+print(f"n_group  = {mode.n_group}")
+print(f"kdom     = {[f'{k:.6f}' for k in mode.kdom]}")
+print(f"band     = {mode.band_num}, parity = {mode.parity}")
+print(f"fields   = {list(mode.fields.keys())}")
+for comp, arr in mode.fields.items():
+    print(f"  {comp}: shape={arr.shape}  |max|={np.abs(arr).max():.6f}")
+
+# %% [markdown]
+# ### Refractive index profile
+#
+# Use ``ModeResult.plot_index()`` which auto-computes ``n`` from the
+# stored :class:`LayerStack` and grid arrays.
+
+# %%
+mode.plot_index(show=True)
+
+
+# %% [markdown]
+# ### 2D mode profile — all field components
+#
+# Use ``ModeResult.plot_mode()`` with ``components="all"`` and
+# ``geometry=True`` to overlay structural geometry boundaries.
+
+# %%
+mode.plot_mode(
+    components="all",
+    norm="abs",
+    geometry=True,
+    suptitle=(
+        f"Rib waveguide fundamental TE mode\n"
+        f"(λ={WAVELENGTH:.2f} µm, slab={SLAB_WIDTH:.1f} µm, rib={RIB_WIDTH:.1f} µm)"
+    ),
+    show=True,
+)
diff --git a/nbs/_meep_mode_solver_soi.ipynb b/nbs/_meep_mode_solver_soi.ipynb
new file mode 100644
index 0000000..fd96164
--- /dev/null
+++ b/nbs/_meep_mode_solver_soi.ipynb
@@ -0,0 +1,1138 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bf5a2f51",
+   "metadata": {},
+   "source": [
+    "# MEEP Eigenmode Solver — 1D Slab Modes\n",
+    "\n",
+    "Solve **1D slab modes** declaratively with the `Simulation` API.\n",
+    "Operations run locally via MEEP — no cloud required.\n",
+    "\n",
+    "**API overview:**\n",
+    "\n",
+    "| API | What it does |\n",
+    "|---|---|\n",
+    "| `sim.mode_solver(wavelengths=[1.55])` | Configure eigenmode solver |\n",
+    "| `sim.solve_modes()` | Run solver, return `ModeSweepResult` |\n",
+    "| `sweep.results` | List of `ModeResult` (`.n_eff`, `.fields`, `.kdom`, `.n_group`, …) |\n",
+    "| `mode_z_grid(stack, ...)` | Z-axis coordinates for field arrays |\n",
+    "| `refractive_index_profile(stack, ...)` | n(z) from the layer stack |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c4b7282",
+   "metadata": {},
+   "source": [
+    "## Part 1 — Quick Start"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6ee92340",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MEEP 1.33.0 ready\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "import gsim.meep as gm\n",
+    "from gsim.common.stack.extractor import Layer, LayerStack\n",
+    "\n",
+    "HAS_MEEP = False\n",
+    "try:\n",
+    "    import meep as mp\n",
+    "\n",
+    "    HAS_MEEP = True\n",
+    "    print(f\"MEEP {mp.__version__} ready\")\n",
+    "except ImportError as err:\n",
+    "    raise SystemExit(\n",
+    "        \"MEEP not found. Install it via conda-forge:\\n\"\n",
+    "        \"    conda install -c conda-forge pymeep\"\n",
+    "    ) from err\n",
+    "\n",
+    "RESOLUTION = 128\n",
+    "WL = 1.55\n",
+    "PML = 1.6\n",
+    "n_points = 1000\n",
+    "\n",
+    "import math\n",
+    "\n",
+    "from gsim.common.stack.materials import resolve_material_at_wavelength\n",
+    "\n",
+    "\n",
+    "def _n_si(wl_um: float) -> float:\n",
+    "    \"\"\"Si refractive index from gsim Sellmeier model (Salzberg & Villa 1957).\"\"\"\n",
+    "    return math.sqrt(resolve_material_at_wavelength(\"si\", wl_um).permittivity_scalar)\n",
+    "\n",
+    "\n",
+    "def _n_sio2(wl_um: float) -> float:\n",
+    "    \"\"\"SiO2 refractive index from gsim Sellmeier model (Malitson 1965).\"\"\"\n",
+    "    return math.sqrt(resolve_material_at_wavelength(\"sio2\", wl_um).permittivity_scalar)\n",
+    "\n",
+    "\n",
+    "def _make_soi_stack(t_si: float) -> LayerStack:\n",
+    "    \"\"\"Build a symmetric SOI slab stack: SiO2 / Si / SiO2.\"\"\"\n",
+    "    t_sio2 = 1.6\n",
+    "    return LayerStack(\n",
+    "        layers={\n",
+    "            \"box\": Layer(\n",
+    "                name=\"box\",\n",
+    "                gds_layer=(0, 0),\n",
+    "                zmin=-t_sio2,\n",
+    "                zmax=0.0,\n",
+    "                thickness=t_sio2,\n",
+    "                material=\"sio2\",\n",
+    "                layer_type=\"dielectric\",\n",
+    "            ),\n",
+    "            \"core\": Layer(\n",
+    "                name=\"core\",\n",
+    "                gds_layer=(1, 0),\n",
+    "                zmin=0.0,\n",
+    "                zmax=t_si,\n",
+    "                thickness=t_si,\n",
+    "                material=\"si\",\n",
+    "                layer_type=\"dielectric\",\n",
+    "            ),\n",
+    "            \"clad\": Layer(\n",
+    "                name=\"clad\",\n",
+    "                gds_layer=(2, 0),\n",
+    "                zmin=t_si,\n",
+    "                zmax=t_si + t_sio2,\n",
+    "                thickness=t_sio2,\n",
+    "                material=\"sio2\",\n",
+    "                layer_type=\"dielectric\",\n",
+    "            ),\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "soi = _make_soi_stack(0.22)\n",
+    "stack = soi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5480aae7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "n_eff   = 3.807716\n",
+      "n_group = 4.104764506210327\n",
+      "kdom    = ['2.456591', '-0.000000', '0.000000']\n",
+      "band    = 1, parity = NO_PARITY\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim = gm.Simulation()\n",
+    "sim.geometry.stack = stack\n",
+    "sim.solver.resolution = RESOLUTION\n",
+    "sim.domain.pml = PML\n",
+    "sim.mode_solver(wavelengths=[WL], num_bands=1, parity=\"NO_PARITY\")\n",
+    "\n",
+    "sweep = sim.solve_modes()\n",
+    "r = sweep.results[0]\n",
+    "\n",
+    "print(f\"n_eff   = {r.n_eff:.6f}\")\n",
+    "print(f\"n_group = {r.n_group}\")\n",
+    "print(f\"kdom    = {[f'{k:.6f}' for k in r.kdom]}\")\n",
+    "print(f\"band    = {r.band_num}, parity = {r.parity}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "adad70fc",
+   "metadata": {},
+   "source": [
+    "## Part 2 — Mode Results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c3bf1ab",
+   "metadata": {},
+   "source": [
+    "### ModeResult fields\n",
+    "\n",
+    "`ModeResult` is a Pydantic model:\n",
+    "\n",
+    "| Attribute | Type | Description |\n",
+    "|---|---|---|\n",
+    "| `n_eff` | `float` | Effective index |\n",
+    "| `wavelength` | `float` | Free-space wavelength (um) |\n",
+    "| `fields` | `dict[str, np.ndarray]` | Complex field arrays keyed by component |\n",
+    "| `kdom` | `list[float]` | Dominant wavevector [kx, ky, kz] |\n",
+    "| `n_group` | `float \\| None` | Group index (from `mode.group_velocity`) |\n",
+    "| `band_num` | `int` | Mode band index (1 = fundamental) |\n",
+    "| `parity` | `str` | Parity constraint used |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e6794830",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ex: shape=(270, 1), |max|=0.000485\n",
+      "Ey: shape=(270, 1), |max|=1.800863\n",
+      "Ez: shape=(270, 1), |max|=0.000649\n",
+      "Hx: shape=(270, 1), |max|=1.989306\n",
+      "Hy: shape=(270, 1), |max|=0.001865\n",
+      "Hz: shape=(270, 1), |max|=6.857442\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim.mode_solver(n_field_z=n_points)\n",
+    "sweep = sim.solve_modes()\n",
+    "r = sweep.results[0]\n",
+    "\n",
+    "for comp, arr in r.fields.items():\n",
+    "    print(f\"{comp}: shape={arr.shape}, |max|={np.abs(arr).max():.6f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41d0cc50",
+   "metadata": {},
+   "source": [
+    "### Z-grid and refractive index profile"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a668cc05",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Z grid: -4.9570 ... 7.1570 um  (142 points)\n",
+      "Index range: 1.0000 - 4.0000\n"
+     ]
+    }
+   ],
+   "source": [
+    "z_um = gm.mode_z_grid(stack, n_points=n_points, pml_thickness=PML)\n",
+    "n_profile = gm.refractive_index_profile(stack, WL, z_grid=z_um)\n",
+    "\n",
+    "print(f\"Z grid: {z_um[0]:.4f} ... {z_um[-1]:.4f} um  ({len(z_um)} points)\")\n",
+    "print(f\"Index range: {n_profile.min():.4f} - {n_profile.max():.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66880123",
+   "metadata": {},
+   "source": [
+    "### Mode profile with index overlay"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6b43aa58",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sim.mode_solver(n_field_z=n_points)\n",
+    "sweep = sim.solve_modes()\n",
+    "r = sweep.results[0]\n",
+    "\n",
+    "z_slab = gm.mode_z_grid(stack, n_points=n_points, pml_thickness=PML)\n",
+    "n_prof = gm.refractive_index_profile(stack, WL, z_grid=z_slab)\n",
+    "dom_comp = max(r.fields, key=lambda k: np.abs(r.fields[k]).max())\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7, 4))\n",
+    "field = r.fields[dom_comp]\n",
+    "ax.plot(z_slab, abs(field), color=\"C0\", linewidth=1.5, label=f\"|{dom_comp}|\")\n",
+    "ax.plot(\n",
+    "    z_slab,\n",
+    "    field.real,\n",
+    "    color=\"C0\",\n",
+    "    alpha=0.35,\n",
+    "    linestyle=\"--\",\n",
+    "    linewidth=1,\n",
+    "    label=f\"Re({dom_comp})\",\n",
+    ")\n",
+    "ax.plot(\n",
+    "    z_slab,\n",
+    "    field.imag,\n",
+    "    color=\"C0\",\n",
+    "    alpha=0.35,\n",
+    "    linestyle=\":\",\n",
+    "    linewidth=1,\n",
+    "    label=f\"Im({dom_comp})\",\n",
+    ")\n",
+    "ax.set_xlabel(\"z (um)\")\n",
+    "ax.set_ylabel(\"Field amplitude (arb. units)\")\n",
+    "\n",
+    "ax_idx = ax.twinx()\n",
+    "ax_idx.plot(z_slab, n_prof, color=\"C3\", linewidth=1.5, label=\"n(z)\")\n",
+    "ax_idx.set_ylabel(\"Refractive index\")\n",
+    "ax_idx.set_ylim(bottom=0.8)\n",
+    "\n",
+    "ax.set_title(\n",
+    "    f\"Mode profile - {dom_comp}  (lambda={r.wavelength:.2f} um, n_eff={r.n_eff:.4f})\"\n",
+    ")\n",
+    "ax.grid(True, alpha=0.2)\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36c52850",
+   "metadata": {},
+   "source": [
+    "### Field component grid"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1945ceb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKEAAAJQCAYAAABW2XehAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0X1JREFUeJzs3Qd0G1XWwPFruTuOnQ7plFADJBBqCCQh9LL03iH0nqVsYIENLfS+sEuHpffQ+eglEEoglEDopJFe3Kuk79xnjSzZki3JI2lG+v/OUawyIz+NZL28O/fdl+P3+/0CAAAAAAAAJJEnmU8OAAAAAAAAKIJQAAAAAAAASDqCUAAAAAAAAEg6glAAAAAAAABIOoJQAAAAAAAASDqCUAAAAAAAAEg6glAAAAAAAABIOoJQAAAAAAAASDqCUACQoc4880zJyckxl//85z8pe573338/uP3OO++c8O8F0vGZt+vvxmnS9XfppONpV1v4jgMAIHEEoQDAJW699dbgACraZdasWeluJlzulVdeCX6eDjrooHQ3B0AbX331lZx//vkyePDg4N/qhhtuGNdx+vLLLzvsS8aNG9el7QEAiCYv6iMAAAAAHGP58uUyatSodDcDAICEkQkFAC40duxY8fv97S4jR44MbnPnnXcG7z/11FPT2l4AQNdp1tEWW2whN9xwg7z00ku2HNInnniiXV+iUw7t2h4AgFAEoQAgQ3VU/2Tu3Lly+umny7Bhw6SoqEi6desmW265pdx2223S3Nwc8+947bXXzH76HOuuu67cf//9CbV14cKFMmnSJNloo42kpKRE+vTpI3vttZdMnz49bLs//vhDTjnlFPO79HeWlpaaAdm1114r9fX1Ydtq4C309T/zzDOy3nrrSffu3eXAAw80GQVer1cuv/xy6d+/v/Tq1cv8zt9++63D4/j666/LiBEjzO/XKTD33ntvu9cTTzvbPr8O5vSY6nEYPny4PPzww+2eP573L57n33bbbWWfffYJ3n7uuefa1RHS33388cfL0KFDpbCwUHr37i3bb7+9XHnllfLXX39JMnT1d954441hU4dyc3OlZ8+e5jnuvvtu8fl8UfeN5f2OxK7PX7yfp0T+Lu36PohHPO+Jnccy3vc2nmPZlc9ZrPSzP3PmzOB0PLfRKb7W8Zk2bVqn04CT9d4DANLIDwBwhVtuucWvX9t6GTt2bKfbn3HGGcHt77777uD9X3zxhb+srCz4WNvLLrvs4m9ubu70eaZNm+b3eDzt9j/qqKOC1ydMmNBpO2fOnOnv2bNnxLaUl5cHt5sxY4a/e/fuUds9atQof2VlZXD7U045JfjYQQcd5M/JyQnbfocddvCfeuqp7Z5nww039Dc1NUV8/Ycffrg/Nze33T433nhjwu0Mff6jjz7an5+f326ft99+25b3r7Pn32abbaI+r76XPp/Pv8EGG0TdZt999/XbLZ7fGe2zesMNN0TdXy8XXHBBwu93NHZ9/uL9PMX7dxnv5yledrwn6fpbjvdYxvOa9Lh3tG3oRb/7I/n666+D2+jfSDxCf3+fPn3M90JJSYl/8803919//fX+hoaGLm0fzYEHHhh8Hj2+lpdffjl4v25j93sPAHAOMqEAwIU++OCDdoVhNYshFscdd5xUVlZKcXGxvPzyy1JXVydLly6VI444wjz+1ltvySOPPNLp82jmknVm/5xzzpFVq1bJd999JzNmzIjrtRx77LFmX7XrrrvK999/L9XV1fLpp5/KvvvuG9xOM2GqqqrM9bPPPltWrFghv/zyS7A+imYHTJ06NeLvePfdd83zLVmyRNZZZx1z30cffWTOqn/++ecmm2bIkCHm/jlz5pj7InnjjTfknXfeMcfv3//+d/D+yy67LPgautJOzTx68cUXZfXq1eZ9soRmK3Xl/evs+fW90+e0aKaBNd3m7bffNr/np59+Mo/pe7Ny5UrTFi1afPHFF5tMBLvZ8Ts1ayR06pBmD3399ddSXl5uHtf3sqmpKaH3OxZd+fzF+3mK9+/Sru+DeCX6nqTybzneY5noa0o3zSbSdtXW1pr2Xnjhhea7WDOM7Ng+Go8nvmGIXe89ACC9CEIBQBb5+eefZfbs2ea6DjZ16pUOPvv16yePP/54cDsNOHREpzpY0x10Wtd1110nPXr0kE022UQuuOCCmNujwQUNOqmCggJ56qmnzBQxnQ6kU8Os4IgOKH788UdzXR+7/vrrzbQLDbxNmTIl+HwaYIkW6Npmm23M69TnDR2Ab7XVViaQseOOOwbv//PPPyM+jwYEtB6XTgXR6UubbrqpuV8HYzoY6mo7jznmGNlzzz3NoPXII49s156uvn+dPX9n9Pf07dvXXNd2aHDi448/Nu/91VdfbaYcdUQHr5FW1vr111+T9juVBm40QGB9tnRq1eabby4VFRXB92/RokVxv9+xSvTzF+/nKd6/S7u+DxKR6HuSqr/lRL7j4nlNOsUvUl2/SJdzzz1X7KZTBTXQqEFG/bvUtmsdQb3fOtGhtZ8S3T4Z7HrvAQDpRRAKADKkMHlHA3nL4sWLY3p+zQ7oyLJly4LXdUCgdXosWrcnVqHtGThwoBnkRaJnvi060Ij2+6K9PuusudJBtkVrvFjy8loXjG1sbIz4PNZZ9ki/W49JV9u58cYbB6/rILZte7r6/nX2/J3RgJFmU2222Wbm86aDYw1qaVBkwIABCdcES+bv1EyWnXbaSW666Sb54YcfTCAgkkjHoLP3O1aJfv7i/TzF+3dp1/dBvLrynqTqbzneY9mV15QOGhx77LHHTK03rTOlwc0zzjgjrB5TaE2+eLePVywZYna99wCA9CIIBQBZRAdToYNaHThFOvMeOiUrEiszRenUnYaGhrAix7Fac801w4qT6zSxSNZYY43gdc0kiPb7QrcLFTowCZWfnx+8rq+7M/PmzQu7Hfq79Zh0tZ2h7dHgi93vX2fP39H9lh122EG++eYb875rRtJDDz1kCsrr6z355JPl999/j7qvFpyP1N7OppJ25XfqdKFvv/02+HnT59Fi2/p7Q49nIu93rBL9/MX7eYr379Ku74N4deU9SdXfcrzHMt7XpNNJI2UFRrrceuutkg6dfRcksr1mvFpCA3VWxl8q3nsAQHoRhAKALKIrQOnFGtTqykPz5883U3F0ao5Op9Ask86W29Yzz9ZZaR1IXHTRRSaApFN7dIWoWG2wwQZmeot11vrQQw81z6HP+cUXX8jhhx/ert01NTWmBonWZ9HMGF0VybLffvtJMj344INm2onWrLrrrrtMfRjrrLwGSpLdTrvev45ohoNFpyO1zYLRaTCafaRTcnSFNv19VlaJBjFiyciLV1d+Z+jAVa/rVER9b/75z3+a4EJX3u9ki/fzFO/fZSo+T3a/J3bp7L2N91g64TVFolMprWDW7rvvHrxf32t9TZ999pl5Xfq50tXnnn322eA248aNS3j7aEKzyHTKp05V/OSTT8xKjACA7EAQCgCyjA6+tA6Kuueee8xgXmueaEBIa37osuWxLMuu006sM986gNClyDWgFFqrIxZa90n3Vf/3f/9nnkOnim299damLZYHHnjALE2vbr/9dhMs0aW6tTCzNV1k8uTJkky77babTJgwwRw/nYpi+de//hV8Dclup13vXzQ6Zc8qpDxr1ixzXd/nq666KpjBMXHiRLOd/l7N8njzzTfNY3oMtNaN3bryO7U+jzUNccGCBbLWWmuZ16RFjvV6V9/vZIv38xTv32WyP092vyd2ieW9jedYxvuaulITygoq6XsfWl/Puv+www7r9PXrVEytMaavRV+Xfq5OO+20YHFxDWwefPDBCW8fjX6mrDpS06ZNM1Owx4wZI3vvvXen+wIAMgNBKADIMjqI0GkjOvDSwazWOtGBmA6itPCrDu7Hjx/f6fPooOOll14ymSn6HJo1cN9998kJJ5wQV3t0f81C0IGWZmVoMV8d4Oyxxx7y6quvBrfbbrvtTFDkpJNOMoM6ndahg+URI0aYAInWIykrK5Nk1+LSqUlan0h///rrr28KY2uGSqraadf7F40OnP/3v/+ZQs2hU2csX331lZx33nkycuRI8zp0KszgwYPN4FJfW2gmlV268js1K+W1116TAw44wGynr08z7F555ZXgYLgr73eyxft5ivfvMtmfJ7vfE7vE8t7Gcyyd8JrioQHHW265xRyHQYMGmb8pbbdmM2lgUuuwhU6vi3f7aPR75fnnnzd/y/o51mm1uu/++++f5FcMAHCKHD+TpwEAiOrMM88MLuGug1SdlgIAAAAgfmRCAQAAAAAAIOkIQgEAAAAAACDpCEIBAAAAAAAg6agJBQAAAAAAgKQjEwoAAAAAAABJRxAKAAAAAAAASUcQCgAAAAAAAElHEAoAAAAAAABJRxAKAAAAAAAASUcQCgAAAAAAAElHEAoAAAAAAABJRxAKAAAAAAAASUcQCgAAAAAAAElHEAoAAAAAAABJRxAKAAAAAAAASUcQCgAAAAAAAElHEAoAAAAAAABJRxAKAAAAAAAASUcQCgAAAAAAAElHEAoAAAAAAABJRxAKAAAAAAAASZeX/F8BIFYvv/yyNDQ0RHysqKhI9t57bw4mAGQ5+goAQGd+++03+frrr6M+vsUWW8g666zDgUTKEYQCHOT444+XnJwcGTt2bLvHevbsSRAKAEBfAQDo1Ouvvy5nnXWW7LjjjtK3b992j5eXlxOEQloQhAIcZvjw4fLss8+muxkAAAejrwAAxGLKlCkybtw4DhYcgyAU4EIzZsyQBQsWyJ577iklJSXB+ysqKuStt96StddeW0aNGpXWNgIA0sfn88kLL7xg+gOdctHWxx9/LJWVlaYfAQBkr6qqKnnzzTejPr7PPvtIYWFhStuEzEYQCnAh7QiOPvpoOfjgg+WRRx4x9/n9fnPf+++/L19++WW6mwgASCOPxyN33HGHzJ8/X3799Vcz1Tt0wKHBp/33358gFABkOe0TnnzyyXb365hixYoVsmjRIllzzTXT0jZkJoJQgMMsW7Ys4nS8wYMHyzbbbGOub7755nL77bfLySefLKNHj5ZTTz1Vrr32WlOs9plnnpH1118/DS0HADiprzjjjDPkkEMOMWe4d9999+A2jz76qBl0nHjiibxhAJDhPvjgA1m+fHm7+3fbbTfp3r27DBgwoF1/8sQTT8jzzz8v++67r/Tr1y+FrUU2IAgFOMzSpUsjno0YM2ZMcGChTjrpJDOd4txzz5Wamhq59NJLzfWDDjooxS0GADixr9BMp/79+8tdd90VFoS6++67ZdiwYaZYLQAgs7377rvy3XfftbtfT2RrEKotHV/oYkla2uPxxx83mbWAnQhCAS4uNqsDCV169fzzz5fttttOrr/++qS3DwDgjr4iLy/PZMxeeeWVMm/ePBkyZIgZXOhgZOrUqSlrKwDAHYXJf/nlF9lvv/3M9DudYRFaexawC2FNwMWam5ulvr4+uMyqDjgAALBoEErPYv/3v/81tzUrKjc3V4499lgOEgAgSKfsab1AHV+89tpr1IFC0hCEAlzshBNOkIULF8rVV18tb7zxhlxzzTXpbhIAwEG01oee1b7//vvNqqrPPfecGWToND0AAJSe1Nb6T3PnzjW1oDbeeGMODJKGtAnApW6++WYzmPjf//4nRx11lDl7cfnll5tpeTvttFO6mwcAcIjTTz/dTN078MADpbGxkYLkAIAgXWFbs2M/+eQTefDBBxlHIOkIQgEuWfFI6RmK/Px8mT59ulx00UVy2mmnmQCU0npQn3/+uRxxxBGmThRnuQEgu/sKy/jx481Zbe0j1lhjDdlrr71S2FIAgBNXx1tvvfVkxIgR8sILL8jTTz9tFrYoLS1t17fss88+UlhYmMIWI9Pl+DX0CcAx0+sqKyujPv7II49IcXGxnHfeeWZFvDvvvDOsU9CpefrY9ttvL+ecc06KWg0AcFpf0baY7E033WQWsbjwwgvluuuuS0ErAQDppKU67rvvvqiP77333nLcccfJRx99JLfddlvU7fQ5evTokaRWIhsRhAIAAMiCwJVOs5gzZ45ssMEG6W4OAADIUgShAAAAMlhdXZ0MHDhQRo4cKe+++266mwMAALIYNaEAAAAytG7Ue++9J88884yZvscKqgAAIN086W4AAAAA7Ld06VJTbFZrebzzzjuy7bbbcpgBAEBaMR0PAAAAAAAASUcmFAAAAAAAAJKOIBQAAAAAAACSjsLkSebz+eSvv/6S7t27S05OTrJ/HQDEzO/3S1VVlQwYMEA8Hs5JpBN9BQCnoq9wDvoKAJnQVxCESjINQA0ePDjZvwYAEjZ//nwZNGgQRzCN6CsAOB19RfrRVwDIhL6CIFSSaQaU9WaUlZVJuqOTFRUVUl5e7oqsLLe1141tpr3ZfXx1yXYNklvfU0gf+orM/TvLhDbT3uw+vvQVzkFfkbl/Z5nQZtqb3ce3Mo5xBUGoJLM+IBqAckIQSi/aDid+cN3eXje2mfZyfJUbPquZjr4ie77H3Nhm2svxVW74rGY6+ors+R5zY5tpL8dXxfJZpQgIAAAAAAAAko4gFAAAAAAAAJKOIBQAAAAAAACSjiAUAAAAAAAAko4gFAAAAAAAAJKOIBTgIPNW1Mp+/54uC1bVprspAIA08/n8csr/vpRJT89Kd1MAAC7z0+Iq2f3WD+XP5TXpbgoQhiAU4CBXvfqDzJq/Wq59fU66mwIASLPvFlbIm7OXyPNfLZRfl1anuzkAABe55rUfZc7iKrnzvV/T3RQgDEEowEG6F+Wbn9UNzeluCgAgzb5dWBG8/t3C1WltCwDAnfz+dLcACEcQCnCQ7kV55md1PUEoAMh2vy9rzX76cznTtAEAscvJ4WjBmQhCAQ5SWhgIQpEJBQBZb0llfcTrAADEyi+kQsFZWka8AByhG0EoAEDA0soG6d2tQKoamglCATFYuHChPPLII7JkyRLZdNNN5eijj5aCgoIu72PXNur//u//5N1335WSkhI58sgjZd111+W9RVKQCAWnIhMKcJA8T05wRSQAQHZbWtUg/cqKZM2yIllc2ZDu5gCONmfOHBP8+fTTT6Vv375yww03yM477yzNzc1d2seubbxerxx88MFy3HHHSWFhobno7dmzZyfxqAAmFQpwFDKhAAfO3SYGBQDZze/3y9KqetmmT2+pK8yTX0PqQwFo76KLLpIRI0bItGnTJCcnR44//nhZe+215dFHHzWBn0T3sWubW2+9Vd5880357rvvZOjQoea+s88+W2pqang7kRT6WQSciEwowIGYuw0A2U2n4NU3+aRf90Lp271QVtY0SrPXl+5mAY7U1NQkb7zxhhx++OHBgfeAAQNk/Pjx8tJLLyW8j13bqLvvvttMv7MCUKq4uFj69OmTtOMCKBKh4DRkQgEO4gn854WlVAEgu62qaTQ/e5UWSF5dy5Seyvpm6dWt4/o2QDaaO3euNDY2muyjUHp7+vTpCe9j1zYVFRXy22+/yeWXX26yo2bOnGkCVYccckhYUKqthoYGc7FUVlYGMyX1kk5WG9Ldjkxtr51tTtXrdtsxpr32iud9JwgFOAjT8QAAqqKuyfwsL86XnEB5Wb2PIBTQXl1dnfnZvXv3sPvLysqktrY24X3s2qaqqsr8vPrqq2X48OGy/fbby2effWaCUjpFb4cddojYxqlTp8qUKVPa3a9BrXQP9PX3V1dXu2bal9vaa0ebm5uagtl6+plJNrcdY9prLytIHguCUIADM6FInAWA7FYZyH4qKwoPQgFoTwM+avXq1WH3r1q1KvhYIvvYvc2QIUPkueeeC27zt7/9TS699FJ5//33I7Zx8uTJMmnSpLBB3uDBg6W8vDzq60oVKwimbXFLwMFN7bWjzfkF+eZnXn6+eY5kc9sxpr32iuc9pyYU4CBkQgEA2mZC6SX0PgDhNDCjmUg//PBD2P16WzOPEt3Hrm00YKTbjRw5MmwbLWau0/mi0RX0dN/QizXY48Ix6PQzEPgc6U8+L3xeclJwDGJFEApwEOuPN90p1gCA9Kqsbwk4lRGEAjrl8XhMfaUHH3wwOAVO6y598skncthhhwW303pMV155Zcz72LWN0qLkb7/9tpkapbxer7z11lsyatQo3mEkSWBcwfGFwxCEAhzEih/76C0AIKtVkgkFxEXrJ+lJvM0339wEhXbeeWc56aSTZK+99gpuo9Pennrqqbj2sWubSy65REpLS2XTTTeVY445xvzUKXw333wz7zSArEJNKMCByIQCgOxmTb0rK8qT3ECWrBWYAtBe37595auvvjLZRkuWLJGLLrqoXZbR0UcfLbvuumtc+9i1jQagNAj2wQcfmCl4xx13nClInp/fMt0WsJs1O4oJFnCatAehHnnkEbntttvMF7aeEbjuuutks8026/I+dmxz/vnny0MPPRS2z0YbbSQfffSRLa8daMtKgCIRCgCymzUdT+tB5XoIQgGxKCgokD333DPq42PHjo17Hzu30al748eP73AbAMh0aZ2O9/TTT8vEiRPlrLPOknfeeUcGDRpkvpg1KNSVfezaRpeYHD16tMyZMyd4efnll5N4RIAWnLEAgOxmrY7XvShfuhW2nDOsbfSmuVUAALdgzW04VVqDUFdffbUcf/zxJh11gw02kP/85z+Sl5cnd911V5f2sWsb66xGnz59gpcePXok6WgArdEnH1EoAMhqtY3Nkp+bIwV5HulW0BKEqmlsCUwBAAC4VdqCUBUVFfLtt9+awn2W3Nxc2WmnnaJOd4tlH7u2sbz33nsyZMgQM13v9NNPl2XLltl4FIAo0/GYjwcAWU2znkoCwaeifI+p7VHbQCYUACDemlAMLOAsaasJ9ddff5mfa6yxRtj9envWrFkJ72PXNqp///5y4403mvnjCxculAsvvFC23357s01JSUnENjY0NJiLpbKyMvjHn+4vAKsN6W5HprbXjjb7Asvi+SU1r9ttx5j22n88AThTTaNXuhXkmus5OTkmG4pMKAAA4HZ56R78aAZSKJ0S5/P5Et7Hrm3U5ZdfHry+zjrryLRp02Tw4MHy5JNPygknnBCxjbpE65QpU9rdr9lX6R7w6e/XOlfWf2idzm3ttaPNdXV1gedp+cwkm9uOMe21lxUkB+A8tQ3NUhwIQqmSglxqQgEAYpYTqArFKUc4TdqCULqUqWo7vU1vW48lso9d20TSr18/MzVPC5RHM3nyZJk0aVLYIE8DV+Xl5VJWVibpZAXBtC1uCTi4qb12tLmoeFXgeVqeI9ncdoxpr73c8J4D2Twdr3dpQfC2FievaaAmFAAAcLe01YTSYM/aa68tH3/8cdj9H374oWyzzTYJ72PXNpHU1taaqXwdBaoKCwtNsCn0Yg32uHAMOvsMWLQwOZ8XPi+p+AwAcG5h8uJ8MqEAAIkJ/jePVCg4TFpXxzv77LPlvvvuk88++0yam5vl+uuvN0GeU045JbjNeeedJzvssENc+9ixjdZ1Oumkk+T3338PZknpSno6Ze/www9P0RFCtrFmbNJXAEB200wozX6ydCvIM4EpAAAAN0vbdDx1zjnnyNKlS80qdRr0GThwoDz//POy/vrrB7epqqqSVatWxbWPHdtoRtOYMWNk7733lrlz55r79Launjdo0KAUHSFk7+p4hKEAIFs1e33S0OwzdaAsJYW5UsPqeACAeFfH4/Q2HCatQSidCnLNNdfIVVddJTU1NdK9e/d229x6660mUymefeza5thjjzWX+vp6KSoqsuU1Ax2xgk+BRfIApIn2O6tXrzb10vLz8zvcVvsQa1EBi2bN9ujRI8mtRKaqbfKan6FBqG4FeVLX5BWvzy+5HqbSAgAAd0rrdDyLx+OJGARSpaWlEf8j39E+dm9DAAoAssOCBQvkn//8p1mEQuv/TZ8+vdN9/v73v5ts2g033DB42WeffVLSXmSmukYrCNV6rtAKSGkgCgCAmFfH4+Q2HMYRQSgAAJzgscceM9Oxp02bFtd+GnRavnx58KJTt4FEWavgdSsMyYQK1IeqZYU8AADgYmmdjgcgHGcqgPS66KKLghlR8dJpecXFxSbDFuhqUfJomVA1gccAAOiQVROKTCg4DP9TBhyEwoGAO7300kvSp08f6datm+y0007y3XffpbtJyIggVPtMKCtLCgAAwI3IhAIchDMVgPuMHDlSPvjgA9lmm21kxYoVcsYZZ8iECRNk9uzZpq5UJLoqq14slZWVwcUJ0r06ptWGdLcjU9sbS5trGprMz+L83OA2er3lseaUv1a3HWPaa//xBADALgShAAfhv3mA+5x66qnB6xp0evDBB6Vfv37yzDPPyOmnnx5xn6lTp8qUKVPa3V9RUZH2AZ/+/urq6uBKsk7ntvbG0ublq6taHvM2mM+E8ngbzc9lqyqloleuo9rrNLTXXlaQHAAAOxCEAgDARjolb8CAAfL7779H3Wby5MkyadKksEHe4MGDpby8XMrKytL6flhBMG2LWwIObmpvTG3OawlC9elRZrZRvXvUtjyWXxi8L1Xcdoxpr73c8J6H+vHHH2XJkiWy0UYbyRprrGHbPl3d5ocffpB58+aF3acrdG+//fYxvzYgHtZfLuU+4DQEoQAHIeMdcD7NCGlubpYePXpEfHzp0qVmoLHWWmtFfQ5dgU8vkQZ7ThjwWe1wQlsysb2dtbmuqbUwufW4NR2vvsmXltfptmNMe+09lm6gi0MccMAB8vnnn8uwYcPk+++/l8svv1z+8Y9/dGkfu7a5/fbb5cUXXzRTuC3aTxCEQrIxvoDTEIQCHIQzFUB6aZ2mqqoqWbVqlbmtU6GWL18uJSUl5qLOPfdcmTFjhhlk6Pa77rqrWVVv+PDhJvik1/UM+FFHHZXmVwO3FyYvDilMXhQMQrE6HhDJZZddJj///LP88ssvZqGIN998U3bffXcZM2aMuSS6j13bKL3+7LPP8gYiJdwSQEb2YXU8wEE4UwGk1wsvvCAbbrihjB8/Xnr37i0nnniiuX3nnXeGTZ/o2bOnua7ZTNdff73cd999Mm7cODnnnHNkq622kpkzZ0bNlAI609jsa/l85bX+N60ov+U6QSggskceecR8Z2sQSO22226y+eaby8MPP9ylfezaxsqY+vDDD+Wbb76R+vp63koklRWC8lF0Fg5DJhQAAAGHHXaYuXTklltuCbutq+I9//zzHEPYpqHZGyEI1ZIJ1RAIUAFotWDBApO1qoGfUHpbAz6J7mPXNhYNQGmG7V9//SW1tbVy9913y4EHHhj9u4CVVLN21Uw72hxaEyoVr9ttx5j22iue950gFAAAgAMzoQrIhAJisnr1avOzV69eYfdrRqs1vTqRfezaRv3tb3+T6667zhT418HaFVdcIUceeaRssskmssEGG0RsIyupZu+qmXa0ubGpZVXVxsam4EqryeS2Y0x707eSKkEowEHccuYAAJA8VrZTYV5rTSjrOtPxgPYKCgrMz7q6urD7NdvIeiyRfezaRu25557B6zpAv/TSS+W2226TV155JWoQipVUs3fVTDvanJ+fb37m5eWlZFVVtx1j2muveN5zglCAgxCDAgBEzoRqXR0PQLjBgwdLbm6uzJ8/P+x+nSoXbaXSWPaxa5tIPB6PqR24aNGiqNuwkmp2r5rZ1Tb7AxPytCZUql6z244x7bVPPO85hckBByEPCgDQmglFYXIgFsXFxbLjjjvKiy++GLxPpx+9/fbbZpU6y+zZs2X69Okx72PXNj6fr91UFW3L3LlzZeTIkbzJSGqmD+MLOA2ZUICDkAkFAAhmQuVGyISiMDkQ0TXXXGNWKT3rrLNku+22M0W/NUtJV60LXVhixowZ8v3338e8jx3beL1e2XrrreWII46Q4cOHy7x58+TGG2+UMWPGyKGHHso7iqSwgk+U+4DTkAkFOIiuXgEAyG66Op4GoDye1tT2/FyP5HpyqAkFRLHtttvKp59+alaUe+qpp2Ts2LEm66mkpCS4jRYB18BPPPvYsY3W5vnkk09MbZ4nn3xSfvzxR7n22mvlvffeC9btAWwXGFZwkhtOQyYUAACAw6bjhdaDshTleQhCAR3YfPPN5Z577on6+Lnnnhv3PnZto6vnXXzxxR0+B5CMk9s+olBwGDKhAAehjwAAaBAqtB5U6JS8BgqTAwDiGFcwvoDTEIQCHITJeACAxmiZUPm5Ut/s5QABADofVwQGFl6iUHAYRwShdMWI6upq2/exaxvV3Nwsy5cvl5qamrjaCcSFTgIAsl60TKjCfKbjAQBiHFYETm9TmBxOk9YglP5BXHLJJdKjRw8zT3rttdeWV199tcv72LVNqDPOOEP69u1r9gGShUwoAECjFiaPWBMq1wSoAACIORPKxwgDzpLWINRtt90m//73v+X//u//pLa2Vk477TQ54IAD5Oeff+7SPnZtY3n22Wfliy++kI022igJRwEAAKBVozfadDwyoQAAsbFCT8Sg4DRpDULdcccdMnHiRLOsqS5ZeuGFF8qAAQPkv//9b5f2sWsb9eeff8rZZ58tjz32mBQUFCTpSAAtmI0HANDi44V5uZFrQlGYHAAQx7iC1fHgNGkLQi1btkx+//13GTNmTNj9O+64o3z22WcJ72PXNlYdqCOOOEL++c9/kgWFlM7dBgBkeSZUbpTC5E0UJgcAxKJlXEEQCk6Tl65frIEgpXWWQuntGTNmJLyPXdsoDT717NlTTj/99JhfV0NDg7lYKisrgzWo0l0UzmpDutuRqe21o82hu6XidbvtGNNe+48nAIdmQuVHno6nNaH0bzcnJyctbQMAOM9fq+uk2euXIb1LItSESl+7AEcFoaz/PHm94Wf0NPvI4/EkvI9d23z00Udyzz33yMcff2xWxbO2r6+vN7f79OkTsY1Tp06VKVOmtLu/oqIi7QM+/f3WSoBu+M+r29prR5v182VZvXp10l+3244x7bWXFSQH4JJMqMAUPQ1EaVYUAACaITvhpg8kPzdHPp08QboVtgzxrZFnuseggGOCUFp/SS1ZsiTsfr3dv3//hPexaxstUK4BKZ2iFxoU+PXXX02hct02N7f9fwAnT54skyZNChvkDR48WMrLy6WsrEzSyfoC0ra4JeDgpvba0ebCwsLg9e5l5ZLrSX4Qyk3HmPbayw3vOZBtmr0+s5JRYYQgk3WfDjgIQgEA1FdzV0ldk1fqmkS+mrdKdlgvfLYPq+MhY2pCPfnkk7LLLrvIuuuuG7zvqquukqVLl8a0vw56N9tsM3n77beD92mm0bvvvis77LBD8D7N0tDgT6z72LXNiSeeaDKeQi+bbLKJnHLKKeZ6pACUFUTQYFPoxRrsceEYdPYZ8EtrUEDDQ3xm+Mwk+zOQSbraLwFOyYJSkWtCtdxHcXJkGr6/gcT9srRlVoP6aXFVu5O31IRCRgSh7r33XrNinAZstMC3pVevXnLNNdfE/DyXXHKJPPjgg/Lwww+bzKNTTz3VTIk77bTTgtuce+65YQXEY9nHrm2AdBYm56wFkPp+CXBCPSgVuSZUayYUkCn4/ga6Zu6K2uD1RRWtpT2sUYWP2XjIhCDUzTffbKakXXbZZWH377nnnvLUU0/F/DyHHHKI3HfffXLbbbfJ+PHjZf78+SYbac011wxu0717d1McPJ597NqmLW1HaWlpzK8PiFtYYXKOH5DqfglwciZUYZ4nWBMKyBR8fwNds7SqNfC0pLK+3ViCTChkRE2oP/74Q7baaitzPXQ6hwZpVq5cGddzHXPMMeYSzS233BL3PnZuE+q9996LeVsgEaFxJzoMID39EuDUTKiCQBCqkSAUMgjf30DXLK9ukPLifMnz5MjSyoZ24wpmVyAjMqEGDhwos2fPbvef/VdffVWGDRtmX+uALBO6egVBKCB29EvIFI2BlXsLI2RCWdlRDc1Mx0Pm4Psb6Jrl1Y3Sp7RA+pUVyeKwTKiWcQWzK5ARQSitm3T88cebwt4ahNKA1E033WTuP+OMM+xvJZCFfMy2AGJGv4RMYRUd72h1PDKhkEn4/ga6ngnVp7RQ1igrNNPxQk9qKzKhkBHT8f7+979LVVWV7LvvvmZVOV01rri4WC688EI5/fTT7W8lkCVC+wwyoYDY0S8hK2pCWZlQgW2ATMD3N5C4Jq9PVtc2SZ/uhaaP0JqBejKjuCCXmlDIrEwozX6aMmWKrFixQr766iv58ssvZfny5fKvf/3L/hYCWYSaUEBi6JeQKawsJ6v+UyhqQiET2fn9fc8998jw4cOlT58+ZuGhmTNn2rKPXdtY9PXqYkcXXXRR3K8RCLWyptH87NOtQMqK8831irqmsFW3ObGNjAhCWYqKimTzzTeXUaNGSUlJiX2tArJUeCZUOlsCuBP9EtzOWvnOWgkvFKvjIZN19fv7sccek7PPPlsuvfRSEwDSgNCECRPkr7/+6tI+dm1j+eCDD+TRRx81K3I3NLQWkQYSURkIOGlhcr2EBaGCq+NxbOHS6XgTJ06M+Unvu+++RNsDZDXrjIXirAXQMfolZCIyoZANkvH9PXXqVFOz9rDDDjO3b7/9dnnuuefk7rvvliuvvDLhfezaRmm2l67M/cQTT1DCBLaorG82P7sX5YvHkxMxCEVNKLg2CFVf31ppv7q6WqZNm2ZWs9AzFurrr7+WhQsXmjpRALqOIBRAv4TsY618V5jXvjA50/GQKeweV6xevdoslBQ6hc/j8chOO+0kH3/8ccL72LWN5bjjjjOX0aNHx/S6gM5U1bcEnMqK8yTX4wnLjmI6HlwfhNK0UctJJ50k55xzjtx4442Sl9fyFM3NzXL++edLbW1tcloKZNl0PM5aAB2jX0LWZUJZhckDgSrArez+/ramvfXr1y/sfr0drTZTLPvYtY269dZbZdmyZWbKXqx0ul7olL3KykrzU1c/a7sCWqpZbUh3OzK1vbG22Qo4lRbmSX6gj1hd1xjYr2Ubny81r9ttx5j22iue9z2h1fFeffVV+f7774MdhXmivDzzpbrZZpsl8pQA2vCx+BFAv4Ss02FNqPzcsEAVkAnsHFdoBlLb250NjGLZp6vbfPPNN3LVVVfJZ599FvY6O6PT/LSIeVsVFRVpH+jr79csNqu4vNO5rb2xtnnpqirz0+NtlLzANktWVpnPiAZzldfvN7ed0F4nob32soLkSQtCVVVVydy5c6VXr15h98+bN888BiAxof+h0A4DAP0SskssmVAEoZBJ7BhXWFlImmkUSm+3zVCKZx+7tvnoo4/MtL0RI0YEH6+rq5MffvjB1LzSAEFubvspuJMnT5ZJkyaFDfIGDx4s5eXlUlZWJk74P6u2xS0BBze1N9Y2N+UsNz/X7F0uRfmBPkJyzT6ewGdKC5PrbSe010lor73iec8TWh3vkEMOkYMPPliefvpp+eOPP+T333831/W+Qw89NJGnBGDmbrfykgoF0C8hi2tCRQhCBe6zsqWATGDHuKJPnz4ybNgw+fDDD9utRLftttsmvI9d25xyyikmCLV48eLgRVfQ06mIej1SAEoVFhaaYFPoxRrsceEY6GeguqEl20lXxisrLjDXqxu8YQEBDbbweeHzkpOCY5DUINSdd94pe++9t1ndYZ111pF1111Xjj32WNlnn33kjjvuSOQpAbThZYwB0C8h63SUCWUFphrpIJBB7BpXnHvuuXL//feb4I8WPtdV6ZYuXSqnnnpqcJszzzxTtt5667j2sWOb/Px8KS0tDbvodD3rfiBRlXWtq+OVFrRMcqptbLmP1fHgVAlNxysuLjbF9XSesp6tUNpp6P0AEhc6A6+ZTCiAfglZXBMqN3oQikwoZBC7xhVnnHGGrFixQvbff38zvW299daTl156yQS1LBogCi12Hss+dm0DJIOVCdW9KE88gUyUmoaWjFprWKHT8QDXB6Es2jloKikAe1hLqSpiUED86JfgdlaAiel4yDZ2fH9fdtll5tLU1GSyjNr697//Lb42/8HqbB87twn16aefRp2GB8SqpqFZcj05ps/Q6VBaO7A1Eyp0XOEXj8f5dZqQHRIKQk2cOLHDx7XAHoD4kQkFJIZ+CdmwOl5rTaiWs9xAJkjG93e0IJDWWIp3n2Rso5hBAjvUNXmlJD83WI+npDC3XSaU8vn94hGCUHBxEMpaetGiZxR++eUXmTVrlpm/DSAxbTsLAPRLyM4gFKvjIVswrgASV9voleKC1oy6bgV57WpCWatud2kKFGCjhD6LTz75ZMT7tQhf2+VJASSYCeUlCAXQLyF7V8drP00nL9djpl1QEwqZhHEF0LXpeCUhQSi9btWJCh1JcG4bTpLQ6njRnHXWWfLCCy/Y+ZRA1tIzFgBS3y8tX75cbrzxRjNF5Keffoppn3nz5pkTMbry0n//+19paGhIsMXIdh2tjmfuz/UEs6WATMa4AohtOl5xYFU81a1QM6ECU7ZDxhJeqpMjU4NQixcvbpdSCyAeFCYH0tkvadHaESNGyA8//GCW2160aFGn++i2us9XX30lgwcPlttvv1122mknU5wWSCQIpdlOeolEg1NkQiEbMK4AOqcBp9BMqG6mJlT7TCjKfMD10/H0DHFbq1atkscee0z23ntvO9oFZCUKkwOJsatfmjBhgsmA0qnlDz74YEz7XHTRRbLFFlvI888/bwqDHnPMMbL22mvL//73PznhhBPieh2AZjlFKkpu0ccavWRCIXMwrgASV9cmCFViakJ5zcp4oeMKVt2G64NQjz76aLv7evbsaf7jfeGFF8b9fH/99ZcsXbpUhg0bJqWlpbbtY9c28+fPN2fS11prLVayQFKFdRZMxwNS3i9tuOGGcR31xsZGefPNN00GlbUyTf/+/WX8+PHy8ssvE4RC3DTLKdpUPKWPsToeMond4wogW2igSYuQF+eHFibPlWaf35ys8IfOsGBcgUwoTB7tP+pz5syJ+T/xWjNDO5iXXnpJBg0aZAJCejbktNNO69I+dm3zyiuvmDPc9fX1kpeXZ7a54IIL5LLLLovxSAHxCe0sKEwOpL5fipfWgtJpd3qSIpRmQn300UdR99M+KLRuVGVlpfnZcuYyvfXgrDakux2Z2t7O2qwBJs12ivZ6rOl4qXy9bjvGtNf+45mJ399AJmTOaqmnsEyowpbhfW2DZkO1bksQCq4PQm200UZRO6SOHmtLi7h+/PHH8uuvv8rAgQPlueeek4MPPli23HJL2WqrrRLex65tNANKA1E6mFBvvfWW7LrrrrL99tubKRtAMtFZAKnvl+JVV1dnfnbv3j3sfr1tPRbJ1KlTZcqUKe3ur6ioSPtAX3+/VUfLyu5yMre1t7M21zU0SV5Oy2chkjzxm+kX0R5PBrcdY9prLytInmnf34DbaV+gwgqTBwJSNY3NYUEoFjyC64NQ0eh/ULp16xbz9lr09eSTTzZBIHXggQfKxhtvLA888EDUIFQs+9i1TduMrHHjxpmMKA1OAcmvCcV/uoBU90vxKisrC9afCrVy5crgY5FMnjxZJk2aFDbI06Lm5eXlHe6XCtaAT9viloCDm9rbWZub/TlSXJhvHotEH6tqbIj6eDK47RjTXnul6z1P9vc34Ha1TS1BqLY1ocxjWhcqZFtiuXBtEOrcc8+NeF35fD6ZNWuWKc4aC53apqtetA02bbPNNvL1118nvI9d21j0TOOPP/5oBggauNpkk03kgAMOiPq6mGKRven0drQ5dDqe15v81+62Y0x77T+ebmdnv5QIDRxp0EhXyNtjjz2C98+ePdv0F9EUFhaaS6TBnhMG+VY7nNCWTGxvR23WOh7dCvKivpbCvFwzHS/Vr9Vtx5j22nssM/H7G3C7usbmdkGo0sB0vOoGzYQKGVdwchtuDULp1LVI11V+fr6MGjVKzjnnnJieS88Sq169eoXd37t3b1mxYkXC+9i1jUUDUNoxLl++3Ox36623dniWmikW2ZtOb0ebGxpal3SvqqlJ+nQLtx1j2uuuKRapYGe/FKuHH35Yfv/9dzOdzuPxyKGHHmqyaE899VRz1v6LL76QGTNmyKWXXmrr70V2aGjySa9uHRcm1yAU4Hbp+P4GMolmO6nisJpQucGaUKEIQsG1QSitj6SOO+44eeihh7r0i7VzUaGFWZXW0LAeS2Qfu7axbLvttmYwod555x3Zc889zQp5Wj8qEqZYZG86vR1tDv38FRYVJ326hduOMe21lxve81T2S+qTTz4xAaXa2lpz+4YbbjArN/3tb38zF6UFx7VfsGo6XXPNNaZO4IgRI2SzzTYzfYVO5w7NjAJipZlQBbnRg1BatLzBSxAK7mf39zeQrUGokrDV8fIi14QiEwpurwllR0ehUxj0DLJOjQult4cOHZrwPnZtE4kOMrbeemt59dVXowahmGKR3en0drZZO4tUvG63HWPaa++xzBR2DWD69u1rTj6onXbaKXi/rqJq0QGTnpCw9OnTR7788kt57733ZMmSJWYF1ZEjR9rSHmSfhiavFIYMKDpaHS+T/oaRvQhAAV0rTG7VgQrNiqrVIFToqtsEoeDGINSZZ55pft55553B69HoNp0pKSkx/9F/+eWX5cgjjzT36Znnt99+O2wKg0550OlCenY5ln3s2kbnouuy26E1O/S2FiXXQBSQDKEVeljFAkhtv6TWW289c+nImDFjImYx6uqpQLIzoTQIZW2n9aEAN0rG9zeQbSJOxwtcr2vUkxWt25IJBVcGoRYsWBDxeldcddVV5j/tGvjZbrvt5Pbbbzd1mnTVOotOc9BpD99//33M+9ixjU7V02DTKaecYlbNW716tfz3v/81AbHTTz/dltcPtOWjgCAg6eyXgHTy+fzS5PVLYX4HQahAgEqzoQhCwa34/ga6TrOd2hYmLw5k0tY1ha+O1+xjGjdcGIR68cUXI17vivHjx5vaGXqG48MPP5RNN93U1OIILfy97rrrmlpN8exjxzZa9+n11183walp06aZYrOjR482tUF0ugaQDJyxAGKXjH4JSCfNblKFHdWECgSoGpp90j1lLQPsxfc30HUaaGqbCVUUCELVaxCKk9vIpJpQdtpxxx3NJRot9B3vPnZtozVArr/++g6fA7ATmVAAkL00sKQ6zoRqGWCwQh7Q3m+//WZOKmt9Pj3BrDMc9MRyV/exa5t3331X3nzzTTOzYvjw4XL00UdL9+6Ek9G1mlBW9pO5HpyOF54JpVm2gGtrQsWCuduADTWhKCAIdIh+CZmmobllQBFTTahAwApwo2R8f3/77bemZt9ee+1lar9qQOixxx6Tjz/+WAoKChLex65tNCiliyDpQkd5eXny4IMPyk033SSff/659O7dO+bjAbQ9cWFlP4UGpEy9KGpCIZNqQgFIkpDOglUsgI7RLyHTWIElK9AUSWHgMWvwAbhRMr6///GPf5g6r0888YS5ffjhh5tVrx9++GE56aSTEt7Hrm0uv/xyGThwYPB3H3vssaYe7WuvvWYyooBET1xY/UJYYXJqQiHTakIBSP50PC1QCyA6+iVk7HS8Dla9IxMKmcDu7+/GxkazyvXdd98dvK9fv36y0047ySuvvBIxCBXLPnZto0IDUGrRokXi9Xpl8ODBth4LZI+GJmsKNzWhkGU1oSorK83P0KLfALpemJxMKCAx9EvIhkyoRm/LGXAgkyT6/T1v3jxpamoy2Ueh9PZHH32U8D52bWPRaXtab1Zf56xZs8zK2+PGjYv6unS1br20PT5acDq06HQ6WG1Idzsytb2xtLk+OIU7J7iNXs/J0ZpQzeHjCq8v6a/dbceY9tornvc9oSCURu1vueUWc9G5zVZ0f9KkSXLuueeKxxP9P08AYsyEcskXOOAE9EvIrEyozmtCMR0PmcKO729rJe3S0tKw+7Xod+gq2/HuY9c2Fl1he/fdd5fly5fLwoULTe2ogw46yEzLi2Tq1KkyZcqUdvdXVFSkfaCvv18LrKscjXo4nNvaG0ubq2vrzc+G2mqp8LZcV0V5HqmsbRCvr3XadmVVjfncpLO9TkN77WUFyZMWhNJ5zw899JBcdNFFstVWW5n7vvjiC/NFqStCXHfddYk8LZD1Qv87QSYUQL+E7BJLJpRVtJzC5MgUdowrysvLzc9Vq1aF3b9y5crgY4nsY9c2lv79+8tRRx0VLFS+/vrrm+DblVdeGXWVcA3GhQ7ydPqePm+6Z6FYQTBti1sCDm5qbyxt9ue0DOX79uoZ1m+UFOZJkz8nbJ+CouKofwupaq/T0F57xfOeJxSEuv/+++WFF16QsWPHBu/T69pxHHDAAQShgASFntWiJhRAv4RsLTLbeU0oMqGQKewYV2hgpkePHvL999/LHnvsEbz/u+++k0033TThfezaJpKSkhJZZ5115M8//4y6TWFhoblEGuw5YZBvtcMJbcnE9nbWZu0H9G7tF0If1xXy6pt84atu+/0ped1uO8a01z7xvOcJzZvTZUVHjhzZ7v4RI0ZIbm70/zgB6Bg1oYDE0C8he2pCtfw/i0woZAo7vr918HPYYYeZgFZVVZW575NPPpHPP/9cjjjiiOB2+rhmF8W6j13baF2nadOmtasP9eWXX8ro0aMTOGpAy4kLnb7ddvCvQSizOl5IFMrLgkdwkISCUFpATwvptXXPPffI+PHj7WgXkJXCzljQWQAxo19CttWEIgiFTGHX9/c111xj6jBtsskmsueee8puu+0m5513nuy6667BbT799FN5+eWX49rHjm00mPbEE0/IRhttZLK7dOW8bbfdVo477riIK/cBsfYZkTJniwtypa4xfPGKZi+1ZuEcCU3H0y9Znbf97LPPmlRZnUKkkXydv33iiSeaud2Wa6+91s72AhkttBg5QSggdvRLyJqaUMHV8VoLzgJuZtf3d8+ePWXGjBkyffp0U0vq5ptvlg033DBsm4kTJ8p+++0X1z52bKPZXk8++aTMnTvXrIrXrVs3E7Bac801u3TskH3u//gPWadPNxm/Yb9AEKp9f1EUyITSAuUWxhVwfRBKv0AnTJhgrv/000/mpxbH0/t0XnNHc5sBRBeWNsvqeAD9ErK0JhSFyZE97BxXaMbRjjvuGPVxzT6Kdx87txk6dKi5AIm68pUfzM8/pu7ZMh0vv31/URLIhArtS1jwCK4PQr399tv2twRAeCYUabNAzOiXkHWZUIFtAbfj+xuITVNIBux3CyukoSnKdLxAJlSZv3Wo7/XRZ8DlNaEAJE+up6W4IJlQAJCtNaGiF2O2zmwzHQ8AskttSJ2nFTWNph+IlDmrQSilK+RZmji5DbdnQqkffvjBFPdbtWpVu8fOP//8rrYLyNpMqDxPjpm3zdxtID70S8imwuTWtkAm4Psb6FxosfGGJq/JhOrdLUJNqIKWIFRtY7PouW1d64hxBVwfhLrzzjvlnHPOkcGDB0uPHj3aPU4QCkiMzsbTIFQDBQQB+iVknZim4+UyHQ+ZhXEFEBudYhd63dSEijIdz8p+Ksr3mIwoakLB9UEoXYb0qaeekoMOOsj+FgHZngllBhhezlgAcaBfQrZkQllFaK0i5oDb8f0NxEYzmywaWDKr40UpTG7Jz20JQlETCq6vCVVZWSl77LGH/a0BspxmQmnarGZDhRYfBNAx+iVkAjKhkI34/gZiUx+aCdWomVCRa0IVBTKhQrNnyYSC64NQumTqa6+9Zn9rgCyna+N5cnIkL5cgFBAP+iVkAiu7qaPC5KyOh0zD9zcQm9Dz0zUNzWbWREfT8axMqJZ9W1fgBlxbE2qrrbaSadOmybrrris5OS2reVn+9a9/2dU+IKv4/X7RP6d8j4czFkAc6JeQNZlQrI6HDMP3NxB72Q5LRV1T1P6iOHQ6Xl7LOJ3V8eD6INTNN98sS5culVmzZsmff/7Z7nGCUEBitG/RoG5+nic4GAFAv4TsENPqeBQmR4ZhXAHEJiQGJTWB+lCR+ou2NaEUNaHg+iDUgw8+KK+88orsueeeXW5Ac3OzfPTRR7JkyRLZdNNNZfjw4bbsY9c2ixcvli+++ELy8vJk1KhR0q9fvy68WqDzMxx6vkJrQjF3G0hPvwSki5580GxY7QOi0RMVGojiRAUyBd/fQOwzJiw1DdGnb1MTChkZhMrPz5cdd9yxy7985cqVsssuu5ifm2yyiXzwwQdywgknyK233tqlfezYRv/I9fY777wjI0eOlNraWvn000/lxhtvlNNOO63Lrx3oqCZULoXJgbT0S0A6tSy37WlX5qAtnX7RyOIVyBB8fwOxCS3rVNsYCEJFWB2PmlDIyMLko0ePlhdffLHLv/ziiy+Wuro6+e677+Tll1+Wt956S26//XZ58803u7SPHdtoEGrs2LHy+++/y0svvSRvv/22efyss86SP/74o8uvHYjWuZiaUKYwOQUEgVT3S0A6aWDJmm7XWRDKmroHuB3f30Bs/OZ0dYvaDqbjhdWEym05qcEMC7g+E6q8vFyOO+44eeGFF2TYsGHtzthde+21nT6HBnmefPJJ+ec//ymlpaXmvm222cZcHn/8cdltt90S2seubTwej3mNofbZZx+ZOHGi/Pjjj7L22msncuiAzv4wWqbj5XqkmbPcQEr7JSDdGpp8UhiyqlE0OuhgOh4yBd/fQBcyoWJdHY+T23B7EOqvv/6ScePGSUVFhcycOTOhXzx//nyzf9s6TDo17quvvkp4H7u2ieSNN94wwSndLpqGhgZzsVRWVpqfGvgKncebDlYb0t2OTG2vHW0OFibPzZG6Rm/SX7vbjjHttf94Zgo7+iXATZlQBKGQKfj+BuL/f5uOE2LJhLJWzyMTCq4PQunUtK7SgYLq0aNH2P29evUKPpbIPnZt09avv/4q5513npx99tkyZMiQqK9r6tSpMmXKlIhtT/eAT39/dXW1ud5ZvQkncFt77WhzU3Oz+P0+yfH7paHJG/XzmK3HmPbaywqSZwI7+iXAGZlQMQShcnU6XssABHA7vr+BLqyOF2NNqGYfU7jh8iBUND6fzxTy1oLfnSkuLjY/a2pqwu6vqqoKPpbIPnZtE2revHmy8847m7PsN9xwQ4eva/LkyTJp0qSwQd7gwYNNqnFZWZmkkxUE07a4JeDgpvba0WZPbq7k5fqlqCBPvDVN5nmSyW3HmPbayw3veSr7JcAJmVCRzmq3pWe2K+ubUtImIF34/gba/E1EzITqbDpeoCYU0/GQaUEond6my6s+8MADMnfu3JgyfjSbSFfD+PPPP8Pu19vrrrtuwvvYtU3oa9Pg0+abb27qSOXldXzICgsLzSXSYM8JAz6rHU5oSya2t6ttbi1M7jFps6l43W47xrTX3mOZqRLpl4B00yl2ZcX5nW7HdDxksq5+f3/99deyZMkSU3ZDTwTbtY8d2+gJ71mzZpnxhJb36N69e1yvDdktYiZUJ9Px8jweyWPVbWTC6niqqalJnnvuOdljjz1krbXWknfffVfOOeecmFeOKygoMGemn3rqqeB9+qWtz7P33nsH7/vkk09k2rRpMe9j1zZqwYIFJgA1YsQIefrpp03gCkgm/Y+Wx9SE8kgThcmBlPZLQLrpFLvCWGpC5VITCpnFju9vDfDoyta6wNDVV18tG2ywgfzrX//q8j52bKP/v9OyHuuvv75ccsklZrVtPSn+6KOPxvz6gNBMqPomX9QglN5nnWe0Tm5rpi3g2kwoXRnu/vvvl0ceeSS4gpwW7H7//ffj/uXXXXedbL/99nLIIYfItttua856jBw5Uo499tjgNnoWZMaMGbLvvvvGvI8d29TX18tOO+1k6uXsueee8thjjwX31f3WW2+9uF8vEFNhcrM6Xg5BKCAN/RKQTg3NvmAR2Y6QCYVMYef3t656vXDhQvnpp5+kZ8+eJpA1YcIEc0JZL4nuY8c2GoQaOnSo/P7778HSH7fddpuccMIJJngVa8YWsluknMBIK6pqprtOydMV9FpObjOugIszoTT4oqmj3377rdx1110mXbYry17rc33zzTey4YYbmi/tU045xXQ6oRlH+jv322+/uPaxY5vm5mYZPXq0OSMzffp085h1WbRoUcKvGeiIX7sXazoec7eBlPdLQLqDULHUhNJtOKsNt7Pz+1uDPJpVdOKJJ5ogkNKTyaNGjZL//e9/Ce9j1zYaYDv33HPDas8efvjhJgPsu+++S+g1I/tEmpoarc+w6kJ5cvTERS4rqsK9mVA6NW6rrbYyX6K77767+ULtKk25veKKK6I+fvzxx8e9jx3blJaWykMPPdTh/oDdtCaUdcZCa0JpZ5PJdXuArkpGvwSkg37fN8aYCaWFaJu8fvH5/OLREQaQ5d/fWkJj5cqVpoRGKJ3loCedE93Hrm0i+eCDD8xPPSEeTUNDg7m0XdVWvy/SXevQakO625Gp7Y3U5tDpeKHTsyO9pqJAEErHEQW5OaZ/SfZrd9sxpr32iud9jysINXPmTLnvvvvkiCOOMCu9acRf00gB2FsTSosIKh1kFOQxwADol5DprMymWFfHs/Yp8rSfigG4gZ3jioqKCvPTykSy9O7dW1avXp3wPnZt05ZmfZ199tkyceJEWWeddaK+rqlTp8qUKVMitj3dA339/Vq2RLnhhKnb2hupzdU1te22aaqvlYqK9q+nMNA1NDU1ii6QV9/YHPyspqq9Tkd77WUFyW0PQm2xxRYmXfamm26SZ5991nQcV155pXlMi3zr1DXtRAAkRv87YRUmV80+nxQkvn4AkPHol5Ap9Cy1iqkmVG5IECpCPRAg276/ddEhVVsbPkjXAXGkVatj3ceubULpYki77rqrbLbZZnLnnXd2+LomT54skyZNChvkaf2o8vLytI+5rCCYtsUtAQc3tTdSm4uLa9pt07tnmZSXl7a7v7RIP5d1UlRYIEUFeeINPE8q2+t0tNde8bznCY1udT7z0UcfbdJItaDgRRddZFJp+/btazoMAF0oTG5qQrX8ETc1uyOdFUg3u/ulmpoaM8XC69X/tnVs2bJl8uuvv4Zd9Cw3EG89KGuqXWesQFVDYHUkINu/v3Wludzc3HbfvXp77bXXTngfu7axLF261NSLGjRokLz44otRA2QWfVyDTaEXa7DHJfuOgd8sXxROT0RE2raowKoJ1brqdrrbzyXzj0GsupxioavEaRFB/aJ9+umnJS8v7gX3AARYNaCsTKgmHwMMIJX9kgadzjjjDOnVq5c5S73mmmvKk08+2eE+l156qan9oTVNrIsudgEkLRMqZDoekEkS/f4uKiqS8ePHy3PPPRe8b9WqVfLOO++EBbJmzZplVq6LdR+7trFOWGgAasCAAfLSSy+FFSkHEi9MnttJYfIcyc/zSFOgjwGcwLaIkXYS++67r7kAaD+4eP37RTJ63T7St3thh4XJNYacZ2VCMcAAUtovXX/99WbgowOVjTbaSO655x456qijzApOeolGA086nQToaiZUXEEoBhXIUIl8f2v9pB122EFOOukk2W677eS///2vrLvuumF1pnT624wZM+T777+PeR87ttHi4jvvvLMJRF1yySXy5ptvBvfdfPPNZejQoV0+Zsh8kcqAFeZ3vDqentwuzGVFVTgLxWaAFHjtu0VyzpOz5Ownvu5wO7/oSkfSWhPKy3Q8IJXuvvtuUyhWA1Dq5JNPNkVjNRjVmb/++stM4wMSUd/kDRs4xFQTiiAUELTlllvKl19+aTKMNMizzz77yMcff2wylUIDPhMmTIhrHzu2aWxsNFPzNECl9a50BW7r8ssvv/AuIiaRVseLtphFcXA6nkh+XsvqeIBTMHcOSIFvF7SsRvHp7yuCU+4i0dl3OaLT8ciEAlJNi8XqFBAdJITafvvtzeCiIzoN48MPPzQrzwwfPtwU2912222T3GJkYhCqKMpZ7VBkQgGR6ffv7bffHvXw6HTrePexY5vu3bubGlBAV+iMiWgnJaIHoVrKfDB9G05CEApIgdl/tS6Juqy6Qfp1bz171pbGp/I0HcpMxyMTCkiV5cuXB5fVDtWnTx+ZPn161P00aHXOOeeY7CldHemss84ydUB0usfAgQMj7qNTM/TSdllbDVI7YdltJ7QjU9sbrc11jYEgVF5up6/FOvPd0OxNyet22zGmvfYfTwDO+1vUExLRTmy31oRqCVQxpoCTEIQCUmD+ytZle39ZUh01CNVamJxMKCDVPFbwt6kp7H6dRqErH0Vz7LHHBq+XlJSYLCitK/X888+bgFQkWj9kypQp7e7XTKp0D/j09+vS4iqelU7SxW3tjdbm5asDgcjmBvM56Ii3qSWAuaqiUioqkl9ZwW3HmPbaywqSA0ivtv89iDYVr21NKC1M7vX5zSVXo1JAmhGEAlKgOSR/9vdl1bL9sD4dFiZn5SMg9XTJbLV48eKw+/W29VgsdEltXVVv7ty5UbeZPHmyTJo0KWyQN3jwYCkvLw8uwZ0uVhBM2+KWgIOb2hutzbkFLScrepWXmvs7Ul7aEhTILyzpdNtktdfJaK+93PCeA9lAa8fGsjJe2+l4WpjcWvAo19N53UEg2QhCASmgZx76lBbK8uoGWVRR32Hnov/XKwqcvWhoooggkCpas2PUqFGmqOxhhx0WzIJ6++23wwJGurpRfX29CRrpYNfn84VlSi1YsED+/PNPGTZsWIeBKr1EGuw5YcBntcMJbcnE9kZqc33g+744P6/T12GthqQ1PlL1mt12jGmvvccSgPNqQnWUCWWNJUxhcmsxC68veD+QTqyOB6SA1++XgT2LzfXFHQShvD6RXD1jEVLvA0DqXH755fLoo4/KbbfdJp9//rkcc8wxUlBQIKeeempYFpPWfLKm7m2zzTby+OOPyzfffCMvv/yy7LXXXmYVpKOOOoq3DjGrs1bHC5y97khBIOhJoVkAyN7V8awTEpGUWJlQHp2O1xJIZoU8OAVBKCAFvF6/lBXlmUtHmVDauWhnYaXXWmfGAaSGLqv9zDPPyLRp0+T444839+mqd6HFyvv16ydDhgwx1zVA9cgjj5hsqeOOO05uueUW2W+//WTmzJlSWlrK24akro5HtiwAZHNNqNzOa0KFnLjQ6XiAEzAdD7DZ23OWy/KGFXLq2HXDMqF0Tnb/8mJZXNlRJpSfTCggzTSIpJdorrnmmrDbG2+8sTzwwAMpaBmyIwiVG3MQikwoAMgebRcuiWU6Xkth8pb7mppZ6RLOQCYUYLPzX/xJrn19TrvC5HmeHFmjvKjD6Xi+wKoVVnptQzNnLAAgq6bjxRKEsup70EcAQNZoG0LqcHW8YGHykD7DS5kPOAOZUEAKaHBJp9n1Kc43A426Rm9Y3Y85iyvlf5/OlaqGZhOEKgqk1xKEAoDsYE2/jisTiiAUAGTVeCJUYQf9RbAmVE5OyIkLMqHgDAShgBSwMqF6dSswt1fUNMiggpLg41e/+qN89Mtycz0sEypwZhwAkNniyYSyzn4zHQ8Askc8q+NZfYnJhGLBIzgM0/GAFJ210EyoXqUtQaiVNY1h2/y+rKb1j9KsjkcmFABkk/rG2FfHa11BlSnbAJAt4pmON7hniQwoL5KN+pcFM2xZ8AhOQRAKSDItSq5MJlSJlQnVGoRq9vpkaVVrnSjNmA0OMMiEAoCsyoTqaFBhYToeAGSf9oXJo5+0KC/Jl08mT5A9Nu0fzIqyFsAA0o0gFJBkuuKdys1pnY63sro1CLWool6avK2dipmORyYUAGSVmkavqeGhKxl1hiAUAGSfNjGoYPmOzhQFMmytkx2AZHtNqBUrVsjTTz8tS5YskU033VT2339/8Xg8Xd7Hrm3q6urkqaeekjlz5sjJJ58s66yzjo2vHtlQjDwYhPLkSO8I0/HmrqgN20+n4xWxOh4AZJXKuiYpK8qPaVvrREV9MwMKAMgWvnaZUDEGoQLbkQkFp0hrJtQff/xhgj8a5KmpqZG///3vss8++4jP5+vSPnZt8/DDD8u6664rL774olx33XUyb968JB4NZGIx8tCfGoTq1a2w3XS8xZUtU/Hyc1vOfmv/EhxgcMYCALJCVX2TlBXHdm7QWvVIV1oFAGRrYfLOawiG1hokEwpOkdZMqIsuukjWWmsteeeddyQ3N1dOO+002WCDDUxg6PDDD094H7u2GT58uMyePdsEqaZNm5bCI4NMOlvhCwtCBWpCVTcEt7OuawHB35fXSG1jc+vqeBSdBYCsUFnfLEN7ta6a2hE9+619Sk1Dc9LbBQBwBr8klgll1YTixAUk2zOhmpub5eWXX5ajjjrKBIGUTnUbO3asPP/88wnvY9c2asstt5SePXsm+Uggk1gBJ+WNkAlVVpRnMp5Cp+NZ1wf2LDY/axu9UpBrBaE4yw0A2TIdr3tRbOcGtW6UZkNpfwEAyA4J14QKBKE4uQ3J9iCUTm2rr6+XYcOGhd2vt3/++eeE97Frm0Q1NDRIZWVl2MVazYBL5h+DuqbWs9LNPp+5zxuY4qmFyVWPkgJZVdsY3Gd5MBOqOHiWQjfVwrO6lGq6XxOXzD4GANJPTzjo4KCsOLaaUKpbQZ7UNJIJBYS65ZZbZOjQoVJUVCRbbbWVfPzxx7bsY8c2q1atkltvvdXMvNBA8vvvv8+bh7i0/X9brNPxrCAUmVCQbJ+Op1PcVFlZWdj95eXlwccS2ceubRI1depUmTJlSrv7Kyoq0j7g099fXV1trsey+k66ua29bafZrV5dIf7ifFlV0XJfc1Oj+Rx0L/TIqpoGc10tXl1rCgaW5rV8PqobWrYryM2RmrrW7ZLBbceY9trLCpIDSK+q+pZgUqyFyVVJYa7UNpAJBVjuv/9+ueSSS8yiQ9ttt51cf/31svvuu8sPP/wgQ4YMSXgfu7bRIJX+n+7OO++UXXfdlTcOMXlu1mJZUrtILt5zo3Y1oayVUjtDTSg4TdqCUKWlpeZn2wH26tWrg48lso9d2yRq8uTJMmnSpLBB3uDBg02Aq23QK9WsIJi2xS0BBze1V1U0twYxS0q7S3lpofxesarldnGReS29uhXJHytqzHVV2eCV3qWFUtqtpRaIz59jHutWmCeNvpbryeK2Y0x77eWG9xzIlql4KtbC5KpbQZ7JqgXQ4oYbbpCJEyfK3nvvbW5fe+218thjj8ndd99tThInuo9d21xxxRXm54IFC3jLELMr3/jN/GwJQrE6HjJD2qbj6VmBbt26yU8//RR2v97eaKONEt7Hrm0SVVhYaIJNoRdrsMcl849BbchqdtpP6H0H3P1psCaU3i4vzg8OOPT2iupG6V1aEDyb0eT1m/s1CKVTLdL9mrhk9jEA4Iyi5Kp7PJlQ1IQCglauXGn+Hz9u3LjgfdrH6e1PPvkk4X3s2gawY9p2u5pQZELBpdIWhNKC4Pvvv7888sgj0tjYciZPU1Z1/vTBBx8c3E4Lhev86Vj3sWsbIBGhc629bXqKPE/LgF+DUBpo0mVSNbNnRU2j9O5WIPmBYuRN3pYaUt203gdTLQAg4y2rapm2rX1BrMyJClbHA4zFixebn3379g07Iv369Qs+lsg+dm2TKGrNpr92ZrovFj2BbS16FBqEiuU5CgNjDB2npPv1cMnsY+D46XhWquoOO+xg5k6PGjVKXnrpJTnooINMgMjy2muvyYwZM+Tcc8+NeR+7tpk5c6Y888wzUlVVZW7fc8898sYbb8jOO+9sLkBboSsVaUfRHAgoKU8gCGUVnq2oazJzu7UYrU7H0xpQYUGowlyZt5KiswCQ6RZX1puf/ctbFqiItcaH9h/a12imLYD2dFAUb9ZvLPvYtU1nqDVrH7fVQVWhg/q/lq2S2rq6sMebG+pjrh2r44xqas26+jPhz6Bas2kNQg0cOFC+/fZbEwBasmSJHHLIIe2COwceeKAJFMWzj13bFBQUSI8ePcwldC65rnoBRFITEoTSRfEaQ4JQoZlQVhCqqbmlcwnPhGq5r7QwT2pZ+QgAMt7iipaBxZrlhTHv062gZbUj7SfimcYHZKI111zT/Fy2bFnY/Xp7jTXWSHgfu7ZJFLVms7cOqvIFVtg28oskNz88W7ZneWnMtWNLCqg16/bPhN/h7Y2nTWkNQiktBH7EEUdEfXyPPfaIex+7ttl0003NBYhVXUjQqNnnk4am9plQwSBUbZM0FQS+TEryg0EoK3ClUy00IKVzwGNdghUA4D6LA6uorhlHJpQOKJRO2yYIhWzXq1cv2WCDDeS9996TAw44IDhge//99+Xoo49OeB+7tulKrVm9tOWUuo5uqzHptvZaJ6aVXg05t23o+CDW11JalCfVDS21ZpPJbceY9tonnvc8bTWhgEyfjqcrWETKhOpR0poJVVkfWBGpKF/yg4XJW4NQirpQAJDZFlfWmexXvcSqrKhl26pAPwJku/PPP18eeOABefXVV02x8H/84x9m5etTTz01uI2uYLfJJpvEtY9d2wDx0qCRpdnrF29oZpSOLQInsGOhJyuqAotgAOmW9kwoIGMLk/skPBMqp/10vOZAgUGtE7XzRv1ku3V6y9kT1gubaqGFZ3vFUawWAOAuiyvqZc3y+Kb6l5e09AurA6utAtlOA0xak+S0004zpTZ0NoPWch06dGiX9rFrm4ceekiOP/744O3x48ebn5dffrn861//SsIRQUYFoXy+4LjBkh+oJxuL7kV5wanfQLoRhAKSVBNKi8U2er0d1oSyVrnQ+3RqxRMnbxvcPpgJRV0oAMhoSyobZOTgHnHtEzq1G0CLSZMmmUs09913X9z72LXNcccdZy5AoplQeglVEEcmlGbPaiaUHQXzga4iCAUkqSaUBpjqm1o7C2v1ImvgELrUqjWtIpQ1LYMluAEgc+kJCR1oxJsJ1SPQl5AJBQCZqbqhzarbbTKh4pmOp6U/dP/6Jp9ZXRVIJ4JQgI2qQs5YNLWZt53r8bTPhPK3Tsdry8qEYv42AGSueStqzc+hvUri2k8XtLD6EgBA5gmt+ac1Y9vWhCrOz41rOp71nAShkG4EoQAbhU6LaGr2SegJC+tkhRVw0oGD9bgVmIp0lpsBBgBkrrkra8zPIb3jC0IF+4jaxqS0CwDgnHFFc0gm1Aunj5bP/lgZVwattYpqZX2z9CtLQmOBOBCEAmwUOi1Cl1VdXdfYLhOqKD9XCvM8YUEo6+xEqB6BorOrahhgAECmmmtlQvXuFtd+oVm1AIDME/r9rgEoq4yH1hDcfEjPuJ4rNBMKSDeCUECSOgudjnfm418Hb4dO2+5Rkm+21a6kKN8jhXnt02mtFfFWUXQWADLW3BU1XZqORx8BAJl/crvZ27I6ntaYTaSwuDUTQzOhgHQjCAUkcTpeKCsTyjqDbQWhIk3FUz2DAwwyoQAgkzOh9Ay1npyIh5686F6YJytqGpLWNgBA+qyubZ8JZS10FC/r5PaKavoMpF/sJfUBxD0dL1RuyFkLnZetZyJ0hTxdrSKS4HQ8MqEAIGP9sbxG1urdLaEz2/3KCmVJJQMKAMhEFSFlPZq9LTWh8hIMQvUpLTQ/lxOEggMQhAJsomcnKuubJDfQNyytqg97PPTMRVlRnpmTrYGoaJlQBXkeKS3MoyYUAGQozYhdWtUg661RmtD+/boXydLK8L4GAJB5mVC6Mp5eEs2E6hsMQjHDAulHEAqwiQaV/P7WdNcpL/8Q9nhop6GZUPVNPnM2wpqjHUnPbvmyksLkAJCRfl5SZX6uv0b3hPZfo6zQnMyob/La3DIAgKNqzWomlNcv+aFFZuPQp3vL+GR5FdmzSD+CUIBNrCkRawS+5NsKTZ8tK24px6ZBK82KimaN7kWyhLPcAJCRfllSbX6un2gmVFnL8txLmZIHABlnWUjASGdc6MWTwNRtVVKQJyUFubKM6XhwAIJQgE0WVdSZn9Gm13naZEJZom2vBvQolhU1jZzlBoAMzoRar19imVD9y1uCUAtXt/Q/AIDMoAGnJVUN0r+sZRpdo9dnMqM6Onndmb7dC8MCW0C6EIQCbLK4oqUuR1lRbueZUCFBqLJOglDqLwYYAJBxfllabc5MDwx818dLC5qrP1fU2NwyAEA6aW1ZDUQN6dVysqGhyWuymDSQlCjtaxasqhO/TsUA0oggFGCTRYEg1Lj1enUahNLluC3RVsdTA3u0dDx/rabwLABkEh0E/LSkStbrVxqWKRuPob1LgivsAQAyh/V//7V6tZyk0CwoLVRuTcNOtM+obmim3izSjiAUYBMrW2m7tXvKu38fK31KC2SPTdaU508fLaeNW1c2H9IzYvZTR9PxBvVqGWBwlhsAMsuSqkZZUd0omwwsT/g5BvcqMYteEIQCgMws8zE0EIT6dVlLDcFBPRPLnFVDerVkz85dWWtLG4FEJT6pFECYn5dWS+/SAjNXu7y8m3xxyc6SEygeuEVIAKpdJlSgSHkkGwRWTPppcUvdEABAZvj+r5bv9RGDeyT8HLpK0rp9u8kPf1Xa2DIAgFMWrtigX0vg6KfFLbeHBE5Qdyl7dllNu7EJkEpkQgE28Pn88suSKtkwZJltKwAVSVhNqA6m42nRWQ1qzVnMAAMAMsn3i1oGFCMGJR6EsvbXwuQUmwWAzKEnoHWm9sZrtqyeujywql1XglDDB5SZn98trLCplUBiCEIBNtC01tpGr6wfEoTqSOjKFh0VJtdA1sYDymT2X5XS2OzjvQKADDFrYaV0K8iVYf1aBhiJGjmkJYj1xZ8rbWoZACDdflxcKWv16SbFBblSkNs6ZB/cM/EglAawepbky6z5q21qJeDS6Xhz5syRe++9V5YsWSKbbrqpnHHGGVJaWtrlfVK5DfDJb8vNQdhyrdhSW2OtCaW2X7ePzPh9pXw9b5Vss05vDjbg0n4JsKyobpBvF1bJrhuvYWo6dcXY9fuan2//sET23LQ/BxlZjXEFMoFmt85dUSuHbDnI3NZAVGOdT4ryPTKwCzWh9OT2qKG95L2flsqqmkbp2a3AxlYDLsmE+uqrr2TUqFGycuVK2WGHHeTZZ581PxsaGrq0Tyq3AdQ7Py41KbPbD+sT0wEJrwnVcRBq3Ab9zM+Xv/2Lgw24tF8CQj371ULx+UV2G75mlw/MoJ4lstmgcnlj9mJZXdvIgUbWYlyBTPHOj0vMzx3W6xssz2HViu3qiYvdhq8hXp9fXv9+sQ0tBRLkT6Ndd93Vv+eeewZvL1++3F9cXOy/++67u7RPKrfpTEVFhV8Ps/5MN5/P51+1apX56QZuae/Piyv9a/3jFf8JD34eV5uHXvSKuXi9HW+rz7XX7R/6N/zn6/55K2qy8hhbaK+9nPT95BTJ6pfc9F7wd5ZcSyrq/COnvOnf8sr/89c1NtnynC98tcD0J5e88G1Svs/5TCSX04+vk76fOsK4IrWc/rl1a3sbmrz+8Te859/k8jf8lXWNps373fmx+Y4/47GZXX5+fU597h2vf9df19jsz8ZjbKG96esr0pYJpWeI3333XTnooIOC9/Xu3VsmTJggr732WsL7pHIbZDctRj5z7ko59dGZouckztxpWELP4+nkjIamzl6424ZS1+SVo+//TD76ZRn1oQAX9UuAqm5olte/WySH/PdTWVXbJBfuvLYU5uXacnD+NmKAbL12L3l0xjz5x3PfmYK22kcB2YJxBTLB/JW1ct7Ts+T35TVy0g7rSGlhy8yJHddvmWkR64yLjnQvypczxg8z0/2OfeBz+X5hhcmMArKiJtS8efOkublZhgwZEna/3v7ggw8S3ieV20TrBEOnYFRWtqxq5vf7zSUW/3zxe/l2QWvBuBwT4mjll5bnsZ7OetbW29Ee94vP6xOPx6NPGvHxds/Vps2R9umoDaE/Ymlf6G294vP7Wl5/Tk7r4x20W+JsX9vnkg4ej/ZcugjeZXtvLCMH9wi+z7G81w8fv5WsqGmMadsd1usjV+47XP718g9y9P2fS54nR3p1K5DSojzJzckxqbl60XhW289LR/Q3e73NkpubF8deIbqWEZwQr9crubn2DNwyrb37bz5Qjhu9Vszbx/qdlC2S1S8lq6+41PQVrSvchHwTBp4rfPu2z9r+cX/Y59bjaf+5bdeytn1Ep7+j7ePx7R9tH5+vpW/LScLvbHtcI+3U2XM0en2ysqZlqlxhnkem/G1j2XmDlj7DDtoP3Xv0KDn10a/kqS/nm0t+bo70KS00v68gzyP5uR7TR8T0fO3+39FBX5GGfiAW9BXZ1Vcwruikr0jSami2/50l8aPW5f/z2tIGv5mKrUEf/bvyBq7rSYNVtY1SWd9sttN6gaeOXSf4f4LTx60ro4b2lDHD+tjy93jSmLXlr9V18sinc2XvOz42/YSOK0oKciUv12PGGTGPKdpswndvcnkzZFyRtiCU9Z/vkpLwCv9ayLW+vj7hfVK5TSRTp06VKVOmtLu/oqIi5jdmZVWtKVqqou2i/+E0P4O3c8K/B9o93vLT7/NLrsdvHmi/bctXjdnWejxsu9bf0fr7A/e1ebL27QvfPvR52z1XyFPpH1pe4A8tdLu2zx/6Gjr6/aHtCz7WQRs7elxvD+lZJHts3FfW69ct+B5XV1eHvSfRjFhDiwEWmP1isc9GPWTEmpvL67OXyY9LakwAq7bRJ80+nzQ0+Vs6sQT6Jb8G+nJaOj03aGmvexb2TGV7V1bWxPx5Cg18ILn9UrL6iuVVtbKsKvx3tP3aafst1PZ7KVpAwe/zSY7HF2H/tpvnxPy7297R9j+3od/Lwc1D7mj7fd/6C/2ia4fm5rZ/vsi/vm2/FbmBnR/Ljl9P6M28nBzZbq1y2XCNbrLrhn2kX/eCmPuKeNx18Aby+dwK+fi3VTJvVZ0sr2mSpmafNDV7pbahOepnq6NPXOtJKff0FTrQ0//v5His/9k4W6rbu6KiOuP6CsYVnfQVldH7o+z7P1l6v8f0pLF+7etJZM0L0P4hJy9H1u9XIoN7Fsu4Yb1kx2E9pba6KmxcsVm/Alv/FieNHSS7rFcub/+0Qn5dViur65qkrtEr9V6v+Hwi3hj+LxL5RJEbPxO0N9XjirQFocrLy83PVatWhd2/YsUK6dGjR8L7pHKbSCZPniyTJk0KezMGDx5snq+srExicdfRW0sy6BeZfpC0LXb+pzdZ3NZeZf0HP1lt3rS8XDZdq+uFbN16jGmvvdzwnmdCv5SsvuJu+gpXfi8ku6/YtUcP2XXE0Kw+xrTXXm54zxlXREdf4c7vhVSMK8aUl8uYjVpW4MvGY0x77RXPe562INSgQYOkZ8+e8u2338qee+4ZvF9vb7bZZgnvk8ptIiksLDSXSG+KE/4YrXY4oS2Z2F43tpn2Zu/xdWKb0ilZ/VIk9BXZ83eWKW2mvdl7fJ3YprYYV6SHkz+3mdBeN7aZ9mbv8c2Jo02edDbyyCOPlPvvv19Wr26pf6T1M7744gs56qijgtv95z//CZ4tjmWfVG4DAMgcyeqXAADu/P5mXAEASeBPI12+b/To0f4111zTP378eH9JSYn/4osvDtvmxBNP9A8fPjyufVK5jZuWtWUZSo4xnwn+5pz6/eQUyeqX3PRe0FdwjPlM8Dfn1O+njjCuSC36Co4xnwn+5hLtK3L0nzQHwcwZhyVLlsgmm2wia6+9dtjjM2fOlJUrV8ouu+wS8z6p3qYjWudD58Xq/NhY63wkC/NeOcZ8Jvibc+r3k5Mkq19yy3tBX8Ex5jPB35xTv586w7gitcea+j8cYz4T/M0l0lekrSaURdNct946eiHuUaNGxb1PqrcBAGSOZPVLAIDkYlwBAM7nnvUIAQAAAAAA4Fppz4TKdNZsR01Pc0JbtB1Orajv9va6sc20N7uPr/W9lOZZ2aCvyOi/s0xoM+3N7uNLX+EcjCsy9+8sE9pMe7P7+FbGMa4gCJVkVVVV5ufgwYOT/asAIOHvKZ3DjfShrwDgdPQV6UdfASAT+oq0FybPdD6fT/766y/p3r172iOWGp3UYNj8+fMdX1jSje11Y5tpb3YfX/36145iwIAB4vEwOzud6Csy9+8sE9pMe7P7+NJXOAd9Reb+nWVCm2lvdh9ffxzjCjKhkkzfgEGDBomT6IfWiR/cTGmvG9tMe7P3+JIB5Qz0FZn9d5Ypbaa92Xt86Sucgb4is//OMqXNtDd7j295jDMrOPUNAAAAAACApCMIBQAAAAAAgKQjCJVFCgsL5fLLLzc/3cBt7XVjm2kvxxfge4HvXvqK9HJbXwy48XPrtva6sc20l+MbKwqTAwAAAAAAIOnIhAIAAAAAAEDSEYQCAAAAAABA0hGEAgAAAAAAQNIRhILx97//XXbeeWf55ptvHHtEVq1aJTfeeKMcfPDBcvTRR8sDDzwgXq9XnODPP/+Us88+W/baay8588wz5ddffxUne+edd+SMM86Q/fbbz7z3v/32m7iFHmf9rP7444/iZNXV1ebzuv/++8uJJ54oX331VbqbBHQZfUXX0FekDn0FkD70FV1DX5E69BXpQRAKct9998mrr75qAhMa6HGiiooK2XzzzWXp0qVy6KGHyo477ij/+te/TEAq3ebPny9bbbWVLFq0SI477jhZsWKFbL311vLHH3+IE11yySVy7bXXyvDhw+X444+XlStXyiabbCIzZ84Up7vzzjvl//7v/8xnVT8TTrV8+XLzGXjhhRfM53WXXXaRs846S+bOnZvupgEJo6/oGvqK1KGvANKHvqJr6CtSh74ijfzIaj/88IN/wIAB/g8++MCvH4f33nvP70RNTU3+ysrKsPvefvtt0+Y5c+b40+mMM87wb7jhhv7m5mZz2+v1+jfZZBP/xIkT/U60YsWKdvdtt912/qOOOsrvZLNmzfIPHDjQ/84775j3/dNPP/U71fHHH+9ff/31/XV1dWGf4dDbgJvQV3QdfUVq0FcA6UNf0XX0FalBX5FeZEJlsfr6epOloVOGhgwZIk6Wl5cn3bt3D7uvd+/e5mdNTY2kk2bm7LPPPpKbm2tuezwe2Xfffc39TtSrV6+I96X7OHZE23bYYYfJHXfcIQMGDBAna2xslCeeeEJOOukkKSoqCvsMh94G3IK+wh70FclHXwGkD32FPegrko++Iv0IQmWx8847T0aMGCGHH364uNENN9xggmebbrpp2udtDxo0KOw+va3ptD6fT5zu22+/NR3e3nvvLU6ldbbGjBlj6is5ndYD0/+IbbDBBnLhhReaAKXW33JyvTWgI/QV9qCvSD76CiB96CvsQV+RfPQV6ZeX7gbAPlpkWoshR7P22mvLvffea64///zz8sYbb6R1YHz55ZfL9OnTO9xG21lWVtbu/ptuukmeffZZeeuttyQ/P1/Sxe/3S1NTkxQXF4fdX1JSEnyssLBQnErrWOnnZvfddzf1oZzo8ccfl48//lhmzZolblBbW2t+nnrqqXLKKaeYjKi3335bRo0aJe+++66pZwakE31F6tFXJB99BWAv+orUo69IPvoKZyAIlWFnIDToEU1paWnw+t13322mjx1wwAHmtmZuWKtZ7LHHHnLVVVclvb0HHnig7LDDDh1u0za4o+666y65+OKLTRAq3QP6nJwc6dGjhynuHUqLk2vbnRyA0iLvEyZMkGHDhsnTTz9tXosT6WdV26ZTHEODPLqahWZvXXbZZeLE6Y76t2W17W9/+5tZze/mm29O+2cWoK9IPfqK5KOvAOxFX5F69BXJR1/hDAShMsjYsWNj3vb66683gRLLkiVLTFbSEUccITvvvLOkwmabbRb3Pv/5z39Mp/jMM8+YaU5OMHLkSPnqq6/C7tPber+TA1Djx4839ZWmTZvm6FpFt9xyi6xevTp4W6c5fvrpp3L00UfLuHHjxGnWWmst6dmzpwwdOjTsfp06OmfOnLS1C7DQV6QHfUVy0VcA9qKvSA/6iuSir3CINBdGh0P88ccfjl4dT91zzz3+wsJC/7Rp0/xO8tBDD/lLSkr83377rbk9e/Zsf2lpqf+///2v34mWLVtmVu/beeed/bW1tX63+fHHHx2/Ot6kSZP8W265pb+6utrcXrRokb9///7+iy++ON1NA7qEviJx9BWpRV8BpA99ReLoK1KLviI9yISCKyxYsMDU1+nXr5/cfvvt5hJaW6qzaX3JdMwxx8jnn38uW2+9tWy88cZm2tWRRx4pEydOFCe64IIL5Pvvvze1tkKzyXRanmaaoet0OquuPKlZUeutt5453rvttptceumlHF4giegr7ENfkXz0FUB60FfYh74i+a7KwHFFjkai0t0IpJ/WhNLiz1o8WacSOU1dXV3UIuY6rU+DU07o0H7//XfzBaFTr5xKv7gWL17c7v7u3bvLNttsI06nNaE++eQTE/SLVLTeSX777TdzrHVRAJ36CLgdfUXX0VekBn0FkD70FV1HX5Ea9BXpQRAKAAAAAAAASedJ/q8AAAAAAABAtiMIBQAAAAAAgKQjCAUAAAAAAICkIwgFAAAAAACApCMIBQAAAAAAgKQjCAUAAAAAAICkIwgFAAAAAACApCMIBTjIkiVLZPvtt5eKioqk/67jjz9eXn755aT/HgCAvegrAAD0FXArglCAg0yePFm22247KS8vT/rvOvTQQ+Wcc86RxsbGpP8uAIB96CsAAPQVcCuCUIBD/PXXX/LYY4/J6aefnpLft9tuu5mfzz77bEp+HwCg6+grAAD0FXAzglBAkrz11luyySabtLtccMEFEbfXAJQ+vs466wTvGzdunLzyyivtptHdcccdwdv777+/uX3hhRfK2LFjZaeddpIXXnhBVq1aJeedd55svfXWstdee8lnn30W9jw5OTlm34cfftj21w4AiA19BQCAvgLZhCAUkCTbbLONPPnkk8HL9ddfL7/99puUlpZG3P799983+4SaM2eOrF69Ouy+P/74w9QDsfzyyy8msNWjRw/zO7baais56KCDTECqf//+JkA1bNgw2XPPPaWysjLsuXTq30cffSRNTU22vnYAQGzoKwAA9BXIJnnpbgCQqcrKykxmk6qtrZVjjjlGdtxxR/nnP/8ZcXsNLmlQKBEadLr44ovNdQ1C/ec//zEDG82OUptvvrncfffdJhtql112Ce43cOBAqaurM0GtQYMGJfS7AQCJo68AANBXIJsQhAJS4IQTTpDq6mp55513JDc3N+I2WiC8oKAgoecfOXJk8LrH45G+ffvKiBEjgvfp8/bq1UuWLl0atl9hYaH52dDQkNDvBQDYh74CAEBfgUxHEApIsmuuuUZef/11mTFjhvTs2TPqdmuuuaYsW7Ysod+Rl5cX031+vz/stv4+rQ21xhprJPR7AQD2oK8AANBXIBsQhAKSSIuKX3755aZQ+EYbbdThtlpA/Ouvvw67T+tH1dTUhN23cOFC29r31VdfmSmD0epUAQCSj74CAEBfgWxBYXIgSbSo+JFHHilXXnml7L333p1uf8ABB8inn34qVVVVwfu0ltOzzz4bLBx+7733yq+//mrrqkz6ewEA6UFfAQCgr0A2IQgFJIkGj3Q1ukcffdRkG1kXXckukjFjxsjGG29sVtKzXH311TJ37lwzVW/AgAHmbHloraeu0ELoOkXw5JNPtuX5AADxo68AANBXIJvk+NsWiQFgC623pKvOtdWjR4+oK9F9+OGHcvzxx5sz4/n5+eY+/ROdP3++qSfVvXt3Ezzq1q2b9OvXzzyumVH6WO/evYPP88svv0ifPn3CalD99NNPJphVXl5ubp944onSv39/ueqqq3jHASBN6CsAAPQVyCYEoQCH0WDR0KFDpaioKKm/RwNda6+9dnCFPACAe9BXAADoK+BGBKEAAAAAAACQdNSEAgAAAAAAQNIRhAIAAAAAAEDSEYQCAAAAAABA0hGEAgAAAAAAQNIRhAIAAAAAAEDSEYQCAAAAAABA0hGEAgAAAAAAQNIRhAIAAAAAAEDSEYQCAAAAAABA0hGEAgAAAAAAQNIRhAIAAAAAAEDSEYQCAAAAAABA0hGEAgAAAAAAQNIRhAIAAAAAAEDSEYQCAAAAAABA0hGEAgAAAAAAQNIRhAIcYocddpDjjz8+4mN//PGHbLLJJnLHHXekvF0AAOegrwAAdOaJJ54wY4cvvvgi4uMXXHCBedzr9XIwkXJ5qf+VACL58ccfJTc3N+JjDQ0NMnv2bFmyZAkHDwCyGH0FAKAzK1asMGOHmpqaiI/Pnz/fPO73+zmYSDkyoQAAAAAAAJB0BKEAl7r33ntNGu0777wTdv8LL7xg7n/yySfT1jYAQPr5fD4ZN26cnHnmmREf33///eWwww5LebsAAM5ilf6IdtHMKsAuBKEAl9L6Ub169ZLDDz9cFi5caO779ddf5bjjjpOhQ4fKoYcemu4mAgDSyOPxyFZbbSX33HOPLFq0KOyxL7/8Ul588UXZdttt09Y+AIAzDBw40JzADr3cfffdphTIvHnzJD8/P91NRAahJhTgIFo8UM82tNXY2Njuvry8PNNBbLHFFnLIIYfIa6+9JgceeKD07NlT/ve//0lOTk6KWg0AcGpfcdppp8nNN98s9913n1x66aXB+++66y4pKCiQo446KuntBQCk76R1t27d2t2/YMGCsNvaH4T2K9qf7LrrrrJq1Sp55ZVXpKysLCXtRXYgCAU4yMYbbywPPvhgxBTZv/3tb+3uHzBggDz++OOmkxg+fLgsX75cPv74Y5MhBQDITPH0Feuss47stttuJhvq4osvNgtg6KBCT2Lsu+++0qdPnxS2HACQSpdddpnJiI20Ot4bb7wRdb8TTzxRPvjgA/nPf/4ju+++e5JbiWxDEApwED1TEenstmY9RbPTTjvJXnvtJS+99JKcffbZsuWWWya5lQAAN/UVZ5xxhuy9997y8ssvy3777ScPPfSQ1NXVmUEGACBzrb322hH7i/Ly8g4DV48++qhceOGFcsoppyS5hchG1IQCXE5TZHVg0b9/f3Nm/Keffkp3kwAADrLHHnuYgYhOwdPluPXM9uDBg2WXXXZJd9MAAA7y8MMPy5VXXikHH3ywXHvtteluDjIUQSjAxf7880855phjTDbUd999Z6ZVHHTQQVJbW5vupgEAHFSg/NRTT5W3337bBKB+/vlnUydE7wcAQL377rty0kknyejRo+WRRx6hviyShv99AC7V0NBgAk46LeOJJ56Q3r17yzPPPCO//PKLnH766eluHgDAQXTqXWFhoZxzzjlmYKFBKAAAlI4fdIGjIUOGyLRp06SoqIgDg6QhCAW4lA4kvv32W3n66aelb9++5r5Ro0bJrbfealJpdSUkAACUnqjQlVSbmppkwoQJstZaa3FgAADGZ599JqtXr5aamhoZN26cqSMVelmxYgVHCrbJ8WtxAABpN2fOHHOWWut2tKXLpOr0iX79+pmL/tn+8MMPUlJSEnF7fUyXWh02bFiKWg8AcFpf0daNN95oVkTS7NnDDjuMNwwAMtTKlSvlr7/+Mn2Fzppoa8GCBSboZBUtr6iokPnz50d9vg033LDDhZKAeBCEAgAAyALbbrutmXKhAxMNZAEAAKQa0/EAAAAy3PTp0810i7POOosAFAAASBsyoQAAADLUF198Iccee6z8+uuvMnbsWHnppZekuLg43c0CAABZiiAUAABAhtIis3/88Yf07NlTBg4cmO7mAACALEcQCgAAAAAAAElHTSgAAAAAAAAkHessJpnP5zOr0HTv3l1ycnKS/esAIGZ+v1+qqqpkwIAB4vFwTiKd6CsAOBV9hXPQVwDIhL6CIFSSaQBq8ODByf41AJCw+fPny6BBgziCaURfAcDp6CvSj74CQCb0FQShkkwzoKw3o6ysTNIdnayoqJDy8nJXZGW5rb1ubDPtze7jW1lZaYLk1vcU0oe+InP/zjKhzbQ3u48vfYVz0Fdk7t9ZJrSZ9mb38a2MY1xBECrJrA+IBqCcEITSi7bDiR9ct7fXjW2mvRxf5YbPaqajr8ie7zE3tpn2cnyVGz6rmY6+Inu+x9zYZtrL8VWxfFYpAgIAAAAAAICkIwgFAAAAAACApCMIBQAAAAAAgKQjCAUAAAAAAICkIwgFAAAAAACApCMIBTjIb8uqZcGq2nQ3AwDgEPNX1sqvS6vS3QwAgIN9M3+1zP6rIt3NAGKSJ1lk2bJl8uWXX0peXp5svvnm0qdPn0738Xq98sknn8iSJUtk0003lQ022CAlbUV2mnDTB+bnn9fule6mAADSrKHZKztc/56UFOTKrMt2lYI8zh0CAMKtqmmUff893fQRX1+6i3QrzKohPlwoK/434/f75aSTTjKBpzvuuEOuvvpqWWutteTee+/tcL9Vq1bJdtttJ0ceeaTcf//9suWWW8r555+fsnYju+jnFAAAyy9Lqs3P2kav/LCokgMDAGjnsz9WmJ+NzT75et5qjhAcL2uCUNtss4388ccf8tprr8n7778vN998s5x22mkyd+7cqPtdcsklUllZKbNnz5bXX39d3nzzTbPfW2+9ldL2IztUNzSnuwkAAAf5Y3lN8PrcFa3XAQCw/LS45YSFmrOYExZwvqwIQnk8Hpk4caLk5+cH79tvv/3MVDsNMEULXD3xxBNy4oknSvfu3c19o0ePlq233loee+yxlLUdmeH2d36Rza/4P3OGIprVtU0pbRMAwNmWVNYHr/+1uvU6AACW0HqyiyroK+B8WTth9P/+7/8kJydHhg8fHvHx+fPny+rVq2WTTTYJu1/rQn311VdRn7ehocFcLJpJZQW10j3dympDutuRqe3tqM03v/Wz+bmiukHWLC+KuG9lXWsQKlWv2W3HmPbafzwBuCMItbq2Ma1tAQA409KqBsn15IjX5w/rNwCnysog1O+//y7nnnuunHnmmTJ06NCI21RUtKwu0LNnz7D7e/XqFXwskqlTp8qUKVMiPl+6B3z6+6urW9I1NQDndG5rbyxtXrZqtRRLccR9l65sTZ/t6DOWzceY9trLCpIDcKbQDFmyZQEA0YJQA3sUS01DM0EouELWBaEWLFggO++8s4wZM8bUd4qmuLglUGAN0C1VVVXBxyKZPHmyTJo0KWyQN3jwYCkvL5eysjJJJysIpm1xS8DBTe2Npc2egmLzWCQ5S1rPckfbJtuPMe21lxvecyCbVdY3ifVnuopMKABABEsr62XtPt2kpjBPFpMJBRfIqiDUwoULZdy4cWaK3dNPPy15edFfvgaOtIZU28LlenudddaJul9hYaG5RBrsOWHAZ7XDCW3JxPZ21uaaBm/U11LX6A17jlRx2zGmvfYeSwDOVVnXLOXF+eLJyZHVIVO2AQBQTV6frKhplG3W6WXGEtN/qzYnbfk/HpwsKwqThwagNt54Y3n22WeloKCg3TYzZsyQV155xVzXQNKECRNMsMqybNkyeffdd2WvvfZKaduROWoao6+Ap0twAwBgqahrkrKifOlRkk9NKABAOytrWmZS9C0tlJ7dCswiSHVNjCngbFmRCaWFwjWgpFPjdFW80MDSdtttJ+uuu665ft9995lA1N57721uX3fddbL99tvL4YcfbrZ74IEHTBbVcccdl7bXAnerbojeKdR2EKACAGTndDwNQBXkemT+qrp0NwcA4DDWwkYma9aTEzyBUVKQFcN8uFRWfDqbmppkyy23NNc1kynUoEGDgkEoDTT17ds3+Nhmm20ms2bNkvvvv1+++eYbE3w6+eSTI2ZRAbHQgoHRkAkFAGg7uBjSq0SK83Pl+4UsJAAACFdZ3zK26F4UHoTqXx69hjGQblkRhCotLZVHH3200+1OPPHEdvdpgOqaa65JUsuQbToKQtUwHQ8AEODz+aWqodlMxyvM90ij12emWRTkZU0lBQBADBmzqqw4T/JyA0GokJVVASfKiiAU4BTVHQSh6piOBwAI0ACULmCqA4tcjyc4bbsgj2xsAECgrwjJhMrP9QQzoQAnIwgFpBCZUACAeE5alBbq6niBPqTRKz1KOH4AgBZVgUyo7kV5UhjIlCUIBacjCAU4pTB5SJYUS6sCQHbTpbZVSUFusM5HaD8BAEBoJlSz12euE4SC0xGEAlKooYMlU0MLk3t9/uC8bgBA9qkP9BfFBbmSFwhCUTsQABAtE0prCYaumAc4FUEoIAV0eW0tKlvfHD0IVRcSoGo2QSjeGgDIVlafUJSfGyxGTiYUACByJlSeOYnd2cwLwAkIQgEp4JeWTqG+qSVNNpKGkMesTgQAkN3T8Yrzc6UovyUIRSYUACBSEEpXUm1o9gUXsQCcjCAUkAJWUMmaXhFJaJaUV5dEAgBItmdCFRd4TCBKMbAAMkNjY6N4PB7Jy2Mohq7RqXc640KLkucydRsu0XJqDUDSaJFxK7GpwyBUyGPWnG4AQJbXhMrPlZKCloFqDVMsAFebOXOm7LjjjtK9e3dZc8015cwzz5Ta2tp0Nwsuz4TSqXg5OTmSn+sx07eZug2nIwgFJFloUlNH0/FCH2M6HgBkN2s6ntaE6lZIJhTgdj/88IOMHTtWtt12W1m1apUsXrxYNt10U5k9e3a6mwYXq6xvMkEoS7eCXKlhOh4cjhxQIMlCp9Z1VJg8NBOK6XgAkN2C0/HIhAIywj//+U/ZeOON5frrrw/ed8opp6S1TciMTKhe3QqCtzVzNnTFbcCJyIQCkswXEoQKLT7e8XQ83hYAyGZWdmxxgU7HIxMKcLPm5mZ544035OCDDza3a2pq0t0kZAjNeiotDMmEKsyVmgYKk8PZyIQCkiw0oGSd2Y6kPrCihSITCgCyW2gmlE7JU9bKRwDcZdmyZVJXV2eCTxtuuKHMmzdP8vPz5dhjjzWZUUVFRRH3a2hoMBdLZWVlsN6oXtLJakO625Gp7Y21zZr1pCcrrG00E2pJZX1aXqfbjjHttVc87ztBKCCV0/GiBKG0EHljyOCCwuQAkN2s/kIDUEV5uZ0ubgHAubRotLrjjjvkrbfeki222EK+++472XnnnaWwsFBuuOGGiPtNnTpVpkyZ0u7+ioqKtA/09fdXV1eHvT4nc1t7Y2mzNzB+yBOv+UyoQo9fquubgred1F6nob32soLksSAIBaRwOp4OIPQLr+0Xc9uz2xQmB4DsZhUm1zPchfkt1RPIhALcqU+fPlJQUCBHHnmkCUApLUqumVAvvfRS1CDU5MmTZdKkSWGDvMGDB0t5ebmUlZVJOllBMG2LWwIObmpvLG2uDky7K+9WbLZRZd2KpK6p0nw+Uv063XaMaa+94nnPCUIBSRaa1aRXm7x+KcgL/yNte3ab6XgAkN1Cp+MV5rUEociEAtwpLy9Ptt9+e6mtrQ27X28XFxdH3U+zpPQSabDnhEG+1Q4ntCUT29tZm0NrB1qP6+p4zT6/NPn8wb7DKe11ItprH4JQgIOExKCCK+QVtOkU2q6ax3Q8AMhudSHT8fQ/dtpvkAkFuHt1vL/97W8yYcIEE5D67LPP5KGHHpJrr7023U2D2zNmA3UDVUmgSHltg1cKA1O5AachEwpIsrZT6/RMdllRfpv7wqfj6RkMAED2qm9sOWGR62k5m1yU5yETCnCxnXbaSZ588klT5+mCCy6QIUOGyO233y4nnHBCupsGt2fMBlZQtTKhrFXzenYrSFvbgI4QhAJSWBNKNbQJOJn7AplQOuDQAoPUhAKA7KaDi9Cz25oRRSYU4G577723uQB2qG1sbp8JVRDIhApkSQFOlPqJokCWB6Ei1fSwMqGssxdt9wEAZHcQSouTUxMKABDaT6iS0EyowkAmVKBoOeBEZEIBKZ+O1z4TyhpY6NmLVbVNZEIBEfzyyy+yZMkS2XDDDc1KQ3btE8s2c+fONduNGjVKevbsGfbYnDlzZMGCBWH3lZaWyrbbbsv7iC7V+gidYlGURyYUACC8nzD9A5lQcBmCUECS+QIxp4JcjzR6fe2KkIcGoayzF2RCAeGrBx100EEyffp0WWeddUzQ58orr5Tzzz+/S/vEss2MGTPkqquukpkzZ8rixYvlvffek3HjxoX9rltvvVVeeOEFs9y2Ze211yYIhS7RfqE4MK3CyoRaXdvEUQUAtMmEau0ryISCGxCEApLMCiiVFOZKY62vw+l4VifibZ8sBWStyy+/XGbPnm0ykfr16yevvfaa7LXXXjJ69GhzSXSfWLb57bff5JRTTpERI0bI0KFDo7Zxhx12kGeffTZJRwDZOrjoFVJUVjOh6psa0tomAIBzWHWfigtaK+wU5+eFBagAJ6ImFJBk3kAQqlsgwFTfQWFy6+wFhcmBVg8//LBMnDjRBIrUnnvuKSNHjjRLW3dln1i2OfLII2WfffYRj6fj7lKzqj755BMT1GpsbOTtQ5dpXxG6vHZLYXIGFQAAq5/whgWeWvqKlv+vUEMQTkYmFJBkfisTKlDbI3ImVHgnwnQ8oMXChQtl2bJlssUWW4QdEr09a9ashPdJ5Hk7otP0li9fLosWLZLm5ma5++67Zb/99ou6fUNDg7lYKisrg98X1ndGulhtSHc7MrW9sbZZV0otzPMEt9HVU3V11XS8TrcdY9pr//EE4NyaUGH1AwP1oSKd9AacgiAUkGTW1LqSwrzOV8cjEwoIs2rVKvOzV69eYff37t07+Fgi+yTyvNHocttTp041Bct1sHbZZZfJ4YcfLt98842sv/76EffR7adMmdLu/oqKirQP+PT3V1dXm+s5OTnidG5rb6xtbmz2So7faz4TKle8pq7gqtWrxZPi1+m2Y0x77WUFyQE4czpeScQgFJmzcC6CUECSWVPrSqxOobnj1fHMPpx1BIyCgpaaOHV1de2mv1mPJbJPIs/bURDKogN0DS7deeed8vLLL8vf//73iPtMnjxZJk2aFDbIGzx4sJSXl0tZWZmkkxUE07a4JeDgpvbG0mbtN7x+kW7FhWYbVVpcZH4WlXQPO+vthPY6De21lxvecyAbtc6kyI0wHY9MKDgXQSggyaypddagQadYRM2ECmzjCwSugGyngRmtx7RgwYKw+/X2WmutlfA+iTxvrPR5NcNKp+ZFU1hYaC6RBntOGPBZ7XBCWzKxvZ21uSmQQqtT8KzHrbPbmg1VkpP6/7657RjTXnuPJQAnFyYPCUIFaglGWo0bcAoKkwOpCkLlRw9CWcVmrXRaCpMDLYqLi83Kcy+++GLwkFRVVck777wju+66a/C+H3/8UWbMmBHzPrE+b6d/3z6f2S+UtuXPP/80K+oBibD6Ca0JZbGuc3YbABC6Al54JhTT8eB8ZEIBSWYlNRUG0mMjBaGs+4oD0/EoTA60uuaaa2T8+PFy3nnnyXbbbSf//ve/ZeDAgWZlO8tNN91kglDff/99zPvEso1mM+mKd1p0XM2cOdMUHl9nnXXMxev1ytZbby1HH320DB8+XObNmyfXX3+9eb5DDz2UtxEJafC2DCwKcj3tBhaskAcACCtMznQ8uAyZUECSWVlNwUyowOAilE6vaNnGE1bMHIDI6NGjZfr06aZA88MPP2wCPB9//LF069YteHg23nhjc388+8SyzXfffSfXXnut3HfffTJhwgR5/fXXzW3dTuXn58uHH35oAlMPPfSQfP3113LFFVfIBx98EHdtKcCiq+BZ0/Es1PkAALTNhNIsWY8np/0JCwqTw8HIhAIcMB2vNRMqMB2PwuRAmC233FIeeOCBqEcltMh3rPvEso1Ozetsel7fvn3NiniAXawTE6FBqMJAnQ8yoQAAVmFyK+jUbuo2NaHgYGRCAUlmFRlvnUoRPQhlbUNhcgDIXq01oVjxCAAQva8IPVlhLSSg91E/EE6WVUGo999/Xw477DAZOXKkfPnll51uf/XVV5ttQy8HHXRQStqKzOGNYXW8huB0PAqTA0C2s/oJMqEAANHoie3Q2oGWIhOEYnU8OFfWTMf7xz/+IZ9++qnsv//+8tRTT0l1dXWn+8yfP99Ms7jhhhuC9+mKSkA8fIGYU3B57SiZUHmeHMkPdCRMxwOA7BWcjhdWmJzV8QAAIX1Fsy+48FEoHXMQhIKTZU0Q6tJLLzXFZhcsWGBWQopVeXm5yYACuloTyhpAWFlPkdJprcKCTMcDgOzVUSYUAwsAgOkrvL5gDaj2QShWOYJzZU0QKnS1o3jokt+6gpIGo3bYYQcTwCIbCvGwspryPR6T7RQtE0oHG7k5LUEoMqEAIHtFDkK1XI/UhwAAso/2B2VF7YfzeuKbwuRwsqwJQiWie/fucsopp8jYsWNl4cKFMmXKFHnxxRflk08+kby8yIeuoaHBXCyVlZXmp9/vN5d0stqQ7nZkanujtdnKatIkJx1QaIfR9jXpakc67cJaYdXrTc3rdtsxpr32H08AzmMtYBF6htuachFpcQsAQPbR8UPoAhahmVArqhvT0iYgFgShOnDNNddIfn5+8Pa2224r6623nqkpdeSRR0bcZ+rUqSZY1VZFRUXaB3z6+61aWLpygtO5rb3R2lwVuF1fXyf5nhyprW80n4dQdQ1NomONutoac7umtrbdNqlqr5PRXntZQXIAzq8JZV1vZNltAIBVmDzSdLw8akLB2QhCdSA0AKXWXnttWWutteS7776Lus/kyZNl0qRJYYO8wYMHm+l8ZWVlkk5WEEzb4paAg5vaG63NRcV15mdptxIpzM8VX47HPB7KKzlSVJAnZd1Lze2CwqJ226SqvU5Ge+3lhvccyEYNgVWNwqbjBRa3IBMKABBazqMtzZylfiCcjCBUHJqammTp0qVmml40hYWF5hJpsOeEAZ/VDie0JRPbG6nNVgKcx+MJTsdr+3r0Pk2dzQ2c6dYZfKl6zW47xrTX3mMJwMGZUHmRMqGYjgcA2U5PzJpMqJCM2bDC5PQVcLD2n9osdsUVV8hBBx1krjc2NpppdbW1tcHbWpRc6z0dfPDBaW4p3MQqMq5Fx60gVMQlVkMKkzcH6kgBALKP1U+E1vqgJhQAwNLk9Yf1DW2DUF6fX5oirMgNOEHWBKFeeuklGTlypOy2227m9sSJE83t//znP8Ft5s2bJ3PmzAlOxdPi40OHDjV1oPr06SPvvfeevP7667L++uun7XXAfax4kp6o0LMVWkQw0llvszpeoDK5j4LRAJC1Iq2OF8yEYlABAFkvUu1AS1Gg72BKHpwqzy3T4D7//HP5/fff5eijjzb3rVixQnr37h3zc4wZM0YeeuihdvevueaaweuXX355MPNJp6lccsklpsbTH3/8IT179pRevXrZ8nqQXazV8fQzpdlOlXVNUQsLegKZUHr2AsgEdnx/A1kbhAoZXAQzoQL1ogCkDn0Z3HCyIjQTStU3+aR7UcqbBrg/CKXZSXvttZf88ssvZiqcNYg56aST5Pjjj5d99tknpufRAFJnQSQtIN6W1vFZd911E2w90BpQ0ql2OrUi0llsU1gwtzUTiiAUMoFd399AtolUE6owt2VQQSYUkFr0ZXAia2ZF6LRtS1HgpAWZUHAqx0/H0zpM2223XbulxM8//3y59tpr09YuIFbW1DoNMOmAou3KRlpYsHU6Xvg+gJvx/Q10tSZUpEwoanwAqURfBrdmQkUqAQI4geMzoT744ANTp6mgoCDs/k033VRmzpyZtnYBsbICSjrTLlJhci1CrpsU5OUyHQ8Zhe9vIDENHdSEaqAmFJBS9GVwWxAq2F+wQh4cyvGZUPX19WZKXNvlxBctWiQlJSVpbBkQb2HyHNMpaNaTZj9Fqv0RnI5HJhQyAN/fgH0FZz2eHMnPzSETCkgx+jI4UUOEjNm2mbORVuQGnMDxQahx48YFV7CzglA1NTVywQUXyM4775zm1gGds+o7adFxPVuh8SXNfop0JsMqTG4VMwfcjO9vwN4z3NaJDACpQ18GtwWhgqupEoSCQzl+Ot6NN94oO+64o7z22msme+Tggw+Wjz76yDw2ffr0dDcPiHk6nhWEsjqF/DbLbWsn0lqYnAML9+P7G7BvOp4qzM9ldTwgxejL4LrpeIFi5Zy0gFM5PhNqww03lO+//1522203s5KSpsSecsop8s0337BqHVzBymqyCpO3PTMR2onkBYJQFCZHJuD7G0hMY7PX1BG0+gQLmVBA6tGXwS3Tti1WdhQLWcCpHJ8Jpfr16yeXXnppupsBJMQbmFmnY4lIhQKDZ7xzPabmh9mH6XjIEHx/A/HTkxM6iAithanMCqusjgekHH0ZnKahyRtW/ylU8KQ3UyvgUI4MQi1YsCDmbQcNGpTUtgB2ZUJpgKmwk0yo3MCAg8LkcCu+v4Gua/L6g1O2Q2kfwqACSD76MrgnE6pl6l2oSDMvACdxZBBq8ODBMW8busoY4PSaUMEglLfl7EXL9ZDC5NZ0PDKh4FJ8fwNdp/1CpCkW2k9U1jdxiIEkoy+Du2tCWTMvWscbgJM4sibUL7/8ErzceeedMmDAALn77rvlyy+/NBe93r9/f/n3v/+d7qYCnbKymjTLqbVTiJAJlRtamJzgKtyJ72+g65q9rYtXtMuE4sw2kHT0ZXDrAhYq0swLwEkcmQk1bNiw4PVDDjlEnn32Wdluu+2C940aNUo222wzOeuss+T0009PUyuB2FjJeh5P5PRYpuMhk/D9DdgzHS8vN7weVLAmFIMKIOnoy+B01vjBCjhFLExOfwGHcmQmVKg5c+bIRhtt1O5+vU8fA5zOymrS6XjW9IqwIFRgal7LdLyW+5iOh0zA9zeQmKYo0/EK83I5sw2kGH0ZXDcdL1AniiAUnMrxQai11lpLbr311nb333bbbeYxwC1BKJ1qV5DX0imEFpYNPZPRWpg8LU0FbMX3N5B4EIpMKMAZ6Mvg7MLkHayORyYUHMqR0/HaBpv23XdfeeaZZ2TLLbc0hci1LtTcuXPlpZdeSnfzgJiL55tMqAidQkOEmlBkQiET8P0NJD4dryi//YpHerJCT2xozai8CAMPAPajL4MTNTS1zKQoyu+gJlTISW/ASRz/P5hddtlFfv31VznooIOktrZW6urq5OCDDzb3TZgwId3NA2IuTK7xpY6CUIX5HsnJyRFNhqIwOTIB399AYqIFmYJ9CAMLwNV9WVNTkyxYsEAqKipsby+yQ0MwE6r9CYvgQkhNBKHgTI7PhFK6Ot6UKVPS3QwgIdZCd2Y6Xm5Hq+O1dCI6Jc8KXAFux/c3EL9Gr18KIhQm15pQ5vFmn5QUcGQBt/ZlJ598sjz00ENyzjnnRCw7AnSpJlTwhEVLthTgNI4PQulZgo4MGjQoZW0BEmFNrdPpeJGWTG3biXg8OUzHQ0bg+xtITLPPJ/kRC5Oz4hHg9r7siSeekNmzZ8vw4cO72DJks46CUJHGG4CTOD4INXjw4Jjq7QCOXx3P0xqEslJowwoLBh4jEwqZgu9vIDFNzZGn4zGwANzdl/3222/y97//XT744AMzpQ9IVLCcR0eZUASh4FCOD0L9+OOPYbd9Pp/88ssv8o9//MOksAKumY4XpTB563S8QBDKk0NNKGQEvr+BxAuTR5qOF6zz0cwUC8BtfVljY6McdthhcsUVV8h6662XhJYim3Q4HS9C+Q/ASRwfhNpwww3b3bfxxhubsxKnnXaanHrqqWlpFxArXyeFydtNx8tp3QdwM76/gfhpVkWTzyd5HqbjAZnUl02ePNlM3Zs4cWLMv7uhocFcLJWVlcHviXTPBrHakO52ZGp7O2tzY7PXLGak5ysiPa6BKA1CpfL1uu0Y0157xfO+Oz4IFc36668vP/zwQ7qbAcQehNLC5JGCUN7wdFrNhGr2uuPLG0gE399Ax1O4tdvI72CKBWe3AXf1Ze+//748+OCD8u677wZrTOkKedXV1eZ2tLpSU6dOjVgQXVfVS/dAX3+/tl/p6s5O57b2dtbm6vpGE2iyApNtFeTlSG19Y0pXYHTbMaa99or2WcyYIJSeEbjpppsoSg531YTKyQkWmtWis9EyoTQIRSYUMhXf30DHmgN9Rn4nq+MBcE9f9ueff0pJSYnsvffewfuWLl0q8+bNkzfeeEPmzp0ruYFVkttmT02aNClskKcZWOXl5VJWVibpZAXBtC1uCTi4qb2dtdkvHnMCWx+LRPsLr+REfTwZ3HaMaa+94nnPHR+EKi0tbXdfbW2tdO/eXR5//PG0tAmIhxVQMjWhAkEoK/sp9LoVoNJglRW4AtyM728gfsE+IcJ0PIrNAu7sy4477jhzCTVy5EgZN26c3HrrrVH3KywsNJdIgz0nDPKtdjihLZnY3o7arH1FQV5u1Nei/UWj15/y1+q2Y0x77ZNRQahHH3203X09e/aUESNGSI8ePdLSJiAeVtKTjiesQFNTsz9sFaTQwUWeFiYnBoUMYOf395IlS8x/9vXnpptuKoceeqjk5eV1eZ9YtqmqqpLHHntM5syZI2eeeaYMGzbMlvYBkVh9Qn5epEwopuMBqcZYBE6kGbGRVsaz6GNkzcKpon9yHeLJJ5+U/fbbL+wyduxYM4DRFSYAp/P6Q6fjtQwqmkIyoazr1mNaO8pHJhQygF3f37oKkQZ2dMpCfn6+XH755bL77ruL1+vt0j6xbHPffffJBhtsIO+9957cdtttwVoeXW0f0Nl0vEiFycmEAjJnLLLGGmtwQh0Ja+gkCKX9BSupwqkcH4R66qmnos7hfPrpp1PeHiBeVkBJaz1ZhWbDg1CB+h+BAYdux3Q8ZAK7vr8vuugiszrR66+/LldeeaUp7Prhhx92OA0iln1i2WarrbaSn376ydT+sLN9QCLLbls1oRhYAO4fi7z55pvyr3/9qwstQ7b3FZH6ibDpeNQPhEM5Ngi1evVqcwm9bl1Wrlwpr7zyivTv3z/dzQRirgml02Sj1YTSwJNmQFm1oyhMDjez8/tbVw967bXX5IgjjhBPIFA7ZMgQU0fjxRdfTHifWJ9Xpw5q3Q872wckWpicTCggdRiLwOmZUB0GoXIJQsG5HFuwQuuGRLpu0f/sX3fddSluFRA/q76TBpdyAoEmK/tJNXt9YYMNDUaRCQU3s/P7W1cO0lWI1l133bD79fb06dMT3ieR57WrfUr30UvbZW31zLoTlt12Qjsytb2dtbmx2RusD9j28YJAX1Hf5E3p63XbMaa99h/PbMRYBI4PQgVObkeimbOhJ70BJ3FsEOqLL74IToWwrlu05oYuT9qrV680tQ5IYHU8j7VaRGvhWSsgZRUsN9vl5EiTVc0ccCE7v791BSLVNhtJl6a2Hktkn0Se1672qalTp8qUKVPa3V9RUZH2AZ/+/urqanPdDavbuK29nbV51eqW+71NjebzEKqpvs78rKyubfdYutrrRLTXXlaQPNswFoGT6QmLwvxOakI1MZ6AMzk2CLXllluan3/88YestdZa6W4O0OWaUNZ/3DXgFFoTSs9ShAWhPDlSH7J6HuA2dn5/W8Eda3qfZdWqVVGnycWyTyLPa1f71OTJk2XSpElhgzwNzpWXl5sAVjpZQTBti1sCDm5qb2dtLqxseay0W4l5PFTvmpZtc/IL2j2WrvY6Ee21lxve82RgLAIn0/FDR5lQpiYUmVBwKEcGoZYvX25+9unTR0pLS4O3I9FtACfTqXUaWAqbo91mdbzQ6Xh5uTnSHDJdD3ATu7+/tb6SPs+cOXPMinMWvb3xxhsnvE8iz2tX+1RhYaG5tNWSLZn+AZ/VDie0JRPb21GbrZpQ2le0C1AFznprNm2qX6vbjjHttfdYZhvGInB6oD2WwuQ6BtGyH3kdBKuAdHBkEKpv377BPzDrejTxTluYO3euWU571KhREWuVRKLbL1myxKx+RNAL8dLxREgMygScQjOhNOAUmgmldUCamY4Hl7L7+1vrRx144IHy0EMPyamnnipFRUXy7bffmnpLzz//fNjqRX/++adZqS6WfWJ9XrvaB8TKmq4dqTB56+p4TLEA3DoWAbpKT1bo+MLqEyIpDASo9MQ3QSg4jSODUF9//XXE610xY8YMueqqq2TmzJmyePFiee+998zqRR3Reh4HHXSQGUyss8465sy2Lr99/vnn29ImZAevr2X1O0vLdLzW/7A0tUmnzfO0nLkA3CgZ39/XXnutjB071tSY2nzzzc1qdEcddZTsu+++wW3eeust8z2vQahY94llm88//1wef/zxYD2cO++806x6p1lPVuZTLM8DxKopuDpe+zPX1llvglCA+/oywC6aBaU6yoQKBqGafVJSwLGHszgyCDVy5MiI17vit99+k1NOOcUstz106NCY9rn88stl9uzZJhOqX79+ZmCx1157yejRo80FiPVshQaWLJFqQukUPIteDw1SAW6SjO/vNddcU2bNmiWvv/66yUo9+eSTZcyYMWHbHHbYYWEnFmLZJ5ZtdKqdVdfqlltuCd7fo0ePuJ4HiD8TyhN1UEEQCnBfXwakMghlneC2tgWcxJFBqI5qiLQV6/S4I4880vxcsGBBzM/98MMPy1lnnWUCUGrPPfc0HZFOuyAIhXhWxwurCaWFAsNWx/NJcX5+8LamzOr8bcCNkvH9rYqLi+WAAw6I+vjOO+8c9z6xbKN1nWKpERXL7wJiYU3HDj05YbEGHAwqAHf2ZYAdrBMRHRUmL8xn+jacy5FBqM7mXqdiHvbChQtl2bJlssUWW4Tdr7f1jHc0DQ0N5tJ2WVttZ7rnjFttSHc7MrW90dqsNZ80CGXdZ9WEsm5bNaGs23k5LdlTqXjdbjvGtNf+45mJ39+AmzUGMmEjDS6s+xqavSlvF5BN6MvgZNaJCGuxikha+wtObMN5HBmEcsLca11eW/Xq1Svs/t69ewcfi2Tq1KkyZcqUdvdXVFSkfcClv9+qa+KGlU7c1t5obW5sahaP+M1nQOn12iZv8HZDk1c8fl/wtt/nNZlQ1u1Ut9fJaK+9rCB5pn1/A5kwHS9SIVm9T09qkAkFJBd9GZys0dtyIqKwg0woMmfhZI4MQjlh7nVBQUsFt7q6unbFyq3HIpk8ebJMmjQpbJA3ePBgKS8vl7KyMkknKwimbXFLwMFN7Y3a5hyP5OXmmvtUUUG+VNR7g7c166m4MD94u7ioQPREuH5ekv263XaMaa+9kvGeO+H7G8iE6XiRVsez6kJxZhtILvoyuGI6Xkc1oUJWxwOcxpFBqLZqamrM6kQ//vijua31OY444ggpKSlJ2u/UwJEuvd22hpTetorURlJYWGgukQZ7ThjkW+1wQlsysb2R2uwN1ISybmt6rE7Hs25rEXI9u23dtoqYayAqP6SWVKra63S0195jmYnf30CmTseLVFcQQPLRl8GJQajCvJa6T5EEF7JoYvo2nCd6+NQhvvzyS1lnnXVMhpGmxurlH//4h6y77rry1Vdf2fq7dJCkS3xbRWZ32GEHsxS3paqqSt555x3Zddddbf29yGxeXR0v5Ix2fl746nd61jt0FSRrW60VBbhZKr+/gUxhLUwRaTqeFZyiJhSQOvRlcOXqeGRCwcEcnwl16qmnyr777iu33367FBUVmfvq6+vl7LPPllNOOUW++OKLmJ5n0aJFMnv27OBqFzNnzpTm5mYzQNKLuummm0wQ6vvvvze3r7nmGhk/frycd955st1228m///1vGThwoEycODFprxeZGYTKDck4yQ9kQlnTyzQgVZAX8nggE6plSkb0MxxAtnx/A9nE6h+iTsfL9zC9Akgh+jK4MggVOJFB5iycyPFBKA0cvfHGG8EBjNLrGiAaMmRIzM/z3XffyfXXX2+uT5gwQV5//XVzOeaYY4JBKJ0mEjo9ZfTo0TJ9+nS566675OGHHzaBqPPPP1+6detm62tEFgShPJGDUFZGVGgmVC6ZUMgQdn1/A9kkUr/QLhOqiel4QKrQl8GxNaEoTA6XcnwQSqdtLF68WPr06RN2v95nBY9ioVPoOptGF1pQ3LLlllvKAw88EEeLgfZBqNAzFS01ofyBLKjAtItA9pOy6kA1BYrTAm5l1/c3kJ2ZUJGDUFoDpKaxOcWtArIXfRmcxspu0szYzmpCUZgcTuT4mlAaGDr00EPltddek2XLlsnSpUvN9UMOOUT+/ve/m6kd1gVwouZ2mVCtBcmtuk+h0/GsOiAavALcjO9vwP7peHpSg0woIHXoy+A0jV5vzJlQrKYKJ3J8JtSJJ55ofu61117tHjvhhBPMpe3y7YDjCpO3mY5nDTSssxNhhckD21KYHG7H9zcQP+u7P3omFDWhgFSiL4M7a0K11JWlJhScyPFBqI8++ijdTQC6HITyeNpnOmkQKtK0C2t1POsxwK34/gbiF+nkRPtMKJbcBlKFvgxOY2U36fTsaMiEgpM5Pgg1ZsyYdDcB6PJ0vNBMqIJAkEkHGsGaUCHTLqz6UEzHg9vx/Q3EL1K/EEoHHdT4AFKHvgxuzIQK1oQKbAs4ieNrQgFu5/P7xZMTaTqeFiYP1ISKMB3PegwAkD1imY6n/YOPuoEAkOWZUJ3XhCIIBSdyfBBqwYIFcvjhh8vgwYOltLS03QVwumavL+yMdn6gU2hqjjYdr+V6M6vjweX4/ga6Mh0vWiYUKx4BqURfBlfWhAr2FUzfhvM4fjreMcccI83NzXLllVdKjx490t0cIG56sjpyJlTkIJQ18NBpfICb8f0N2J8JFazz0eSTovzo9UAA2IO+DK7MhAr0IWRCwYkcH4SaMWOGzJ07V/r27ZvupgAJ0YymzmpChZ7xzmV1PGQIvr+BLtSECuk3QlmDjgZzdjufQwwkGX0ZnIaaUHA7x0/H69+/v9TV1aW7GUDCtMB4bqDYeLSaUBGn47E6HlyO728gsSCUnpjICcmgjZYJBSD56MvgNNYUu9CastGn49FXwHkcH4S66KKL5OSTT5Zff/1V/H6mJ8GtQSiJfTqelQnFdDy4HN/fQPz05ES0qXihS3IzsABSg74MTmOdhIilJpQ1dQ9wEscHoUaNGiWff/65rLfeeuLxeMyZwdAL4GS6epHGkvJCM6EiFiaPMB2PwuRwOb6/gfhpvxBtKp4iEwpILfoyOI11EsI6KREJNaHgZI6vCXXCCSfIVlttJSeddBKFyeE63kD2nidKTajG5vbT8UKn6wFuxvc3kFhh8o7ObrM6HpBa9GVwak2oaKuoWuU99MQ2mVBwIscHoX7++Wd57733pFevXuluCpDQVDwVelY7NMhkZTuF14TKCdsXcCu+v4H46QmKjqbjtWZCsew2kAr0ZXBiEEr7gs5mBWk2FKvjwYkcPx1v7bXXloqKinQ3A0iIFUiypthFrwnV+rgVsLIeA9yK728gwel4HZzdpiYUkFr0ZXAazW6ysmI7ooEqglBwIscHoU477TSTBvvdd9+ZVfLq6+vDLoAbpuPl5kQJQlnT8UI6Eqt+lE7JANyM728gfvrdH1smFCcqgFSgL4PTNMYThOKkNhzI8dPxzj77bPNzs802i/g4K+bBybyBQFJuyFntgrxATahmX7BjyA8pXG6dAacwOdyO728gfnqCouPV8Vh2G0gl+jI4TYPXFyw83hGm48GpHB+E+uijj9LdBCBhzb6OMqH80hxhOp71eCOZUHA5vr+B+DX5fFJSmBvDstvUhAJSgb4MTqM1ATtawCL0pAXT8eBEjg9CjRkzJt1NABLm83dWE6r9dDyrU2kKrHwBuBXf30D8dJp2TJlQ9BFAStCXwWl0JoVVH7AjOqZgdTw4keNrQkVSU1MjDzzwgGy//fbpbgoQUyZU5NXxWqfjhabUWteZw41MxPc3EMN0vJAp2tEzoThRAaQLfRmcsDpeZyhMDqdyfCZUqM8++0zuu+8+efLJJ6WwsFD22muvdDcJiK0mVFgQylr9zh9cAS90JSSrU+EsNzIJ399AHEGoQO3ADlfHIwgFpBx9GdwUhNLMWU5YwIkcH4RasWKF/O9//5P7779ffvvtN7NC3nvvvSc77LCD5OZ2noYIOGJ1vCiZUNYKeKFTL4I1oRhgwOX4/gbipycorFVSO5qOx8ACSA36MjhNQzyr41E/EA7k2Ol4b731lhx66KEyYMAAE4A66aST5K+//jKPjRs3jgAUXMHr83VSE6r9dDyrU7EeA9yG728gcboyaiw1oQhCAclFXwbXT8fLJRMKzuTYTKhdd91Vtt56a5P1NHr06HQ3B0iIFUcKDUKF1nyy6j6FDjio9wG34/sbSIzfr9O0tTB59Ol4rI4HpAZ9GZxKxw+hJ7A7zITy+kzfkhOyUjeQbo7NhNpnn31k5syZcu6558q9994r1dXV6W4SkNAZ7XaFyQO1PnQFJCvbKXTAQWFyuB3f30BigiumdpgJRU0owM192apVq6SqqsqW50L2afb6xOvzx1iYPFe0Moi1UBLgFI4NQr300ksyf/582X///eX666+X/v37y8knn5zuZgFx0U5CeTqpCZUXIROKmlBwK76/ga6duOgoCEW2LODOvkzLi2y00UYybNgwU25kxIgRMn36dFvbjMxnzaKwTkh0JHhimzqzcBjHBqGUftlPnjxZfv75Z9MR1NbWSlFRkfkC1/t1hQrADUGovChBKKsjCU2pDX0ccCu+v4H4aYas6mg6nlUTikEF4J6+zOv1yqeffiovvviiKXS+cuVKs8iSZlvpbSBW1nd/bJlQ9BdwJkcHoSw6h3X8+PHy6KOPyqJFi+TMM8+UN998U7bddtt0Nw2ILRMqJ/J0u9apF6FBqpbrDDCQCfj+BmLXRCYUkJF9ma7ofd9998kGG2xgbufn58sll1xipuZ98cUXSW49Mok1PohldbzgSQtObMNhXBGECtWjRw8544wz5KuvvpIvv/wy3c0BOmQFmULPVlhBJn2sqdknGp8KLVyu/9FpWVKVTChkFr6/gY611gmM/t8zzazVLoNltwF392Vz5swxPwcOHGhj65DpGhIJQjGmgMO4LggVatSoUeluAhD3gEIDThp40gCUWYrb42m3YkVhbstqFkCmivf7+7nnnpOxY8fKhhtuKAcffLD89NNPtuxjxzZ6NnuttdYKu+y2225xvT4g1ul41okKayACwH1jES1yftZZZ5kV+DbddNOo2zU0NEhlZWXYRelqZ1yy8xg0NHmDY4vOtrXGH7pPutvNJTuOQazyYt4SQNysMw+hQSgdQOhtDVA1+SIvxZ1PJhQQNG3aNDnssMPklltuke22205uvvlm2XHHHWX27NnSp0+fhPexaxut57HxxhvLXXfdFfz9BQUFvINIynQ88/nSExUEoQBXqq+vl/322098Pp889thjHW47depUmTJlSrv7Kyoq4hrwJYP+fmvFwLYnU53Ibe2N1uZlqwK3fU3mc9Dh/s2N5ueK1ZXSp9CblvY6Ge21lxUkjwVBKCAFmVBtiweaAURgdTwNOLVlPQ5A5IorrpCjjz7a1OBQDz30kCkW+5///Ef++c9/JryPXduokpISkwEF2NFn5HWQCaUK83PJhAJcSDObNAC1YMECef/996OeSLFo8fNJkyaFDfIGDx4s5eXlUlZWJulkBcG0LW4JOLipvdHanLuqJZjUs3uJub8j3Utbit7nF3W+bbLa62S0117xvOeuno4HOF3r6nfhf5Sa/WQyoby+iGe8qQkFtKiqqjJ1N0Knt2lB1wkTJpj/wCe6j13bWD766COTDaXZUhdeeGGnZyeBjqfjkQkFZGoA6s8//5T33ntP1lxzzU73KSwsNMGm0Is12OOSncfAmopdlJ/X6bZWTSgdb6S73Vyy4xjEKqsyob7++mtz9nrJkiVm/rWeWejZs2fU7e+44w559dVXw+7TM936HEAsWle/Cx9QtEzH80uzTscLKUpuIQgFtNCzxartf9b19rfffpvwPnZto3r37m2yorRu1MKFC02NqNdee01mzpxpBhDRBiN6sbSt85FOicztTye3tbejNjd5rVofOR2+nsJ8rQnVUuMjFdx2jGmv/ccTXeP1euXAAw80Jza0zmBNTY38+uuv5rF+/fqlPasJ7lHX2NJPFBd0nktizcRgdgWcJmuCUDNmzJBx48bJxIkTTWFZDSRpJ6CrWug0iki05od2EjqgsHTv3j2FrUamrnRk1YSKNh1PH69rbE5ZOwGn0poZKi8vvLvSjCT9T32i+9i1jbryyivF42n5O95ss81kxIgR5oTFk08+Kccee2zENlLnI3trOnTU5lUVVeZnc2NDh9l0eeI3A5FUZdy57RjT3vTV+UD0Y6ir4ek44rjjjmvXH+jYBIhFXaAweXF+bqfbankPRQ1BOE3WBKEuvvhi2WOPPeTOO+80t/fee2+zJOr9999vVqeIZo011pDdd989hS1FNgShrEwnrylMHnk6XkUtNaGA0OLfoZYvXy59+/ZNeB+7tlFWAMoyYMAAGTp0qPzwww9R30DqfGRvTYeO2lxY3GR+lpV2XL+juDBfqhobUlLjw43HmPbayw3vudPpzAsr8wnoioYmazpebuyZUCxkAYfJippQdXV18uGHH5p52Bb9j9TOO+8sb7zxRof7zpo1Sw444AA5/vjj5YEHHgieGQdiYX3pty1MnufpuCZUIYXJgeCJgCFDhsgnn3wSdkSmT58uW221VcL72LVNtJWPFi1aJL169Yq6DXU+0l+3wIkXXTFVFeTmdrhdYV6u6V/S3V4u2XMMADgrEyqWIJT2FYrpeHCarAhCzZ8/30yd0NUkQg0aNMgUB4xGl9jWgrS6PLdOsdCaH5pN1dHceK3xoSm3oZe29Qm4ZM8xsIJQVn0P66KBJ52Kp3WhtCZU2/00aKVnOtLdfi6Zfwzc4PTTT5f77rtPvv/+e9Pmu+66y3x3n3TSScFt/vGPf4QVEI9lHzu2aWxslPPOO0+WLl1qbuuUpVNOOcVse+ihh6boCCFTNDXHujqe1oTipBgAZJt4puNZhcnpL+A0WTEdTwcJqri4OOx+rQVlPRbJNddcI6WlpcHbu+66qwlGPf/886a4YCTU+bCP22pQRGpzVU2tud5QWyOhpTtyxCcNzc1mOl6O5LWr65GX4zOdTLLrfbjtGNPe7KzzccEFF5iC31tuuaXJICoqKpLHH39chg8fHjZFTreJZx87ttH6UMOGDTOPa9atHlO9risfaV0oIB66WIX5XLE6HgCgw8LkTMeDe2VFEKpHjx7m58qVK8Pu1zofHa2OFxqAUjro0DofurJFtCAUdT7s47YaFJHa3JzT8ie2Ru8eUl7eWgC/uCBfvNVNZsChtT3a1vUoKyk0j5WUdu90MGJne52O9trLDe+5VXPp9ttvl+uuu05Wr15tpsm1rcOkj4WuNhfLPnZso8fwjDPOMBftU3SFIw1MAXbWEYyUCaXTK3w+v3girLAKAMhM9c2B6XiBqXYdoSYUnCorglA67U4LzH799dey1157Be/X26NGjYr5ebQelA5CdJpeNHqmPNKS3E6ZU++2+f1ua2/bNlfVt6xwV15cEPYadKpFcHW8XE+711ecnxdMny2IoZOxq71uQHvtPZZuotmsbTNaLb179457H7u3idYGIFahU7hjWvHI65MiT3L7CACAc9QHMqGKCjo/SR3aVwBOkhU1odQxxxxjVsLTKRvqzTffNEGo0OWzb731Vjn11FPN9aamJvnvf/8bLESuGRi6DLdOjwotcA50xApClRa1WeI9WBMqcmHyonxP2LxvAEDmi3U6njUNo54+AgCySjw1oaxMKGtFPcApsiITSl1xxRXy3XffyXrrrWcuel1rPo0ZMya4jRaenTFjhrmem5trbmsW1brrrisLFiwwUz2eeOIJGTFiRBpfCdyksr5JuhfmSW6b6RI6wNCzEs0mCNX+jHdRYIBhzfsGgP9v706ApCqvBY6fHnqmZ19hgGFYBkE2EYgboiYKQTHqC5JKucalCp9WGaIvhS9oqFiSBUzMCxb6KiruL5X4jBaRaOIC5CmbG4iCsiPLMAMzA8Psa99X39fTY89MT09PT9++t/v+f1VTzfT08nn79j3ec893PiS+cKfj+atlG1raJfebmd4AgATX2JFQCmd1vM7peO2cT8BeHJOEysjIkHfeeUe+/PJLOXHihEyePFn39gikVjhS0+0U1fNj1apVuvpp165duneUaj4baioe0N3phhbJTuvZH0Ylnr6ZdtHzZMN/dYNKKABwDrViajjT8dI7LlSoJBQAwDnUBWp3kiusnrGd0/FYTRU245gklJ9KPqmfYAJXRApsan7JJZfEYGRIRCdqmmVkXs8+Mu6AwOEPEEGTUJxgAIBjhF0JRbUsADhSrZpl0a3NR6hFLBSSULAbx/SEAmJNTbWrrGuWwqzUHn8LTDypJuW9nmDQ7wMAHKO142p1sLgQvBLK13cQAOAMNU1tQWdZBMPMCtgVSSjAJOU1TWIYIsNzeyahAqdaBG9MTtNZAHCa1o7G5MEqZAMxHQ8AnFsJlZ0aXhIqPcVXMVXPzArYDEkowCTHTjfq2xG5oafjhewJ1cJqFgDgFOFPx/umMTkAwDlqGlslOy286XhqYSS14nZDM1WzsBeSUIBJSjuSUMV5PZcuCrzK7V+5IhDlswDgPGFPx+u4UMF0PABwDq/XkNrmNsnyhFcJpWSkuKmEgu2QhAJMUlrtT0IFqYRKcgX9tx89oQDAedr6OR2PvoEA4Bx1LW261Ue4lVBKumcQFyxgOyShAJMcrmrQtyODVEIlB1Q/hewJxVQLAHCMln6ujsd0PABwjtom37S6cHtCKRkpbmloZuo27IUkFGCS/RV1MjjTIznpPQNFckD1U7DpeBke3wlGHXO4AcBRq6qGtzoePaEAwIn9oJRwV8fzV87Ws5IqbIYkFGACwzDkwMk6GVeYEfTvgVe5A1fK88v0dKxmQRIKAByjtd0IqxKqczoeJxYA4BinG1r0bU4/klAZHiqhYD8koQATlNc06SqmcYWZQf/e1+p4WR1ltv6yWwBA4mM6HgCgNydqmvTt0OzUfldCqQvkgF2QhAJMsP9knb4dX5gV9O+B1U+BCanulVBMxwMAZ03HU7O11bLaoWR0TMdrpG8gADhG+ZlmfTssJ/wkVEaKW9SaF80dq68CdkASCjDBV2W1+nb80OCVUIHVTylBpuOpE5CMlEF6GVYAgHOm4/U1FU9JTU4Sl4vG5ADgJOVnfCtvD+tPJVRHn1lafMBOSEIBJvj08GmdSJpWnBtGT6jgX8PMVLfUNvkaEAIAEl9ruzesJJTL5ZK05EHS0MqKRwDgpHYf6vxiSJYn7OdkdFTOMrsCdkISCogyNedaJaEmDc/SzQCDCVz5qLcTDtUXqo6eUADgsCRU6Kl4gX0+aEwOAM5RXtMsQzI9fU7ZDuRfSa+mkdkVsA+SUECUHatukqr6Fjl/dH6vj0npY3U8f18oGpMDgHOEOx1PSUsZJA30hAIAR03H608/KCU33ZeEqm70rawH2AFJKCDKSjuaBp7Vy8p44VdCuSmdBQCHNSYPNwmVnuwmCQUADooPFbXN/eoHpeR0VEKdaaTFB+yDJBQQZVV1visNqly2N+H0hPInodrVkhYAgITXoiuhXGGfWNRwUgEAjlB2pkmvcjciL61fz8tNS9G31Q0koWAfJKGAKKus9x3kQzUN7DodL/jXMDfdHzQonwUAJwi3MbmSk54s1Y2tug8hACCxHa5q0LejC9L79TwqoWBHJKGAKFP9oJTCEEmortPxgl/1LsjwJaFOdbweACDxp1u4w0xC5aYl60pZVjwCgMR3+FS9vh2Vnx5RTyim48FOSEIBFlRChTMdL78jCeVPagEAEltLm1dSwpyOl9cRI5hiAQBOqoTK6Nfz/KvjnWE6HmyEJBQQZZV1LZLlcUtq8qBeHxNY/dRXEopKKABIbGpK3bYjp6W8pqlzKna4UyxIQgFA4jtcVS9JLpERuf3rCaXOSdxJLi5qw1bcVg8ASMQkVGF271VQ3RNPKe7epuP5XoNKKABIbC9tOSwPv7GrzyraQCy7DQDOqoQqyk2TFHf/akiSklw6rlTUNpk2NqC/qIQCouxkXYsM7WP5VHdSUtB/B62E6lhtDwCQmHaWnun899A+LmL4seIRADiD6v93sLJezhqSGdHzVZ/ak7XNUR8XECmSUEAUNbS0SV1ze8im5N2rn5J7uaLhvxpeUceVCwBIZPUtbfpWTbW4ZmpRWM/p7BtYx4kFACT6VDzVM/DsoREmobJTpaK2WbxeVlOFPTAdD4iikzW+k4H+VEKFWh1PldyWnm7kMwKABKZODlRSafOS2SH7CQYaluOLM+UdcQcAkJj2nazTt+OHZkX0fHVxvM1ryKmGFhmcGV61LWAmKqGAKDrRUera13SKwOqnlF4ak6s53Kr5YGk1SSgASPQk1JBMT9gJKGVYx8WO8jPECABIZHtP+JJQZ0eYhPJfHC8/w+wK2ANJKCCKjp7yLZ/a18oVyWrORQd3L0kopSg3VVdCqZWTAACJu6BFuA3J/dJSBukV8so4qQCAhLb3RK2+HV8Y2XS8kfm+85IjHecpgNVIQgFRdKiyXt+WDM4Ie3W83qbjKcW56VLf0s4S3ACQ0L0E2/qdhFKG56RKeQ1XtgEgke07UasvcGd4IuukM6Ygo8t5CmA1klBAFKmDu0opjcpPD/k4d0DiKbmX1fGUsUMyuswFBwAkFn/fv74qaINRzzle3Sht7V4TRgYAsFpzm1cOVNTLxGGRTcULvDj+NUko2ARJKCCKDlbUyfAcj3j66OsRWAmlej/1ZkJHwNlTXhPFUQIArHaoqkEWv7pDPj18Wv9enNf/JNS4oZnS2m7I11VMsQCARLTnRL1uKj5tZG7Er5GbniJ56clc1IZtkIQCokRNp1AVS5OH9T1f2xPQmDyUicOy9e2XZb654ACAxPD0pqPy2rZSWbpmp/69OC90BW0wZxf6LlTsP0mMAIBEtKvjHGAgSShlanGufFlWI61UzsIGSEIBUfL5sWrxGiJTi/oul3W5eq9+CqRW2VM9Pz75+lQURggAsIvdJ3y9OdQV7kgrofzVsruOUy0LAIloZ5mvJce04pwBvc704hxpafPKV2XEC1jPcUmoqqoq2b17tzQ1NZn6HDjP/+2t0LffGumrXooGlayaObZAV1idpPksHM6s43csHwMojS3tcvT0N/uJO8klRRH0hFI9QjI9btl6sIoNC8QJYgXC1e41ZOvX1TKuMFNPqRuIi8YW6Nv3O85XACs5JgnV2toqt99+uxQVFcncuXOlsLBQnnvuuag/B87k9Rryjy/KdeXSlOHhLZ+6aclsee+n3+7zcVdMLNS3az8vG/A4gXhk1vE7lo8BAn389anOCih/09iUMKdpB3IPSpILS/Jl+5FqOVXfwkYGbIxYgUhiRVV9q1w5eeiAN56KFVmpbnnzi3IxjG/iD2AFxyShfv3rX8s777wje/bskaNHj8of//hHueuuu2T79u1RfQ6c6Z0vy+XIqQZZMGOEJIU51U6tajSuo59HKCrwZKe65YXNh6SptT0KowXii1nH71g+Bgj0+rZSfTs403dle/zQ8C5eBPNv04p0Qut/PznKRgZsjFiB/lCJoqffP6j/rc4vBkotinT9jBF6Ot77+yr5MGApxyShnnnmGVm4cKGMGTNG/37zzTfLhAkTZPXq1VF9Dpxnd3mNLF2zS7I8brljlm9fiabU5EFy7xXj5OipRlny2ufS3EYiCs5i1vE7lo8B/D48WCVrPz8uF47O6Ww0W5iVGvEGmnfOMCnKSZUn1++XPeU0KAfsiliB/iSgnvngoGzYUyHzJg2Wswojv1AR6K7LxkpqcpI+n1AregNWcYsDlJWVyfHjx+XCCy/scv/MmTNl27ZtUXtOtGw7clqqG6JfVq8qL+vr6yUjo1n6Ktbpq0qzz7/3OZbQj9B/NQypb2iQjPRG1Rwp7Pfu690HOnY1P1uthFdZ2yw7jlXrXlBqVsWTN8+QwuxUOXOmWaJt4WVj5aNDp2TNZ8dl68FT8t3JhTIyL10KMj2SPMjV2T9K/UtVYqnNpf7t22yBv/se49+c6nNoaGiQ9PSmsJulmymc/TLcfdgOYj3eUfnpYVXXxROzjt+xfEysYkWwY1v3+4wwjsdGkGNvz9c2Inyv7o+J9HUC7lXfM30cq+tyHIvovYJtw1Dv3dsYg7xOTVOrbiD+5udlkpY8SP7zu2NlcF62vtCwaPY4iZR6/oofnCt3vvCxXPfERpk3ZZhMLsqWISo+uJMkOcmlp+0lqTgQ4XGIY6+5iBWJz86xoq9jbo8YEfBE37G3Uf+/ZrBX6Pu1u//dGNDYuusSKjr+nzdNx4oob4te7ujvf49qHK5mVmzcVyl7TtTqqdo/mztWomVkfro8+oNz5T9e+UzmrfxAZk8s1PGiMMujY4mqllLnFeHO6uj+sFDnFXb8/3Zim3XnFW6nNABUCgp8Ddn81O+VlZVRe47S3Nysf/xqamo6v5Thzr997O09svkATUbjgfqf+otKCuSBqybIjFG5nZ9ztOdaq/f571u+Jc9tOiR//uio/M/WI1F9fSSGf//2WHnw6olhPz4eegKYdfyO5WOCIVY41/SRufLwdZNkTJZLcnLS5YmbZgz4+3jZ+MHy57sukuVv7ZY3dhzXP4CTYoXdESvQH7lpyXp2xf1zxonR0hDV76Cawq2STv/17l7dTuSfu8r5cBDzWOGIJFRycrK+DUwO+X/3/y0az1GWL18ujzzySI/7z5w5E/YHc+t5Q+WqCXliBrVqU2pqeGX/oSpjQiWzQ2W6QybBu//R+Ga8fVXpRPqeoV/W1WtCKCNlkOSkuaWkIF3SUwZ1+Yzr6nzlrWZUFt00fbDcOK1AymqapbKuVU43tOrKLLVnqff2dl5lUYkw3xUWb8c/fI/x3xp6fOq2ublJPJ6+t7HZwv1+9GcftoNYjnfckHS9H4bLnyR34vE7lo8xM1bMm5jf5b5g3+LuX+2g3/RuF7HVccG337r69To9DyM9HxXW6/R4TpDX6Ryuob9naWq83a+89jk+XSva52MkCq/jcSfJmPw03QfKjFhxdt4gef6WKbpB+bHqZqmqb9HxQfWLUrftAziHsVOsCAfjDe2swWkJFyvszu6xos/jco+/qzuMkP+f3vfxN/Qx09Xn64U+3ve40+gYb1pa590937N/8aCv5wd/TO9jdLtcMjzHI8NzUvWqqSoBZcZ5xaQCtzxz42SpbWqT0uomqaxv1VVYrV6vtLb7ziH6YvQjVtg5kc15hTXnFY5IQo0YMUJ/EVQpbCBVFjty5MioPUd58MEH5ac//WmXD0M9PicnR7Kzs8Ma79UzcsQM6gCgdiQ1lnj5n8h4Gm/gQdbsMef62og4bhsz3uiKh8/crON3LB8TDLHCuccFs2NFTo5ISZGztzHjja54+MztjlhhvXg7LsTivELFi+KBL7wXt9uY8UZXfz5zRzQmz8zM1HOw33rrrS5Zz3Xr1smcOXM671OrGqnVjfrznO48Ho9ONgX+iL8XDz9sA/YB9gGb7QNOPX7H8jHBECus3/f5YRuwDyROrLA7YgXHG4437ANO2AfC5YhKKGXZsmVyzTXXyKRJk+Tiiy+WlStXSlZWltx9992dj1Hlrlu3bpWdO3eG/RwAQHwev2P5GACAsxErAMBBlVDKlVdeqa9Uf/jhh3oaRGFhoWzcuFGXC/qNGjVKJk6c2K/nAADi8/gdy8cAAJyNWAEAPi7Dzp3CEoDqCaVORNT82HB7QpmFea9sY/YJvnN2PT45nZ0+C2IF25h9gu+cXY9PTmenz4JYwTZmn+A7F+nxyTGVUAAAAAAAALCOY3pCWcVfaGaH5W3VWNQ44qXJZLyNNx7HzHidvX39xyUKYq1HrEjc71kijJnxOnv7Eivsg1iRuN+zRBgz43X29q3px3kFSSiT1dbW6ttQS3UDgNXHKfoXWYtYAcDuiBXWI1YASIRYQU8ok3m9Xjl+/LheKcnqjKXKTqpkmFrK3Op55Ik43ngcM+N19vZVVypUoCgqKpKkJGZnW4lYkbjfs0QYM+N19vYlVtgHsSJxv2eJMGbG6+zta/TjvIJKKJOpD6C4uFjsRO20dtxxE2W88Thmxuvc7UsFlD0QKxL7e5YoY2a8zt2+xAp7IFYk9vcsUcbMeJ27fXPCXBmaS98AAAAAAAAwHUkoAAAAAAAAmI4klIN4PB55+OGH9W08iLfxxuOYGS/bF+C4wLGXWGGteIvFQDzut/E23ngcM+Nl+4aLxuQAAAAAAAAwHZVQAAAAAAAAMB1JKAAAAAAAAJiOJBQAAAAAAABMRxIK2sGDB2Xjxo1y5swZW2+RtrY22bVrlxw4cEDa29vFTioqKuTjjz+WkydPSjxQ4/3ss8+kurpa4sn+/fv1vlpbWyt219LSIjt27JCjR49aPRQgKogVA0esiA1iBWAdYsXAEStig1hhEQOOV1paagwdOtRQu8OGDRtsuT1aWlqMpUuXGoMHDzamTJliFBcXGyUlJca6desMO1i8eLHh8XiMyZMn69tFixYZXq/XsKPNmzcbl156qVFYWGhMnz7dSEtLMxYuXGi0trYadnf48GGjoKBA76tbtmwx7Gz16tVGXl6eMWHCBP2zYMECo66uzuphAREjVgwcsSI2iBWAdYgVA0esiA1ihXWohHI4r9crt956q9xxxx1iZ42NjXrZT1UBtXPnTjl8+LDMnz9fFixYIDU1NZaO7U9/+pM8+eSTsnnzZl2l9dFHH8mzzz4rzz//vNjRvn37ZMWKFXLixAnZvn27roZ67bXX5Le//a3YvQrupptukoULF4rdqe15zz33yAsvvCC7d+/WP7fffrucPn3a6qEBESFWDByxIjaIFYB1iBUDR6yIDWKFtVwqE2XxGGChZcuW6Slkq1atkpKSEtmwYYNcfvnlcfGZ7NmzRyZOnCibNm2SWbNmWTaOOXPmSH5+vrz66qud96lkiZqCpaaNxYMf/vCHUl9fL2+99ZbY1UMPPaQTaL/85S9l0qRJsmXLFpk5c6bY0eTJk+WCCy6QF1980eqhAFFBrBg4YkVsECsA6xArBo5YERvECmtRCeVgKkHy9NNP66qdeKSSZy6XS8aOHWvpOFQ10XnnndflvgsvvFDfHw/UlQBVDTVu3Dixq3Xr1ukrQ0899ZTYXVlZmXz11Vdy3XXX6cqnTz/9VM/rB+IVsSI6iBXmI1YA1iFWRAexwnzECuu5rR4Aomfr1q06odCbjIwMmTFjhv73qVOn5JZbbpFnnnlGCgsL5euvv475R6FO1KuqqkI+RlW6uN09d9Njx47J4sWL5a677pJhw4aJVVQhoWrsXVBQ0OV+9XtDQ4M0NzfraYR2tnTpUj017/777xc7Ugmc2267TV5++WVdcWb3xu/Hjx/Xt//617/kxz/+sRQVFemqve9973vy0ksvSVpamtVDhMMRK2KPWGE+YgUQXcSK2CNWmI9YYQ8koRLII488EnLFMFUxpE6CFZXAUZUvWVlZ+spFeXm5vv+LL77QSSk1nchsKqnw/vvvh3zMm2++KTk5OT0OHldddZWcc8458vjjj4uVVCWWSpI1NTX16GGlJCcni52p7bdy5UpZs2aN5RVlvbnvvvvk3HPPlZSUFL2vHjlyRN//+eefS25urp6SaSf+z1z1CNu7d69kZ2frpOn555+vy9SXL19u9RDhcMSK2CNWmI9YAUQXsSL2iBXmI1bYA0moBPKPf/wj7MeqxI6q0lmyZIn+Xf1bUdPz1Anzo48+Kmb7zW9+0+/nVFZWyuzZs2Xo0KHyxhtvSGpqqlht1KhRUlpa2uU+9XtxcbEkJdl3xusTTzwhP/vZz3QT7Xnz5oldqUSTSjz591V/gk81g1d9t1SPKDsZPXp0Z18wlYBS1L5wzTXXyAcffGDx6ABihVWIFeYiVgDRxXmFNYgV5iJW2ISFK/PBRg4dOqSXvd+wYYNhVxUVFcbUqVONK664wqivrzfs4p577jGmTJlieL1e/bu6nTZtmnHnnXcadvXEE08YHo/HWLt2rRFvvvrqK72vbtmyxbCrmTNnGvfdd1+X+6688kpj/vz5lo0JiAZiReSIFbFFrACsQ6yIHLEitogV1qASCnFB9VeaO3eu7r/02GOPybZt2zr/plZK696TKZZUNdErr7wiP/rRj+SGG27QlUWHDh2Sv/71r2JHasW2RYsW6XGrqwH+FfwyMzNl+vTpVg8vIaxYsUKuvfZa3Q9KbdP33ntP1q9fr1efBGAeYkX0ECvMR6wArEGsiB5ihflWJOB5BUkoaGpa2yWXXNKj/5JdqFXGVGN19aP66gT61a9+JZdffrllYxszZoxu3vi73/1O/vCHP0hJSYn+3a6rzakE2axZs/TUsMDpYePHj5fnn39e7C49PV3vq/6pbnb0ne98R9599109ZVDdqn3ik08+kWnTplk9NGBAiBWRI1bEFrECsA6xInLEitgiVljDpcqhLHpvAAAAAAAAOIR9uyYDAAAAAAAgYZCEAgAAAAAAgOlIQgEAAAAAAMB0JKEAAAAAAABgOpJQAAAAAAAAMB1JKAAAAAAAAJiOJBQAAAAAAABMRxIKsJnXX39damtrTX+ftWvXSlVVlenvAwCIPmIFAIBYgXhEEgqwkVdeeUWWL18umZmZpr/X5s2b5YEHHjD9fQAA0UWsAAAQKxCvXIZhGFYPAoCI1+uV8ePHy2OPPSbXX3+96ZuksrJSiouLZceOHTJhwgQ+AgCIA8QKAACxAvGMJBRgkmPHjsnGjRt73D969Gi5+OKLe9z/97//Xe644w4pKyuT5ORkfd/f/vY3mT59un6O3/r162XIkCEydepU/fs///lPGTt2rOTn58v27dtl0KBBctlll+nXUK/18ccf68fPnDlTXC5Xl/f8/ve/LyUlJbJy5UoTtgAAoC/ECgAAsQJO4rZ6AECiKi0tlTVr1nS5TyWVFixY0GsSyp888rv77rt1ZVRgEmrZsmVy6aWXdiahFi9eLNnZ2fr9zj33XJ10GjFihNx5553y+9//Xs455xzZunWrzJkzR/7yl790ec/Zs2fLqlWrSEIBgEWIFQAAYgWchCQUYJKLLrqoS9JHJZNUomnJkiVBH79t2zaZO3duxFPrvvjiC52MOnz4sJx11lny1FNP6ftUf6ndu3fLpEmT5KGHHtKJKj+VyDpw4ICcPn1a8vLyInpvAEDkiBUAAGIFnITG5EAMvP322/Lggw/KSy+91FnBFCyRFGki6KabbtIJKEVVTQ0fPlxuvvnmzgbnEydOlNzcXNm7d2+X5/nfT703AMBaxAoAALECiY4kFGCyffv2yY033ihLly7VU/F6oxJG9fX1Eb1H9+SVx+MJel9TU1OX+/zvl5WVFdH7AgCig1gBACBWwAlIQgEmqqmp0c2/Ve+lX/ziFyEfe/bZZ8uhQ4e63JeUlKRXQgrUPZE0EOr9VIVUYWFh1F4TANA/xAoAALECTkESCjCJSh7dcsst4na79TS87ivTdacah3dfTU81GN+/f3/n7xUVFbJr166ojXHTpk06QaaSXQCA2CNWAACIFXASGpMDJlm9erVuRL58+XJZu3Zt5/2qZ1Ow1fFUD6cHHnhAPvnkEzn//PP1fbfddpv8/Oc/l4yMDD1d79lnn9VJrWhoa2uT119/XV588cWovB4AoP+IFQAAYgWchCQUYJIhQ4bIDTfcIJ999pn+8Zs1a1bQJFROTo785Cc/kccff1xefvllfd+iRYv066xfv17y8/M7T1ZUo3G/q6++WiZMmNDlta699loZN25cl/vmz58vY8aM6fxdrdynEmLz5s2L6n83ACB8xAoAALECTuIyDMOwehAAvmkUfu+99+pElEpKmUlVWKnE1AUXXMDmB4A4QqwAABArEK9IQgEAAAAAAMB0dCMGAAAAAACA6UhCAQAAAAAAwHQkoQAAAAAAAGA6klAAAAAAAAAwHUkoAAAAAAAAmI4kFAAAAAAAAExHEgoAAAAAAACmIwkFAAAAAAAA05GEAgAAAAAAgOlIQgEAAAAAAMB0JKEAAAAAAAAgZvt/L2c+VVAnNHQAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1200x600 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "comps = sorted(\n",
+    "    r.fields.keys(),\n",
+    "    key=lambda c: \"ExEyEzHxHyHz\".index(c) if c in \"ExEyEzHxHyHz\" else 99,\n",
+    ")\n",
+    "n_cols = min(3, len(comps))\n",
+    "n_rows = (len(comps) + n_cols - 1) // n_cols\n",
+    "\n",
+    "fig, axes = plt.subplots(\n",
+    "    n_rows, n_cols, figsize=(4 * n_cols, 3 * n_rows), squeeze=False\n",
+    ")\n",
+    "for idx, comp in enumerate(comps):\n",
+    "    ax = axes[idx // n_cols][idx % n_cols]\n",
+    "    ax.plot(z_slab, np.abs(r.fields[comp]), linewidth=1.2, label=f\"|{comp}|\")\n",
+    "    ax.set_title(comp)\n",
+    "    ax.set_xlabel(\"z (um)\")\n",
+    "    ax.set_ylabel(\"Amplitude\")\n",
+    "    ax.grid(True, alpha=0.2)\n",
+    "\n",
+    "for idx in range(len(comps), n_rows * n_cols):\n",
+    "    axes[idx // n_cols][idx % n_cols].set_visible(False)\n",
+    "\n",
+    "fig.suptitle(\n",
+    "    f\"Field components - slab mode  lambda={r.wavelength:.2f} um\", fontweight=\"bold\"\n",
+    ")\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3e20a2a3",
+   "metadata": {},
+   "source": [
+    "## Part 3 — Advanced"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "856415a5",
+   "metadata": {},
+   "source": [
+    "### Wavelength sweep & dispersion\n",
+    "\n",
+    "`mode_solver.sweep_wavelength(start, stop, num)` populates the wavelength\n",
+    "list linearly.  Multiple wavelengths + single band dispatches to the\n",
+    "efficient shared-cell sweep internally."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "b8a2da05",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  lambda = 1.50 um -> n_eff = 3.817275, n_group = 4.102009879990331\n",
+      "  lambda = 1.52 um -> n_eff = 3.814099, n_group = 4.102948178609803\n",
+      "  lambda = 1.53 um -> n_eff = 3.810913, n_group = 4.103866468575508\n",
+      "  lambda = 1.55 um -> n_eff = 3.807716, n_group = 4.10476456967535\n",
+      "  lambda = 1.57 um -> n_eff = 3.804510, n_group = 4.105642374062419\n",
+      "  lambda = 1.58 um -> n_eff = 3.801294, n_group = 4.106499818617173\n",
+      "  lambda = 1.60 um -> n_eff = 3.798069, n_group = 4.107336867537379\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sim.mode_solver.sweep_wavelength(1.50, 1.60, 7)\n",
+    "sweep = sim.solve_modes()\n",
+    "\n",
+    "# sweep.results are ordered by wavelength ascending\n",
+    "wl_results = {r.wavelength: r for r in sweep.results}\n",
+    "wavelengths = sorted(wl_results)\n",
+    "n_effs = [wl_results[wl].n_eff for wl in wavelengths]\n",
+    "n_groups = [wl_results[wl].n_group for wl in wavelengths]\n",
+    "\n",
+    "for wl in wavelengths:\n",
+    "    print(\n",
+    "        f\"  lambda = {wl:.2f} um -> n_eff = {wl_results[wl].n_eff:.6f}, n_group = {wl_results[wl].n_group}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ed37684",
+   "metadata": {},
+   "source": [
+    "### Multi-band modes\n",
+    "\n",
+    "The symmetric SOI slab (Si 220 nm core, SiO2 cladding) at lambda=1.55 um\n",
+    "has V-parameter ~ 1.41 -- supports a single TE mode (TE0).\n",
+    "Bands beyond 1 are **leaky / radiation modes**: MEEP's MPB omega-solve\n",
+    "can converge to them because the finite PML-bounded cell discretises\n",
+    "the radiation continuum.  The library logs a warning for modes with\n",
+    "``n_eff`` below the minimum cladding index."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1fa3487b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "V-parameter = 1.411  ->  1 guided TE mode(s)\n",
+      "  band 1: n_eff=2.830654  (GUIDED)  n_group=3.566623358095478  kdom=['1.8262', '-0.0000']...\n",
+      "  band 2: n_eff=2.027256  (GUIDED)  n_group=3.7788121488479747  kdom=['1.3079', '-0.0000']...\n",
+      "  band 3: n_eff=1.435427  (LEAKY)  n_group=1.4566389463385117  kdom=['0.9261', '-0.0000']...\n",
+      "  band 4: n_eff=1.435427  (LEAKY)  n_group=-1.456384879169587  kdom=['-0.9261', '0.0000']...\n"
+     ]
+    }
+   ],
+   "source": [
+    "V_param = (2 * np.pi / WL) * 0.22 / 2 * np.sqrt(_n_si(WL) ** 2 - _n_sio2(WL) ** 2)\n",
+    "print(\n",
+    "    f\"V-parameter = {V_param:.3f}  ->  {max(1, int(2 * V_param / np.pi) + 1)} guided TE mode(s)\"\n",
+    ")\n",
+    "\n",
+    "soi_sim = gm.Simulation()\n",
+    "soi_sim.geometry.stack = soi\n",
+    "soi_sim.solver.resolution = RESOLUTION\n",
+    "soi_sim.domain.pml = PML\n",
+    "soi_sim.mode_solver(wavelengths=[WL]).first(4)\n",
+    "band_sweep = soi_sim.solve_modes()\n",
+    "\n",
+    "band_results = {r.band_num: r for r in band_sweep.results}\n",
+    "for band, r in sorted(band_results.items()):\n",
+    "    tag = \"GUIDED\" if r.n_eff > _n_sio2(WL) else \"LEAKY\"\n",
+    "    print(\n",
+    "        f\"  band {band}: n_eff={r.n_eff:.6f}  ({tag})  n_group={r.n_group}  kdom={[f'{k:.4f}' for k in r.kdom[:2]]}...\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57f87da9",
+   "metadata": {},
+   "source": [
+    "### Multi-band field profiles"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "1d06e4c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArIAAAGGCAYAAACHemKmAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAY+pJREFUeJzt3QeYE9XXBvCznboLS69SRHoTRIoCgmJFQLqAgO1TAUWUv6yiFEFQUbAjqAiioqCAFCmiNBEUkN57k45L3zrf897sxCSbZCfZ9Ly/5wnZTSYzN3eH3ZMz594boWmaJkREREREQSbS3w0gIiIiInIHA1kiIiIiCkoMZImIiIgoKDGQJSIiIqKgxECWiIiIiIISA1kiIiIiCkoMZImIiIgoKDGQJSIiIqKgxECWiIiIiIISA1miINe/f38pVKiQV7bv2bOnlC1bVgLN2LFjJSIiQv7991+f918w9I+/+pKIyNcYyBJ5ydChQ1WAgNv27dvtbnPjjTeq5+vVq+fRYz/++ONStGhRj+6TyF/mzZsnrVu3llKlSkn+/PmlVq1a8uyzz8qOHTvsbr9q1Sp56KGH1PaxsbFSsmRJ9f3KlSsd/j/dtWuX0zbs3btXXnrpJalTp45qww033CBdu3a12wZXtoWTJ09Knz59pFixYpI3b1655ZZbZO7cuYb7hyicMZAl8jL8Ifvyyy/t/rHdv3+/et6XPvzwQ2bfKGi8+eab8uCDD6qgcM2aNXL27FmZOHGibNy4UVq1apVt+9GjR0uLFi2kdOnSsmLFCrl8+bKsXr1aZc5btmypnnfHvffeKwsXLlQZ7NOnT8vixYvl4sWL0qBBA1m7dq3b2165ckW1a+vWraqdeH8Iujt06CCzZ892q61E4YSBLJGX4Y/S9OnTJSMjw+rxKVOmSN26dVVWloiy0zRNxowZI7feequMHz9eKlasqDKWt912mwpSn3jiCavtf/rpJ5VhRTYUH9huuukmlZHF/7H3339fPY7nkeF1VZcuXWT9+vVy3333qQ+f1apVk5kzZ6ps7qhRo9ze9qOPPpLdu3fL1KlTpWrVqmr7pKQkFaQPHDhQMjMzeWoQOcFAlsjLcMkQlw4XLVpklYXBH7a+ffvafQ0yNI0bN872OP4I4o8hskyO3HnnnfL555/LuXPnzKUNuCHT425NKLJKHTt2lPj4eFWy8OSTT6oMk7226beEhAR1OfjXX3+1W1eKmswePXqo7RITE1U5xNWrV7Md+5tvvpEaNWpInjx5pGbNmjJnzhzD7UaA0LlzZ/MlaWT13n77bbl+/brT1xl9L670jz16X5w5c0Y6deqkXo/vP/nkE/X8qVOnVPtxfFx2HjZsmN39/Pzzz3L77bdLgQIF1PtEoLdgwYJc9eXff/8t7du3lyJFikhcXJza/tNPP/VI/xqVlpYmly5dkjJlymR7LioqSl5//XWrx0aOHKnO7ddee83u/vA4nh8xYoTLbXnjjTdUP1hCf5coUUIOHjzo9rY//PCDCrRRLmH7AfjIkSPy559/Om2XK/+fPHW+EQUSBrJEXoasUNOmTa3KCxDEpqSkqD88nvbLL7/IY489pgIQZLT0m7s1s8gI/d///Z88/fTTcuzYMRUMIfP1wAMPWGWLkOnSj5Weni6bNm1Sf6Dvv/9+2blzZ7Z99uvXTwX52Cf6Bvu1DUC++uor1Ue4tHzo0CEVnM2aNUtdYs4J2nDXXXepoB9lHAjsZ8yYIefPn1eXep1x9b0Y6R9n/Yt6T9zw+iFDhsgzzzyj9oFgBF8fPXpUBW0I1L777jur1+N7tKt27dqqznPPnj1y8803S9u2beXrr792qy+R7WzSpIkKxv744w8V+Lz88svywgsvmDOKuelfo5BNRb0o9vfbb7853RYf1DZs2CB33HGHytrag8fxIRHb6R/scgO17+hLZFLd3RYlBfZeX716dfPzOTH6/8kT5xtRwNGIyCteeeUVDf/Fjh49qk2aNEmLi4vTzp07p55r3ry51qFDB/V13bp11c1SixYttFtvvTXbPl9//XW1z0uXLpkf69evn5aQkGC13WOPPaYVKVLEbrvsbe9Ijx491PFmz55t9fiMGTPU4z/++GOO+yhWrJg2ZMiQbPtcuHCh1XZ9+/bV4uPjzd9nZGRoZcqUUX1hKTU1VStfvrzax4ULFxwed9euXWqb7777zmn7XOkPR+/F3f7RX79o0SKrx2vUqKHlz59fmz9/vtXjtWvX1u666y7z95mZmVrZsmW1m2++Odu+GzdurJUoUUJLT093uS+rV6+u1alTR73W0vDhw7U8efJo58+fN9y/ubVz506tVq1a6lgVK1bUunXrpo0fP17bvXu31XYbNmxQ2wwcONDp/p577jm1Hba3/H+K47gCfde0aVMtMjJSW7NmjVvbXrlyRR0b54GtjRs3qufeeOMNp/s2+v/JE+cbUSBiRpbIBzBiOTIyUr799ls1wAsZLEdlBb6G+l3Ly+i4IVOjQ7uRXbTUrl07tZ3lpXZcSh88eLDKQOPStb4vZPP27dtn9fro6Ghp06aN1WO4tIp96JkyXLY+fvy4yiBaiomJUbWHOSlXrpy6xIqsFPodGUOjXHkvRvvHEbwflINYQk0lLs/b9hGydAcOHDB/jz7CzwqXoW2h1AGXirdt2+ZSX+L8RNYZ+8Tle0toJ9qFy93u9m9O55st9MWWLVtk3bp1qiwGWVoMokJfDBgwQGXNQb/Pib4djusu7ANZeGSzcfkd2evcbOusLUbaaeT/kyfON6JAxECWyAdQi4ZRyLjkh1vx4sXVyGZXGf1j7UkIVvCH0hKCO7wnyz+SCHymTZsmEyZMkH/++UddwkR7K1SooGodLeH92wZJ2B/o85nqgRHqCm3Ze8xWvnz5ZMmSJer4uOSK0grUcGIUPMo6nHHlvRjtH0dQi2jbFwULFlSlIQg6bB+3nO9V7yNML2VLfwxtcKUvUc8NuKyM94W24YaAHbW3+nFz07+uQjDXqFEjGTRokBoUhdrRXr16qQFdCIyhfPny6v7w4cNO94XXAgJxdz333HNqsCba46ge18i26EOUO1y4cCHb6/SfM86vnBj5/+SJ840oEDGQJfIR/LHHSGb88cWgC9vgxxIGW2CQiy1k1TwNbbGspcXNcpJ/1DyiHtISAhVke/DHD06cOCHLli1TNZTI8BUuXFgFH3idvWybkSyTvm9kFW3Ze8weTHeEQXb4Y4y6T0zLhJpAjF53xNX3YqR/nHHUF0b6SA9ynPURAkxX+lKvpX7rrbfU+8JsG7jpwTxuDz/8sNv9m9P5ZgSyshjZD7i6oQdo9evXV7W0165ds/s6PL58+XLVbndrxv/3v//JBx98oALUd955J9fbInOKjLktvRYbHw5y4kp2OTfnG1EgYiBL5CMY9Y4sEP7oI6h1pnLlympgiOXsBMgEIgNmBEaQeyorhgDGdgQ8JmtHAIL3ZMl2pDYGnNgGeUZhAAzmArWdKgn7wxydrkDWq3nz5iqoQBBjb2J8W0bfiyv942noI4zotzf7wI8//qiyrZhtwJW+xLYoqcBAMKNTP7nTv0YggMYHCnvt0D/UWc7AgYwn/n8hm2wPHsfzr776qlvtQWkAZmVASQOy9Z7YFtl/lKugBMT254ffF8hEE5FjDGSJfASXZnFZEwGO7VQ7tjDrALJHL774orqMiyl78BgyTkZg/wiCkZ2ynb/WVZhaCZdzkaVElnjp0qUqw4SZGPSaSwRJCGDee+89NW0TspEIhHBJFUG5u/2FyeuRQcOIeWQOcdn40UcfVfPv5gQZwu7du6s+wOV1TEWEkdnIdGFkuyOuvhcj/eMt6CNkTpHpR/0ogjtklDH/KGoy8Rwy/6725aRJk9RMDd26dZPNmzervsO5i37ANF84p9ztX1fg/8q7776rpqKbP3++6l8EophuDFOc4coF7nWYLmz48OGqhhYBJAJEfABE3S9+Jngcz6OG2VXoSwTC6GfMSeupbbFNlSpVpHfv3mrGCUzNh3aivhrvHT87InLC36PNiMJh1gJn7M1aAF9//bVWpUoVLTY2Vj2/ZMkSw7MWpKSkaL169dISExO1iIgI9ZozZ8443N4RjHLGaPeTJ09q7dq10woUKKD2iVkRbGcMOHz4sNa+fXutUKFC6talSxft1KlTWtWqVdVrbfdpa/Lkyaqde/futXp82rRpWrVq1VQ/4H7WrFnamDFjcpy1IC0tTY2ob926tZrBAW3HSPxx48ap55z1n6vvxUj/OOtfW71791YzDthyNBvFvHnz1Kj4fPnyaXnz5tWaNGmizZ07N9t2rvTltm3btO7du2slS5ZU21eoUEHr2rWrtnr1apf6N7cweh8zEeD/QMGCBVVbKlWqpD366KPZzhXdb7/9pn5+xYsX16Kjo9U9fj543JbRWQtwjmA7ezfbn4kr28KJEyfU/1c8h9lNGjRoYGhGEFf/P3nqfCMKJBH4x1mgS0REREQUiHjNgoiIiIiCEgNZIiIiIgpKDGSJiIiIKCgxkCUiIiKioMRAloiIiIiCEgNZIiIiIgpKjtfIDCFYFQaThGPdaC7DR0RERBS4MDMsFkDBAjU5LQri90AWq8tMnjxZdu3aJSNGjFDLKdrCc9gGq9HUrl1b+vXrJwUKFDB8DASxWOqPiIiIiILD0aNHpWzZsk638euCCOPGjZOPP/5YLeOI5SCx1GHLli2tttm4caNaErFLly5qmcLPPvtMrQ++du3abGuhO5KcnKzW40aHxMfHizehO3E8LJ3I7C/xPCH+PiFv498dCrVzBUuDIwGJJanR1oANZJGNRUP1jKm9QPbuu+9Wa4UvWLBAfY9157Et1qB+6qmnDHcIOgI/PAayFAiC5ZcJ+RfPE+J5QuH4O+WiC3GbXwd73XDDDU5rH1JSUuTXX3+VTp06mR8rUqSItG7dWhYuXOijVhIRERFRIPJ7jawzR44cUWUE5cuXt3oc369YscJpAIybZWSvfxLxdgJaP4YfE90UBHieEM8T4u8T4t8e+1yJoQI6kNWD0Xz58lk9joFe169fd/i6MWPGqIFjtpCi9kUge/nyZfV1IKftyb94nhDPk9CdJQcJGF//Prl69aqkpqby7w4F1bmC0lF7V+b1BKShfUgA0wt8L1y4YPU46mQxeMuRpKQkGTRoULaiYezPFzWyEOj1J+RfPE+I50nouXLlihw7dsznV+T0KzzXrl3j3x0KqnMFbcCsBPnz58/2eEgEsnhzhQsXli1btsh9991nfhzf16lTx+HrMJuBvRkN0DG++MHpxwmEk4QCF88T4nkSOjIyMlQQiyuIxYoV8+nvfwQmOH5UVBT/7lDQnCtoy5kzZ9T/mypVqqg2hVwgizfSo0cP+fzzz9UMBcjCojb2r7/+krFjx/q7eUREREpaWpr6w4wgNm/evGEbnFBg0wLsXMH/l0OHDqn/P5aBrCv8GsguX75cPvzwQ5XihmHDhqk3hTljcYPRo0eruWSrV6+ubuvWrZOXX35ZWrVq5c+mExERZRMIwQFROP1/8WsgW7FiRenWrZv6um/fvubHa9SoYf4aNa2rV69WWVis7FWrVi31OiIiInLu7NmzajGg+vXr+6SrVq1aJbfccovkyZPHY/vctm2bKjV0NjYmENpv+dqTJ0+qgd833nijV9pJARLIYh5Z3IxE7I0aNfJJm4iIiEIFEkFYRRP3vnDvvfeqwLNChQrZnsNI+TVr1pi/b9iwYY7LzZ8+fVoeeugh2bx5s0fad/78eTl48KA0aNDA5fbnxPK1uIT/wAMPqHYbXYU0t/bv368GHFarVk1iY2Nz3B4fcP755x+pVKmSFC1aNNvzWKwKAXnVqlWzDcYCPIeyABzP8kPG8ePHZe/evdm2R58XLFhQPC2ga2SJiIgoNCBDOXz4cPU1xrv8/fffUq9ePaeveeedd9RYGU/VHe/bt0+Nu/n000/Fm0qVKiW33nqrTJs2TZ544gmvHmvr1q3y+OOPq+w7Alj08/fffy9NmjSxuz2C7D59+shPP/2kBlnt3LlTXnnlFRkyZIh5ZijsD2WdiYmJahXWL774Qtq3b2/eBz4c4WeJIBjPT58+Xdq2baue+/PPP+W9994zb4uZp9BGrA3gjUAWbyjkJScnYy4Ude9tmZmZ2oULF9Q9Ec8T8srvk/RUTfvpWU37uovptmUmO9rPrl27pu3YsUPd+xrOj7S0NLt/d2bPnq01a9ZMS09P17Zt26YdO3bM6vmLFy9qv/32m7rheexHd+bMGW3jxo1aRkaGtn37dm3v3r12j797925t//796uv8+fNrBw8ezLHNUVFR2t9//+10Gxy3ePHi2s6dO50ec+XKleZ+P3HihLZ161arbVesWKFdv35dfX3u3Dlt/fr1LrVff429GMLZa+fNm6c1btzY4fsz2r85WbBggfbXX3+Zv09KStLq1q1rd1ucI4sWLdLi4+O1U6dOqcfWrl2rRUREqPYA+nvJkiXm13z55Zda0aJFzd+jnTExMartMHXqVK1YsWLmPrY1bNgwrVWrVi79v3ElbmMg62EMZInnCXn998mRPzVtWPx/tw9vZaf7WSAHsjfddJNWr149rX79+lqBAgVUoKPbtWuX1qJFC3WrXLmyVrNmTXOwi9dWrVpVa9SokdagQQMtISFBe/75582vTU1N1dq2bauCmFq1amn33XeflidPHo8Fslu2bNEKFy5s9VhKSop2//33q2PWrl072zEnT56stWvXzuo1cXFx2tGjR9XXP//8s3ovRts/ePBgrVChQlrDhg21xMREbcaMGYZfiwAY79NRMJZT/7pryZIlWpEiRew+h3ME76FKlSrmx3DOIpDdt2+f3dfgA050dLR6zzB+/Hj14UiHcw8/p2XLltk9XsWKFVWw661ANvtyCkREFNhSL5nuGz4mEpcgkmpaTZDInj179sibb76pLhVjHvYPPvhA1q9fr55D/SNmEMINl93vuOMOta3uwIEDMnHiRLU9bnjtv//+q56bOnWqqsvEDZeOb7vtNqerbroK7bFdov7LL79Ul7LRLrwXtNfdY+bU/h9++EFmz56t2oEB5+ij/v37q/dv5L3jsjzmFUZbHXHWv5jRSf/Z2LuhRtWeb7/9Vlq3bi3OanlR8zp06FD5+eefVRlB165dpXLlylbbofxj3rx5MmDAALXIVExMjLnNlttidS6Md0Jf2Fq5cqWaK7Zjx47iLayRJSIKNqlXTPcFSojEFWQgG4DumbBSzl1J9dr+i+SPlUUDmxvaFiPn27Rpo77GrD9YYOjXX39Vg60AS+ru3r1b1UYiQEF9pQ4zBekzHmA/RYoUURPYY3DPsmXL5JFHHjHXPSLIw/SYnoLA0Hag1G+//SY9e/Y0DxLDHPODBw92a/85tR81pAhQUUOqr4iF94/aXqPvHbW9+hSj9jjrXwxM02uK7UFN6z333GP12GeffSZLlixRdaqOoE9Rz4ptly5dqgZ1jRo1Ktt2I0eOVEE1zovnn3/eatCe7awOeJ943BYC/s6dO9sdLOYpDGSJiIJNSlYGNq6A6Xb5lL9bRAHMdml2BEnJycnqa4yqx+h6ZA6LFy+uRr1fupSV8RdRj1tC9g2Br778u+W+EVzieU9BexDMWUK7LY+JACmnYzpaMjin9iOAw+h7zHKgK1mypKHXQmZmphroVKJECYdtc9a/yOg6C2QxW4AlDLh69dVXVbBfunRpcQQBrJ5pxvERONesWVPN1W85QxSCdUCmuFmzZirjimnQ0C588LGEgWYIwi1dvXpVZs2aJfPnzxdvYiBLRBRs9FKC2PymW2aaSHqqSHTOU+6QbxjNlvoCgjGMZNezmBs2bFAZRHj//feld+/e5ozcjBkz1CVnI5BBRHZSh6BYD8I8ARljlBEguNYzejjmpk2bzNvgsr7lMRMSElTwqMPr7WUKjbQfc9qjtOHjjz82P5aSkiKRkZEyZ86cHN/7jh07VHvcnfvelYzs999/Ly+88ILKsNoGuMhsr127Vs1igFkNEJgjcNWDaASnmGUBgSoCWcv+hrp166r3jKnQsC3myp0yZYp5hTBMt4WgGI9bQmkGFrm6/fbbxZsYyBIRBWtpQWwBUyCrHrssEp3o12ZRYMLynw8//LCaBgqXnXEpGZd79QwjMm8IclBzidU0EbQYgcv6CHwQEOI2ZsyYHF/7+++/m5fzRaYPl64bN25sdwECBIEtW7ZUwZk+9dP//d//qWmtUAKBY6KeF8fUV4jCvnDJHwE6gtAJEyY4XD0qp/bjcjqmB0MGGyUGCIoxbRfKMoy898WLF6s5cN1dvapMmTKqFjYnixcvll69eqk2IPjVX9O8eXPVJvxcUUuMeWOxT9TI3n///WpqMwS06F/MJ4vtAVNtYT5cBMnIKuN7TNNVu3Zt9Twy+CijQD936tRJxo8fLx06dMhWY4t6Zmzj7dXuONiLiCioA9mseRk54IvswET3GMyDQBb1iqjXxOIIesYNAUmLFi3ko48+UplODDZCoKi/1nZFMAS8emYXl6IXLVqkMpO4VP3uu++qWlxnq2K99dZbKsuILB0uheNrfXCTPc8++6wKpHQIvDBAST/m2LFjVaCkzzNbrlw59TgGKuH+7bffljvvvNNca4vL4vpiCDm1H1lK9AkCb2Rlt2/fLt99953aR06vRaD+1VdfmTPfjn42zvrXqMOHD6vXoaYX/anf9Awx2oSfsd4H+BrbIouMQB8ZWHzAQJALGNyFDxDffPONuqGsAMGxPtgL9/jwgw8aGKiGnyXmy7WE0gv0AbL93haBqQskxKFD0eG2tTXegO7EcXA8rrlNPE/IK79PFiWJrP1YpPd8kY3TRLZ+L/LMWpHi1dnhfoLLt7hki8vInlye1eh5ol/mDcW/O48++qjKFCOw1Pta72NcMsfgNdtaWn9DAIygF1nSQKIF2Lni6P+NK3EbSwuIiIK9RtYyS0sUYiwzstCuXTuV6cNl7xEjRqhyg0CDkoScVi0jz2AgS0QUKjWyRGEAdbFYAhVZOwxwCsRAlnyHgSwRUbAGsmr6rYLWU3IRhThkOjFqngg42IuIKNjoQStLC4gozDGQJSIKNnoZQYxljSwzskQUfhjIEhEFY2lBdB6RqGhOv0VEYY2BLBFRMAayGOgFnLWAiMIYA1kiomCDMgI9gGUgSzksT/v111/7rI+wMADm/vQkTMp/6tQpCfT2W752z549smDBAg+3juzhrAVERMEEa9ggkE0oZ/pez8yyRpbswGpUn3zyifTo0cMn/fPaa6+pZVkxmb09586dUytiYTUprB5100035dh+rAbWvXt3j7QPk++vXLnS4YpTObXfGcvXYpUsLNSAVdKwgpe3nXOxX7Ewwvz582X//v1qpTOszmV0fxs3blRLHdvq06ePWvJYX+hg4cKFanlcLBt88803i7cwI0tEFEzSr4tomf9lYjEFF3D6LQpwixcvVkENApw//vhDBTdYNtcZLDH7xBNPeGwVKiw3e+nSJfE2LAH84IMPyqeffhqQ/dqjRw81B++OHTukY8eOaqlfo/tLSUlRywrrt/Xr16uFKfSVuQ4dOiSNGjVSK5tt3bpVLd07cuRIr71/ZmSJiIKJHrDqASxLC8iAw4cPyy+//CKFChVSAVZMTIx6HBmzL7/8Un1drFgxueuuu6R8+fLmsoQ///xTWrRooTJwsbGx0qlTJ6ulRBHI/PTTTxIdHS333HOP0zYgW4egR892NmvWTIYPH+4wO5qamiozZ87MtszrhQsXZN68eeZjov2PPfaY2u+WLVtk3759KjOqGzdunFo0oWDBgup9495o+7F6GN47Mpd16tSxylzm9NoOHTqoIPyVV16x+/6M9K8RJV3sVyzrO3fuXBVwFi9eXB555BG58847VR8VLlw4x/01adJE3XT9+vVTq63h3AL0MYJhfUnhzp07S9u2bVU/YGlcT2NGlogoWJentbxnaQE5cODAAXWZe8OGDSogeeCBB9SlZcjIyDBn1n777TepX7++/P333+bL+v/73/+kffv26nLy+PHjVUCiw2uQecPiBHjtHXfcoTKejtStW9fqkj2CKASrjuCYCI70gAjOnz+vjokM4fLly6VVq1aSlJSkgltAYDht2jSr/QwdOtRcu7p792754IMPDLUfbWvdurW8+uqrsmvXLhUs60GpkffesGFDFayePn3a7vvLqX+Nqutiv6K9zZs3V9vBbbfdJkWKFJHVq1e7vD88PmPGDKugGWUVlj+zfPnyqQDWU1l1W8zIEhEF6/K0lvcMZAPLJ81Erpzx3v7zFxN5+ndDmyKQQl3ojTfeKFevXlX1jj///LMKbhF0WF5WRjCFDKY+QAyX4Tdv3qzqPBEMImuLLC6ydh9//LHccMMNKpuIIOWHH35QGUUjkOnEsZzVvh45csQqIAIcs1KlSirjB8iIIhvojpzaj7KA9PR0FRzjeQTR6Lunn35aBcs5vfe8efOqgBDvQw8abTnrXwTLEydOdNj++++/X2rXru1yv544cUJKly5t9Ri+P378eLZtc9of+h8ZZJQP2EJtM94TBr2hTjsy0ju5UwayRERBGchmZWKjYkSi4v57nMhG9erVVRCrZ8dwGRnZWQSygMvmyG5igA+yt8g+Wr5WH6yEoAyBFmYQ0C8/I7urZ9qQTTSadevfv7/K5o0aNcrpdrb7Q+ZSbzfce++9bgdIObV/1apVUqBAAXnnnXdUBhs31L6i7tPoe0fb9Oy3Pc76V8+WO2IvS9rfQL+iPbZtddTOnPaHzHjPnj3tlgwgiEX7MfALmWlvYSBLRBRMUi9ZZ2LV1/kZyAYag9lSX7AN9PA9Mm2AWlNcFkYghqwhRqlbTj+l19LqEADpAQ/2YblvPGckkB04cKCsW7dOli1b5rQetGzZsio7acneMW3bZwlt1d+rrZzaj1IBZGTPnj1rfgyZSWSxjbx3DIpCyQPehyPO+hfBoV53ag9qat3pV2S5kWW29M8//2TLfue0PwTcmNkAmVd7Ro8ebb4igD7o0qWL1KhRQzyNNbJERMFcWqB/zdICcgAZVv2yMYIzZF9RBwnff/+9qjFFZg0zBKCu06h69eqpAWQ6BDyOgkbdSy+9JL/++qu6JO8sSANMC4Us8Zkz/5VoYMCV5TFR72l5TGQ0MbBNh8ypo7rdnNqPkfvIYKP0Qr9hQBSy20beO2qNUX5gGyAaZVm/bO9mmZF9yUm/4oMJ2q7P1oD6WJSa6NleZOfxgQG1skb2p0P5CWqqkVW2hMF2ln2hZ3tZI0tERNlLC/QZDC4eN80x66UBFRS8cMkal+NxKRyBX4kSJdTMBYB5ThHkXLx4UQUzCMiMXqrHaHUEMpghAMEd6m5tM4yWJk+erILl559/Xn2tGzx4sN1L03FxcWrfGGH/+OOP2z0mMoKYNUAPkjADwLFjx+Thhx9Wsy8gGHM0Uj6n9j/77LOq9hUDyhDkIUBGacOaNWsMvXe0Ozfz92IAlmX9srv9euHCBfVhBSUAKJXAzAsIZjE/7N133y3ffvutvPjii+YSB6M/J3z4QWBva9OmTepY+FkgoEUfoo65WrVq4g0sLSAiCvZAFl9rGSLpKSIxrk3dQ6ENg5MwhycCF8wL+uijj6ogTw9WEZDhsi+mrUJgg2AFA3j01yIgsYTtEQjr2U9kPDFfKIJJZO8wOMnRYgLlypVTo/TBsvbTWQ0p5jpFsKQHsjg2MojIJOOYc+bMkcqVK0t8fLx6HsdGm/A8gja85/fee8/8PAaKYeJ+I+3HYC3Mo4pj7Ny5U01NhufxOKbwcvZalBXMmjVLZT6d/Wyc9a9R5XLoV7QJGVa9D2D27NlqtgHUR3/00UdWsyUY+Tnhgw/qk+0NAsOgN2TOUbaCQPazzz5THwa8JUJzdgaFCHQ4fpBIr1v+IL0B3Ynj4HjeSqNT8ON5Qm6fJ6veFVk2QqTTFyK1Opoem9ZO5MBykcEHRPIXYef6AQa0YNWoihUrujwPqCfOE1yG9uYUR/6EABFTVOmrRh09elQFW/Djjz+qYBd9H0gQ+OLDQdeuXSWQaAF2rjj6f+NK3MaMLBFRKNTIqucuMZClkPPUU09ZfY8sIFabQrYP02Dp88IGEtSN2taOkncwkCUiCvrSAj2Q5RRcFPrmz5+vLukja4eaXwwKo/DFQJaIKJhX9rL8moEshQGMorc3yIjCE6ffIiIKykD2v/XiuUwtEYUrBrJEREE//VZWUJuSFeQSEYUJBrJERKEw/Zblc0REYYKBLBFRyNTIMiNLROGFgSwRUTBB+UBMPpHIKDuzFjCQJWvr1q2Tl19+2WfdgqmxTp8+7dF9Dho0SP755x/zsq9YhcofffLWW2+p41Ng4awFRETBBOUDltlY4PRb5AACQGerS3kaVnMaM2aMw+f37NmjVnrCcriNGzeWxx57TC1F6whWzNq2bZuUKlVKfX/q1ClZvny5X/oEc9dixaulS5eKt2HVLdygatWq8uabbxp+7eDBg+Xs2bMyZcoUq8ex2hmW0sXKZFhRrGnTpubnvvnmG/W8pUmTJknx4sUN799fGMgSEQVbIGu7ehdrZCkIbN261bxEbs2aNeX999+XFStWqDlhHZkwYYIKdgNB69at1VK5O3bskBo1anj1WPXq1VMrXf3yyy+qj4z64YcfVACclpaWLfjEhwC8h8OHD6vldrEUMb4HvCes+GXZ11ji1+j+/YmBLBFRsMCK4igfKFzB+nHWyFIOkInDcq6YgxVLuurLve7fv199D8WKFZOHHnpI7r33XvMl+Llz58odd9whM2fOlNjYWLUtlhPVYRlWLCEbHR0tffv2ddqGChUqyB9//KG21YO1hg0bqqAoJiYm2/ZY8ADZTz0zaQ8ygx9++KF6H3Xr1pVnn31WtdPZ+7K1bNkymT59uvTo0UMWLFgg48ePNz+3Zs0amTVrlrz77rtqSdd77rlH9cWwYcPs7mvkyJEq07xp0yYVuGOxhgEDBqglYV1RrVo1dcP7W79+vaHXXLx4UYYOHarakJSUZPUcSikKFy5sXqL2xIkTKgOrB7JQuXJltRSwO/v3J9bIEhEFi7SriGazlxZw+i1yYvPmzaq+8/bbb1cBTLNmzSQlJUU9V6RIEenTp4+6IRBExhSZOv0SPIJELAHbvHlzuXz5sgrksDQsHDx4UO0zPj5evRb7uH79usN2FCxY0BzEwoEDB1TJgL0gFjZs2CDly5dX+7fn3LlzKhg+c+aMatfvv/8unTp1yvF9WUKgjucGDhyoAtDPP/9ctUuH9255/Pr166tg3BEEvr1791b9gKwn+g9ZZV9ISkpSC0XoZRiWEMRaOnTokNxwww1WjyHz261bN5W93b17t0v79ydmZImIgnnqLcvvOf1WwOj4U0c5f/281/afmCdRfnjwB0PbIgs3e/ZslY195JFHpE6dOiqriDpJPGaZhUtMTFQ1rA8++KD6HvWUyEgiy4kgJyEhQY4ePaqCoI8++ki9duzYsWrbWrVqqWAwJx07dpR///1XBcLIEjuCOtqiRYs6fP69995TQTnaAV26dFFZ3507d0r16tWdvi/46quvVGYVWd+bbrpJPYZAeOrUqTJixAjVRgS6yDrrkN1Fu5xB8Pzaa6+pr9PT01Vf69nhL7/8UubMmWP3dehj2zpVo9atW6cCbJRrOKrhRZkCAvO9e/eqcwCD6HTIRiM7jg84CGjxAQFBOQJ3o/v3FwayRETBPPWW5fcMZMkOBGkIWHUINvWMG4JcXLr/9ddfVYYTtwsXLpi3vfHGG1WABcimIrOHAA+B7K5du+S+++4zb3vLLbdYZVwdQcYyOTlZBZKvvvqqupwfGZn9AjEGgaWmpjrNNCMYRvCJ94EbAjEMKMNleWfvC5f9UQ+KIFUPYgHlEQj2hw8frl6PQA59oMP+nQ1OA8v6WQyWQn9Z9pHlz8KSq+UHuvT0dJUpRUDvbB9VqlRRfb9v3z71IQBBeteuXdVzCPxxAzyG94lyCvyMjO7fXxjIEhEFC33lLr2UQBejB7KXfN8msstottQXrl5FScp/UCJQqVIl9TUydJ9++qn0799fBV3IZiJrqENdqC0EjJA/f36rfeNyOoKenOhZUQRMyPCihAABni3UbB47dszhfnB8zCRgmXlFEIrMYk7vC4PNENihphYlBxhYBSiVQKkDZkbAqHyUHVhCNhrtcsa2z/T+gr/++stpRrZt27biqg0bNqhyiLffflvdMP0Zgmf0C4LPMmXKqO3w4QOlGqiRRTCNchM9kLWFDwKYMcKV/fsLA1kiomAvLYiKFonOy4ws2YXsKy4LN2nSRF0Wx8Cvfv36mQMrXFZ++umn1feoFTUKQR+CQwxmQpYyp+mYcMka2UpcngcEl8j86QPPbNWuXVvdY+CWveARdbHILCKYQlALCEox2j6n94UM8BdffCG9evVSA8EQXOqZZ2RlMagJGV+UK1hCP1pmoV3lqYwsMqVHjhyRV155RWWUp02bZn4Oc92ib1HigA8KgPKGzp07W21jWeuKkgY8jyAcH07wPWp8wcj+/SkoAtkrV66o+gxcFsCnCXuf3IiIwjaQ1R9jaQHZgSDwySefVJlJXEpHFg61pYCvUfv622+/qemZXAlMMBUV6mdxSbps2bIqOHR22R2BYsuWLVXdKwaMIVDE/KjlypWzuz32hwwrgrAhQ4Zkex5B6Nq1a9UsCqjpxLRSaEubNm0MvS8EjgjQsIgDyhMwtRSysbj8jpIHZBwtB0khk7169WqrzK6rkAnGLScImNE3eE+4oS3IPuu1t9u3b1fz6wLaaJmVRnYZ2WjLxxB8YrAWyiSQXUWWGHP+6jZu3Kj6GM/j54J6Z33RCCP796cIzTLnHYBQ34JPCSjg1qfuKF26tEp5o3jbCEwZgZMYNTmORj96CroTx8Hx7F2SIeJ5Qm7/Ptk+R2Rmb5FWQ0WaD7beeEIdkWsXRJKOsoP9AJfVUa+JoEq/TO0r+pRKCMxs/+5g5gHURGIaKAQryAYiSLG9XI4MGwJe/F3FpeQ777zT/FpkXnWLFy9WNbZ6YIhSAmyP2ljMDrBo0SJp1aqV5MuXz25bkYHFdFIIZBHQ5fR3/Pjx42qKKATgCIRxWRttbdGihXkblB+gXhcxgmU9q9H3hem/kKVGoIiAHP2JOAPTirVr1868P0zLhaBYH9xmD2IUBObYD2B7ZMQx64MrMLvEn3/+afVYiRIlVFZdn/cVsU1jO4Pr0Ef4WSNjbQnvG/2IGR1Q+2ubAUZfY79oP0oLHHG0f0/+v3Elbgv4QBYnFla1+Pbbb9X3eFOoa0Hdi/7JJCcMZCnQ8AMPuXWe/D1dZG4/kXveFGn8lPXGnzQTOb1D5LXzKNJjB/tYoAayoQBZV1zeNpq8yi2M7ke2F5fuLacGW7VqlQrWvZ0QC6dz5boHAtmALy3AJyXLyw54Y/hEaaSgnIgopKRmDayJtZPtisknomWKpF2z/zxRkDIypZenPPXUU2pKMNSe2s5va5mZpsAR8IEsCrmfeOIJVXeDEXeYvwzpdYw0dASXLvTJnvXIHvTpObxJP0aAJ7rJz3iekFvnSfp1QQ5Fi4ozrfJlKTrO9Fx6ikhMXnawj+k/I3///uffntzBHLcY7NWoUaOQ70stAN6fo/83rrQt4ANZTOuAAV4oSsZ0IajLwPQU9tYA1o0ZM0ZNZmwLKWpfBLIoCIdASNtTYOJ5Qu6cJ3FXLgpC1Ksp6ZKWnGy1bX4tUpA/unjhrGip/N3ja5jvFHWfuGyLm6/pq21R7mA5XvDHzzAcz5WMjAzVnkuXLtlNQAZ9IIs3h2kuUJyNEXKAN4vRiSj6fuedd+y+DiPzLFesQIegPAFlCb4Y7AUc7EU8T8jjv0+iTQFqvvhCeNB64zymcoL4/HHZnyOf1Pph0n3UHvpr0vhAnKyeAlNUgJwraAdmp8DyxZY1sq4kAgM6kMUIOkwTgTnedHizmFoD89E5gjIEe1OAoGN8kSXVj8OMLPE8IY/+PslMMz2G0gLb32VRpjkwIzLSONjLD/Tf9/743W95pZF/dyiYzhVH/29caVv2NeECCGphUWyN+dIs4XtH884REYWs9KzlOqNNQasVBLeQ4XhJTyKiUBPQGVmUD2DkIFbYwLxlqJHF/LGYW23lypX+bh4RkW9lpFgHrZb04BaDvYiIwkRAZ2Rh2LBhsmDBAvU1lpxDfeyePXvUiEIiorCiZ1ujrKcFMj2WFciitIAoCxYosJzU39uw+AAWIvDkYCAsJoDJ/AErdeV2In53+wTL3GIJXAosAR/I6qMIsZLG5MmTVXYWsxgQEYVvaUGck9ICZmQp+yA0X8FKVkZG/H/88cdSsmRJFVQ6gyVksWJXqVKl1PcY2X727Fm/9AmW5MVgcl8YN26c6h/c7r//fsOvS09PV/Pd1qlTx+rxCxcuqEHwWE3t1ltvVVObWsJyuPrx9Ju9DySO9u9PQRHIEhERSwsoNGAgNwJZPah05qOPPpLevXtLIMDSvih5XL58uU8WZti0aZP873//cynofvfdd1Wwj3JMS2+88YZavnf27Nnq67feekumTJlifh4zQj344IPqmPoNy/Qa3b8/MZAlIgoWetkASwvIxZHqmFu9du3aKpu2Zs0a83ObN282Z+DwPMr59JUzkS3FvO0IfJCBa9iwoSxevNhq319//bVaSh7lflOnTjXUHiwx//rrr+e4lO/Jkydl69atcttttzldvhalBli6vlOnTmpZ2Zzel73sJ6b5xHz1TZs2tXruu+++UwGernXr1mo7Rx5++GGZMGGCmm0JberWrZucP39eXIW58tF2V6YMPXjwoPoZ2MsaI3B95pln1FK/eA+dO3eW33//3WqbfPnyWWVkbafocrZ/f2IgS0QULPSBXCwtIBf88ccfcubMGfnhhx+kS5cuKvDTL8/jUrOegUOGDmNS9HnbkS3F97jHsq3IjPbo0UMt/qAHkQiOXnvtNfVaBLVXrlxx2pa5c+eqjF6HDh1ybPfff/+tBnnbm04Tdu/eLXfffbdqE4JujKF54IEH1Bz0zt6XpVdffVW+//57dcO89YcOHVIDynUoacSUn5ZZWSzM5AiCVgTGyKjimAjGURrpC88884xaECpv3uwr+1lOZ4U2YgrTZs2aWW0zY8YMVcaBDzv42pX9+1NAz1pARET2Zi2wN/1WjHUdLfnVgXbtJf2892pToxOLSKW5cwxtm5iYKOPHj1fTWSIjh6B05syZ8vTTT0t0dLTKvgHuR44cqS4f9+vXTz1WsWJF9RgMGDBABa2HDx9W2UYEiKgbbd++vXr+k08+UZevHcHl6xdffDHHuljLgAuLgTgrO3jkkUekV69e6nuMoZk+fboKNJE9dva+kKXG+0HGd9myZWqOesC+vvzyS5VhRnZ39erVVkFdoUKFcrzU/+yzz5qDX/TxpEmTzM+hHXpZhS1kqBFIu+Pbb79VP0tkjx317zfffCPPP/+8an/37t3VUry6IUOGqEw5PmQgyMXPFR8g9A8cRvbvLwxkiYiCrrTATiCrZ2k5jyzZQDCKIFZXtWpV80AeZFBffvll+fXXX1WAg0CmePHi5m31QVa6/Pnzm7OuCPT0IFafsQDBjiPIfvbs2VNtZwQuqzvL8O7fv19dHkfdJwJT3PAeEAxWr17d6fvatm2byrziXg9i4dFHH5UmTZqowB+X0ZG9Llq0qPl5LBmd0+V+y9pSy/4CBJJPPvmk3de5u0BBcnKy+b06g6C0ZcuWauYnDPwaPny4uumlDLgBPhzs2LFDfSjAa4zu318YyBIRhURpgT79FmctCARGs6W+gMvbljCVFYJZGDVqlApsMDsAAj0EhghajChWrJh5WixA+YKjOlTAIKljx46pzK2+PbKCyKDqWV9LKA9AXSZKBbCMqS1kWnEJH9NiWULWFDXBzt4X6ma7du2qZgRAu8qWLaseR78gCEYJBAJZjOa3hH2iXe5CgOzpjOzOnTvVADoE4IDSDwSf6B9klPUsOUoCcAz0x3PPPadqefVA1haCe30gntH9+wtrZImIgi0jG2knB8F5ZMkBBI/65W0EdEuXLlW1pPp0WQhEUF+K4MXogC1ANvaLL75QwRem3MKAKmdwCR8ZUMtR8QjsBg8ebHd71MciI4xaWXuQ3UXWECPoEVRhRoH3339flTAYeV8oLcCl/1atWlkF5Aiu0SaUNuj9pFu1apWqy3UXMrKWMwNY3tatW2d4P6NHjzaXVDRo0EBlx/X9oOSiSJEi6mtk4wFBvP6BBvXRKBVA31iWFpw4ccK8eurEiRPN8/Ua2b8/MZAlIgoWyLZivlh7lyD1LC1X9iIbCFgWLlyo6k0xoAlziKLGVQ+s5s+fr55DNtKVedpx2RmDx5DBRHYWNZUY+e4Igh/bUfHInlpe2reFy/Co7XQ0xzwCOmRVcbkf7cc9aoKNvq8XXnhBBa4IZhH8AjK1KEfAe7McaIZAb+/evWomB3fhvdrO16rfSpQoYd4ObcdjaB8y1vgaMyLoEKxjblhA2YjlfgoXLqwy2JYzD9SvX1/NyIDn8AEB96gZ1mHmCQz+Qv/hHkGyXk9sZP/+FKGhqCTEXbx4UZ3MSIW7MpWFO9CdOA6O5269C4U+nifk1nkyoY7ItQsiSXZWTto+R2Rmb5FWQ0Wa289wkffgMiwugyNDldO0Ut44T5ARRVBh+3cHtaGo0URwhzYia2nvMj3+TuLvY1pamjrnUBdq+VodygEQyFjWwuJSM/aJx5AdRcBqJMDBvnBMR7MSAI6PIAszL6AdOBaCOBzDEmpX9RpPd94X2o16VtzQT8gEY9YBy+m4EFSivhej9x1BcKlfwgd7xzICr9MDVR36CX2vv1+UcRQqVCjba/VL//hwYQuP48MGflb2YhT0rbMPFjnt31P/b1yJ21gjS0QUTKUF9uaQBZYWkB0IfvRA0VmArQcLyL7pg5ssX6uzF7wgONZZDqjKiZFACIElBmXpUz7hWLZBLNgLYl15X5btRgYYZQ+2c8ri8rweSDpi+7y9YxmB1+izLtjj6P3qfeSob9EfzlZeyymIzWn//sBAlogo2EoL7InOCiZYWkAhxtkUXJ7WuHFjVceLeWVt2Qugyf8YyBIRBQvMERvnIGOiB7icfovIbahNRVbSnSwq+QcDWSKiYIEg1d4cslalBVwQgchdlnPGUnDgrAVERMEA43JZWhDwwmD8NFFA/X9hIEtEFAwysyaa52CvgKSP0seIbiIyRv//kptpvFhaQEQU7Kt6WdXIcmUvf8B0RpjWCFNKYYS8vSmu/DH9FlGgnitYsQ3/X/TpwNzFQJaIKBjota+OamTNsxYwI+gPCAow9yjmxDx8+LDPj+9oGVeiQD5X0A4sVpGboJqBLBFRKASyHOzld5hfEytm+bq8AFk2fSJ7f2fZKLBpAXauOFqgwxUMZImIQqK0QJ+1gKUF/oQ/yv5Y2QsrQeG4gRCcUODSQvBcCYzcMhER5bK0ICvAZWkBEYURBrJERMGApQVERNkwkCUiCqrSAgcZ2UhUikVwQQQiCisMZImIgkFGmvPSAtS74Tmu7EVEYYSBLBFRMNAHcenzxTqqk9Uzt0REYYCBLBFRMNAHcTkqLQBmZIkozDCQJSIKhcFe+nMsLSCiMMJAlogoqEoLnASyyNZy+i0iCiMMZImIgqq0wEmNLOpnuSACEYURBrJERKFWWqBpPmsWEZE/MZAlIgql0gLLqbqIiEIcZtB2yZEjR2TWrFmycuVKOXbsmHqsXLly0rx5c+ncubOULVvWG+0kIgpv6QYzsnrQ62x2AyKicMvIHjp0SLp16yaVK1eWzz77TBISEqRVq1bqFh8fL5MmTZKKFStK9+7d5fDhw95tNRFRuJYWOK2RZUaWiMKL4Yxso0aN5LHHHpNdu3apYNaeffv2yeeffy633HKLnD592pPtJCIKb0ZqZPUgl4siEFGYMBzIbt++XYoVK+Z0mxtvvFHGjBkjgwYN8kTbiIjI1cFeltsSEYU4w6UFOQWxKD24evWqoW2JiMhFepY1p5W9gIEsEYUJt2Yt2LBhgwwYMMD8fc+ePVV9bMmSJWXNmjWebB8REVllZJ3UyLK0gIjCjFuB7Isvvihdu3ZVX2/btk3mzZsna9eulcGDB0tSUpKn20hERIZKC2JM98zIElGYcHn6LVi/fr00aNBAfb1kyRLp0KGD3HrrrVKzZk0ZN26cp9tIRETmlb2cBbJZ2VoGskQUJtzKyBYoUEDVxML8+fPVFFyQnJysniMiIm8tiMDSAiKiXGVkO3XqJPfff7/UqlVLNm3aJG3btlWPL168WO699153dklERIZKC7LKB5yWFnBlLyIKD24Fsu+++66aagsLH4wYMUIKFy6sHsccs8OGDfN0G4mIKN3Igghx1tlbIqIQ51Ygi6zrL7/8ku3xt956S+688067zxERUS5wsBcRkWdqZJctW2b38czMTPntt9/c2SUREXlsZS8uiEBE4cGljCyWoLX3tR7EYg7ZMmXKeK51RERksyACSwuIiNwKZKtUqWL3a12ePHnkgw8+cGWXRERkBEsLiIhyF8gePHhQ3WMVL/1rXUxMjJQoUUKio90quzVE0zR1i4x0qyKCiCi4A9mIKJHIKMfbsLSAiMKMSxFhhQoV1O3SpUvmr/UbSgq8FcRu2bJF2rRpozK+xYsXVyuLXb9+3SvHIiIK2NICZ2UFlvWznLWAiMKE4cgTU2tBtWrV5NixY063xTaesmfPHrn99tulT58+MmvWLImLi5OJEyfK5s2b1WpiRERhAXPDOptD1iqQ5TyyRBQeDAey1atXV/e4tK9/7Qi28ZRXXnlFzVk7YcIEiYiIUI8999xzHts/EVFQQJbV2apeVqUFnEeWiMKD4UD26NGjdr/2poyMDFm4cKG89tprKohNT0/3ag0uEVFA18jG5He+jXllL06/RUThwXBUWLZsWbtfe9OZM2fk6tWrKoCtV6+ebN++XRITE6V3794yatQoiY21P59iSkqKuukuXrxoNVjMm/RjePs4FNx4npDL5wnmhs1bGA86fkFUrOC6lYaMLH8HhQ3+PqFQO1dcaZ/b6U0EmKibPX/+fLbnsLqXJ9/IuHHjZMGCBdKkSRNZv369WlksKipKxowZY/d1eBxL59pKTk72SSB7+fJl9bVeCkHE84Ry+/ukUEaKZEZEy6XkZIfbR11Lk4Iiknrtslxzsh2FFv7doVA7V/QEpNcC2SVLlsjDDz8s586ds/u8p4LFokWLqmm9evbsKU2bNlWP3XLLLdK3b1+ZO3euw0A2KSlJBg0aZNUh5cqVk4SEBImPjxdv0t87jhXIJwn5F88Tcuk8iS8oEZnpEhmTR/1ucehqYXUXGyUS62w7Cin8fUKhdq640ja3AtmBAwfK448/Li+99JIULmz6xekNCGKRhU1Nta73QtmAo7ICwMwGuNnrGF/84PTjBPJJQv7H84QMnyeZplkIIjCYy9nvleg8pu3UnLP8/RNO+PuEQulccaVtbq0scPjwYXn11Ve9GsRazlrwzTffyOzZs+X06dMyb948mTJliqqTJSIKC/osBDnOWpD1AZ+zFhBRmHArI4t5Yg8dOiQ1a9YUb8NCCFOnTlWDuxBAly9fXt588015+umnvX5sIqKAoM8Ly3lkiYhyH8giiERG9O2331ZzvNqmgD09q8FDDz2kbkREYUlfqSvHlb2ynufKXkQUJtwKZJ944gl136pVK7vPB/q0DkREQQVTb1mu3JVjaQHnkSWi8OBWILtz507Pt4SIiOzLMBjImpeoZSBLROHB7RpZIiIKtNICPZDlErVEFB7cCmQ3bdrk9HmswkVERD4e7BUZJRIR9d/2REQhzq1Atn79+k6fZ40sEZEfpt/Ss7acfouIwoRbgeyZM2esvs/MzJS9e/fKc889J/379/dU24iIyLLmVR/MlVN5AWtkiShMRLu7dKyt4sWLq/lee/XqJX369PFE24iIyJXBXvo2DGSJKEy4tbKXI1isYM+ePZ7cJRERsbSAiMhzGdnr169ne+zChQsyduxYqVy5sju7JCIiR1haQETkuUA2b968dh8vWbKkfPfdd+7skoiIHGFpARGR5wLZVatWZXuscOHCarnauDgDo2qJiMjzK3vpA8Iy0zEKVyTSo9VjREShEcjedtttnm8JERF5JiOrvyYyD3uUiEIaP64TEYXKyl6Wc81ydS8iCgMMZImIQq20wPI1REQhjIEsEVGolhYQEYU4BrJEREEz/VacC4FsVjkCEVEI82ggO3ToUHUjIiJvLIhgpLQgK9hlaQERhQGPBrITJ05UNyIi8iCWFhAReW76LUfOnj3ryd0REZE7K3tZvoaIKISxRpaIKNAxI0tE5NmM7JkzZ+Szzz6TnTt3qu9r1Kghjz/+uBQtWtTdXRIRkbMa2eg8LtTIXmdfElHIcysju3z5cqlUqZJMnjxZrl27pm6TJk1Sj61cudLzrSQiCmfp14wHsjF5TfdpDGSJKPS5lZEdMGCAPPPMMzJmzBiJzFrLOzMzU5KSkqR///6yZcsWT7eTiCh8pV2zDlKd0YPdtKvebRMRUbBmZPfv3y9DhgwxB7FqR5GR8tJLL8m+ffs82T4iItKzq0YC2Zh8pnuWFhBRGHArkL3pppvsBqwIcPEcERF5o7TASCCrZ2SzXkNEFMIMlxYcO3bM/PVTTz0lnTt3lpEjR8ott9wimqbJ+vXr5bXXXlPlBURE5EEISjGtlsVVMIf0YJeBLBGFAcOBbLly5bI91rt372yPIcj9v//7v9y3jIiI/gtKjZQVgL4dSwuIKAwYDmT1abaIiMjHEJQaKSuwmrWApQVEFPoMB7LVqlUzfz1r1izp1KmTt9pERESWEJTmNzhHtz5rATOyRBQG3Brs1b17dzXdFhER+aq0IGs2gpzo23H6LSIKA24FslWqVJFt27Z5vjVERGQtI00itAxjiyFYzVrABRGIKPS5tSDCwIEDpUePHmpBBCxNGxsba/V82bJlPdU+IqLwppcIGB3sZS4tYI0sEYU+twJZfVaCtm3b2n0e03EREVHuRbiyPC1wsBcRhRG3AlnOYEBE5BsRrmZkGcgSURhxK5C1nMGAiIgCqbSA88gSUfhwa7AXERH5OCNrtLQgOg6v4mAvIgoLbmVk09PT5ZNPPpGZM2fKkSNH1PeOlrMlIiJPZGQNTr8VEWHK3nL6LSIKA25lZEePHi3jx4+Xhx56SA4fPixDhw6VNm3ayMmTJ6Vbt26ebyURkYR7jazBjKyeveWCCEQUBtwKZKdOnSrfffedmoZLn8Xgiy++kE8//VQ2bdrk6TYSEYWtCH2pWaNL1ILKyHL6LSIKfW4FsignqF+/vvo6b968cunSJfV1ly5d5I8//vBsC4mIwpmrg730bRnIElEYcCuQzcjIkOhoU3ltxYoVZfXq1err3bt3q8CWiIg8IyLDjUAW2VvMP8s5vYkoxLk12MvSU089Jd27d5cmTZrIn3/+KT179vRMy4iI6L/MqtFZCyzradNTXKutJSIKh0A2LS3N/PWAAQOkfPnyqqQAA70eeeQRT7aPiCisubwggu0ytQxkiSiEuRXI6mUFunbt2qkbERF5GLKqLtfI5vsvm5u3MH8kRBSyDNfIonxg7969OW63Z88etS0REXlyQQRXAtmsjCwHfBFRiDOcka1Xr540bNhQGjVqJG3btpUGDRpIiRIlRNM0NX/sX3/9JT/99JNs3LhRXn75Ze+2mogoTESgPMDleWS5TC0RhQfDgexLL70kffv2lYkTJ6rbzp07rZ6vUaOGysRita9ixYp5o60yZ84cdewOHTqouWuJiEKeu9NvATOyRBTiXKqRLV68uLz22mvqdv78ebUUbUREhJQpU0YSExO910oROXTokBpYhuVwq1Wr5tVjEREFd2kBA1kiCg9uT7+FwNXbwasOwSuyva+//rpMmDDBJ8ckIgoIbpUW6LMWZAXBREQhyq0FEXxt6NChUrZsWenTp4+/m0JE5Kfpt7JmInBp1oKr3mkUEVGoLIjgbUuXLpVvvvlGNm3aZPg1KSkp6qa7ePGiusfANNy8ST+Gt49DwY3nCRk9T/SsqhYdZ3ylrug4icBrUCPL30Uhj79PKNTOFVfaF9CB7KlTp6R3797y1VdfuVTGMGbMGBkxYkS2x5OTk30SyF6+fFl9jfphIp4nlJvfJ/lSrqivk6+kiqQkG3pdbLoIcrLXLl6Q1GRjr6Hgxb87FGrnip6ADPpAdtasWXLlyhV5++231Q0OHDgg//77r+zatUsWLlwokZHZqyOSkpJk0KBBVh1Srlw5SUhIkPj4eK+2WQ+UcaxAPknIv3iekNHzJDMzTTSJkITEYvjLY6zjCpoWQcgbI5I3IYGdHeL4+4RC7VxxpW0BHchivtrKlStbPYZFGerUqaOm33L0RuPi4tTNFrb3xQ9OP04gnyTkfzxPyNB5knFd1bxG2PnQ7lCsqUY2AqUF/D0UFvj7hELpXPFKIIsBV+4YNWqUuKt8+fLqZqlgwYJyww03yD333OP2fomIgoUKRl2ZsQC4IAIRhYloV+ZxJSIiH8Ngr7iCrr2GS9QSUZgwHMhOnz5dAsHHH3/ss/lriYgCYvqtAsVde5F5+q2sOWiJiEKUW/PI/vrrr36buqFp06Zc2YuIwoOWKREZKW6UFugLIjCQJaLQ5lYg26ZNGzUIa+TIkXLkyBHPt4qIiP5bmcuV5Wmtlqjlyl5EFNrcCmSPHj2qZg3AQgUVK1aUu+++W7777jurRQiIiCiX9EBUD0yN0rfnErVEFOLcCmRLlSolL730kprLdeXKlWr52Mcff1xKly4tAwYMcGkVLiIickAvDXB31gIuUUtEIc6tQNZSs2bN5K233pKXX35ZrRYxceJEqV+/vtxxxx2yZ88ez7SSiCgc6YO1XC4tyAp8WVpARCHO7UA2MzNTFi1aJF26dFGZ2GnTpsno0aPlxIkTKlOLrG2nTp0821oionAMZN2eR5aDvYgotLm1shcWR5g6daqcP39eBau//PKL3H777ebnixUrJlOmTJG8eV3MIhARkZ3BXlnTaRkVFS0SGcPpt4go5LkVyC5cuFCSkpKkR48ear1ee7BE7I8//pjb9hERhS+9xtXVjKx6TV4GskQU8twKZDdu3Ghou/bt27uzeyIisqxxdbVGVr0mD2ctIKKQl+vBXkRE5OXSAlen39Jfw8FeRBTiXMrI3nnnnYa2Q80sERH5ubTg4gn+CIgopLkUyBYtWtTqeyyC0LVrV0+3iYiIPFFakJkmkpkhEhnF/iSikORSIDtjxoxsgaztY0RE5OcFEdRr9EURronEFeCPhIhCEmtkiYgCfolaF6ffsg1kiYhCFANZIqJAr5FFmYCruCgCEYUBBrJERCE5awGXqSWi0OdSjeysWbMMPcalaYmIPFla4Ob0W5ZZXSKicA9kO3fubOgxTdNy1yoiIhJJ90RpQVYwTEQU7oHspUuXvNcSIiLyYEZWLy3gYC8iCl0uBbIFCnAKFyIi30+/5U4gmzXTATOyRBTCONiLiChQ6dlUdxdEUPtgjSwRhS7DGdmhQ4e6dYBRo0a59ToiorBnLi3IzYIIrJElotBlOJA9dOiQd1tCRET2Swtyk5HV90FEFM6B7PTp073bEiIispZ2TbSoWJHIKPdrZDnYi4hCGGtkiYgC1bULosUWdO+1eeLN+yAiClUMZImIAlHKJYm4ckYyE8q79/rCFUz35w96tFlERIGEgSwRUSC6YBqXkFkoKyB1N5C9wECWiEIXA1kiokB0/oC6y0y4wb3XY9aCgqVFzh3AcouebRsRUYBgIEtEFMCBbEYhNwNZSKwkkpLMOlkiClkMZImIAlFWbavbGVlIZJ0sEYU2BrJERIFcWuBujayekbXYFxFRqGEgS0QUiM4fFC0uXrS8ie7vg4EsEYU4BrJERIEGy8pePG6aeSAiwv39FK5ouufMBUQUohjIEhEFmn8Pi4j2X0bVXYlZgSxLC4goRDGQJSIKNHrgqWdU3ZUnQSRfEQayRBSyGMgSEQUafTUuPaOaG8jqXjmjVgojIgo1DGSJiAI1I5vb0gLLfXCpWiIKQQxkiYgCzQUPZmQ54IuIQhgDWSKiQMzIRucRKVgq9/viFFxEFMIYyBIRBZKMdJF/j2RNveWBX9GcuYCIQhgDWSKiQHLhkEhmukhiZc/sr8iNpvuzez2zPyKiAMJAlogokJzebrovUcMz+8uXKFKghMjpHSKa5pl9EhEFCAayRESB5PRO033x6p7bJ/Z1PVnk0j+e2ycRUQBgIEtEFEiQOYXiNT23T31fp7L2TUQUIhjIEhEFEgSbkTEiRTxUI2uZ3dWDZCKiEMFAlogoUKRdFzm/X6RYVZGoGM/tV6+31csWiIhCRLQEgSNHjsi6deskOjpaGjVqJGXKlPF3k4iIPO/sHhEt07P1sVCsmvVAMiKiEBHQGVlN06R79+7SsmVLmTlzpnz++edSpUoVmTBhgr+bRkQUHAO9IDa/aV7aM7tFMjM8u28iIj+KDvRAtl27dvL1119LZKQp5v7qq6+kT58+0rZtW6lc2YM1ZERE/qZnTD050EuHfWKO2vMHRYpmzS1LRBTkAjoji+C1W7du5iAW7r77bsnMzJTdu3f7tW1EREGTkbXcJwd8EVEICeiMrD3z58+XqKgoqVOnjsNtUlJS1E138eJFc4YXN2/Sj+Ht41Bw43lCdiHIjC0gklBOLV7g0fOkeA2JwLmHY1Rvyx9ACOHvEwq1c8WV9gVVILtz504ZNGiQupUtW9bhdmPGjJERI0Zkezw5Odkngezly5fV1xER+LNBxPOEDEi5KIWSj0l6yfpy2eLDt6d+n0TmKyfxmBjh+Ga5mpzMH0kI4d8dCrVzRU9AhlQge+DAAWnTpo3cd999MnbsWKfbJiUlqWDXskPKlSsnCQkJEh+PX+XeowfKOFYgnyTkXzxPKJuju9RdVKna6veHx8+TAvVEi4yRmPN7zfun0MDfJxRq54orbQuKQPbgwYNq5oKmTZuqwV6WNbP2xMXFqZu9jvHFD04/TiCfJOR/PE/Iyj+bTedFqTo4OTx/nkTHihSvJnJym0jqZZG4gvwBhBD+PqFQOldcaVtAD/aCQ4cOqSC2SZMmavYC1McSEYWcY+tN92UaeO8YZRoiJyNy4m/vHYOIyIcCOiN7/fp1ueOOO9R98+bN5bPPPjM/h+C2WrWsSb6JiILd8Q0iUbEiJWp57xgIkjdMMR2rYnPvHYeIyEcCOpDNyMhQ023B1q1brZ6rXbu2n1pFRORhV8+blqZFxhQlAN6iZ3v17C8RUZAL6EA2f/78MnHiRH83g4jIu05sNN2XxaV/LypW1TS91/Gs4xERBbmAr5ElIgp5emDpzfpYiIwSKV1f5NIJkYsnvHssIiIfYCBLRBQOA710+jFQJ0tEFOQYyBIR+RPmdURQmbewSGIl7x+PgSwRhRAGskRE/vTvYZGrZ00Bpi/mddTrcDngi4hCAANZIiJ/0i/x+6KsAOJLixQsJXJik0hmhm+OSUTkJQxkiYj86eifvg1k9WOlXhI5vcN3xyQi8gIGskRE/nRghUhElEj5Jr47ZoXbTfcHV/rumEREXsBAlojIXy6dEjmzU6TMzSJ54n133Eot/guiiYiCGANZIiJ/0TOiFbMCS18pVk2kQAmRw7+LZKT59thERB7EQJaIyF8OLrfOkPoKZkeo2Fwk9TJX+SKioMZAlojIX/PHHlgpEp1HpGwj3x9fzwIfZHkBEQUvBrJERP5w4aBI8hGR8o1FYvL4/viskyWiEMBAlojIH/SBVr6uj9UVKi9SuKLIsT9FUq/6pw1ERLnEQJaIyB/0S/q+ro+1hGNnpIocWeO/NhAR5QIDWSIiX0tPEdn7i0i+oiKl6vmv/2+803S/+2f/tYGIKBcYyBIR+dqB5aaVtardLxIZ5b/+r9xaJCafyM75IpmZ/msHEZGbGMgSEfnajp9M99Uf9G/fx+YzZWUvnxQ59pd/20JE5AYGskREvoQFCHYvEIlLMM3l6m812pnud2YF10REQYSBLBGRL2E1rWsXRKreIxId6/++r9JGJCrWFMhiblsioiDCQJaIKBzLCnR54kUq3SHy7xGRfzb7uzVERC5hIEtE5CsZ6SK75psGWFVuFTj9Xr2t6X7HHH+3hIjIJQxkiYh8Ze8SkcunRKo9YBpoFSiqP2BaKnfTt6YaXiKiIMFAlojIVzZ8abpv0Cew+jxvYZEa7U2zF+xZ7O/WEBEZxkCWiMgXko+J7FsqUqSKyA1NA6/PG/Q23W+c6u+WEBEZxkCWiMgX/p4uomWaAsaIiMDr8/JNRIreJLJ3qci/R/3dGiIiQxjIEhF5W2aGyMavTNNc1X04MPsbwbUqedBMQTcRURBgIEtE5G2Yo/XiMdMgr/xFAre/63YXiYoTWf+FSNo1f7eGiChHDGSJiLwpM1Nk5TjT182eC+y+zpcocnMvkSunRTawVpaIAh8DWSIib9rzs8ipbSJV7hYpXS/w+7rZQJHIGJHf3xNJT/F3a4iInGIgS0TkLVjydcVbpq+bDw6Ofi5UTqRed5FLJ1grS0QBj4EsEZG3YE7WfzaJVGopUu6W4Onn2waJRESJrB4vknbd360hInKIgSwRkTcgAFw0xPR1y5eDq48TK4rU7yGSfNRUYkBEFKAYyBIRecOaD0QuHDRNt1X+1uDr49bDRPIkiKx+V+T8QX+3hojILgayRESeduGwyKpxInEJIneNCM7+zV9UpPVrIunILCf5uzVERHYxkCUi8vR0W/OeNQWArYaKFCgevP3boK9IqbqmmRe2zPR3a4iIsmEgS0TkSbgUf2C5SPmmIg0fDe6+jYwSefBD04pk8weKnNvv7xYREVlhIEtE5ClH1or89oZI3kSRjp+JREUHf9+WqiPSZrRI6mWRWX05tywRBRQGskREnnDhkMj3j4hoGSIdJooklAmdfm30hGl53X82i8ztbyqfICIKAAxkiYhy6/IZka86iFw+JdIySeSmu0OrTyMiRNp9JFK8hsjW70WWDDUt9kBE5GcMZImIcuPKWZHpD4mcP2CqiW3xUmj2Z95CIj1/EEkoL7L2I5HlYxnMEpHfMZAlInIXgtfP7xI5uUWkZgeR+8aZspehKr60SK8fRfIXE1kxVmTBIJHMDH+3iojCGANZIiJ3HFgh8nmb/zKxHT83jfIPdUWriDy2RCSxksj6L0S+7SZy5Zy/W0VEYYqBLBGRKzLSRH4ZITKtnciVM6a5Yu9/NzyCWB2C2MeWipRpKLJ3icjEZqbAnojIxxjIEhEZtf9XkU+amuaKxUIHveaINB8c2uUEzlb+6vuzSNNnRS79IzLtQZHZT4lcOuXvlhFRGAmBSQ6JiHwwP+zKcSL7lpq+r9VR5N63TMFcOIuOFWnzukjlVqZ62c3fiuycJ9LoSZHGz4gUKObvFhJRiAuaQDY9PV0uX74shQoV8ndTiCgcpF4R2T5HZONUkaPrTI+VrC1yz1iRCrf5u3WBpfIdIs+sFfnjQ5FV400Z67WfiNTuJHLzIyJlbwnPrDUReV3AB7KapsmQIUPkww8/lMzMTClWrJj6+sEHH/R304goFOeDxfKyu+aJ7P1FJO2K6fFyt4rc/oJIlTYMyByJjjP1UcPHRP6aLLJ2osjfX5luhSuKVH9ApMrdImUbisTk9d3PlIhCWsAHsuPHj5dJkybJihUrpH79+vLee+9Jp06dZOvWrVK1alV/N4+IglXKJZGT20RObjVNn3V8g8jpHf89n7+4yM29ROr3EilZy58tDb75ZlE33PQ5kd0LRf6eLnLgN5E1H5hukTEipeqKlG9s+oCARRYKVwiN5XyJyOciNKQ8A1jFihVV4Pr222+bH6tUqZK0b99e3n33XUP7uHjxoiQkJEhycrLEx8d7PYOM4+B4EbyURjxPfA/Lp6Yki1w9L3LtgukeswskHxX594jpduGwSPIR69dFRIqUri9S4XaRqveaLof7eSaCkPl9cu1fkb1LRQ6uMNUbn9tr/TyC28SKIkWqmILagiVFCpYy3RcoYQqO4+JFYvL46x0EtJA5T8jrtCA5V1yJ2wL6I/CZM2fk0KFDcttt1vVot99+u/z5558SqH5c8b7ExsSKuHqO5OozhePXRnhpv7l5XYSz57XctMfd/eZEc6/vHTyHH0l6WppEx0RLhMMTxb1jquPmqg+dvdT192pMpkRkZkiEZrqJZv29+fHMDInU0iUiI1UiM1MkMiNFIjPTJCLjukThsfQrEp12Jce2ZEbFyfXi1eR6gfJyLeuWUqCsZERnXfI+eV7k5GLxO02T69evS548eUKgpCG/SKn71C069aLkS94n+S7ul7irJyXu6j8Se/W4RF45ImLz+cJSZkS0ZETnk8zofKb7qDjJjIwRLSpGPafha3WLlszIaNEiYkWLjBINH1Lw/ywiQrSIKNEwYY/6Gvem5/C1frOa0CfC9guLn0PWl5q95+x+L6KZf452fp7u/ow1kdS0VPf+7lB40dw/V8oWqyotG3aQQBPwgSwULWo9Mhh1sn/88YfD16WkpKibZWSvfxLxdgIa+y/1zreSkFVaR0S+FJt1cw551vxyUfLLNhF1I/9LMPRzM+XIU7NuROQr6XmjRFvV3ifHciVWC+hAVk97Y8YCS/g+KsrxJb8xY8bIiBEjsj2OFLUvAtmCmTESJ5lePQ45+Rmwc/wowiv7y/Yzzfrd8F8mLHThvYf+u8wNi7NAsz5bHJw9dvfhDPufSCQ6Kp+Ko3xBT0AGfSBbunRpdX/qlPUE2/hef86epKQkGTRokFWHlCtXTtVb+KJGtua8FQFff0L+FSx1SuRfPE+I5wmF4++UCBfaFtCBLDq6bt26snTpUunSpYs5G7ts2TLp16+fw9fFxcWpm72O8cUPTj9OIJ8k5H88T4jnCfH3CfFvTwgHsjB06FB5+OGHpXHjxtKkSRMZN26cmk/26aef9nfTiIiIiMiPAj6QxdRbGLiF+WNHjhwptWvXluXLl0vx4sX93TQiIiIi8qOAD2ShR48e6kZEREREpLOYLI+IiIiIKHgwkCUiIiKioMRAloiIiIiCEgNZIiIiIgpKDGSJiIiIKCgxkCUiIiKioBQU0295Ykk2V9fuzc2xcByu7EU8T4i/T8gX+HeHQu1c0eM1PX6TcA9kL126pO7LlSvn76YQERERkcH4LSEhwek2EZqRcDfIYUnbEydOSMGCBb3+CQSfIhAwHz16VOLj4716LApePE+I5wnx9wnxb499CE0RxJYuXVoiI51XwYZFRhadULZsWZ8eE0EsA1nieUL8fUL8u0OBJj4IYpScMrE6DvYiIiIioqDEQJaIiIiIghIDWQ+Li4uTYcOGqXsinifE3yfkbfy7Q+F8roTFYC8iIiIiCj3MyBIRERFRUGIgS0RERERBiYEsEREREQUlBrI+tGHDBlmzZo0vD0lBBJM///3333Lq1Cl/N4UCxO7du2Xjxo2SkpLi76ZQgMrIyJBdu3bJnj17JD093d/NoSBYIOr333+XLVu2SKhgIOsjP/30kzRq1EhatWrlq0NSkDhw4IB06tRJypcvL48++qhUqVJF7r33Xjl79qy/m0Z+8s8//0jDhg2lSZMm0rlzZylTpoz8/PPP/HmQlTfeeEMt9tOhQwe555575IYbbpC5c+eyl8ihUaNGSfPmzeXJJ5+UUMFA1geOHTsm/fr1UzciW/v375fu3bvL+fPnVUb20KFDcvz4cXnmmWfYWWEKH2gwPQ6W1sb50b9/f+nWrRs/3JCVK1euyNatW2Xnzp3qA/HTTz+tzhP8/iCytWrVKpk6dap06dJFQgkDWR9c9unRo4cMGTJEatSo4e3DURC66667pGPHjhIREaG+T0xMlK5du8rq1av93TTyAwSvixcvlv/973+SJ08e9djgwYMlLS1NZs2axZ8JmY0ePVqKFi1q/h6B7PXr11UZG5ElJEp69eolU6ZMMbz0a7BgIOtlI0eOlAIFCjAbSy7566+/5MYbb2SvhaFNmzYJpvdu0KCB+bH8+fNL9erVVcaeyNnvDahcuTI7ibJd5Xn44YdVWUGoifZ3A4JtMM7mzZudboN6pQoVKqivV6xYIZMnT+YfnzCUUzYVn4hr165t97kZM2aomupFixZ5qXUU6JkTKFKkiNXj+F5/jsjWuXPnVMLkoYcekpo1a7KDyOyDDz5Q5SYzZ86UUMRA1gVHjx5VJQLOoNYRv0yQUUFJQZ8+fWTv3r3qhlo3PI4gB5+YS5UqldufHwVoOUlO50n9+vXVLxdbS5YsUefMO++8I23atPFiKylQxcTEqHtcIs6bN6/58WvXrkmxYsX82DIKVBcvXpT77rtPfdjBpWMiy7gFZUofffSRrFu3Tj128uRJlZhDLFKnTh2Jj4+XYMYlar0YzLRo0cLqMZw8KMhv2rSpDBo0SH1yJtItXbpU2rVrp8pRXnzxRXZMmFq7dq2arQCDeGrVqmV+vFKlSqp2esyYMX5tHwUWBCR33323pKamyi+//CKFChXyd5MowKbwe+yxx6weQ1INAwURxH7yyScOrw4GCwayPjRx4kQZOHCgyrQQWVq2bJm0bdtWhg8frj49U/jCoK6SJUvKCy+8IC+//LJ6DEEt/ujgPOEUfmQZxGLaLcwzjA/ChQsXZudQjp566ilVi48PzaGApQVEfoZfJg8++KC6NIhsvWV97W233ebXtpF/Sgtef/11FchioChKkIYNG6ZKTRjEkg6LH9x///1qIQSUE2zfvt38HAaK4sMQUThgIOtD+IPUrFkzXx6SggAu86BmFqUntrW1nIIrPGEOYdTDfv3113L16lU12hjlSEQ6XNnDKk1Vq1aVsWPHWnUMpmtDmRKRPfigg/E6oYKlBUREREQUlDiPLBEREREFJQayRERERBSUGMgSERERUVBiIEtEREREQYmBLBEREREFJQayRERERBSUGMgSERERUVBiIEtEFMCrN33//fdq2VpvmzVrllp/nYgomDCQJSIKUB999JFMmzZNLVvrbQsWLJDRo0d7/ThERJ7Elb2IiAIQlqYtV66czJ8/X5o0aeL14+3evVvq1asnR44cUcvjEhEFg2h/N4CIKBzs3btXNmzYkO3xqlWrSv369bM9/s0330jRokWtgtgZM2bIHXfcISVKlDA/tnDhQqlSpYq6wezZs6VBgwYqi7t582bJnz+/NGvWTCIjI+Xw4cOyadMmFSDffPPN2dpRp04d+fzzz2XIkCEefvdERN7BQJaIyAcOHjwoc+bMMX+fkZGhgs7nnnvObiCLTGyrVq2sHuvevbssXbrUKpAdNGiQ9O/f3xzIPvHEE1K9enU5fvy41KxZU37//XcV2LZs2VKmTJki1apVk1WrVknfvn1lwoQJVvvH8XBcBrJEFCwYyBIR+UCbNm3UTffiiy9KYmKiPPvss3a337hxowwePNjtQWI7duyQPHnyyPr16+WWW26R1NRU9VhsbKwsX75cWrdurQLWkiVLml9Xu3ZtGT9+vFvHJCLyBw72IiLysenTp8v777+vZgq44YYb7G5z9uxZKVy4sFv7f+SRR1QQC8jGInjt06ePugeUK2RmZsq+ffusXofjpaSkyKVLl9w6LhGRrzGQJSLyIWRIcfkfgWzz5s0dblegQAG3p8OyDIAjIiJUvazlY3Fxcer++vXrVq/D8VBLmy9fPreOS0TkawxkiYh85OTJk9K+fXtVn/rUU0853famm25SdbWWEJQik2rJNhjNDRzvxhtvlKioKI/tk4jImxjIEhH5AGpUH3roIRUovvfeezlujxpWDNSyVKZMGatygP3798vRo0c91kYc78477/TY/oiIvI2DvYiIfGDs2LHy119/qcFUP/zwQ47Tbz366KMyZswYNa9r+fLlzbWvw4cPVyt9aZomn332meTNm9cj7UtOTpbFixfLmjVrPLI/IiJfYCBLROQDmLu1Y8eOsnr1aqvH77vvPruBLAaB9ezZUz744AN5++231WOvv/66VKpUSdauXatmG0BAPGnSJFWGoEPW13YAWadOnaRs2bJWj3Xt2tVqxoLJkyer6bfstYWIKFBxZS8iogB16tQpSUpKkk8//dTry9RiLlrMaavPR0tEFAwYyBIRERFRUOJgLyIiIiIKSgxkiYiIiCgoMZAlIiIioqDEQJaIiIiIghIDWSIiIiIKSgxkiYiIiCgoMZAlIiIioqDEQJaIiIiIghIDWSIiIiIKSgxkiYiIiCgoMZAlIiIiIglG/w9/aFgPCIfmewAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 700x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "soi_sim.mode_solver(n_field_z=n_points)\n",
+    "band_sweep = soi_sim.solve_modes()\n",
+    "band_results = {r.band_num: r for r in band_sweep.results}\n",
+    "\n",
+    "zz = gm.mode_z_grid(soi, n_points=n_points, pml_thickness=PML)\n",
+    "\n",
+    "for comp in (\"Ex\", \"Ey\", \"Ez\", \"Hx\", \"Hy\", \"Hz\"):\n",
+    "    fig, ax = plt.subplots(figsize=(7, 4))\n",
+    "    for band, r in sorted(band_results.items()):\n",
+    "        if comp in r.fields:\n",
+    "            tag = \"guided\" if r.n_eff > _n_sio2(WL) else \"leaky\"\n",
+    "            ax.plot(\n",
+    "                zz,\n",
+    "                abs(r.fields[comp]),\n",
+    "                linewidth=1.3,\n",
+    "                label=f\"band {band} ({tag}) n={r.n_eff:.4f}\",\n",
+    "            )\n",
+    "    ax.set_xlabel(\"z (um)\")\n",
+    "    ax.set_ylabel(f\"|{comp}| (arb. units)\")\n",
+    "    ax.set_title(\"Multi-band slab modes - SOI 220 nm\")\n",
+    "    ax.legend(fontsize=\"small\", loc=\"upper right\")\n",
+    "    ax.grid(True, alpha=0.2)\n",
+    "    fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7acc301",
+   "metadata": {},
+   "source": [
+    "### Parity modes\n",
+    "\n",
+    "MEEP's eigenmode solver supports parity constraints along Y and Z.\n",
+    "For the symmetric SOI slab, ``EVEN_Y`` selects TE0.  ``ODD_Y`` selects\n",
+    "the first odd-symmetry mode -- leaky if V < pi/2 ~ 1.57."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "40b52fbf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  NO_PARITY : n_eff=2.830654  (guided)\n",
+      "  EVEN_Y    : n_eff=2.830654  (guided)\n"
+     ]
+    },
+    {
+     "ename": "ValidationError",
+     "evalue": "1 validation error for ModeSolver\nparity\n  Input should be 'NO_PARITY', 'EVEN_Y', 'ODD_Z' or 'EVEN_Y+ODD_Z' [type=literal_error, input_value='ODD_Y', input_type=str]\n    For further information visit https://errors.pydantic.dev/2.12/v/literal_error",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mValidationError\u001b[39m                           Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[18]\u001b[39m\u001b[32m, line 12\u001b[39m\n\u001b[32m      8\u001b[39m         p_sim.mode_solver(wavelengths=[WL], band=\u001b[32m1\u001b[39m, parity=parity)\n\u001b[32m      9\u001b[39m         r = p_sim.solve_modes().results[\u001b[32m0\u001b[39m]\n\u001b[32m     10\u001b[39m         tag = \u001b[33m\"guided\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m r.n_eff > n_sio2 \u001b[38;5;28;01melse\u001b[39;00m \u001b[33m\"leaky\"\u001b[39m\n\u001b[32m     11\u001b[39m         print(f\"  {parity:10s}: n_eff={r.n_eff:.6f}  ({tag})\")\n\u001b[32m---> \u001b[39m\u001b[32m12\u001b[39m     \u001b[38;5;28;01mexcept\u001b[39;00m RuntimeError \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[32m     13\u001b[39m         print(f\"  {parity:10s}: not found ({exc})\")\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/dev/gds/dev/gsim/src/gsim/meep/models/api.py:718\u001b[39m, in \u001b[36mModeSolver.__call__\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m    716\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"Update fields in place, return self for fluent chaining.\"\"\"\u001b[39;00m\n\u001b[32m    717\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs.items():\n\u001b[32m--> \u001b[39m\u001b[32m718\u001b[39m     \u001b[30;43msetattr\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mk\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mv\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    719\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/prg/mambaforge/envs/gsim/lib/python3.12/site-packages/pydantic/main.py:1030\u001b[39m, in \u001b[36mBaseModel.__setattr__\u001b[39m\u001b[34m(self, name, value)\u001b[39m\n\u001b[32m   1028\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__setattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, name: \u001b[38;5;28mstr\u001b[39m, value: Any) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m   1029\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m (setattr_handler := \u001b[38;5;28mself\u001b[39m.__pydantic_setattr_handlers__.get(name)) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1030\u001b[39m         \u001b[30;43msetattr_handler\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mname\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mvalue\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m   1031\u001b[39m     \u001b[38;5;66;03m# if None is returned from _setattr_handler, the attribute was set directly\u001b[39;00m\n\u001b[32m   1032\u001b[39m     \u001b[38;5;28;01melif\u001b[39;00m (setattr_handler := \u001b[38;5;28mself\u001b[39m._setattr_handler(name, value)) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/prg/mambaforge/envs/gsim/lib/python3.12/site-packages/pydantic/main.py:111\u001b[39m, in \u001b[36m<lambda>\u001b[39m\u001b[34m(model, name, val)\u001b[39m\n\u001b[32m    105\u001b[39m         \u001b[38;5;28mobject\u001b[39m.\u001b[34m__setattr__\u001b[39m(model, \u001b[33m'\u001b[39m\u001b[33m__pydantic_private__\u001b[39m\u001b[33m'\u001b[39m, {})\n\u001b[32m    106\u001b[39m     model.__pydantic_private__[name] = val  \u001b[38;5;66;03m# pyright: ignore[reportOptionalSubscript]\u001b[39;00m\n\u001b[32m    109\u001b[39m _SIMPLE_SETATTR_HANDLERS: Mapping[\u001b[38;5;28mstr\u001b[39m, Callable[[BaseModel, \u001b[38;5;28mstr\u001b[39m, Any], \u001b[38;5;28;01mNone\u001b[39;00m]] = {\n\u001b[32m    110\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mmodel_field\u001b[39m\u001b[33m'\u001b[39m: _model_field_setattr_handler,\n\u001b[32m--> \u001b[39m\u001b[32m111\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mvalidate_assignment\u001b[39m\u001b[33m'\u001b[39m: \u001b[38;5;28;01mlambda\u001b[39;00m model, name, val: \u001b[30;43mmodel\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43m__pydantic_validator__\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mvalidate_assignment\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mmodel\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mname\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mval\u001b[39;49m\u001b[30;43m)\u001b[39;49m,  \u001b[38;5;66;03m# pyright: ignore[reportAssignmentType]\u001b[39;00m\n\u001b[32m    112\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mprivate\u001b[39m\u001b[33m'\u001b[39m: _private_setattr_handler,\n\u001b[32m    113\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mcached_property\u001b[39m\u001b[33m'\u001b[39m: \u001b[38;5;28;01mlambda\u001b[39;00m model, name, val: model.\u001b[34m__dict__\u001b[39m.\u001b[34m__setitem__\u001b[39m(name, val),\n\u001b[32m    114\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mextra_known\u001b[39m\u001b[33m'\u001b[39m: \u001b[38;5;28;01mlambda\u001b[39;00m model, name, val: _object_setattr(model, name, val),\n\u001b[32m    115\u001b[39m }\n\u001b[32m    118\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mBaseModel\u001b[39;00m(metaclass=_model_construction.ModelMetaclass):\n\u001b[32m    119\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"!!! abstract \"Usage Documentation\"\u001b[39;00m\n\u001b[32m    120\u001b[39m \u001b[33;03m        [Models](../concepts/models.md)\u001b[39;00m\n\u001b[32m    121\u001b[39m \n\u001b[32m   (...)\u001b[39m\u001b[32m    148\u001b[39m \u001b[33;03m        __pydantic_private__: Values of private attributes set on the model instance.\u001b[39;00m\n\u001b[32m    149\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n",
+      "\u001b[31mValidationError\u001b[39m: 1 validation error for ModeSolver\nparity\n  Input should be 'NO_PARITY', 'EVEN_Y', 'ODD_Z' or 'EVEN_Y+ODD_Z' [type=literal_error, input_value='ODD_Y', input_type=str]\n    For further information visit https://errors.pydantic.dev/2.12/v/literal_error"
+     ]
+    }
+   ],
+   "source": [
+    "parities = [\"NO_PARITY\", \"EVEN_Y\", \"ODD_Y\"]\n",
+    "for parity in parities:\n",
+    "    try:\n",
+    "        p_sim = gm.Simulation()\n",
+    "        p_sim.geometry.stack = soi\n",
+    "        p_sim.solver.resolution = RESOLUTION\n",
+    "        p_sim.domain.pml = PML\n",
+    "        p_sim.mode_solver(wavelengths=[WL], band=1, parity=parity)\n",
+    "        r = p_sim.solve_modes().results[0]\n",
+    "        tag = \"guided\" if r.n_eff > _n_sio2(WL) else \"leaky\"\n",
+    "        print(f\"  {parity:10s}: n_eff={r.n_eff:.6f}  ({tag})\")\n",
+    "    except RuntimeError as exc:\n",
+    "        print(f\"  {parity:10s}: not found ({exc})\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "be9df683",
+   "metadata": {},
+   "source": [
+    "## Part 4 — Validation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b586603",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "source": [
+    "### Analytical SOI slab benchmark\n",
+    "\n",
+    "Validate against the analytical transcendental equation for a symmetric\n",
+    "dielectric slab waveguide.\n",
+    "\n",
+    "**Structure:** Si core (n=3.4777), thickness 220 nm, SiO2 cladding (n=1.4440).\n",
+    "\n",
+    "**Even:**  $\\tan(\\kappa t/2) = \\gamma / \\kappa$\n",
+    "**Odd:**   $\\tan(\\kappa t/2) = -\\kappa / \\gamma$\n",
+    "\n",
+    "where $\\kappa = \\sqrt{n_\\mathrm{core}^2 k_0^2 - \\beta^2}$,\n",
+    "$\\gamma = \\sqrt{\\beta^2 - n_\\mathrm{clad}^2 k_0^2}$,\n",
+    "$k_0 = 2\\pi/\\lambda$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "c9f5cf20",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Analytical TE slab modes (Si 220nm / SiO2):\n",
+      "  TE0: n_eff = 2.849464\n"
+     ]
+    }
+   ],
+   "source": [
+    "def solve_slab_analytical(\n",
+    "    wavelength: float,\n",
+    "    n_core: float,\n",
+    "    n_clad: float,\n",
+    "    t_core: float,\n",
+    "    polarization: str = \"TE\",\n",
+    ") -> dict[int, float]:\n",
+    "    \"\"\"Solve the symmetric slab transcendental equation.\n",
+    "\n",
+    "    Args:\n",
+    "        wavelength: Free-space wavelength (um).\n",
+    "        n_core: Core refractive index.\n",
+    "        n_clad: Cladding refractive index.\n",
+    "        t_core: Core thickness (um).\n",
+    "        polarization: ``\"TE\"`` or ``\"TM\"``.\n",
+    "\n",
+    "    Returns:\n",
+    "        Dict mapping mode number (0=fundamental) to n_eff.\n",
+    "    \"\"\"\n",
+    "    k0 = 2.0 * np.pi / wavelength\n",
+    "\n",
+    "    def _te_even(beta: float) -> float:\n",
+    "        kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))\n",
+    "        gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))\n",
+    "        if kappa == 0:\n",
+    "            return -1e6\n",
+    "        return np.tan(kappa * t_core / 2) - gamma / kappa\n",
+    "\n",
+    "    def _te_odd(beta: float) -> float:\n",
+    "        kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))\n",
+    "        gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))\n",
+    "        if gamma == 0:\n",
+    "            return -1e6\n",
+    "        return np.tan(kappa * t_core / 2) + kappa / gamma\n",
+    "\n",
+    "    if polarization == \"TE\":\n",
+    "        fns = [_te_even, _te_odd]\n",
+    "    else:\n",
+    "\n",
+    "        def _tm_even(beta: float) -> float:\n",
+    "            kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))\n",
+    "            gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))\n",
+    "            if kappa == 0:\n",
+    "                return -1e6\n",
+    "            return np.tan(kappa * t_core / 2) - gamma / kappa * (n_core / n_clad) ** 2\n",
+    "\n",
+    "        def _tm_odd(beta: float) -> float:\n",
+    "            kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))\n",
+    "            gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))\n",
+    "            if gamma == 0:\n",
+    "                return -1e6\n",
+    "            return np.tan(kappa * t_core / 2) + kappa / gamma * (n_clad / n_core) ** 2\n",
+    "\n",
+    "        fns = [_tm_even, _tm_odd]\n",
+    "\n",
+    "    beta_min = n_clad * k0\n",
+    "    beta_max = n_core * k0\n",
+    "\n",
+    "    results: dict[int, float] = {}\n",
+    "    mode_idx = 0\n",
+    "    for fn in fns:\n",
+    "        betas = np.linspace(beta_min + 1e-4, beta_max - 1e-4, 10000)\n",
+    "        vals = np.array([fn(b) for b in betas])\n",
+    "        sign_changes = np.where(np.diff(np.signbit(vals)))[0]\n",
+    "        for si in sign_changes:\n",
+    "            b_lo = betas[si]\n",
+    "            b_hi = betas[min(si + 1, len(betas) - 1)]\n",
+    "            try:\n",
+    "                from scipy.optimize import bisect\n",
+    "\n",
+    "                beta_root = bisect(fn, b_lo, b_hi, xtol=1e-12)\n",
+    "                n_eff = beta_root / k0\n",
+    "\n",
+    "                kappa = np.sqrt(max(n_core**2 * k0**2 - beta_root**2, 0))\n",
+    "                gamma = np.sqrt(max(beta_root**2 - n_clad**2 * k0**2, 0))\n",
+    "                if gamma <= 0 or kappa <= 0:\n",
+    "                    continue\n",
+    "                kt2 = kappa * t_core / 2.0\n",
+    "                if abs(np.tan(kt2)) > 1e4:\n",
+    "                    continue\n",
+    "\n",
+    "                if n_eff not in results.values():\n",
+    "                    results[mode_idx] = n_eff\n",
+    "                    mode_idx += 1\n",
+    "            except Exception:\n",
+    "                pass\n",
+    "\n",
+    "    return results\n",
+    "\n",
+    "\n",
+    "def _analytical_ngroup(\n",
+    "    wavelength: float,\n",
+    "    n_core: float,\n",
+    "    n_clad: float,\n",
+    "    t_core: float,\n",
+    "    polarization: str = \"TE\",\n",
+    ") -> dict[int, float]:\n",
+    "    \"\"\"Group index from analytic derivative of the characteristic equation.\n",
+    "\n",
+    "    Uses implicit differentiation: n_g = dbeta/dk0 = -dF/dk0 / dF/dbeta.\n",
+    "    \"\"\"\n",
+    "    k0 = 2.0 * np.pi / wavelength\n",
+    "    n1, n2 = n_core, n_clad\n",
+    "    t = t_core\n",
+    "\n",
+    "    if polarization == \"TE\":\n",
+    "\n",
+    "        def _even_fn(beta: float) -> float:\n",
+    "            kappa = np.sqrt(max(n1**2 * k0**2 - beta**2, 0))\n",
+    "            gamma = np.sqrt(max(beta**2 - n2**2 * k0**2, 0))\n",
+    "            if kappa == 0:\n",
+    "                return -1e6\n",
+    "            return kappa * np.tan(kappa * t / 2) - gamma\n",
+    "\n",
+    "        def _odd_fn(beta: float) -> float:\n",
+    "            kappa = np.sqrt(max(n1**2 * k0**2 - beta**2, 0))\n",
+    "            gamma = np.sqrt(max(beta**2 - n2**2 * k0**2, 0))\n",
+    "            if gamma == 0:\n",
+    "                return -1e6\n",
+    "            return gamma * np.tan(kappa * t / 2) + kappa\n",
+    "\n",
+    "        def _te_even_n_g(n_eff: float, kappa: float, gamma: float) -> float:\n",
+    "            k2 = kappa**2\n",
+    "            g2 = gamma**2\n",
+    "            com = gamma / k2 + (t / 2) * (1 + g2 / k2) + 1 / gamma\n",
+    "            num = n1**2 * gamma / k2 + n1**2 * (t / 2) * (1 + g2 / k2) + n2**2 / gamma\n",
+    "            return num / (n_eff * com)\n",
+    "\n",
+    "        def _te_odd_n_g(n_eff: float, kappa: float, gamma: float) -> float:\n",
+    "            k2 = kappa**2\n",
+    "            g2 = gamma**2\n",
+    "            com = kappa / g2 + gamma * t / (2 * kappa) * (1 + k2 / g2) + 1 / kappa\n",
+    "            num = (\n",
+    "                n2**2 * kappa / g2\n",
+    "                + n1**2 * gamma * t / (2 * kappa) * (1 + k2 / g2)\n",
+    "                + n1**2 / kappa\n",
+    "            )\n",
+    "            return num / (n_eff * com)\n",
+    "\n",
+    "        fns = [(_even_fn, _te_even_n_g), (_odd_fn, _te_odd_n_g)]\n",
+    "    else:\n",
+    "        # TM modes not implemented for analytic group index\n",
+    "        return {}\n",
+    "\n",
+    "    beta_min = n2 * k0\n",
+    "    beta_max = n1 * k0\n",
+    "\n",
+    "    results: dict[int, float] = {}\n",
+    "    seen_neff: set[float] = set()\n",
+    "    mode_idx = 0\n",
+    "    for fn, ng_fn in fns:\n",
+    "        betas = np.linspace(beta_min + 1e-4, beta_max - 1e-4, 10000)\n",
+    "        vals = np.array([fn(b) for b in betas])\n",
+    "        sign_changes = np.where(np.diff(np.signbit(vals)))[0]\n",
+    "        for si in sign_changes:\n",
+    "            b_lo = betas[si]\n",
+    "            b_hi = betas[min(si + 1, len(betas) - 1)]\n",
+    "            try:\n",
+    "                from scipy.optimize import bisect\n",
+    "\n",
+    "                beta_root = bisect(fn, b_lo, b_hi, xtol=1e-12)\n",
+    "                n_eff = beta_root / k0\n",
+    "                kappa = np.sqrt(max(n1**2 * k0**2 - beta_root**2, 0))\n",
+    "                gamma = np.sqrt(max(beta_root**2 - n2**2 * k0**2, 0))\n",
+    "                if gamma <= 0 or kappa <= 0:\n",
+    "                    continue\n",
+    "                kt2 = kappa * t / 2.0\n",
+    "                if abs(np.tan(kt2)) > 1e4:\n",
+    "                    continue\n",
+    "                n_eff_rounded = round(n_eff, 10)\n",
+    "                if n_eff_rounded in seen_neff:\n",
+    "                    continue\n",
+    "                seen_neff.add(n_eff_rounded)\n",
+    "                results[mode_idx] = ng_fn(n_eff, kappa, gamma)\n",
+    "                mode_idx += 1\n",
+    "            except Exception:\n",
+    "                pass\n",
+    "\n",
+    "    return results\n",
+    "\n",
+    "\n",
+    "analytical = solve_slab_analytical(\n",
+    "    wavelength=WL, n_core=_n_si(WL), n_clad=_n_sio2(WL), t_core=0.22, polarization=\"TE\"\n",
+    ")\n",
+    "print(\"Analytical TE slab modes (Si 220nm / SiO2):\")\n",
+    "for mode, n_eff in sorted(analytical.items()):\n",
+    "    print(f\"  TE{mode}: n_eff = {n_eff:.6f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "576ae6ca",
+   "metadata": {},
+   "source": [
+    "### Compare MEEP with analytical"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "5fabb5ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MEEP  TE0: n_eff = 2.830654\n",
+      "Anal. TE0: n_eff = 2.849464\n",
+      "Relative error: 6.60e-03\n",
+      "\n",
+      "MEEP  band 2: n_eff = 1.466298\n",
+      "\n",
+      "MEEP  band 3: n_eff = 1.403185\n",
+      "\n",
+      "MEEP  band 4: n_eff = 1.498309\n"
+     ]
+    }
+   ],
+   "source": [
+    "# MEEP fundamental TE0 via Simulation API\n",
+    "meep_sim = gm.Simulation()\n",
+    "meep_sim.geometry.stack = soi\n",
+    "meep_sim.solver.resolution = RESOLUTION\n",
+    "meep_sim.domain.pml = PML\n",
+    "meep_sim.mode_solver(wavelengths=[WL], band=1, parity=\"EVEN_Y\")\n",
+    "r_meep = meep_sim.solve_modes().results[0]\n",
+    "\n",
+    "if 0 in analytical:\n",
+    "    n_analytical = analytical[0]\n",
+    "    rel_error = abs(r_meep.n_eff - n_analytical) / n_analytical\n",
+    "    print(f\"MEEP  TE0: n_eff = {r_meep.n_eff:.6f}\")\n",
+    "    print(f\"Anal. TE0: n_eff = {n_analytical:.6f}\")\n",
+    "    print(f\"Relative error: {rel_error:.2e}\")\n",
+    "else:\n",
+    "    print(\"No analytical TE0 mode found.\")\n",
+    "\n",
+    "# Higher-order modes\n",
+    "meep_sim.mode_solver(wavelengths=[WL]).first(4).at_slab()\n",
+    "higher = meep_sim.solve_modes()\n",
+    "for r in higher.results:\n",
+    "    if r.band_num > 1:\n",
+    "        print(f\"\\nMEEP  band {r.band_num}: n_eff = {r.n_eff:.6f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2686416d",
+   "metadata": {},
+   "source": [
+    "### Wavelength sweep — Meep vs Analytical"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c674050d",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [],
+   "source": [
+    "wl_analytical_neff = [\n",
+    "    solve_slab_analytical(wl, _n_si(wl), _n_sio2(wl), 0.22, \"TE\").get(0)\n",
+    "    for wl in wavelengths\n",
+    "]\n",
+    "wl_analytical_ngroup = [\n",
+    "    _analytical_ngroup(wl, _n_si(wl), _n_sio2(wl), 0.22, \"TE\").get(0)\n",
+    "    for wl in wavelengths\n",
+    "]\n",
+    "\n",
+    "fig, (ax_neff, ax_ng) = plt.subplots(1, 2, figsize=(12, 4.5))\n",
+    "\n",
+    "ax_neff.plot(wavelengths, n_effs, \"o-\", label=\"Meep\", linewidth=1.5)\n",
+    "ax_neff.plot(wavelengths, wl_analytical_neff, \"s--\", label=\"Analytical\", linewidth=1.5)\n",
+    "ax_neff.set_xlabel(\"Wavelength (um)\")\n",
+    "ax_neff.set_ylabel(\"n_eff\")\n",
+    "ax_neff.set_title(\"n_eff — Meep vs Analytical\")\n",
+    "ax_neff.legend()\n",
+    "ax_neff.grid(True, alpha=0.3)\n",
+    "\n",
+    "ax_ng.plot(wavelengths, n_groups, \"o-\", label=\"Meep\", linewidth=1.5)\n",
+    "ax_ng.plot(wavelengths, wl_analytical_ngroup, \"s--\", label=\"Analytical\", linewidth=1.5)\n",
+    "ax_ng.set_xlabel(\"Wavelength (um)\")\n",
+    "ax_ng.set_ylabel(\"n_group\")\n",
+    "ax_ng.set_title(\"n_group — Meep vs Analytical\")\n",
+    "ax_ng.legend()\n",
+    "ax_ng.grid(True, alpha=0.3)\n",
+    "\n",
+    "fig.suptitle(\"SOI slab — wavelength sweep validation\", fontweight=\"bold\")\n",
+    "fig.tight_layout()\n",
+    "\n",
+    "for wl, m_n, m_g, a_n, a_g in zip(\n",
+    "    wavelengths, n_effs, n_groups, wl_analytical_neff, wl_analytical_ngroup\n",
+    "):\n",
+    "    err_n = abs(m_n - a_n) / a_n if a_n else float(\"nan\")\n",
+    "    err_g = abs(m_g - a_g) / a_g if a_g else float(\"nan\")\n",
+    "    print(\n",
+    "        f\"  lambda={wl:.2f} um  \"\n",
+    "        f\" n_eff: M={m_n:.6f} A={a_n:.6f} err={err_n:.2e}  \"\n",
+    "        f\" n_group: M={m_g} A={a_g} err={err_g:.2e}\"\n",
+    "        if a_g\n",
+    "        else f\" n_group: M={m_g} A=None\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c97718e-c161-4f1c-ae27-7073197eded0",
+   "metadata": {
+    "lines_to_next_cell": 0
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd72802d",
+   "metadata": {},
+   "source": [
+    "## Part 5 — Parameter Studies\n",
+    "\n",
+    "### Core thickness sweep\n",
+    "\n",
+    "Vary the silicon core thickness and re-solve the slab mode. Thicker\n",
+    "cores -> higher confinement -> larger n_eff."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11bbfd3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thicknesses = [0.15, 0.18, 0.22, 0.25, 0.30, 0.35, 0.40]\n",
+    "\n",
+    "n_eff_thick: list[float] = []\n",
+    "n_group_thick: list[float | None] = []\n",
+    "analytical_thick = [\n",
+    "    solve_slab_analytical(WL, _n_si(WL), _n_sio2(WL), t, \"TE\").get(0)\n",
+    "    for t in thicknesses\n",
+    "]\n",
+    "analytical_ng_thick = [\n",
+    "    _analytical_ngroup(WL, _n_si(WL), _n_sio2(WL), t, \"TE\").get(0) for t in thicknesses\n",
+    "]\n",
+    "\n",
+    "\n",
+    "for t, m_n, a_n, m_g, a_g in zip(\n",
+    "    thicknesses, n_eff_thick, analytical_thick, n_group_thick, analytical_ng_thick\n",
+    "):\n",
+    "    err_n = abs(m_n - a_n) / a_n if a_n else float(\"nan\")\n",
+    "    err_g = abs(m_g - a_g) / a_g if a_g else float(\"nan\")\n",
+    "    print(\n",
+    "        f\"  t_Si={t:.2f} um  \"\n",
+    "        f\" n_eff: M={m_n:.6f} A={a_n:.6f} err={err_n:.2e}  \"\n",
+    "        f\" n_group: M={m_g} A={a_g:.6f} err={err_g:.2e}\"\n",
+    "        if a_g\n",
+    "        else f\" n_group: M={m_g} A=None\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "for t in thicknesses:\n",
+    "    wg = _make_soi_stack(t)\n",
+    "    ts = gm.Simulation()\n",
+    "    ts.geometry.stack = wg\n",
+    "    ts.solver.resolution = RESOLUTION\n",
+    "    ts.domain.pml = PML\n",
+    "    ts.mode_solver(wavelengths=[WL], band=1, parity=\"NO_PARITY\")\n",
+    "    r = ts.solve_modes().results[0]\n",
+    "    n_eff_thick.append(r.n_eff)\n",
+    "    n_group_thick.append(r.n_group)\n",
+    "    print(f\"  t_Si = {t:.2f} um -> n_eff = {r.n_eff:.6f}, n_group = {r.n_group}\")\n",
+    "\n",
+    "\n",
+    "fig, (ax_neff, ax_ng) = plt.subplots(1, 2, figsize=(12, 4.5))\n",
+    "\n",
+    "ax_neff.plot(thicknesses, n_eff_thick, \"o-\", label=\"Meep\", linewidth=1.5)\n",
+    "ax_neff.plot(thicknesses, analytical_thick, \"s--\", label=\"Analytical\", linewidth=1.5)\n",
+    "ax_neff.set_xlabel(\"Si core thickness (um)\")\n",
+    "ax_neff.set_ylabel(\"n_eff\")\n",
+    "ax_neff.set_title(\"n_eff — Meep vs Analytical\")\n",
+    "ax_neff.legend()\n",
+    "ax_neff.grid(True, alpha=0.3)\n",
+    "\n",
+    "ax_ng.plot(thicknesses, n_group_thick, \"o-\", label=\"Meep\", linewidth=1.5)\n",
+    "ax_ng.plot(thicknesses, analytical_ng_thick, \"s--\", label=\"Analytical\", linewidth=1.5)\n",
+    "ax_ng.set_xlabel(\"Si core thickness (um)\")\n",
+    "ax_ng.set_ylabel(\"n_group\")\n",
+    "ax_ng.set_title(\"n_group — Meep vs Analytical\")\n",
+    "ax_ng.legend()\n",
+    "ax_ng.grid(True, alpha=0.3)\n",
+    "\n",
+    "fig.suptitle(\"SOI slab — thickness sweep validation\", fontweight=\"bold\")\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6647a22",
+   "metadata": {},
+   "source": [
+    "### Summary\n",
+    "\n",
+    "| Feature | API |\n",
+    "|---|---|\n",
+    "| Slab modes (1D) | `sim.mode_solver(wavelengths=[1.55]); sim.solve_modes()` |\n",
+    "| Field profiles | `sim.mode_solver(n_field_z=...); r.fields[\"Ey\"]` |\n",
+    "| Z-grid utility | `gm.mode_z_grid(stack, n_points)` |\n",
+    "| Index profile | `gm.refractive_index_profile(stack, z_grid, wavelength)` |\n",
+    "| Dispersion sweep | `sim.mode_solver.sweep_wavelength(start, stop, n)` |\n",
+    "| Group index | `r.n_group` — direct from `mode.group_velocity` |\n",
+    "| Analytical group index | `_analytical_ngroup(wl, n_core, n_clad, t, pol)` — implicit diff |\n",
+    "| Multi-band | `sim.mode_solver.first(4)` or `num_bands=4` |\n",
+    "| Parity modes | `sim.mode_solver(parity=\"EVEN_Y\", …)` |\n",
+    "| Core thickness sweep | Vary `layer.thickness` -> new sim -> `n_eff(t)` |\n",
+    "| Analytical validation | Transcendental eq + dispersive n(lambda) from gsim Sellmeier models |\n",
+    "| Wavelength sweep validation | Meep vs analytical — n_eff + n_group over wavelength |\n",
+    "| Thickness sweep validation | Meep vs analytical — n_eff + n_group over core thickness |\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/nbs/_meep_mode_solver_soi.py b/nbs/_meep_mode_solver_soi.py
new file mode 100644
index 0000000..f104602
--- /dev/null
+++ b/nbs/_meep_mode_solver_soi.py
@@ -0,0 +1,719 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.2
+#   kernelspec:
+#     display_name: Python 3 (ipykernel)
+#     language: python
+#     name: python3
+# ---
+
+# %% [markdown]
+# # MEEP Eigenmode Solver — 1D Slab Modes
+#
+# Solve **1D slab modes** declaratively with the `Simulation` API.
+# Operations run locally via MEEP — no cloud required.
+#
+# **API overview:**
+#
+# | API | What it does |
+# |---|---|
+# | `sim.mode_solver(wavelengths=[1.55])` | Configure eigenmode solver |
+# | `sim.solve_modes()` | Run solver, return `ModeSweepResult` |
+# | `sweep.results` | List of `ModeResult` (`.n_eff`, `.fields`, `.kdom`, `.n_group`, …) |
+# | `mode_z_grid(stack, ...)` | Z-axis coordinates for field arrays |
+# | `refractive_index_profile(stack, ...)` | n(z) from the layer stack |
+
+# %% [markdown]
+# ## Part 1 — Quick Start
+
+# %%
+import matplotlib.pyplot as plt
+import numpy as np
+
+import gsim.meep as gm
+from gsim.common.stack.extractor import Layer, LayerStack
+
+HAS_MEEP = False
+try:
+    import meep as mp
+
+    HAS_MEEP = True
+    print(f"MEEP {mp.__version__} ready")
+except ImportError as err:
+    raise SystemExit(
+        "MEEP not found. Install it via conda-forge:\n"
+        "    conda install -c conda-forge pymeep"
+    ) from err
+
+RESOLUTION = 128
+WL = 1.55
+PML = 1.6
+n_points = 1000
+
+import math
+
+from gsim.common.stack.materials import resolve_material_at_wavelength
+
+
+def _n_si(wl_um: float) -> float:
+    """Si refractive index from gsim Sellmeier model (Salzberg & Villa 1957)."""
+    return math.sqrt(resolve_material_at_wavelength("si", wl_um).permittivity_scalar)
+
+
+def _n_sio2(wl_um: float) -> float:
+    """SiO2 refractive index from gsim Sellmeier model (Malitson 1965)."""
+    return math.sqrt(resolve_material_at_wavelength("sio2", wl_um).permittivity_scalar)
+
+
+def _make_soi_stack(t_si: float) -> LayerStack:
+    """Build a symmetric SOI slab stack: SiO2 / Si / SiO2."""
+    t_sio2 = 1.6
+    return LayerStack(
+        layers={
+            "box": Layer(
+                name="box",
+                gds_layer=(0, 0),
+                zmin=-t_sio2,
+                zmax=0.0,
+                thickness=t_sio2,
+                material="sio2",
+                layer_type="dielectric",
+            ),
+            "core": Layer(
+                name="core",
+                gds_layer=(1, 0),
+                zmin=0.0,
+                zmax=t_si,
+                thickness=t_si,
+                material="si",
+                layer_type="dielectric",
+            ),
+            "clad": Layer(
+                name="clad",
+                gds_layer=(2, 0),
+                zmin=t_si,
+                zmax=t_si + t_sio2,
+                thickness=t_sio2,
+                material="sio2",
+                layer_type="dielectric",
+            ),
+        }
+    )
+
+
+soi = _make_soi_stack(0.22)
+stack = soi
+
+# %%
+sim = gm.Simulation()
+sim.geometry.stack = stack
+sim.solver.resolution = RESOLUTION
+sim.domain.pml = PML
+sim.mode_solver(wavelengths=[WL], num_bands=1, parity="NO_PARITY")
+
+sweep = sim.solve_modes()
+r = sweep.results[0]
+
+print(f"n_eff   = {r.n_eff:.6f}")
+print(f"n_group = {r.n_group}")
+print(f"kdom    = {[f'{k:.6f}' for k in r.kdom]}")
+print(f"band    = {r.band_num}, parity = {r.parity}")
+
+# %% [markdown]
+# ## Part 2 — Mode Results
+
+# %% [markdown]
+# ### ModeResult fields
+#
+# `ModeResult` is a Pydantic model:
+#
+# | Attribute | Type | Description |
+# |---|---|---|
+# | `n_eff` | `float` | Effective index |
+# | `wavelength` | `float` | Free-space wavelength (um) |
+# | `fields` | `dict[str, np.ndarray]` | Complex field arrays keyed by component |
+# | `kdom` | `list[float]` | Dominant wavevector [kx, ky, kz] |
+# | `n_group` | `float \| None` | Group index (from `mode.group_velocity`) |
+# | `band_num` | `int` | Mode band index (1 = fundamental) |
+# | `parity` | `str` | Parity constraint used |
+
+# %%
+sim.mode_solver(n_field_z=n_points)
+sweep = sim.solve_modes()
+r = sweep.results[0]
+
+for comp, arr in r.fields.items():
+    print(f"{comp}: shape={arr.shape}, |max|={np.abs(arr).max():.6f}")
+
+# %% [markdown]
+# ### Z-grid and refractive index profile
+
+# %%
+z_um = gm.mode_z_grid(stack, n_points=n_points, pml_thickness=PML)
+n_profile = gm.refractive_index_profile(stack, WL, z_grid=z_um)
+
+print(f"Z grid: {z_um[0]:.4f} ... {z_um[-1]:.4f} um  ({len(z_um)} points)")
+print(f"Index range: {n_profile.min():.4f} - {n_profile.max():.4f}")
+
+# %% [markdown]
+# ### Mode profile with index overlay
+
+# %%
+sim.mode_solver(n_field_z=n_points)
+sweep = sim.solve_modes()
+r = sweep.results[0]
+
+z_slab = gm.mode_z_grid(stack, n_points=n_points, pml_thickness=PML)
+n_prof = gm.refractive_index_profile(stack, WL, z_grid=z_slab)
+dom_comp = max(r.fields, key=lambda k: np.abs(r.fields[k]).max())
+
+fig, ax = plt.subplots(figsize=(7, 4))
+field = r.fields[dom_comp]
+ax.plot(z_slab, abs(field), color="C0", linewidth=1.5, label=f"|{dom_comp}|")
+ax.plot(
+    z_slab,
+    field.real,
+    color="C0",
+    alpha=0.35,
+    linestyle="--",
+    linewidth=1,
+    label=f"Re({dom_comp})",
+)
+ax.plot(
+    z_slab,
+    field.imag,
+    color="C0",
+    alpha=0.35,
+    linestyle=":",
+    linewidth=1,
+    label=f"Im({dom_comp})",
+)
+ax.set_xlabel("z (um)")
+ax.set_ylabel("Field amplitude (arb. units)")
+
+ax_idx = ax.twinx()
+ax_idx.plot(z_slab, n_prof, color="C3", linewidth=1.5, label="n(z)")
+ax_idx.set_ylabel("Refractive index")
+ax_idx.set_ylim(bottom=0.8)
+
+ax.set_title(
+    f"Mode profile - {dom_comp}  (lambda={r.wavelength:.2f} um, n_eff={r.n_eff:.4f})"
+)
+ax.grid(True, alpha=0.2)
+fig.tight_layout()
+
+# %% [markdown]
+# ### Field component grid
+
+# %%
+comps = sorted(
+    r.fields.keys(),
+    key=lambda c: "ExEyEzHxHyHz".index(c) if c in "ExEyEzHxHyHz" else 99,
+)
+n_cols = min(3, len(comps))
+n_rows = (len(comps) + n_cols - 1) // n_cols
+
+fig, axes = plt.subplots(
+    n_rows, n_cols, figsize=(4 * n_cols, 3 * n_rows), squeeze=False
+)
+for idx, comp in enumerate(comps):
+    ax = axes[idx // n_cols][idx % n_cols]
+    ax.plot(z_slab, np.abs(r.fields[comp]), linewidth=1.2, label=f"|{comp}|")
+    ax.set_title(comp)
+    ax.set_xlabel("z (um)")
+    ax.set_ylabel("Amplitude")
+    ax.grid(True, alpha=0.2)
+
+for idx in range(len(comps), n_rows * n_cols):
+    axes[idx // n_cols][idx % n_cols].set_visible(False)
+
+fig.suptitle(
+    f"Field components - slab mode  lambda={r.wavelength:.2f} um", fontweight="bold"
+)
+fig.tight_layout()
+
+# %% [markdown]
+# ## Part 3 — Advanced
+
+# %% [markdown]
+# ### Wavelength sweep & dispersion
+#
+# `mode_solver.sweep_wavelength(start, stop, num)` populates the wavelength
+# list linearly.  Multiple wavelengths + single band dispatches to the
+# efficient shared-cell sweep internally.
+
+# %%
+sim.mode_solver.sweep_wavelength(1.50, 1.60, 7)
+sweep = sim.solve_modes()
+
+# sweep.results are ordered by wavelength ascending
+wl_results = {r.wavelength: r for r in sweep.results}
+wavelengths = sorted(wl_results)
+n_effs = [wl_results[wl].n_eff for wl in wavelengths]
+n_groups = [wl_results[wl].n_group for wl in wavelengths]
+
+for wl in wavelengths:
+    print(
+        f"  lambda = {wl:.2f} um -> n_eff = {wl_results[wl].n_eff:.6f}, n_group = {wl_results[wl].n_group}"
+    )
+
+
+# %% [markdown]
+# ### Multi-band modes
+#
+# The symmetric SOI slab (Si 220 nm core, SiO2 cladding) at lambda=1.55 um
+# has V-parameter ~ 1.41 -- supports a single TE mode (TE0).
+# Bands beyond 1 are **leaky / radiation modes**: MEEP's MPB omega-solve
+# can converge to them because the finite PML-bounded cell discretises
+# the radiation continuum.  The library logs a warning for modes with
+# ``n_eff`` below the minimum cladding index.
+
+# %%
+V_param = (2 * np.pi / WL) * 0.22 / 2 * np.sqrt(_n_si(WL) ** 2 - _n_sio2(WL) ** 2)
+print(
+    f"V-parameter = {V_param:.3f}  ->  {max(1, int(2 * V_param / np.pi) + 1)} guided TE mode(s)"
+)
+
+soi_sim = gm.Simulation()
+soi_sim.geometry.stack = soi
+soi_sim.solver.resolution = RESOLUTION
+soi_sim.domain.pml = PML
+soi_sim.mode_solver(wavelengths=[WL]).first(4)
+band_sweep = soi_sim.solve_modes()
+
+band_results = {r.band_num: r for r in band_sweep.results}
+for band, r in sorted(band_results.items()):
+    tag = "GUIDED" if r.n_eff > _n_sio2(WL) else "LEAKY"
+    print(
+        f"  band {band}: n_eff={r.n_eff:.6f}  ({tag})  n_group={r.n_group}  kdom={[f'{k:.4f}' for k in r.kdom[:2]]}..."
+    )
+
+# %% [markdown]
+# ### Multi-band field profiles
+
+# %%
+soi_sim.mode_solver(n_field_z=n_points)
+band_sweep = soi_sim.solve_modes()
+band_results = {r.band_num: r for r in band_sweep.results}
+
+zz = gm.mode_z_grid(soi, n_points=n_points, pml_thickness=PML)
+
+for comp in ("Ex", "Ey", "Ez", "Hx", "Hy", "Hz"):
+    fig, ax = plt.subplots(figsize=(7, 4))
+    for band, r in sorted(band_results.items()):
+        if comp in r.fields:
+            tag = "guided" if r.n_eff > _n_sio2(WL) else "leaky"
+            ax.plot(
+                zz,
+                abs(r.fields[comp]),
+                linewidth=1.3,
+                label=f"band {band} ({tag}) n={r.n_eff:.4f}",
+            )
+    ax.set_xlabel("z (um)")
+    ax.set_ylabel(f"|{comp}| (arb. units)")
+    ax.set_title("Multi-band slab modes - SOI 220 nm")
+    ax.legend(fontsize="small", loc="upper right")
+    ax.grid(True, alpha=0.2)
+    fig.tight_layout()
+
+# %% [markdown]
+# ### Parity modes
+#
+# MEEP's eigenmode solver supports parity constraints along Y and Z.
+# For the symmetric SOI slab, ``EVEN_Y`` selects TE0.  ``ODD_Y`` selects
+# the first odd-symmetry mode -- leaky if V < pi/2 ~ 1.57.
+
+# %%
+parities = ["NO_PARITY", "EVEN_Y", "ODD_Y"]
+for parity in parities:
+    try:
+        p_sim = gm.Simulation()
+        p_sim.geometry.stack = soi
+        p_sim.solver.resolution = RESOLUTION
+        p_sim.domain.pml = PML
+        p_sim.mode_solver(wavelengths=[WL], band=1, parity=parity)
+        r = p_sim.solve_modes().results[0]
+        tag = "guided" if r.n_eff > _n_sio2(WL) else "leaky"
+        print(f"  {parity:10s}: n_eff={r.n_eff:.6f}  ({tag})")
+    except RuntimeError as exc:
+        print(f"  {parity:10s}: not found ({exc})")
+
+# %% [markdown]
+# ## Part 4 — Validation
+
+# %% [markdown]
+# ### Analytical SOI slab benchmark
+#
+# Validate against the analytical transcendental equation for a symmetric
+# dielectric slab waveguide.
+#
+# **Structure:** Si core (n=3.4777), thickness 220 nm, SiO2 cladding (n=1.4440).
+#
+# **Even:**  $\tan(\kappa t/2) = \gamma / \kappa$
+# **Odd:**   $\tan(\kappa t/2) = -\kappa / \gamma$
+#
+# where $\kappa = \sqrt{n_\mathrm{core}^2 k_0^2 - \beta^2}$,
+# $\gamma = \sqrt{\beta^2 - n_\mathrm{clad}^2 k_0^2}$,
+# $k_0 = 2\pi/\lambda$
+
+
+# %%
+def solve_slab_analytical(
+    wavelength: float,
+    n_core: float,
+    n_clad: float,
+    t_core: float,
+    polarization: str = "TE",
+) -> dict[int, float]:
+    """Solve the symmetric slab transcendental equation.
+
+    Args:
+        wavelength: Free-space wavelength (um).
+        n_core: Core refractive index.
+        n_clad: Cladding refractive index.
+        t_core: Core thickness (um).
+        polarization: ``"TE"`` or ``"TM"``.
+
+    Returns:
+        Dict mapping mode number (0=fundamental) to n_eff.
+    """
+    k0 = 2.0 * np.pi / wavelength
+
+    def _te_even(beta: float) -> float:
+        kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))
+        gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))
+        if kappa == 0:
+            return -1e6
+        return np.tan(kappa * t_core / 2) - gamma / kappa
+
+    def _te_odd(beta: float) -> float:
+        kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))
+        gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))
+        if gamma == 0:
+            return -1e6
+        return np.tan(kappa * t_core / 2) + kappa / gamma
+
+    if polarization == "TE":
+        fns = [_te_even, _te_odd]
+    else:
+
+        def _tm_even(beta: float) -> float:
+            kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))
+            gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))
+            if kappa == 0:
+                return -1e6
+            return np.tan(kappa * t_core / 2) - gamma / kappa * (n_core / n_clad) ** 2
+
+        def _tm_odd(beta: float) -> float:
+            kappa = np.sqrt(max(n_core**2 * k0**2 - beta**2, 0))
+            gamma = np.sqrt(max(beta**2 - n_clad**2 * k0**2, 0))
+            if gamma == 0:
+                return -1e6
+            return np.tan(kappa * t_core / 2) + kappa / gamma * (n_clad / n_core) ** 2
+
+        fns = [_tm_even, _tm_odd]
+
+    beta_min = n_clad * k0
+    beta_max = n_core * k0
+
+    results: dict[int, float] = {}
+    mode_idx = 0
+    for fn in fns:
+        betas = np.linspace(beta_min + 1e-4, beta_max - 1e-4, 10000)
+        vals = np.array([fn(b) for b in betas])
+        sign_changes = np.where(np.diff(np.signbit(vals)))[0]
+        for si in sign_changes:
+            b_lo = betas[si]
+            b_hi = betas[min(si + 1, len(betas) - 1)]
+            try:
+                from scipy.optimize import bisect
+
+                beta_root = bisect(fn, b_lo, b_hi, xtol=1e-12)
+                n_eff = beta_root / k0
+
+                kappa = np.sqrt(max(n_core**2 * k0**2 - beta_root**2, 0))
+                gamma = np.sqrt(max(beta_root**2 - n_clad**2 * k0**2, 0))
+                if gamma <= 0 or kappa <= 0:
+                    continue
+                kt2 = kappa * t_core / 2.0
+                if abs(np.tan(kt2)) > 1e4:
+                    continue
+
+                if n_eff not in results.values():
+                    results[mode_idx] = n_eff
+                    mode_idx += 1
+            except Exception:
+                pass
+
+    return results
+
+
+def _analytical_ngroup(
+    wavelength: float,
+    n_core: float,
+    n_clad: float,
+    t_core: float,
+    polarization: str = "TE",
+) -> dict[int, float]:
+    """Group index from analytic derivative of the characteristic equation.
+
+    Uses implicit differentiation: n_g = dbeta/dk0 = -dF/dk0 / dF/dbeta.
+    """
+    k0 = 2.0 * np.pi / wavelength
+    n1, n2 = n_core, n_clad
+    t = t_core
+
+    if polarization == "TE":
+
+        def _even_fn(beta: float) -> float:
+            kappa = np.sqrt(max(n1**2 * k0**2 - beta**2, 0))
+            gamma = np.sqrt(max(beta**2 - n2**2 * k0**2, 0))
+            if kappa == 0:
+                return -1e6
+            return kappa * np.tan(kappa * t / 2) - gamma
+
+        def _odd_fn(beta: float) -> float:
+            kappa = np.sqrt(max(n1**2 * k0**2 - beta**2, 0))
+            gamma = np.sqrt(max(beta**2 - n2**2 * k0**2, 0))
+            if gamma == 0:
+                return -1e6
+            return gamma * np.tan(kappa * t / 2) + kappa
+
+        def _te_even_n_g(n_eff: float, kappa: float, gamma: float) -> float:
+            k2 = kappa**2
+            g2 = gamma**2
+            com = gamma / k2 + (t / 2) * (1 + g2 / k2) + 1 / gamma
+            num = n1**2 * gamma / k2 + n1**2 * (t / 2) * (1 + g2 / k2) + n2**2 / gamma
+            return num / (n_eff * com)
+
+        def _te_odd_n_g(n_eff: float, kappa: float, gamma: float) -> float:
+            k2 = kappa**2
+            g2 = gamma**2
+            com = kappa / g2 + gamma * t / (2 * kappa) * (1 + k2 / g2) + 1 / kappa
+            num = (
+                n2**2 * kappa / g2
+                + n1**2 * gamma * t / (2 * kappa) * (1 + k2 / g2)
+                + n1**2 / kappa
+            )
+            return num / (n_eff * com)
+
+        fns = [(_even_fn, _te_even_n_g), (_odd_fn, _te_odd_n_g)]
+    else:
+        # TM modes not implemented for analytic group index
+        return {}
+
+    beta_min = n2 * k0
+    beta_max = n1 * k0
+
+    results: dict[int, float] = {}
+    seen_neff: set[float] = set()
+    mode_idx = 0
+    for fn, ng_fn in fns:
+        betas = np.linspace(beta_min + 1e-4, beta_max - 1e-4, 10000)
+        vals = np.array([fn(b) for b in betas])
+        sign_changes = np.where(np.diff(np.signbit(vals)))[0]
+        for si in sign_changes:
+            b_lo = betas[si]
+            b_hi = betas[min(si + 1, len(betas) - 1)]
+            try:
+                from scipy.optimize import bisect
+
+                beta_root = bisect(fn, b_lo, b_hi, xtol=1e-12)
+                n_eff = beta_root / k0
+                kappa = np.sqrt(max(n1**2 * k0**2 - beta_root**2, 0))
+                gamma = np.sqrt(max(beta_root**2 - n2**2 * k0**2, 0))
+                if gamma <= 0 or kappa <= 0:
+                    continue
+                kt2 = kappa * t / 2.0
+                if abs(np.tan(kt2)) > 1e4:
+                    continue
+                n_eff_rounded = round(n_eff, 10)
+                if n_eff_rounded in seen_neff:
+                    continue
+                seen_neff.add(n_eff_rounded)
+                results[mode_idx] = ng_fn(n_eff, kappa, gamma)
+                mode_idx += 1
+            except Exception:
+                pass
+
+    return results
+
+
+analytical = solve_slab_analytical(
+    wavelength=WL, n_core=_n_si(WL), n_clad=_n_sio2(WL), t_core=0.22, polarization="TE"
+)
+print("Analytical TE slab modes (Si 220nm / SiO2):")
+for mode, n_eff in sorted(analytical.items()):
+    print(f"  TE{mode}: n_eff = {n_eff:.6f}")
+
+# %% [markdown]
+# ### Compare MEEP with analytical
+
+# %%
+# MEEP fundamental TE0 via Simulation API
+meep_sim = gm.Simulation()
+meep_sim.geometry.stack = soi
+meep_sim.solver.resolution = RESOLUTION
+meep_sim.domain.pml = PML
+meep_sim.mode_solver(wavelengths=[WL], band=1, parity="EVEN_Y")
+r_meep = meep_sim.solve_modes().results[0]
+
+if 0 in analytical:
+    n_analytical = analytical[0]
+    rel_error = abs(r_meep.n_eff - n_analytical) / n_analytical
+    print(f"MEEP  TE0: n_eff = {r_meep.n_eff:.6f}")
+    print(f"Anal. TE0: n_eff = {n_analytical:.6f}")
+    print(f"Relative error: {rel_error:.2e}")
+else:
+    print("No analytical TE0 mode found.")
+
+# Higher-order modes
+meep_sim.mode_solver(wavelengths=[WL]).first(4).at_slab()
+higher = meep_sim.solve_modes()
+for r in higher.results:
+    if r.band_num > 1:
+        print(f"\nMEEP  band {r.band_num}: n_eff = {r.n_eff:.6f}")
+
+# %% [markdown]
+# ### Wavelength sweep — Meep vs Analytical
+
+# %%
+wl_analytical_neff = [
+    solve_slab_analytical(wl, _n_si(wl), _n_sio2(wl), 0.22, "TE").get(0)
+    for wl in wavelengths
+]
+wl_analytical_ngroup = [
+    _analytical_ngroup(wl, _n_si(wl), _n_sio2(wl), 0.22, "TE").get(0)
+    for wl in wavelengths
+]
+
+fig, (ax_neff, ax_ng) = plt.subplots(1, 2, figsize=(12, 4.5))
+
+ax_neff.plot(wavelengths, n_effs, "o-", label="Meep", linewidth=1.5)
+ax_neff.plot(wavelengths, wl_analytical_neff, "s--", label="Analytical", linewidth=1.5)
+ax_neff.set_xlabel("Wavelength (um)")
+ax_neff.set_ylabel("n_eff")
+ax_neff.set_title("n_eff — Meep vs Analytical")
+ax_neff.legend()
+ax_neff.grid(True, alpha=0.3)
+
+ax_ng.plot(wavelengths, n_groups, "o-", label="Meep", linewidth=1.5)
+ax_ng.plot(wavelengths, wl_analytical_ngroup, "s--", label="Analytical", linewidth=1.5)
+ax_ng.set_xlabel("Wavelength (um)")
+ax_ng.set_ylabel("n_group")
+ax_ng.set_title("n_group — Meep vs Analytical")
+ax_ng.legend()
+ax_ng.grid(True, alpha=0.3)
+
+fig.suptitle("SOI slab — wavelength sweep validation", fontweight="bold")
+fig.tight_layout()
+
+for wl, m_n, m_g, a_n, a_g in zip(
+    wavelengths, n_effs, n_groups, wl_analytical_neff, wl_analytical_ngroup
+):
+    err_n = abs(m_n - a_n) / a_n if a_n else float("nan")
+    err_g = abs(m_g - a_g) / a_g if a_g else float("nan")
+    print(
+        f"  lambda={wl:.2f} um  "
+        f" n_eff: M={m_n:.6f} A={a_n:.6f} err={err_n:.2e}  "
+        f" n_group: M={m_g} A={a_g} err={err_g:.2e}"
+        if a_g
+        else f" n_group: M={m_g} A=None"
+    )
+
+
+# %%
+# %% [markdown]
+# ## Part 5 — Parameter Studies
+#
+# ### Core thickness sweep
+#
+# Vary the silicon core thickness and re-solve the slab mode. Thicker
+# cores -> higher confinement -> larger n_eff.
+
+# %%
+thicknesses = [0.15, 0.18, 0.22, 0.25, 0.30, 0.35, 0.40]
+
+n_eff_thick: list[float] = []
+n_group_thick: list[float | None] = []
+analytical_thick = [
+    solve_slab_analytical(WL, _n_si(WL), _n_sio2(WL), t, "TE").get(0)
+    for t in thicknesses
+]
+analytical_ng_thick = [
+    _analytical_ngroup(WL, _n_si(WL), _n_sio2(WL), t, "TE").get(0) for t in thicknesses
+]
+
+
+for t, m_n, a_n, m_g, a_g in zip(
+    thicknesses, n_eff_thick, analytical_thick, n_group_thick, analytical_ng_thick
+):
+    err_n = abs(m_n - a_n) / a_n if a_n else float("nan")
+    err_g = abs(m_g - a_g) / a_g if a_g else float("nan")
+    print(
+        f"  t_Si={t:.2f} um  "
+        f" n_eff: M={m_n:.6f} A={a_n:.6f} err={err_n:.2e}  "
+        f" n_group: M={m_g} A={a_g:.6f} err={err_g:.2e}"
+        if a_g
+        else f" n_group: M={m_g} A=None"
+    )
+
+
+for t in thicknesses:
+    wg = _make_soi_stack(t)
+    ts = gm.Simulation()
+    ts.geometry.stack = wg
+    ts.solver.resolution = RESOLUTION
+    ts.domain.pml = PML
+    ts.mode_solver(wavelengths=[WL], band=1, parity="NO_PARITY")
+    r = ts.solve_modes().results[0]
+    n_eff_thick.append(r.n_eff)
+    n_group_thick.append(r.n_group)
+    print(f"  t_Si = {t:.2f} um -> n_eff = {r.n_eff:.6f}, n_group = {r.n_group}")
+
+
+fig, (ax_neff, ax_ng) = plt.subplots(1, 2, figsize=(12, 4.5))
+
+ax_neff.plot(thicknesses, n_eff_thick, "o-", label="Meep", linewidth=1.5)
+ax_neff.plot(thicknesses, analytical_thick, "s--", label="Analytical", linewidth=1.5)
+ax_neff.set_xlabel("Si core thickness (um)")
+ax_neff.set_ylabel("n_eff")
+ax_neff.set_title("n_eff — Meep vs Analytical")
+ax_neff.legend()
+ax_neff.grid(True, alpha=0.3)
+
+ax_ng.plot(thicknesses, n_group_thick, "o-", label="Meep", linewidth=1.5)
+ax_ng.plot(thicknesses, analytical_ng_thick, "s--", label="Analytical", linewidth=1.5)
+ax_ng.set_xlabel("Si core thickness (um)")
+ax_ng.set_ylabel("n_group")
+ax_ng.set_title("n_group — Meep vs Analytical")
+ax_ng.legend()
+ax_ng.grid(True, alpha=0.3)
+
+fig.suptitle("SOI slab — thickness sweep validation", fontweight="bold")
+fig.tight_layout()
+
+# %% [markdown]
+# ### Summary
+#
+# | Feature | API |
+# |---|---|
+# | Slab modes (1D) | `sim.mode_solver(wavelengths=[1.55]); sim.solve_modes()` |
+# | Field profiles | `sim.mode_solver(n_field_z=...); r.fields["Ey"]` |
+# | Z-grid utility | `gm.mode_z_grid(stack, n_points)` |
+# | Index profile | `gm.refractive_index_profile(stack, z_grid, wavelength)` |
+# | Dispersion sweep | `sim.mode_solver.sweep_wavelength(start, stop, n)` |
+# | Group index | `r.n_group` — direct from `mode.group_velocity` |
+# | Analytical group index | `_analytical_ngroup(wl, n_core, n_clad, t, pol)` — implicit diff |
+# | Multi-band | `sim.mode_solver.first(4)` or `num_bands=4` |
+# | Parity modes | `sim.mode_solver(parity="EVEN_Y", …)` |
+# | Core thickness sweep | Vary `layer.thickness` -> new sim -> `n_eff(t)` |
+# | Analytical validation | Transcendental eq + dispersive n(lambda) from gsim Sellmeier models |
+# | Wavelength sweep validation | Meep vs analytical — n_eff + n_group over wavelength |
+# | Thickness sweep validation | Meep vs analytical — n_eff + n_group over core thickness |
+#
diff --git a/nbs/_meep_mode_solver_tfln.ipynb b/nbs/_meep_mode_solver_tfln.ipynb
new file mode 100644
index 0000000..155ba60
--- /dev/null
+++ b/nbs/_meep_mode_solver_tfln.ipynb
@@ -0,0 +1,340 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e04e7487",
+   "metadata": {},
+   "source": [
+    "# MEEP Mode Solver - TFLN Ridge Waveguide\n",
+    "\n",
+    "Compute the fundamental TE mode of a **thin-film lithium niobate (TFLN)**\n",
+    "ridge waveguide at lambda = 1.55 um.\n",
+    "\n",
+    "**Reference design** (*Ying Li et al.*, ACS Omega 2023, 8(10), 9644--9651):\n",
+    " - SiO2 cladding everywhere (no Si substrate)\n",
+    " - LiNbO3 slab: 220 nm thick, extends laterally\n",
+    " - LiNbO3 ridge: 180 nm on top of slab -> total 400 nm\n",
+    " - Ridge width w0 = 1.1 um\n",
+    " - Sidewall angle 17deg -> **supported via ``mp.Prism``**\n",
+    "   with native ``sidewall_angle`` parameter (in radians).\n",
+    "   The n_eff difference vs. vertical sidewalls is ~0.0045\n",
+    "   (1.8533 vs 1.8578).\n",
+    "\n",
+    "**Key concept** --- ``background_material=\"sio2\"`` sets the MEEP\n",
+    "``default_material`` to SiO2.  Any\n",
+    "space not covered by an explicit layer is filled with SiO2 instead of air.\n",
+    "\n",
+    "**Expected results**:\n",
+    " - n_eff ~ 1.85 (fundamental TE-like mode, mode_index=0)\n",
+    " - n_group ~ 2.20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37b720a2",
+   "metadata": {},
+   "source": [
+    "### Imports & MEEP check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fda3050b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gdsfactory as gf\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "import gsim.meep as gm\n",
+    "from gsim.common.stack.extractor import Layer, LayerStack\n",
+    "\n",
+    "try:\n",
+    "    import meep as mp\n",
+    "\n",
+    "    print(f\"MEEP {mp.__version__} ready\")\n",
+    "except ImportError as err:\n",
+    "    raise SystemExit(\n",
+    "        \"MEEP not found. Install it via conda-forge:\\n\"\n",
+    "        \"    conda install -c conda-forge pymeep\"\n",
+    "    ) from err\n",
+    "\n",
+    "plt.close()\n",
+    "\n",
+    "gf.gpdk.PDK.activate()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6cf08bd",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "source": [
+    "### LiNbO3 material (Zelmon 1997)\n",
+    "\n",
+    "LiNbO3 is birefringent and is now registered as a uniaxial material\n",
+    "in ``gsim.common.stack.materials.MATERIALS_DB`` (notebook no longer\n",
+    "manually registers it).  Both ordinary and extraordinary Sellmeier\n",
+    "models from Zelmon et al. (JOSA B 14(12), 3319--3322, 1997) are included:\n",
+    "\n",
+    "Ordinary:\n",
+    "  n_o^2 = 1 + 2.6734 lam^2/(lam^2 - 0.01764) + 1.2290 lam^2/(lam^2 - 0.05914)\n",
+    "            + 12.614 lam^2/(lam^2 - 474.60)\n",
+    "\n",
+    "Extraordinary:\n",
+    "  n_e^2 = 1 + 2.9804 lam^2/(lam^2 - 0.02047) + 0.5981 lam^2/(lam^2 - 0.0666)\n",
+    "            + 8.9543 lam^2/(lam^2 - 416.08)\n",
+    "\n",
+    "For x-cut TFLN the TE mode's dominant E-field aligns with the\n",
+    "extraordinary axis (zz)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c447eb0",
+   "metadata": {},
+   "source": [
+    "### Build the GDS component\n",
+    "\n",
+    "Two LiNbO3 layers:\n",
+    " - **Slab** (layer 1,0): wide rectangle (thin-film slab)\n",
+    " - **Ridge** (layer 2,0): narrow rectangle (core on top of slab)\n",
+    "\n",
+    "The SiO2 BOX is provided by ``background_material=\"sio2\"`` --- no\n",
+    "separate GDS layer needed.  Layers without GDS polygons are treated\n",
+    "as full-width backgrounds (``mode_solver.py:434--435``).\n",
+    "\n",
+    "**Sidewall angle note**: set ``sidewall_angle=17.0`` on the ridge\n",
+    ":class:`Layer` to create a trapezoidal ridge cross-section via\n",
+    "``mp.Prism`` with native ``sidewall_angle``."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a627ee4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SLAB_WIDTH = 5.0  # um --- wide slab\n",
+    "CORE_WIDTH = 1.1  # um --- w0 from reference design\n",
+    "LENGTH = 10.0  # um --- waveguide length (arbitrary for mode solving)\n",
+    "\n",
+    "c = gf.Component()\n",
+    "\n",
+    "# LiNbO3 ridge (layer 2) --- narrow core on top\n",
+    "c.add_polygon(\n",
+    "    [\n",
+    "        (-LENGTH / 2, -CORE_WIDTH / 2),\n",
+    "        (LENGTH / 2, -CORE_WIDTH / 2),\n",
+    "        (LENGTH / 2, CORE_WIDTH / 2),\n",
+    "        (-LENGTH / 2, CORE_WIDTH / 2),\n",
+    "    ],\n",
+    "    layer=(2, 0),\n",
+    ")\n",
+    "\n",
+    "# Ports at both ends\n",
+    "c.add_port(\n",
+    "    name=\"o1\",\n",
+    "    center=(-LENGTH / 2, 0),\n",
+    "    width=CORE_WIDTH,\n",
+    "    orientation=180,\n",
+    "    layer=(1, 0),\n",
+    ")\n",
+    "c.add_port(\n",
+    "    name=\"o2\",\n",
+    "    center=(LENGTH / 2, 0),\n",
+    "    width=CORE_WIDTH,\n",
+    "    orientation=0,\n",
+    "    layer=(1, 0),\n",
+    ")\n",
+    "\n",
+    "print(f\"Component: {c.name}\")\n",
+    "print(f\"  Ports:  {[p.name for p in c.ports]}\")\n",
+    "print(f\"  Layers: {list(c.layers)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05ba7ecd",
+   "metadata": {},
+   "source": [
+    "### Layer stack\n",
+    "\n",
+    "Vertical material profile.  SiO2 fills all background space via\n",
+    "``background_material=\"sio2\"``.\n",
+    "\n",
+    "| Region  | Material | Z-range (um)   | GDS layer |\n",
+    "|---------|----------|----------------|-----------|\n",
+    "| Ridge   | LiNbO3   | 0.22 ... 0.40    | (2,0) |\n",
+    "| Slab    | LiNbO3   | 0.00 ... 0.22    | (1,0) |\n",
+    "| BOX     | SiO2     | -2.0 ... 0.0     | (0,0) --- no polygons |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6df05ba5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SLAB_THICKNESS = 0.22  # um  (h3)\n",
+    "CORE_THICKNESS = 0.40  # um --- total LiNbO3 thickness\n",
+    "RIDGE_THICKNESS = CORE_THICKNESS - SLAB_THICKNESS  # 0.18 um\n",
+    "\n",
+    "layers = {\n",
+    "    \"box\": Layer(\n",
+    "        name=\"box\",\n",
+    "        gds_layer=(0, 0),\n",
+    "        zmin=-1.0,\n",
+    "        zmax=0.0,\n",
+    "        thickness=1.0,\n",
+    "        material=\"sio2\",\n",
+    "        layer_type=\"dielectric\",\n",
+    "    ),\n",
+    "    \"slab\": Layer(\n",
+    "        name=\"slab\",\n",
+    "        gds_layer=(1, 0),\n",
+    "        zmin=0.0,\n",
+    "        zmax=SLAB_THICKNESS,\n",
+    "        thickness=SLAB_THICKNESS,\n",
+    "        material=\"linbo3\",\n",
+    "        layer_type=\"dielectric\",\n",
+    "    ),\n",
+    "    \"ridge\": Layer(\n",
+    "        name=\"ridge\",\n",
+    "        gds_layer=(2, 0),\n",
+    "        zmin=SLAB_THICKNESS,\n",
+    "        zmax=CORE_THICKNESS,\n",
+    "        thickness=RIDGE_THICKNESS,\n",
+    "        material=\"linbo3\",\n",
+    "        layer_type=\"dielectric\",\n",
+    "        sidewall_angle=17.0,\n",
+    "    ),\n",
+    "}\n",
+    "stack = LayerStack(layers=layers)\n",
+    "\n",
+    "print(\"Layer stack (+ SiO2 background):\")\n",
+    "for name, l in stack.layers.items():\n",
+    "    print(\n",
+    "        f\"  {name:6s}  z=[{l.zmin:+.3f}, {l.zmax:+.3f}]  \"\n",
+    "        f\"t={l.thickness:.3f}  material={l.material}  gds={l.gds_layer}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1101eb23",
+   "metadata": {},
+   "source": [
+    "### Solve the fundamental TE-like mode\n",
+    "\n",
+    "Use the declarative :class:`Simulation` + :class:`ModeSolver` API.\n",
+    "Grids are auto-constructed from ``y_span``, ``n_field_y``, and\n",
+    "``n_field_z`` settings on the mode solver."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d6c957de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "WAVELENGTH = 1.55  # um\n",
+    "RESOLUTION = 64  # grid points per um\n",
+    "PML_THICKNESS = WAVELENGTH  # um\n",
+    "\n",
+    "sim = gm.Simulation(\n",
+    "    geometry=gm.Geometry(component=c, stack=stack),\n",
+    "    domain=gm.Domain(\n",
+    "        pml=PML_THICKNESS,\n",
+    "        margin_z=(0.0, 0.5),\n",
+    "    ),\n",
+    ")\n",
+    "sim.mode_solver.wavelengths = [WAVELENGTH]\n",
+    "sim.mode_solver.fundamental().at_port(\"o1\")\n",
+    "sim.mode_solver.y_span = SLAB_WIDTH\n",
+    "sim.mode_solver.n_field_y = 1000\n",
+    "sim.mode_solver.n_field_z = 1000\n",
+    "sim.mode_solver.background_material = \"sio2\"\n",
+    "\n",
+    "sweep = sim.solve_modes()\n",
+    "mode = sweep.at(WAVELENGTH).band(1)\n",
+    "\n",
+    "print(f\"n_eff     = {mode.n_eff}\")\n",
+    "print(f\"n_group   = {mode.n_group}\")\n",
+    "print(f\"kdom      = {[f'{k:.6f}' for k in mode.kdom]}\")\n",
+    "print(f\"band      = {mode.band_num}, parity = {mode.parity}\")\n",
+    "print(f\"fields    = {list(mode.fields.keys())}\")\n",
+    "for comp, arr in mode.fields.items():\n",
+    "    print(f\"  {comp}: shape={arr.shape}  |max|={np.abs(arr).max():.6f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "352da39e",
+   "metadata": {},
+   "source": [
+    "### Refractive index profile\n",
+    "\n",
+    "Use ``ModeResult.plot_index()`` which auto-computes ``n`` from the\n",
+    "stored :class:`LayerStack` and grid arrays."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76005c3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mode.plot_index(show=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c215543",
+   "metadata": {},
+   "source": [
+    "### 2D mode profile — all field components\n",
+    "\n",
+    "Use ``ModeResult.plot_mode()`` with ``components=\"all\"`` and\n",
+    "``geometry=True`` to overlay structural geometry boundaries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6c39c87f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mode.plot_mode(\n",
+    "    components=\"all\",\n",
+    "    norm=\"abs\",\n",
+    "    geometry=True,\n",
+    "    suptitle=(\n",
+    "        f\"TFLN ridge waveguide fundamental TE mode\\n\"\n",
+    "        f\"(λ={WAVELENGTH:.2f} µm, w0={CORE_WIDTH:.1f} µm, \"\n",
+    "        f\"h_slab={SLAB_THICKNESS * 1000:.0f} nm, h_ridge={RIDGE_THICKNESS * 1000:.0f} nm, \"\n",
+    "        f\"bg=SiO2)\"\n",
+    "    ),\n",
+    "    show=True,\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/nbs/_meep_mode_solver_tfln.py b/nbs/_meep_mode_solver_tfln.py
new file mode 100644
index 0000000..6dc9aa4
--- /dev/null
+++ b/nbs/_meep_mode_solver_tfln.py
@@ -0,0 +1,257 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.2
+#   kernelspec:
+#     display_name: Python 3 (ipykernel)
+#     language: python
+#     name: python3
+# ---
+
+# %% [markdown]
+# # MEEP Mode Solver - TFLN Ridge Waveguide
+#
+# Compute the fundamental TE mode of a **thin-film lithium niobate (TFLN)**
+# ridge waveguide at lambda = 1.55 um.
+#
+# **Reference design** (*Ying Li et al.*, ACS Omega 2023, 8(10), 9644--9651):
+#  - SiO2 cladding everywhere (no Si substrate)
+#  - LiNbO3 slab: 220 nm thick, extends laterally
+#  - LiNbO3 ridge: 180 nm on top of slab -> total 400 nm
+#  - Ridge width w0 = 1.1 um
+#  - Sidewall angle 17deg -> **supported via ``mp.Prism``**
+#    with native ``sidewall_angle`` parameter (in radians).
+#    The n_eff difference vs. vertical sidewalls is ~0.0045
+#    (1.8533 vs 1.8578).
+#
+# **Key concept** --- ``background_material="sio2"`` sets the MEEP
+# ``default_material`` to SiO2.  Any
+# space not covered by an explicit layer is filled with SiO2 instead of air.
+#
+# **Expected results**:
+#  - n_eff ~ 1.85 (fundamental TE-like mode, mode_index=0)
+#  - n_group ~ 2.20
+
+# %% [markdown]
+# ### Imports & MEEP check
+
+# %%
+import gdsfactory as gf
+import matplotlib.pyplot as plt
+import numpy as np
+
+import gsim.meep as gm
+from gsim.common.stack.extractor import Layer, LayerStack
+
+try:
+    import meep as mp
+
+    print(f"MEEP {mp.__version__} ready")
+except ImportError as err:
+    raise SystemExit(
+        "MEEP not found. Install it via conda-forge:\n"
+        "    conda install -c conda-forge pymeep"
+    ) from err
+
+plt.close()
+
+gf.gpdk.PDK.activate()
+
+# %% [markdown]
+# ### LiNbO3 material (Zelmon 1997)
+#
+# LiNbO3 is birefringent and is now registered as a uniaxial material
+# in ``gsim.common.stack.materials.MATERIALS_DB`` (notebook no longer
+# manually registers it).  Both ordinary and extraordinary Sellmeier
+# models from Zelmon et al. (JOSA B 14(12), 3319--3322, 1997) are included:
+#
+# Ordinary:
+#   n_o^2 = 1 + 2.6734 lam^2/(lam^2 - 0.01764) + 1.2290 lam^2/(lam^2 - 0.05914)
+#             + 12.614 lam^2/(lam^2 - 474.60)
+#
+# Extraordinary:
+#   n_e^2 = 1 + 2.9804 lam^2/(lam^2 - 0.02047) + 0.5981 lam^2/(lam^2 - 0.0666)
+#             + 8.9543 lam^2/(lam^2 - 416.08)
+#
+# For x-cut TFLN the TE mode's dominant E-field aligns with the
+# extraordinary axis (zz).
+
+
+# %% [markdown]
+# ### Build the GDS component
+#
+# Two LiNbO3 layers:
+#  - **Slab** (layer 1,0): wide rectangle (thin-film slab)
+#  - **Ridge** (layer 2,0): narrow rectangle (core on top of slab)
+#
+# The SiO2 BOX is provided by ``background_material="sio2"`` --- no
+# separate GDS layer needed.  Layers without GDS polygons are treated
+# as full-width backgrounds (``mode_solver.py:434--435``).
+#
+# **Sidewall angle note**: set ``sidewall_angle=17.0`` on the ridge
+# :class:`Layer` to create a trapezoidal ridge cross-section via
+# ``mp.Prism`` with native ``sidewall_angle``.
+
+# %%
+SLAB_WIDTH = 5.0  # um --- wide slab
+CORE_WIDTH = 1.1  # um --- w0 from reference design
+LENGTH = 10.0  # um --- waveguide length (arbitrary for mode solving)
+
+c = gf.Component()
+
+# LiNbO3 ridge (layer 2) --- narrow core on top
+c.add_polygon(
+    [
+        (-LENGTH / 2, -CORE_WIDTH / 2),
+        (LENGTH / 2, -CORE_WIDTH / 2),
+        (LENGTH / 2, CORE_WIDTH / 2),
+        (-LENGTH / 2, CORE_WIDTH / 2),
+    ],
+    layer=(2, 0),
+)
+
+# Ports at both ends
+c.add_port(
+    name="o1",
+    center=(-LENGTH / 2, 0),
+    width=CORE_WIDTH,
+    orientation=180,
+    layer=(1, 0),
+)
+c.add_port(
+    name="o2",
+    center=(LENGTH / 2, 0),
+    width=CORE_WIDTH,
+    orientation=0,
+    layer=(1, 0),
+)
+
+print(f"Component: {c.name}")
+print(f"  Ports:  {[p.name for p in c.ports]}")
+print(f"  Layers: {list(c.layers)}")
+
+# %% [markdown]
+# ### Layer stack
+#
+# Vertical material profile.  SiO2 fills all background space via
+# ``background_material="sio2"``.
+#
+# | Region  | Material | Z-range (um)   | GDS layer |
+# |---------|----------|----------------|-----------|
+# | Ridge   | LiNbO3   | 0.22 ... 0.40    | (2,0) |
+# | Slab    | LiNbO3   | 0.00 ... 0.22    | (1,0) |
+# | BOX     | SiO2     | -2.0 ... 0.0     | (0,0) --- no polygons |
+
+# %%
+SLAB_THICKNESS = 0.22  # um  (h3)
+CORE_THICKNESS = 0.40  # um --- total LiNbO3 thickness
+RIDGE_THICKNESS = CORE_THICKNESS - SLAB_THICKNESS  # 0.18 um
+
+layers = {
+    "box": Layer(
+        name="box",
+        gds_layer=(0, 0),
+        zmin=-1.0,
+        zmax=0.0,
+        thickness=1.0,
+        material="sio2",
+        layer_type="dielectric",
+    ),
+    "slab": Layer(
+        name="slab",
+        gds_layer=(1, 0),
+        zmin=0.0,
+        zmax=SLAB_THICKNESS,
+        thickness=SLAB_THICKNESS,
+        material="linbo3",
+        layer_type="dielectric",
+    ),
+    "ridge": Layer(
+        name="ridge",
+        gds_layer=(2, 0),
+        zmin=SLAB_THICKNESS,
+        zmax=CORE_THICKNESS,
+        thickness=RIDGE_THICKNESS,
+        material="linbo3",
+        layer_type="dielectric",
+        sidewall_angle=17.0,
+    ),
+}
+stack = LayerStack(layers=layers)
+
+print("Layer stack (+ SiO2 background):")
+for name, l in stack.layers.items():
+    print(
+        f"  {name:6s}  z=[{l.zmin:+.3f}, {l.zmax:+.3f}]  "
+        f"t={l.thickness:.3f}  material={l.material}  gds={l.gds_layer}"
+    )
+
+# %% [markdown]
+# ### Solve the fundamental TE-like mode
+#
+# Use the declarative :class:`Simulation` + :class:`ModeSolver` API.
+# Grids are auto-constructed from ``y_span``, ``n_field_y``, and
+# ``n_field_z`` settings on the mode solver.
+
+# %%
+WAVELENGTH = 1.55  # um
+RESOLUTION = 64  # grid points per um
+PML_THICKNESS = WAVELENGTH  # um
+
+sim = gm.Simulation(
+    geometry=gm.Geometry(component=c, stack=stack),
+    domain=gm.Domain(
+        pml=PML_THICKNESS,
+        margin_z=(0.0, 0.5),
+    ),
+)
+sim.mode_solver.wavelengths = [WAVELENGTH]
+sim.mode_solver.fundamental().at_port("o1")
+sim.mode_solver.y_span = SLAB_WIDTH
+sim.mode_solver.n_field_y = 1000
+sim.mode_solver.n_field_z = 1000
+sim.mode_solver.background_material = "sio2"
+
+sweep = sim.solve_modes()
+mode = sweep.at(WAVELENGTH).band(1)
+
+print(f"n_eff     = {mode.n_eff}")
+print(f"n_group   = {mode.n_group}")
+print(f"kdom      = {[f'{k:.6f}' for k in mode.kdom]}")
+print(f"band      = {mode.band_num}, parity = {mode.parity}")
+print(f"fields    = {list(mode.fields.keys())}")
+for comp, arr in mode.fields.items():
+    print(f"  {comp}: shape={arr.shape}  |max|={np.abs(arr).max():.6f}")
+
+# %% [markdown]
+# ### Refractive index profile
+#
+# Use ``ModeResult.plot_index()`` which auto-computes ``n`` from the
+# stored :class:`LayerStack` and grid arrays.
+
+# %%
+mode.plot_index(show=True)
+
+# %% [markdown]
+# ### 2D mode profile — all field components
+#
+# Use ``ModeResult.plot_mode()`` with ``components="all"`` and
+# ``geometry=True`` to overlay structural geometry boundaries.
+
+# %%
+mode.plot_mode(
+    components="all",
+    norm="abs",
+    geometry=True,
+    suptitle=(
+        f"TFLN ridge waveguide fundamental TE mode\n"
+        f"(λ={WAVELENGTH:.2f} µm, w0={CORE_WIDTH:.1f} µm, "
+        f"h_slab={SLAB_THICKNESS * 1000:.0f} nm, h_ridge={RIDGE_THICKNESS * 1000:.0f} nm, "
+        f"bg=SiO2)"
+    ),
+    show=True,
+)
diff --git a/nbs/palace_cpw_lumped.ipynb b/nbs/palace_cpw_lumped.ipynb
index 9368ae7..8d0e8f3 100644
--- a/nbs/palace_cpw_lumped.ipynb
+++ b/nbs/palace_cpw_lumped.ipynb
@@ -581,8 +581,11 @@
   }
  ],
  "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
diff --git a/nbs/palace_cpw_lumped.py b/nbs/palace_cpw_lumped.py
index 9d25465..72c4ce5 100644
--- a/nbs/palace_cpw_lumped.py
+++ b/nbs/palace_cpw_lumped.py
@@ -1,13 +1,14 @@
 # ---
 # jupyter:
 #   jupytext:
+#     formats: ipynb,py:percent
 #     text_representation:
 #       extension: .py
 #       format_name: percent
 #       format_version: '1.3'
 #       jupytext_version: 1.19.2
 #   kernelspec:
-#     display_name: .venv
+#     display_name: Python 3 (ipykernel)
 #     language: python
 #     name: python3
 # ---
diff --git a/nbs/palace_cpw_waveport.ipynb b/nbs/palace_cpw_waveport.ipynb
index 7b2e5e6..484cce1 100644
--- a/nbs/palace_cpw_waveport.ipynb
+++ b/nbs/palace_cpw_waveport.ipynb
@@ -46,12 +46,6 @@
    "execution_count": 1,
    "id": "326779ea",
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-06-12T07:04:20.163347Z",
-     "iopub.status.busy": "2026-06-12T07:04:20.163156Z",
-     "iopub.status.idle": "2026-06-12T07:04:22.708002Z",
-     "shell.execute_reply": "2026-06-12T07:04:22.707646Z"
-    },
     "papermill": {
      "duration": 2.54829,
      "end_time": "2026-06-12T07:04:22.708430",
@@ -62,9 +56,16 @@
     "tags": []
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:2026-06-23 17:24:05,880:jax._src.xla_bridge:852: An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -157,12 +158,6 @@
    "execution_count": 2,
    "id": "79d69cc8",
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-06-12T07:04:22.712666Z",
-     "iopub.status.busy": "2026-06-12T07:04:22.712492Z",
-     "iopub.status.idle": "2026-06-12T07:04:23.350002Z",
-     "shell.execute_reply": "2026-06-12T07:04:23.349634Z"
-    },
     "papermill": {
      "duration": 0.639064,
      "end_time": "2026-06-12T07:04:23.350467",
@@ -224,12 +219,6 @@
    "execution_count": 3,
    "id": "5ef21513",
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-06-12T07:04:23.354173Z",
-     "iopub.status.busy": "2026-06-12T07:04:23.354105Z",
-     "iopub.status.idle": "2026-06-12T07:04:29.176436Z",
-     "shell.execute_reply": "2026-06-12T07:04:29.175950Z"
-    },
     "papermill": {
      "duration": 5.823922,
      "end_time": "2026-06-12T07:04:29.177017",
@@ -246,12 +235,12 @@
        "Mesh Summary\n",
        "========================================\n",
        "Dimensions: 800.0 x 330.0 x 217.9 µm\n",
-       "Nodes:      43,804\n",
-       "Elements:   314,587\n",
-       "Tetrahedra: 231,039\n",
-       "Edge length: 1.08 - 79.63 µm\n",
+       "Nodes:      43,842\n",
+       "Elements:   314,803\n",
+       "Tetrahedra: 231,263\n",
+       "Edge length: 1.08 - 80.27 µm\n",
        "Quality:    0.634 (min: 0.000)\n",
-       "SICN:       0.685 (all valid)\n",
+       "SICN:       0.686 (all valid)\n",
        "----------------------------------------\n",
        "Volumes (3):\n",
        "  - si [1]\n",
@@ -285,12 +274,6 @@
    "execution_count": 4,
    "id": "9e3ee508",
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-06-12T07:04:29.179935Z",
-     "iopub.status.busy": "2026-06-12T07:04:29.179788Z",
-     "iopub.status.idle": "2026-06-12T07:04:31.002909Z",
-     "shell.execute_reply": "2026-06-12T07:04:31.002558Z"
-    },
     "papermill": {
      "duration": 1.826372,
      "end_time": "2026-06-12T07:04:31.004882",
@@ -310,10 +293,13 @@
     },
     {
      "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "06f54c458aff4536ba4ade730cb01d97",
+       "version_major": 2,
+       "version_minor": 0
+      },
       "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=1200x900>"
+       "Widget(value='<iframe src=\"http://localhost:37967/index.html?ui=P_0x7fe248efe480_0&reconnect=auto\" class=\"pyvi…"
       ]
      },
      "metadata": {},
@@ -553,8 +539,11 @@
   }
  ],
  "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -568,7 +557,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.10"
+   "version": "3.12.0"
   },
   "papermill": {
    "default_parameters": {},
diff --git a/nbs/palace_cpw_waveport.py b/nbs/palace_cpw_waveport.py
index 9db6ab3..8738bc0 100644
--- a/nbs/palace_cpw_waveport.py
+++ b/nbs/palace_cpw_waveport.py
@@ -1,13 +1,14 @@
 # ---
 # jupyter:
 #   jupytext:
+#     formats: ipynb,py:percent
 #     text_representation:
 #       extension: .py
 #       format_name: percent
 #       format_version: '1.3'
 #       jupytext_version: 1.19.2
 #   kernelspec:
-#     display_name: .venv
+#     display_name: Python 3 (ipykernel)
 #     language: python
 #     name: python3
 # ---
diff --git a/pyproject.toml b/pyproject.toml
index 1a80fbc..f6cdd31 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -189,10 +189,11 @@ reportMissingImports = "none"
 reportMissingTypeStubs = "none"
 
 [tool.pytest.ini_options]
-addopts = "--tb=short -m 'not cloud'"
+addopts = "--tb=short -m 'not cloud and not meep_local'"
 markers = [
   "cloud: tests that submit jobs to GDSFactory+ cloud servers (deselected by default; run with `pytest -m cloud`)",
   "sim_smoke_test: smallest cloud sims (one per solver) run automatically per-PR; run with `pytest -m sim_smoke_test`",
+  "meep_local: tests requiring a local MEEP installation (deselected by default; run with `pytest -m meep_local`)",
 ]
 norecursedirs = ["scripts"]
 testpaths = ["tests"]
@@ -319,6 +320,7 @@ include = ["tests/**"]
 
 [tool.ty.overrides.rules]
 possibly-missing-attribute = "ignore"
+invalid-argument-type = "ignore"
 
 [tool.ty.rules]
 missing-argument = "ignore"
diff --git a/src/gsim/common/stack/materials.py b/src/gsim/common/stack/materials.py
index fa516da..bbba49b 100644
--- a/src/gsim/common/stack/materials.py
+++ b/src/gsim/common/stack/materials.py
@@ -121,11 +121,27 @@ class DispersionModel(BaseModel):
     - ``sellmeier``: Sellmeier equation with B, C terms (optical)
     - ``lorentzian``: Lorentzian susceptibility poles (general dispersive)
     - ``constant``: Constant permittivity (single-frequency)
+
+    Per-axis anisotropic models:
+        Set ``axis`` to ``"xx"``, ``"yy"``, or ``"zz"`` to restrict a model
+        to one dielectric-tensor component.  When a material has per-axis
+        models covering the target wavelength,
+        :meth:`MaterialProperties.evaluate_at_wavelength` combines them
+        into a tensor permittivity ``[eps_xx, eps_yy, eps_zz]``.
+        Models with ``axis=None`` are isotropic (apply to all axes) and
+        serve as fallback for axes without a dedicated model.
     """
 
     model_config = ConfigDict(validate_assignment=True)
 
     type: Literal["sellmeier", "lorentzian", "constant"]
+    axis: Literal["xx", "yy", "zz"] | None = Field(
+        default=None,
+        description=(
+            "Dielectric-tensor component this model applies to. "
+            "None = isotropic (all axes)."
+        ),
+    )
 
     sellmeier_terms: list[SellmeierTerm] | None = Field(
         default=None,
@@ -219,6 +235,31 @@ def _is_tensor(val: float | list[float] | None) -> bool:
     return isinstance(val, list)
 
 
+_AXES: tuple[Literal["xx", "yy", "zz"], ...] = ("xx", "yy", "zz")
+
+
+def _find_best_covering_model(
+    models: list[DispersionModel],
+    wavelength_um: float,
+) -> DispersionModel | None:
+    """Find the best model covering a wavelength from a list of candidates.
+
+    Priority: covering model > unspecified-validity model > None.
+    """
+    covered: list[DispersionModel] = []
+    unspecified: list[DispersionModel] = []
+    for m in models:
+        if m.validity.is_unspecified:
+            unspecified.append(m)
+        elif m.validity.covers_wavelength(wavelength_um):
+            covered.append(m)
+    if covered:
+        return covered[0]
+    if unspecified:
+        return unspecified[0]
+    return None
+
+
 class ResolvedMaterial(BaseModel):
     """Result of evaluating a material's dispersion model at a specific frequency.
 
@@ -375,29 +416,82 @@ def evaluate_at_wavelength(self, wavelength_um: float) -> ResolvedMaterial:
         """Evaluate material properties at a specific wavelength.
 
         Resolution strategy:
-        1. Scan dispersion_models for one whose validity covers the wavelength.
-        2. If no model covers it, use a model with unspecified validity (warn).
-        3. If no dispersion models, fall back to the permittivity field directly.
+        1. Group dispersion_models by ``axis`` (None = isotropic).
+        2. If any per-axis models exist, evaluate each axis independently,
+           falling back to isotropic models for uncovered axes.  The
+           result is a tensor permittivity [eps_xx, eps_yy, eps_zz].
+        3. If only isotropic models, pick the best covering one (scalar).
+        4. If no dispersion models, fall back to the permittivity field.
         """
-        covered_models = []
-        unspecified_models = []
-
+        axis_models: dict[str | None, list[DispersionModel]] = {
+            None: [],
+            "xx": [],
+            "yy": [],
+            "zz": [],
+        }
         for model in self.dispersion_models:
-            if model.validity.is_unspecified:
-                unspecified_models.append(model)
-            elif model.validity.covers_wavelength(wavelength_um):
-                covered_models.append(model)
+            axis_models[model.axis].append(model)
+
+        has_anisotropic = any(
+            axis_models[ax]
+            for ax in _AXES  # type: ignore[arg-type]
+        )
+
+        base = ResolvedMaterial(
+            permittivity=self.permittivity,
+            conductivity=self.conductivity,
+            loss_tangent=self.loss_tangent,
+            permeability=self.permeability,
+            material_axes=self.material_axes,
+        )
+
+        if has_anisotropic:
+            eps_components: list[float] = []
+            model_types: set[str] = set()
+            model_sources: list[str] = []
+            all_within_validity = True
+            validity_notes: list[str] = []
+
+            for ax in _AXES:
+                model = _find_best_covering_model(
+                    axis_models[ax],
+                    wavelength_um,  # type: ignore[arg-type]
+                )
+                if model is None:
+                    model = _find_best_covering_model(axis_models[None], wavelength_um)
+                if model is None:
+                    eps_components.append(1.0)
+                    validity_notes.append(f"{ax}: no model found, using eps=1.0")
+                    all_within_validity = False
+                    continue
+
+                eps_components.append(model.evaluate_permittivity(wavelength_um))
+                model_types.add(model.type)
+                if model.source:
+                    model_sources.append(f"{ax}({model.source})")
+                if model.validity.is_unspecified:
+                    validity_notes.append(
+                        f"{ax}: validity unspecified ({model.source or 'unknown'})"
+                    )
+
+            base.permittivity = eps_components
+            if any(t in ("sellmeier", "lorentzian") for t in model_types):
+                base.conductivity = None
+            base.model_type = "/".join(sorted(model_types)) if model_types else ""
+            base.model_source = "; ".join(model_sources) if model_sources else ""
+            base.within_validity = all_within_validity
+            base.validity_note = "; ".join(validity_notes) if validity_notes else ""
+            return base
+
+        if self.dispersion_models:
+            selected = _find_best_covering_model(self.dispersion_models, wavelength_um)
+        else:
+            selected = None
 
-        selected: DispersionModel | None = None
         within_validity = True
         validity_note = ""
 
-        if covered_models:
-            selected = covered_models[0]
-            within_validity = True
-        elif unspecified_models:
-            selected = unspecified_models[0]
-            within_validity = True
+        if selected is not None and selected.validity.is_unspecified:
             validity_note = (
                 f"validity range unspecified (source: {selected.source or 'unknown'})"
             )
@@ -407,25 +501,11 @@ def evaluate_at_wavelength(self, wavelength_um: float) -> ResolvedMaterial:
                 stacklevel=3,
             )
 
-        base = ResolvedMaterial(
-            permittivity=self.permittivity,
-            conductivity=self.conductivity,
-            loss_tangent=self.loss_tangent,
-            permeability=self.permeability,
-            material_axes=self.material_axes,
-        )
-
         if selected is not None:
             eps = selected.evaluate_permittivity(wavelength_um)
             base.permittivity = (
                 self.permittivity if _is_tensor(self.permittivity) else eps
             )
-            # When a dispersive model (Sellmeier/Lorentzian) covers the
-            # target wavelength, the material behaves as a dielectric at
-            # this frequency — any conductivity from the RF constant model
-            # is physically incorrect and must be dropped.  For example,
-            # silicon has sigma=2 S/m at RF but is a pure dielectric
-            # (n~3.47) at optical wavelengths.
             if selected.type in ("sellmeier", "lorentzian"):
                 base.conductivity = None
             base.model_type = selected.type
@@ -709,13 +789,43 @@ def dielectric(
             ),
         ],
     ),
-    "tfln": MaterialProperties(
-        permittivity=44.0,
+    "linbo3": MaterialProperties(
         dispersion_models=[
             DispersionModel(
-                type="constant",
-                permittivity=44.0,
-                source="unspecified",
+                type="sellmeier",
+                axis="xx",
+                sellmeier_terms=[
+                    SellmeierTerm(B=2.6734, C=0.01764),
+                    SellmeierTerm(B=1.2290, C=0.05914),
+                    SellmeierTerm(B=12.614, C=474.60),
+                ],
+                epsilon_inf=1.0,
+                validity=ValidityRange(valid_wavelength=(0.4, 5.0)),
+                source="Zelmon et al. 1997 (LiNbO3 ordinary, o-polarized)",
+            ),
+            DispersionModel(
+                type="sellmeier",
+                axis="yy",
+                sellmeier_terms=[
+                    SellmeierTerm(B=2.6734, C=0.01764),
+                    SellmeierTerm(B=1.2290, C=0.05914),
+                    SellmeierTerm(B=12.614, C=474.60),
+                ],
+                epsilon_inf=1.0,
+                validity=ValidityRange(valid_wavelength=(0.4, 5.0)),
+                source="Zelmon et al. 1997 (LiNbO3 ordinary, o-polarized)",
+            ),
+            DispersionModel(
+                type="sellmeier",
+                axis="zz",
+                sellmeier_terms=[
+                    SellmeierTerm(B=2.9804, C=0.02047),
+                    SellmeierTerm(B=0.5981, C=0.0666),
+                    SellmeierTerm(B=8.9543, C=416.08),
+                ],
+                epsilon_inf=1.0,
+                validity=ValidityRange(valid_wavelength=(0.4, 5.0)),
+                source="Zelmon et al. 1997 (LiNbO3 extraordinary, e-polarized)",
             ),
         ],
     ),
@@ -736,6 +846,8 @@ def dielectric(
     "si3n4": "Si3N4",
     "si": "silicon",
     "ge": "germanium",
+    "tfln": "linbo3",
+    "lithium_niobate": "linbo3",
 }
 
 
diff --git a/src/gsim/meep/__init__.py b/src/gsim/meep/__init__.py
index 3b8138d..617592c 100644
--- a/src/gsim/meep/__init__.py
+++ b/src/gsim/meep/__init__.py
@@ -23,21 +23,33 @@
 """
 
 from gsim.gcloud import RunResult, register_result_parser
+from gsim.meep.mode_solver import (
+    mode_x_grid,
+    mode_y_grid,
+    mode_z_grid,
+    refractive_index_profile,
+    solve_cross_section_mode,
+    solve_slab_mode,
+    solve_slab_modes,
+    solve_slab_wavelength_sweep,
+)
 from gsim.meep.models import (
     FDTD,
     Domain,
     DomainConfig,
     Geometry,
     Material,
+    ModeResult,
+    ModeSolver,
     ModeSource,
     ResolutionConfig,
     SimConfig,
     SourceConfig,
     SParameterResult,
     Symmetry,
-    # Config models used by Simulation.write_config()
     WavelengthConfig,
 )
+from gsim.meep.results import ModeSweepResult
 from gsim.meep.simulation import BuildResult, Simulation
 
 
@@ -58,7 +70,10 @@ def _parse_meep_result(run_result: RunResult) -> SParameterResult:
     "DomainConfig",
     "Geometry",
     "Material",
+    "ModeResult",
+    "ModeSolver",
     "ModeSource",
+    "ModeSweepResult",
     "ResolutionConfig",
     "SParameterResult",
     "SimConfig",
@@ -66,4 +81,12 @@ def _parse_meep_result(run_result: RunResult) -> SParameterResult:
     "SourceConfig",
     "Symmetry",
     "WavelengthConfig",
+    "mode_x_grid",
+    "mode_y_grid",
+    "mode_z_grid",
+    "refractive_index_profile",
+    "solve_cross_section_mode",
+    "solve_slab_mode",
+    "solve_slab_modes",
+    "solve_slab_wavelength_sweep",
 ]
diff --git a/src/gsim/meep/mode_solver.py b/src/gsim/meep/mode_solver.py
new file mode 100644
index 0000000..7e37a1f
--- /dev/null
+++ b/src/gsim/meep/mode_solver.py
@@ -0,0 +1,1943 @@
+"""Standalone MEEP eigenmode solver for 1D slab and 2D waveguide cross-sections.
+
+Provides two public entry points:
+
+- :func:`solve_slab_mode` — 1D slab mode from a layer stack
+- :func:`solve_cross_section_mode` — 2D waveguide cross-section at a port or position
+
+Both use ``sim.get_eigenmode()`` internally and return a :class:`ModeResult`.
+MEEP is an optional dependency imported lazily; see :func:`_import_meep`.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING, Any
+
+from gsim.meep.models.results import ModeResult
+
+if TYPE_CHECKING:
+    import numpy as np
+    from gdsfactory import Component
+
+    from gsim.common.stack.extractor import LayerStack
+    from gsim.meep.models.config import MaterialData
+
+# Lazy MEEP import guard.
+_MEET_NOT_FOUND_MSG = (
+    "MEEP is required for local mode solving. "
+    "Install it via conda-forge:\n"
+    "    conda install -c conda-forge pymeep"
+)
+
+_PARITY_MAP: dict[str, int] = {
+    "NO_PARITY": 0,
+    "EVEN_Y": 1,
+    "ODD_Y": 2,
+    "EVEN_Z": 3,
+    "ODD_Z": 4,
+}
+
+# Per-process cache for material resolution — keyed by
+# (frozenset(material_names), wavelength_um).  The same stack/lambda
+# invoked many times (multi-band, parity, comparison sections in
+# notebooks) will reuse the sellmeier evaluation.
+_MATERIAL_CACHE: dict[tuple, dict] = {}
+
+_MAX_MATERIAL_CACHE = 64
+
+
+def _resolve_materials_cached(
+    used_materials: set[str],
+    overrides: dict | None = None,
+    wavelength_um: float | None = None,
+    overlay: dict | None = None,
+) -> dict[str, MaterialData]:
+    """:func:`resolve_materials` with a process-local LRU cache."""
+    from gsim.meep.materials import resolve_materials
+
+    key = (frozenset(used_materials), wavelength_um)
+    cached = _MATERIAL_CACHE.get(key)
+    if cached is not None:
+        return cached
+    result = resolve_materials(used_materials, overrides, wavelength_um, overlay)
+    if len(_MATERIAL_CACHE) >= _MAX_MATERIAL_CACHE:
+        _MATERIAL_CACHE.pop(next(iter(_MATERIAL_CACHE)))
+    _MATERIAL_CACHE[key] = result
+    return result
+
+
+def _import_meep():
+    """Lazily import meep — raises ImportError with install instructions if missing."""
+    import logging
+
+    try:
+        import meep as mp
+    except ImportError:
+        raise ImportError(_MEET_NOT_FOUND_MSG) from None
+    _level = logging.getLogger("meep.native").getEffectiveLevel()
+    if _level == logging.NOTSET or _level >= logging.WARNING:
+        mp.verbosity(0)
+    elif _level >= logging.INFO:
+        mp.verbosity(1)
+    else:
+        mp.verbosity(2)
+    return mp
+
+
+# ------------------------------------------------------------------
+# Material helpers
+# ------------------------------------------------------------------
+
+
+def _meep_medium(material_data: MaterialData) -> Any:
+    """Convert a resolved MaterialData to a MEEP Medium object."""
+    mp = _import_meep()
+
+    eps = material_data.epsilon_diag
+    if isinstance(eps, list):
+        eps = eps[0]
+
+    return mp.Medium(epsilon=eps)
+
+
+def _layer_has_any_polygon(component: Component, layer: object) -> bool:
+    """Return ``True`` if *layer* has at least one GDS polygon in *component*.
+
+    Used as a fallback gate: when ``_layer_y_intervals_at_x`` /
+    ``_layer_x_intervals_at_y`` return no intervals AND this returns
+    ``False``, the layer is treated as a full-width background layer
+    (e.g. buried oxide, cladding) spanning the entire simulation domain.
+    """
+    gds_layer = getattr(layer, "gds_layer", None)
+    if gds_layer is None:
+        return False
+    try:
+        polys = component.get_polygons_points(layers=(tuple(gds_layer),), merge=True)
+        if not isinstance(polys, dict):
+            return False
+        return any(len(v) > 0 for v in polys.values())
+    except Exception:
+        return False
+
+
+# ------------------------------------------------------------------
+# Slab (1D) geometry builder
+# ------------------------------------------------------------------
+
+
+def _build_slab_xz_cell(
+    stack: LayerStack,
+    materials: dict[str, MaterialData],
+    resolution: float,
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+    *,
+    background_material: str = "air",
+) -> tuple[Any, Any]:
+    """Build a 2D XZ MEEP simulation cell for a 1D slab (uniform layers).
+
+    Each non-air layer becomes a rectangular block spanning the full
+    *x*-width. The cell is centred vertically on the stack midpoint
+    adjusted for asymmetric margins.
+
+    Args:
+        stack: Resolved :class:`LayerStack`.
+        materials: ``MaterialData`` keyed by material name.
+        resolution: Pixels per µm.
+        z_margin: Extra distance (µm) added below and above the stack.
+            A single float adds the same margin on both sides; a
+            ``(bottom, top)`` tuple adds asymmetric margins. Default 0.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            Set to e.g. 1.0 to enable PML absorbing boundaries.
+        background_material: Material name for the MEEP default medium
+            (fills space not covered by any layer). Default ``"air"``
+            (epsilon=1.0). Set to e.g. ``"sio2"`` to model a buried-oxide
+            background without explicit full-span geometry layers.
+
+    Returns:
+        ``(sim, cell_size)`` — initialized MEEP :class:`Simulation` object
+        and ``mp.Vector3`` cell dimensions.
+    """
+    mp = _import_meep()
+
+    z_min = min(layer.zmin for layer in stack.layers.values())
+    z_max = max(layer.zmax for layer in stack.layers.values())
+    if isinstance(z_margin, (tuple, list)):
+        z_margin_bottom, z_margin_top = z_margin
+    else:
+        z_margin_bottom = z_margin_top = z_margin
+    z_center = (z_min + z_max) / 2.0 + (z_margin_top - z_margin_bottom) / 2.0
+
+    # The slab problem is 1D but MEEP requires >=2 cells in the propagation
+    # direction for MPB to distinguish the guided eigenmode from the trivial
+    # vacuum plane-wave solution. 2 pixels is sufficient and minimizes memory.
+    x_span = 2.0 / resolution
+    z_span = (z_max - z_min) + z_margin_bottom + z_margin_top
+    if pml_thickness > 0:
+        x_span += 2 * pml_thickness
+        z_span += 2 * pml_thickness
+    # Snap to integer pixel counts to avoid meep grid-volume warnings.
+    x_span = round(x_span * resolution) / resolution
+    z_span = round(z_span * resolution) / resolution
+    cell_size = mp.Vector3(x_span, 0.0, z_span)
+
+    geometry: list[object] = []
+    for layer in stack.layers.values():
+        if layer.material == "air":
+            continue
+        mat_data = materials.get(layer.material)
+        if mat_data is None:
+            continue
+        medium = _meep_medium(mat_data)
+        z_size = layer.zmax - layer.zmin
+        if z_size <= 0:
+            continue
+        z_lo = layer.zmin - z_center
+        z_hi = z_lo + z_size
+        if abs(layer.zmin - z_min) < 1e-12:
+            z_lo = -z_span / 2.0
+        z_size = z_hi - z_lo
+        block_center_z = (z_lo + z_hi) / 2.0
+        block = mp.Block(
+            size=mp.Vector3(x_span, mp.inf, z_size),
+            center=mp.Vector3(0.0, 0.0, block_center_z),
+            material=medium,
+        )
+        geometry.append(block)
+
+    bg = materials.get(background_material)
+    default_medium = _meep_medium(bg) if bg is not None else mp.Medium(epsilon=1.0)
+
+    sim_kwargs: dict = dict(
+        cell_size=cell_size,
+        geometry=geometry,
+        resolution=resolution,
+        default_material=default_medium,
+    )
+    if pml_thickness > 0:
+        sim_kwargs["boundary_layers"] = [
+            mp.PML(thickness=pml_thickness, direction=mp.X),
+            mp.PML(thickness=pml_thickness, direction=mp.Z),
+        ]
+    sim = mp.Simulation(**sim_kwargs)
+    return sim, cell_size
+
+
+def _subtract_intervals(
+    base: tuple[float, float],
+    subtract: list[tuple[float, float]],
+) -> list[tuple[float, float]]:
+    """Return the sub-intervals of *base* remaining after removing *subtract*.
+
+    Used to carve "pillar" regions below a layer block that extend all
+    the way down to the cell floor when no lower layer is present.
+    """
+    result = [base]
+    for s0, s1 in subtract:
+        new_result: list[tuple[float, float]] = []
+        for r0, r1 in result:
+            if s1 <= r0 or s0 >= r1:
+                new_result.append((r0, r1))
+            else:
+                if r0 < s0:
+                    new_result.append((r0, min(s0, r1)))
+                if r1 > s1:
+                    new_result.append((max(s1, r0), r1))
+        result = new_result
+        if not result:
+            break
+    return result
+
+
+# ------------------------------------------------------------------
+# Cross-section (2D) geometry builders
+# ------------------------------------------------------------------
+
+
+def _build_component_xz_cell(
+    component: Component,
+    stack: LayerStack,
+    y_cut: float,
+    x_span: float,
+    materials: dict[str, MaterialData],
+    resolution: float,
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+    *,
+    background_material: str = "air",
+) -> tuple[Any, Any]:
+    """Build a 2D XZ MEEP simulation cell at a *y*-slice of a component.
+
+    For each non-air layer, the component's GDS polygons are intersected
+    with the horizontal line *y = y_cut*.  Each contiguous interval on *x*
+    becomes a rectangular block with the layer's material and *z* extent.
+
+    Args:
+        component: GDSFactory component (must have polygons).
+        stack: Resolved :class:`LayerStack`.
+        y_cut: *y* coordinate of the cross-section plane (µm).
+        x_span: Total *x* extent of the simulation cell (µm).
+        materials: ``MaterialData`` keyed by material name.
+        resolution: Pixels per µm.
+        z_margin: Extra distance (µm) added below and above the stack.
+            A single float adds the same margin on both sides; a
+            ``(bottom, top)`` tuple adds asymmetric margins. Default 0.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            Set to e.g. 1.0 to enable PML absorbing boundaries.
+        background_material: Material name for the MEEP default medium
+            (fills space not covered by any layer). Default ``"air"``
+            (epsilon=1.0).
+
+    Returns:
+        ``(sim, cell_size)`` — initialized MEEP :class:`Simulation` object
+        and ``mp.Vector3`` cell dimensions.
+    """
+    mp = _import_meep()
+
+    z_min = min(layer.zmin for layer in stack.layers.values())
+    z_max = max(layer.zmax for layer in stack.layers.values())
+    if isinstance(z_margin, (tuple, list)):
+        z_margin_bottom, z_margin_top = z_margin
+    else:
+        z_margin_bottom = z_margin_top = z_margin
+    z_center = (z_min + z_max) / 2.0 + (z_margin_top - z_margin_bottom) / 2.0
+    xz_span = x_span
+    if pml_thickness > 0:
+        x_span += 2 * pml_thickness
+    x_span = round(x_span * resolution) / resolution
+    z_span = (z_max - z_min) + z_margin_bottom + z_margin_top
+    if pml_thickness > 0:
+        z_span += 2 * pml_thickness
+    z_span = round(z_span * resolution) / resolution
+    cell_size = mp.Vector3(x_span, 0.0, z_span)
+
+    geometry: list[object] = []
+    layer_data: list[dict] = []
+    for layer in stack.layers.values():
+        if layer.material == "air":
+            continue
+        mat_data = materials.get(layer.material)
+        if mat_data is None:
+            continue
+        layer_thickness = layer.zmax - layer.zmin
+        if layer_thickness <= 0:
+            continue
+        intervals = _layer_x_intervals_at_y(component, layer, y_cut)
+        if not intervals and not _layer_has_any_polygon(component, layer):
+            intervals = [(-xz_span / 2, xz_span / 2)]
+        layer_data.append(
+            {
+                "layer": layer,
+                "medium": _meep_medium(mat_data),
+                "z_lo": layer.zmin - z_center,
+                "z_hi": layer.zmax - z_center,
+                "intervals": intervals,
+                "sidewall_angle": getattr(layer, "sidewall_angle", 0.0),
+            }
+        )
+
+    for ld in layer_data:
+        below_intervals: list[tuple[float, float]] = []
+        for od in layer_data:
+            if od is ld:
+                continue
+            if od["z_hi"] <= ld["z_lo"] + 1e-12:
+                below_intervals.extend(od["intervals"])
+
+        for x0, x1 in ld["intervals"]:
+            x_center = (x0 + x1) / 2.0
+            x_size = x1 - x0
+            if x_size <= 0:
+                continue
+            z_lo = ld["z_lo"]
+            z_hi = ld["z_hi"]
+            block_z_size = z_hi - z_lo
+            sw_angle_deg = ld.get("sidewall_angle", 0.0)
+            if block_z_size > 0:
+                if sw_angle_deg:
+                    sw_rad = math.radians(sw_angle_deg)
+                    vertices = [
+                        mp.Vector3(x0, -1000.0, z_lo),
+                        mp.Vector3(x1, -1000.0, z_lo),
+                        mp.Vector3(x1, 1000.0, z_lo),
+                        mp.Vector3(x0, 1000.0, z_lo),
+                    ]
+                    prism = mp.Prism(
+                        vertices=vertices,
+                        height=block_z_size,
+                        material=ld["medium"],
+                        sidewall_angle=sw_rad,
+                    )
+                    geometry.append(prism)
+                else:
+                    block_z_center = (z_lo + z_hi) / 2.0
+                    block = mp.Block(
+                        size=mp.Vector3(x_size, mp.inf, block_z_size),
+                        center=mp.Vector3(x_center, 0.0, block_z_center),
+                        material=ld["medium"],
+                    )
+                    geometry.append(block)
+
+            bottom_free = _subtract_intervals((x0, x1), below_intervals)
+            for bx0, bx1 in bottom_free:
+                bx_center = (bx0 + bx1) / 2.0
+                bx_size = bx1 - bx0
+                if bx_size <= 0:
+                    continue
+                ext_z_lo = -z_span / 2.0
+                ext_z_hi = ld["z_lo"]
+                ext_z_size = ext_z_hi - ext_z_lo
+                if ext_z_size <= 0:
+                    continue
+                block = mp.Block(
+                    size=mp.Vector3(bx_size, mp.inf, ext_z_size),
+                    center=mp.Vector3(bx_center, 0.0, (ext_z_lo + ext_z_hi) / 2.0),
+                    material=ld["medium"],
+                )
+                geometry.append(block)
+
+    bg = materials.get(background_material)
+    default_medium = _meep_medium(bg) if bg is not None else mp.Medium(epsilon=1.0)
+
+    sim_kwargs: dict = dict(
+        cell_size=cell_size,
+        geometry=geometry,
+        resolution=resolution,
+        default_material=default_medium,
+    )
+    if pml_thickness > 0:
+        sim_kwargs["boundary_layers"] = [
+            mp.PML(thickness=pml_thickness, direction=mp.X),
+            mp.PML(thickness=pml_thickness, direction=mp.Z),
+        ]
+    sim = mp.Simulation(**sim_kwargs)
+    return sim, cell_size
+
+
+def _build_component_yz_cell(
+    component: Component,
+    stack: LayerStack,
+    x_cut: float,
+    y_span: float,
+    materials: dict[str, MaterialData],
+    resolution: float,
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+    *,
+    background_material: str = "air",
+) -> tuple[Any, Any]:
+    """Build a 2D YZ MEEP simulation cell at an *x*-slice of a component.
+
+    For each non-air layer, the component's GDS polygons are intersected
+    with the vertical line *x = x_cut*.  Each contiguous interval on *y*
+    becomes a rectangular block with the layer's material and *z* extent.
+
+    Args:
+        component: GDSFactory component (must have polygons).
+        stack: Resolved :class:`LayerStack`.
+        x_cut: *x* coordinate of the cross-section plane (µm).
+        y_span: Total *y* extent of the simulation cell (µm).
+        materials: ``MaterialData`` keyed by material name.
+        resolution: Pixels per µm.
+        z_margin: Extra distance (µm) added below and above the stack.
+            A single float adds the same margin on both sides; a
+            ``(bottom, top)`` tuple adds asymmetric margins. Default 0.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            Set to e.g. 1.0 to enable PML absorbing boundaries.
+        background_material: Material name for the MEEP default medium
+            (fills space not covered by any layer). Default ``"air"``
+            (epsilon=1.0).
+
+    Returns:
+        ``(sim, cell_size)`` — initialized MEEP :class:`Simulation` object
+        and ``mp.Vector3`` cell dimensions.
+    """
+    mp = _import_meep()
+
+    z_min = min(layer.zmin for layer in stack.layers.values())
+    z_max = max(layer.zmax for layer in stack.layers.values())
+    if isinstance(z_margin, (tuple, list)):
+        z_margin_bottom, z_margin_top = z_margin
+    else:
+        z_margin_bottom = z_margin_top = z_margin
+    z_center = (z_min + z_max) / 2.0 + (z_margin_top - z_margin_bottom) / 2.0
+    yz_span = y_span
+    if pml_thickness > 0:
+        y_span += 2 * pml_thickness
+    y_span = round(y_span * resolution) / resolution
+    z_span = (z_max - z_min) + z_margin_bottom + z_margin_top
+    if pml_thickness > 0:
+        z_span += 2 * pml_thickness
+    z_span = round(z_span * resolution) / resolution
+    cell_size = mp.Vector3(0.0, y_span, z_span)
+
+    geometry: list[object] = []
+    layer_data: list[dict] = []
+    for layer in stack.layers.values():
+        if layer.material == "air":
+            continue
+        mat_data = materials.get(layer.material)
+        if mat_data is None:
+            continue
+        layer_thickness = layer.zmax - layer.zmin
+        if layer_thickness <= 0:
+            continue
+        intervals = _layer_y_intervals_at_x(component, layer, x_cut)
+        if not intervals and not _layer_has_any_polygon(component, layer):
+            intervals = [(-yz_span / 2, yz_span / 2)]
+        layer_data.append(
+            {
+                "layer": layer,
+                "medium": _meep_medium(mat_data),
+                "z_lo": layer.zmin - z_center,
+                "z_hi": layer.zmax - z_center,
+                "intervals": intervals,
+                "sidewall_angle": getattr(layer, "sidewall_angle", 0.0),
+            }
+        )
+
+    for ld in layer_data:
+        below_intervals: list[tuple[float, float]] = []
+        for od in layer_data:
+            if od is ld:
+                continue
+            if od["z_hi"] <= ld["z_lo"] + 1e-12:
+                below_intervals.extend(od["intervals"])
+
+        for y0, y1 in ld["intervals"]:
+            y_center = (y0 + y1) / 2.0
+            y_size = y1 - y0
+            if y_size <= 0:
+                continue
+            z_lo = ld["z_lo"]
+            z_hi = ld["z_hi"]
+            block_z_size = z_hi - z_lo
+            sw_angle_deg = ld.get("sidewall_angle", 0.0)
+            if block_z_size > 0:
+                if sw_angle_deg:
+                    sw_rad = math.radians(sw_angle_deg)
+                    vertices = [
+                        mp.Vector3(-1000.0, y0, z_lo),
+                        mp.Vector3(1000.0, y0, z_lo),
+                        mp.Vector3(1000.0, y1, z_lo),
+                        mp.Vector3(-1000.0, y1, z_lo),
+                    ]
+                    prism = mp.Prism(
+                        vertices=vertices,
+                        height=block_z_size,
+                        material=ld["medium"],
+                        sidewall_angle=sw_rad,
+                    )
+                    geometry.append(prism)
+                else:
+                    block_z_center = (z_lo + z_hi) / 2.0
+                    block = mp.Block(
+                        size=mp.Vector3(mp.inf, y_size, block_z_size),
+                        center=mp.Vector3(0.0, y_center, block_z_center),
+                        material=ld["medium"],
+                    )
+                    geometry.append(block)
+
+            bottom_free = _subtract_intervals((y0, y1), below_intervals)
+            for by0, by1 in bottom_free:
+                by_center = (by0 + by1) / 2.0
+                by_size = by1 - by0
+                if by_size <= 0:
+                    continue
+                ext_z_lo = -z_span / 2.0
+                ext_z_hi = ld["z_lo"]
+                ext_z_size = ext_z_hi - ext_z_lo
+                if ext_z_size <= 0:
+                    continue
+                block = mp.Block(
+                    size=mp.Vector3(mp.inf, by_size, ext_z_size),
+                    center=mp.Vector3(0.0, by_center, (ext_z_lo + ext_z_hi) / 2.0),
+                    material=ld["medium"],
+                )
+                geometry.append(block)
+
+    bg = materials.get(background_material)
+    default_medium = _meep_medium(bg) if bg is not None else mp.Medium(epsilon=1.0)
+
+    sim_kwargs: dict = dict(
+        cell_size=cell_size,
+        geometry=geometry,
+        resolution=resolution,
+        default_material=default_medium,
+    )
+    if pml_thickness > 0:
+        sim_kwargs["boundary_layers"] = [
+            mp.PML(thickness=pml_thickness, direction=mp.Y),
+            mp.PML(thickness=pml_thickness, direction=mp.Z),
+        ]
+    sim = mp.Simulation(**sim_kwargs)
+    return sim, cell_size
+
+
+def _poly_to_shapely(poly):
+    """Convert a polygon (numpy array, tuple of coords, or klayout) to shapely.
+
+    Returns ``None`` if conversion fails.
+    """
+    import numpy as np
+    from shapely.geometry import Polygon
+
+    # numpy array from get_polygons_points (Nx2 or NxM)
+    if isinstance(poly, np.ndarray):
+        coords = poly.reshape(-1, 2)
+        if len(coords) >= 3:
+            return Polygon(coords)
+        return None
+
+    # list/tuple of coordinate pairs
+    if isinstance(poly, (tuple, list)):
+        return Polygon(poly)
+
+    # klayout PolygonWithProperties
+    if hasattr(poly, "to_simple_polygon"):
+        sp = poly.to_simple_polygon()
+        coords = [(sp.point(i).x, sp.point(i).y) for i in range(sp.num_points())]
+        if len(coords) >= 3:
+            return Polygon(coords)
+        return None
+
+    return None
+
+
+def _layer_x_intervals_at_y(
+    component: Component,
+    layer: object,
+    y_cut: float,
+) -> list[tuple[float, float]]:
+    """Return sorted *x*-intervals where *layer*'s polygons intersect *y = y_cut*.
+
+    Args:
+        component: GDSFactory component.
+        layer: A :class:`Layer` with ``.gds_layer`` attribute.
+        y_cut: *y* coordinate of the slicing line.
+
+    Returns:
+        Sorted list of ``(x_min, x_max)`` tuples.
+    """
+    from shapely.geometry import LineString, MultiLineString
+
+    gds_layer = getattr(layer, "gds_layer", None)
+    if gds_layer is None:
+        return []
+
+    try:
+        polys = component.get_polygons_points(layers=(tuple(gds_layer),), merge=True)
+    except Exception:
+        try:
+            polys = component.dup().get_polygons_points(
+                layers=(tuple(gds_layer),), merge=True
+            )
+        except Exception:
+            return []
+    if not isinstance(polys, dict) or not polys:
+        return []
+
+    cut_line = LineString([(-1e6, y_cut), (1e6, y_cut)])
+
+    intervals: list[tuple[float, float]] = []
+    for polygons in polys.values():
+        for poly in polygons if isinstance(polygons, list) else [polygons]:
+            try:
+                spoly = _poly_to_shapely(poly)
+                if spoly is None:
+                    continue
+            except Exception:
+                continue
+            if spoly.is_empty:
+                continue
+            intersection = spoly.intersection(cut_line)
+            if intersection.is_empty:
+                continue
+            lines: list = []
+            if isinstance(intersection, LineString):
+                lines = [intersection]
+            elif isinstance(intersection, MultiLineString):
+                lines = list(intersection.geoms)
+            else:
+                for g in getattr(intersection, "geoms", []):
+                    if isinstance(g, LineString):
+                        lines.append(g)
+            for line in lines:
+                coords = list(line.coords)
+                if len(coords) < 2:
+                    continue
+                xs = [c[0] for c in coords]
+                intervals.append((min(xs), max(xs)))
+
+    intervals.sort()
+    return _merge_intervals(intervals)
+
+
+def _merge_intervals(
+    intervals: list[tuple[float, float]],
+) -> list[tuple[float, float]]:
+    """Merge overlapping intervals."""
+    if not intervals:
+        return []
+    merged: list[tuple[float, float]] = [intervals[0]]
+    for start, end in intervals[1:]:
+        last_start, last_end = merged[-1]
+        if start <= last_end:
+            merged[-1] = (last_start, max(last_end, end))
+        else:
+            merged.append((start, end))
+    return merged
+
+
+def _layer_y_intervals_at_x(
+    component: Component,
+    layer: object,
+    x_cut: float,
+) -> list[tuple[float, float]]:
+    """Return sorted *y*-intervals where *layer*'s polygons intersect *x = x_cut*.
+
+    Analogous to :func:`_layer_x_intervals_at_y` but slicing vertically
+    at a fixed *x* coordinate.  Used for YZ waveguide cross-sections.
+
+    Args:
+        component: GDSFactory component.
+        layer: A :class:`Layer` with ``.gds_layer`` attribute.
+        x_cut: *x* coordinate of the slicing line.
+
+    Returns:
+        Sorted list of ``(y_min, y_max)`` tuples.
+    """
+    from shapely.geometry import LineString, MultiLineString
+
+    gds_layer = getattr(layer, "gds_layer", None)
+    if gds_layer is None:
+        return []
+
+    try:
+        polys = component.get_polygons_points(layers=(tuple(gds_layer),), merge=True)
+    except Exception:
+        try:
+            polys = component.dup().get_polygons_points(
+                layers=(tuple(gds_layer),), merge=True
+            )
+        except Exception:
+            return []
+    if not isinstance(polys, dict) or not polys:
+        return []
+
+    cut_line = LineString([(x_cut, -1e6), (x_cut, 1e6)])
+
+    intervals: list[tuple[float, float]] = []
+    for polygons in polys.values():
+        for poly in polygons if isinstance(polygons, list) else [polygons]:
+            try:
+                spoly = _poly_to_shapely(poly)
+                if spoly is None:
+                    continue
+            except Exception:
+                continue
+            if spoly.is_empty:
+                continue
+            intersection = spoly.intersection(cut_line)
+            if intersection.is_empty:
+                continue
+            lines: list = []
+            if isinstance(intersection, LineString):
+                lines = [intersection]
+            elif isinstance(intersection, MultiLineString):
+                lines = list(intersection.geoms)
+            else:
+                for g in getattr(intersection, "geoms", []):
+                    if isinstance(g, LineString):
+                        lines.append(g)
+            for line in lines:
+                coords = list(line.coords)
+                if len(coords) < 2:
+                    continue
+                ys = [c[1] for c in coords]
+                intervals.append((min(ys), max(ys)))
+
+    intervals.sort()
+    return _merge_intervals(intervals)
+
+
+# ------------------------------------------------------------------
+# Eigenmode computation helpers
+# ------------------------------------------------------------------
+
+
+def _compute_eigenmode(
+    sim: Any,
+    cell_size: Any,
+    wavelength: float,
+    *,
+    band_num: int = 1,
+    parity: str = "NO_PARITY",
+    kpoint: Any | None = None,
+    eigensolver_tol: float = 1e-6,
+    field_x_grid: np.ndarray | None = None,
+    field_y_grid: np.ndarray | None = None,
+    field_z_grid: np.ndarray | None = None,
+    x_grid: np.ndarray | None = None,
+    y_grid: np.ndarray | None = None,
+    z_grid: np.ndarray | None = None,
+    stack: Any | None = None,
+    component: Any | None = None,
+    port_or_position: str | tuple[float, float] | None = None,
+    cross_section_plane: str | None = None,
+) -> ModeResult:
+    """Run ``sim.get_eigenmode()`` and pack the result into a :class:`ModeResult`.
+
+    Field profiles are only extracted when both a horizontal grid
+    (``field_x_grid`` or ``field_y_grid``) and ``field_z_grid`` are
+    provided.  Otherwise ``result.fields`` is empty.
+
+    For XZ cells, use ``field_x_grid`` + ``field_z_grid`` (samples at
+    ``(x, 0, z)``).  For YZ cells, use ``field_y_grid`` +
+    ``field_z_grid`` (samples at ``(0, y, z)``).
+
+    Args:
+        sim: Initialized MEEP :class:`Simulation` object.
+        cell_size: ``mp.Vector3`` cell dimensions.
+        wavelength: Free-space wavelength in µm.
+        band_num: Mode band index (1 = fundamental).
+        parity: Parity string (``"NO_PARITY"``, ``"EVEN_Y"``, etc.).
+        kpoint: Optional ``mp.Vector3`` wavevector for the eigenmode.
+            When set, MEEP can compute group velocity.
+        eigensolver_tol: MPB convergence tolerance (default 1e-6).
+        field_x_grid: 1D array of *x* coordinates for field sampling
+            (µm, origin at cell centre).  For XZ cells.
+        field_y_grid: 1D array of *y* coordinates for field sampling
+            (µm, origin at cell centre).  For YZ cells.
+        field_z_grid: 1D array of *z* coordinates for field sampling
+            (µm, origin at cell centre).  ``None`` skips extraction.
+        x_grid: User-facing X-axis grid (µm, absolute frame) stored on
+            :class:`ModeResult` for downstream plotting.  ``None`` if
+            unavailable.
+        y_grid: User-facing Y-axis grid (µm, absolute frame) stored on
+            :class:`ModeResult`.  ``None`` if unavailable.
+        z_grid: User-facing Z-axis grid (µm, absolute frame) stored on
+            :class:`ModeResult`.  ``None`` if unavailable.
+        stack: :class:`LayerStack` stored on :class:`ModeResult` for
+            index profile reconstruction.
+        component: GDSFactory :class:`Component` for cross-section modes.
+        port_or_position: Port name or ``(x, y)`` position for
+            cross-section modes.
+        cross_section_plane: ``"xz"`` or ``"yz"`` for cross-section
+            modes.  ``None`` for slab modes.
+
+    Returns:
+        :class:`ModeResult` with effective index, fields (if grids
+        provided), wavevectors, and group index.
+    """
+    mp = _import_meep()
+    import numpy as np
+
+    frequency = 1.0 / wavelength
+    parity_int = _PARITY_MAP.get(parity, 0)
+    if kpoint is None:
+        kpoint = mp.Vector3()
+
+    # The mode propagates along X — we place a flux plane at the centre
+    # of the cell in the YZ plane.
+    where = mp.Volume(
+        center=mp.Vector3(0.0, 0.0, 0.0),
+        size=mp.Vector3(0.0, cell_size.y, cell_size.z),
+    )
+
+    mode = sim.get_eigenmode(
+        frequency,
+        mp.X,  # propagation direction
+        where,
+        band_num=band_num,
+        kpoint=kpoint,
+        parity=parity_int,
+        resolution=0,
+        eigensolver_tol=eigensolver_tol,
+    )
+
+    if mode is None:
+        raise RuntimeError(
+            f"get_eigenmode returned None for band {band_num} "
+            f"at wavelength {wavelength} µm"
+        )
+
+    # --- optional field profile sampling ---
+    fields: dict[str, np.ndarray] = {}
+    if field_z_grid is not None:
+        _horizontal_grid = field_y_grid if field_y_grid is not None else field_x_grid
+        if _horizontal_grid is not None:
+            _use_yz = field_y_grid is not None
+            for comp_name in ("Ex", "Ey", "Ez", "Hx", "Hy", "Hz"):
+                try:
+                    comp = getattr(mp, comp_name)
+                    arr = np.zeros(
+                        (len(field_z_grid), len(_horizontal_grid)),
+                        dtype=np.complex128,
+                    )
+                    for iz, z in enumerate(field_z_grid):
+                        for ih, h in enumerate(_horizontal_grid):
+                            if _use_yz:
+                                pt = mp.Vector3(0.0, float(h), float(z))
+                            else:
+                                pt = mp.Vector3(float(h), 0.0, float(z))
+                            arr[iz, ih] = mode.amplitude(pt, comp)
+                    if np.any(arr != 0):
+                        fields[comp_name] = arr
+                except Exception:
+                    pass
+
+    # Compute n_eff from dominant wavevector
+    kdom_vec = mode.kdom
+    kdom_list = [float(kdom_vec.x), float(kdom_vec.y), float(kdom_vec.z)]
+    kdom_mag = float(np.linalg.norm(kdom_list))
+    n_eff = kdom_mag / frequency if frequency > 0 else 0.0
+
+    # Group index from MEEP's internal group_velocity (dw/dk at Gamma)
+    n_group: float | None = None
+    try:
+        vg = mode.group_velocity
+        if vg is not None and vg != 0:
+            n_group = 1.0 / float(vg)  # c=1 in MEEP -> n_g = 1/vg
+    except Exception:
+        pass
+
+    return ModeResult(
+        n_eff=n_eff,
+        wavelength=wavelength,
+        frequency=frequency,
+        fields=fields,
+        kdom=kdom_list,
+        n_group=n_group,
+        band_num=band_num,
+        parity=parity,
+        x_grid=x_grid,
+        y_grid=y_grid,
+        z_grid=z_grid,
+        stack=stack,
+        component=component,
+        port_or_position=port_or_position,
+        cross_section_plane=cross_section_plane,
+    )
+
+
+# ------------------------------------------------------------------
+# Mode validation
+# ------------------------------------------------------------------
+
+
+def _validate_mode(
+    result: ModeResult,
+    material_data: dict[str, MaterialData],
+    _stack: object,
+    *,
+    is_slab: bool = False,
+) -> None:
+    """Warn if the mode result appears unphysical (leaky / below cutoff).
+
+    Checks performed:
+    - **Minimum cladding index**: if ``n_eff`` is below the lowest
+      non-air refractive index in the stack, the mode is likely a
+      radiation / leaky mode rather than a guided mode.
+    - **Slab kz cleanliness**: for a 1D slab mode the dominant
+      wavevector should have negligible *z*-component (kz ~= 0).
+      A large ``kz`` indicates a spurious mode picked up by MPB.
+    - **Negative group index**: ``n_group < 0`` is unphysical for
+      forward-propagating dielectric modes.
+    """
+    import logging
+    import math
+
+    logger = logging.getLogger(__name__)
+
+    # --- minimum cladding index ---
+    n_clad_min = None
+    n_core_max = None
+    for mat in material_data.values():
+        eps = getattr(mat, "epsilon_diag", None)
+        if eps is None:
+            continue
+        if isinstance(eps, list):
+            eps = eps[0]
+        if eps <= 0:
+            continue
+        n = math.sqrt(float(eps))
+        if n_clad_min is None or n < n_clad_min:
+            n_clad_min = n
+        if n_core_max is None or n > n_core_max:
+            n_core_max = n
+
+    issues: list[str] = []
+
+    if n_clad_min is not None and result.n_eff <= n_clad_min:
+        issues.append(
+            f"n_eff={result.n_eff:.6f} is <= minimum cladding index "
+            f"(n_clad_min={n_clad_min:.6f}); mode is likely a radiation"
+            f" / leaky mode, not a guided mode"
+        )
+
+    if n_core_max is not None and result.n_eff > n_core_max + 0.01:
+        issues.append(
+            f"n_eff={result.n_eff:.6f} exceeds maximum core index "
+            f"(n_core_max={n_core_max:.6f}); result may be unphysical"
+        )
+
+    # --- slab kz purity ---
+    if is_slab and len(result.kdom) >= 3:
+        kz = abs(result.kdom[2])
+        kx = abs(result.kdom[0])
+        if kx > 0 and kz > kx * 0.05:
+            issues.append(
+                f"Slab mode has significant kz ({kz:.4f} vs kx={kx:.4f}); "
+                f"result may be a spurious 2D parasitic mode picked up by MPB"
+            )
+
+    # --- negative group index ---
+    if result.n_group is not None and result.n_group < 0:
+        issues.append(
+            f"n_group={result.n_group:.6f} is negative; "
+            f"unphysical for forward-propagating dielectric modes"
+        )
+
+    if issues:
+        summary = "; ".join(issues)
+        logger.info(
+            "Mode band %d physical validity concern: %s", result.band_num, summary
+        )
+
+
+# ------------------------------------------------------------------
+# Public utilities
+# ------------------------------------------------------------------
+
+
+def mode_z_grid(
+    stack: LayerStack,
+    n_points: int,
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+) -> np.ndarray:
+    """Compute Z-axis coordinates in absolute frame matching layer ``zmin``/``zmax``.
+
+    The returned grid has the same length as the Z (first) axis of
+    ``ModeResult.fields`` arrays produced by :func:`solve_slab_mode`
+    and :func:`solve_cross_section_mode`.
+
+    Args:
+        stack: :class:`LayerStack` defining the vertical material profile.
+        n_points: Number of grid points (typically ``resolution * z_span``).
+        z_margin: Extra distance (µm) added below and above the stack.  A
+            single float adds the same margin on both sides; a ``(bottom,
+            top)`` tuple adds asymmetric margins.  Must match the
+            ``z_margin`` passed to the solver.  Default 0 — grid covers
+            exactly the stack extent.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            When set, extends the span by ``pml_thickness`` on each side
+            to match the MEEP cell including PML boundaries.
+            Must match the ``pml_thickness`` passed to the solver.
+
+    Returns:
+        ``np.ndarray`` of *z* coordinates in µm (absolute frame).
+    """
+    import numpy as np
+
+    z_min = min(layer.zmin for layer in stack.layers.values())
+    z_max = max(layer.zmax for layer in stack.layers.values())
+    if isinstance(z_margin, (tuple, list)):
+        z_margin_bottom, z_margin_top = z_margin
+    else:
+        z_margin_bottom = z_margin_top = z_margin
+
+    bottom = z_min - z_margin_bottom - pml_thickness
+    top = z_max + z_margin_top + pml_thickness
+    span = top - bottom
+    dz = span / n_points
+    return np.linspace(bottom + dz / 2, top - dz / 2, n_points)
+
+
+def mode_x_grid(n_points: int, x_span: float, pml_thickness: float = 0.0) -> np.ndarray:
+    """Compute X-axis coordinates centred on the cell midpoint.
+
+    The returned grid has the same length as the X (second) axis of
+    ``ModeResult.fields`` arrays produced by
+    :func:`solve_cross_section_mode`.
+
+    Args:
+        n_points: Number of grid points (typically ``resolution * x_span``).
+        x_span: Total X-extent of the MEEP cell in µm (excluding PML).
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            When set, extends the span by ``2 * pml_thickness`` to match
+            the MEEP cell including PML boundaries.
+
+    Returns:
+        ``np.ndarray`` of *x* coordinates in µm, origin at cell midpoint.
+    """
+    import numpy as np
+
+    total_span = x_span + 2 * pml_thickness
+    dx = total_span / n_points
+    return np.linspace(-total_span / 2 + dx / 2, total_span / 2 - dx / 2, n_points)
+
+
+def mode_y_grid(n_points: int, y_span: float, pml_thickness: float = 0.0) -> np.ndarray:
+    """Compute Y-axis coordinates centred on the cell midpoint.
+
+    The returned grid has the same length as the Y (second) axis of
+    ``ModeResult.fields`` arrays produced when using a YZ cross-section
+    in :func:`solve_cross_section_mode`.
+
+    Args:
+        n_points: Number of grid points (typically ``resolution * y_span``).
+        y_span: Total Y-extent of the MEEP cell in µm (excluding PML).
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            When set, extends the span by ``2 * pml_thickness`` to match
+            the MEEP cell including PML boundaries.
+
+    Returns:
+        ``np.ndarray`` of *y* coordinates in µm, origin at cell midpoint.
+    """
+    import numpy as np
+
+    total_span = y_span + 2 * pml_thickness
+    dy = total_span / n_points
+    return np.linspace(-total_span / 2 + dy / 2, total_span / 2 - dy / 2, n_points)
+
+
+def refractive_index_profile(
+    stack: LayerStack,
+    wavelength: float,
+    *,
+    z_grid: np.ndarray,
+    y_grid: np.ndarray | None = None,
+    x_grid: np.ndarray | None = None,
+    component: Component | None = None,
+    port: str | None = None,
+    background_material: str = "air",
+) -> np.ndarray:
+    """Compute piecewise-constant refractive index at a wavelength.
+
+    **1D** (default) — profile along *z* only, returns ``(nz,)``::
+
+        n_prof = refractive_index_profile(stack, wavelength, z_grid=z_grid)
+
+    **2D YZ cross-section** — returns ``(nz, ny)``::
+
+        n_yz = refractive_index_profile(
+            stack,
+            wavelength,
+            z_grid=z_grid,
+            y_grid=y_grid,
+            component=component,
+            port="o1",
+        )
+
+    **2D XZ cross-section** — returns ``(nz, nx)``::
+
+        n_xz = refractive_index_profile(
+            stack,
+            wavelength,
+            z_grid=z_grid,
+            x_grid=x_grid,
+            component=component,
+            port="o1",
+        )
+
+    The cross-section plane is auto-detected from the port orientation
+    (same logic as :func:`solve_cross_section_mode`):
+    - Port at 0° / 180°: YZ plane, ``x_cut`` from port centre *x*.
+    - Port at 90° / 270°: XZ plane, ``y_cut`` from port centre *y*.
+
+    Layers with no GDS polygons are treated as full-span background layers
+    (same fallback as ``_build_component_yz_cell``).
+
+    Args:
+        stack: :class:`LayerStack` defining the vertical material profile.
+        wavelength: Free-space wavelength in µm for material evaluation.
+        z_grid: 1D array of *z* coordinates (absolute frame, matching
+            ``mode_z_grid`` output).
+        y_grid: 1D array of *y* coordinates (absolute frame).  Use with YZ
+            cross-sections.  Mutually exclusive with ``x_grid``.
+        x_grid: 1D array of *x* coordinates (absolute frame).  Use with XZ
+            cross-sections.  Mutually exclusive with ``y_grid``.
+        component: GDSFactory component (required for 2D mode together
+            with ``port``).
+        port: Port name in *component*.  Auto-derives the slice coordinate
+            and cross-section plane.
+
+    Returns:
+        ``np.ndarray`` — 1D ``(nz,)`` or 2D ``(nz, ny)`` / ``(nz, nx)``.
+    """
+    import numpy as np
+
+    used_materials: set[str] = {layer.material for layer in stack.layers.values()}
+    used_materials.discard("air")
+    if background_material != "air":
+        used_materials.add(background_material)
+    material_data = _resolve_materials_cached(
+        used_materials,
+        overrides={},
+        wavelength_um=wavelength,
+    )
+    bg_mat = material_data.get(background_material)
+    n_bg = 1.0
+    if bg_mat is not None and bg_mat.epsilon_diag is not None:
+        eps_bg = bg_mat.epsilon_diag
+        if isinstance(eps_bg, list):
+            eps_bg = eps_bg[0]
+        if eps_bg > 0:
+            n_bg = np.sqrt(eps_bg)
+
+    if component is None or port is None:
+        if y_grid is not None and x_grid is None and component is not None:
+            raise ValueError(
+                "port is required for 2D refractive_index_profile "
+                "when component is given"
+            )
+        if x_grid is not None:
+            raise ValueError(
+                "port is required for 2D refractive_index_profile when x_grid is given"
+            )
+        n_profile = np.full_like(z_grid, n_bg)
+        for layer in stack.layers.values():
+            if layer.material == "air":
+                continue
+            mat = material_data.get(layer.material)
+            if mat is None or mat.epsilon_diag is None:
+                continue
+            eps = mat.epsilon_diag
+            if isinstance(eps, list):
+                eps = eps[0]
+            if eps <= 0:
+                continue
+            mask = (z_grid >= layer.zmin) & (z_grid < layer.zmax)
+            n_profile[mask] = np.sqrt(eps)
+        return n_profile
+
+    # --- 2D path ---
+    port_info = None
+    for p in component.ports:
+        if p.name == port:
+            port_info = p
+            break
+    if port_info is None:
+        available = [p.name for p in component.ports]
+        raise ValueError(
+            f"Port '{port}' not found in component. Available: {available}"
+        )
+
+    port_ori = float(getattr(port_info, "orientation", 0))
+    use_yz = port_ori % 180 == 0
+
+    if use_yz:
+        if y_grid is None:
+            raise ValueError(
+                "y_grid is required for YZ cross-section (port orientation "
+                f"{port_ori}°). Pass y_grid as returned by mode_y_grid()."
+            )
+        if x_grid is not None:
+            raise ValueError(
+                "x_grid is not valid for YZ cross-section (port orientation "
+                f"{port_ori}°). Use y_grid instead."
+            )
+        x_cut = float(port_info.center[0])
+        horizontal_grid = y_grid
+        interval_func = _layer_y_intervals_at_x
+        cut_coord = x_cut
+    else:
+        if x_grid is None:
+            raise ValueError(
+                "x_grid is required for XZ cross-section (port orientation "
+                f"{port_ori}°). Pass x_grid as returned by mode_x_grid()."
+            )
+        if y_grid is not None:
+            raise ValueError(
+                "y_grid is not valid for XZ cross-section (port orientation "
+                f"{port_ori}°). Use x_grid instead."
+            )
+        y_cut = float(port_info.center[1])
+        horizontal_grid = x_grid
+        interval_func = _layer_x_intervals_at_y
+        cut_coord = y_cut
+
+    nh = len(horizontal_grid)
+    nz = len(z_grid)
+    n_profile = np.full((nz, nh), n_bg)
+    set_by_layer = np.zeros((nz, nh), dtype=bool)
+
+    layer_h_masks: dict[tuple, np.ndarray] = {}
+    for layer in stack.layers.values():
+        if layer.material == "air":
+            continue
+        gds_layer = getattr(layer, "gds_layer", None)
+        if gds_layer is None:
+            continue
+        intervals = interval_func(component, layer, cut_coord)
+        if not intervals and not _layer_has_any_polygon(component, layer):
+            intervals = [(-np.inf, np.inf)]
+        mask = np.zeros(nh, dtype=bool)
+        for lo, hi in intervals:
+            mask |= (horizontal_grid >= lo) & (horizontal_grid <= hi)
+        layer_h_masks[gds_layer] = mask
+
+    for layer in stack.layers.values():
+        if layer.material == "air":
+            continue
+        mat = material_data.get(layer.material)
+        if mat is None or mat.epsilon_diag is None:
+            continue
+        eps = mat.epsilon_diag
+        if isinstance(eps, list):
+            eps = eps[0]
+        if eps <= 0:
+            continue
+        gds_layer = getattr(layer, "gds_layer", None)
+        h_mask = layer_h_masks.get(gds_layer)
+        if h_mask is None:
+            continue
+        z_mask = (z_grid >= layer.zmin) & (z_grid < layer.zmax)
+        n_profile[np.ix_(z_mask, h_mask)] = np.sqrt(eps)
+        set_by_layer[np.ix_(z_mask, h_mask)] = True
+
+    for ih in range(nh):
+        col = n_profile[:, ih]
+        col_set = set_by_layer[:, ih]
+        if not col_set.any():
+            continue
+        first_set = int(np.where(col_set)[0][0])
+        if first_set > 0:
+            fill_mask = ~col_set[:first_set]
+            col[:first_set][fill_mask] = col[first_set]
+
+    return n_profile
+
+
+# ------------------------------------------------------------------
+# Public API
+# ------------------------------------------------------------------
+
+
+def solve_slab_mode(
+    stack: LayerStack,
+    wavelength: float,
+    *,
+    band_num: int = 1,
+    parity: str = "NO_PARITY",
+    resolution: float = 32,
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+    eigensolver_tol: float = 1e-6,
+    field_z_grid: np.ndarray | None = None,
+    background_material: str = "air",
+) -> ModeResult:
+    """Solve for the 1D slab mode of a uniform layer stack.
+
+    The slab is assumed infinite in *x* and *y*; the mode propagates along
+    *x* with field variation only along *z*.  Uses a 2D XZ MEEP simulation
+    cell.
+
+    By default no field profiles are extracted.  Pass a ``field_z_grid``
+    to sample the eigenmode fields along *z* at ``x=0`` (a single column).
+
+    Args:
+        stack: Layer stack defining the vertical material profile.
+        wavelength: Free-space wavelength in µm.
+        band_num: Mode band index (1 = fundamental TE/TM slab mode).
+        parity: Parity of the mode (``"NO_PARITY"``, ``"EVEN_Y"``, etc.).
+        resolution: Pixels per µm (default 32).
+        z_margin: Extra distance (µm) added below and above the stack.  A
+            single float adds the same margin on both sides; a ``(bottom,
+            top)`` tuple adds asymmetric margins.  Default 0 — cell
+            exactly spans the stack extent.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            Set to e.g. 1.0 to enable PML absorbing boundaries.
+        eigensolver_tol: MPB convergence tolerance (default 1e-6).
+            Relax to 1e-5 for faster but less accurate solves.
+        field_z_grid: 1D array of *z* coordinates (µm, absolute frame
+            matching ``mode_z_grid``) at which to sample
+            ``mode.amplitude()``.  The *x*-coordinate is fixed at 0.
+            When ``None`` (default) no field extraction is performed
+            and ``result.fields`` is empty.
+
+    Returns:
+        :class:`ModeResult` with effective index, field profiles (if
+        ``field_z_grid`` provided), and group index.
+    """
+    _import_meep()
+    import numpy as np
+
+    if stack is None:
+        raise ValueError("stack must be a LayerStack, got None")
+
+    used_materials: set[str] = set()
+    for layer in stack.layers.values():
+        used_materials.add(layer.material)
+    for diel in stack.dielectrics:
+        used_materials.add(diel["material"])
+    if background_material != "air":
+        used_materials.add(background_material)
+
+    material_data = _resolve_materials_cached(
+        used_materials,
+        overrides={},
+        wavelength_um=wavelength,
+    )
+
+    _z_margin_cell = z_margin
+    sim, cell_size = _build_slab_xz_cell(
+        stack,
+        material_data,
+        resolution,
+        z_margin=_z_margin_cell,
+        pml_thickness=pml_thickness,
+        background_material=background_material,
+    )
+    sim.init_sim()
+
+    field_x_grid: np.ndarray | None = None
+    field_z_grid_meep: np.ndarray | None = None
+    if field_z_grid is not None:
+        field_x_grid = np.array([0.0])
+        # Compute z_cell_center same way as _build_slab_xz_cell
+        z_min = min(layer.zmin for layer in stack.layers.values())
+        z_max = max(layer.zmax for layer in stack.layers.values())
+        if isinstance(z_margin, (tuple, list)):
+            zm_bottom, zm_top = z_margin
+        else:
+            zm_bottom = zm_top = z_margin
+        z_cell_center = (z_min + z_max) / 2.0 + (zm_top - zm_bottom) / 2.0
+        field_z_grid_meep = field_z_grid - z_cell_center
+    else:
+        field_z_grid_meep = None
+
+    try:
+        result = _compute_eigenmode(
+            sim,
+            cell_size,
+            wavelength,
+            band_num=band_num,
+            parity=parity,
+            eigensolver_tol=eigensolver_tol,
+            field_x_grid=field_x_grid,
+            field_z_grid=field_z_grid_meep,
+            z_grid=field_z_grid,
+            stack=stack,
+        )
+    finally:
+        sim.reset_meep()
+
+    _validate_mode(result, material_data, stack, is_slab=True)
+    return result
+
+
+def solve_cross_section_mode(
+    component: Component,
+    stack: LayerStack,
+    *,
+    port: str | None = None,
+    position: tuple[float, float] | None = None,
+    x_span: float | None = None,
+    y_span: float | None = None,
+    cross_section_plane: str = "auto",
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+    eigensolver_tol: float = 1e-6,
+    wavelength: float,
+    band_num: int = 1,
+    parity: str = "NO_PARITY",
+    resolution: float = 32,
+    field_x_grid: np.ndarray | None = None,
+    field_y_grid: np.ndarray | None = None,
+    field_z_grid: np.ndarray | None = None,
+    background_material: str = "air",
+) -> ModeResult:
+    """Solve for the eigenmode of a 2D waveguide cross-section.
+
+    Takes a slice through the component at a specified port or position
+    and builds a 2D MEEP cell.  The cross-section plane is determined by
+    the port orientation (auto-detected by default):
+
+    - **YZ plane**: port orientation 0° or 180° (waveguide along X).
+      Slice at *x = port_center[0]*, build YZ cell.
+    - **XZ plane**: port orientation 90° or 270° (waveguide along Y).
+      Slice at *y = port_center[1]*, build XZ cell.
+
+    By default no field profiles are extracted.  Pass horizontal and
+    vertical grids to sample the eigenmode fields on a 2D grid.
+
+    One of ``port`` or ``position`` must be given:
+     - ``port="o1"`` — auto-extracts the cross-section at the port
+       centre.  Requires ``y_span`` (YZ) or ``x_span`` (XZ) to be
+       passed explicitly.
+     - ``position=(x, y)`` — requires ``x_span`` for XZ or ``y_span`` for
+       YZ, and ``cross_section_plane`` must be set explicitly.
+
+    Args:
+        component: GDSFactory component with ports and polygons.
+        stack: Layer stack (already resolved by caller or via
+            :meth:`Simulation._resolve_stack_and_materials`).
+        port: Port name to auto-extract slice location and span.
+        position: Arbitrary ``(x, y)`` point — only one coordinate is
+            used depending on the cross-section plane.
+        x_span: Total *x*-extent of the cell in µm. Required for XZ
+            cross-sections when using ``position``.
+        y_span: Total *y*-extent of the cell in µm. Used for YZ
+            cross-sections; auto-derived from port width.
+        cross_section_plane: ``"auto"`` (default), ``"xz"``, or ``"yz"``.
+            ``"auto"`` detects from port orientation.
+        z_margin: Extra distance (µm) added below and above the stack.  A
+            single float adds the same margin on both sides; a ``(bottom,
+            top)`` tuple adds asymmetric margins.  Default 0 — cell
+            exactly spans the stack extent.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+            Set to e.g. 1.0 to enable PML absorbing boundaries.
+        eigensolver_tol: MPB convergence tolerance (default 1e-6).
+            Relax to 1e-5 for faster but less accurate solves.
+        wavelength: Free-space wavelength in µm.
+            band_num: Mode band index (1 = fundamental).
+        parity: Parity of the mode.
+        resolution: Pixels per µm (default 32).
+        field_x_grid: 1D array of *x* coordinates for field sampling
+            (µm, absolute frame).  For XZ cells.  ``None`` skips.
+        field_y_grid: 1D array of *y* coordinates for field sampling
+            (µm, absolute frame).  For YZ cells.  ``None`` skips.
+        field_z_grid: 1D array of *z* coordinates for field sampling
+            (µm, absolute frame matching ``mode_z_grid``).  ``None``
+            skips extraction.
+        background_material: Material name for the MEEP default medium
+            (fills space not covered by any layer). Default ``"air"``
+            (epsilon=1.0).
+
+    Returns:
+        :class:`ModeResult` with effective index, field profiles (if
+        grids provided), and group index.
+    """
+    _import_meep()
+
+    if stack is None:
+        raise ValueError("stack must be a LayerStack, got None")
+    if component is None:
+        raise ValueError("component must be a Component, got None")
+
+    _use_yz: bool
+    _span: float
+
+    if port is not None:
+        port_info = None
+        for p in component.ports:
+            if p.name == port:
+                port_info = p
+                break
+        if port_info is None:
+            available = [p.name for p in component.ports]
+            raise ValueError(
+                f"Port '{port}' not found in component. Available: {available}"
+            )
+        port_ori = float(getattr(port_info, "orientation", 0))
+
+        if cross_section_plane == "auto":
+            _use_yz = port_ori % 180 == 0
+        elif cross_section_plane == "yz":
+            _use_yz = True
+        elif cross_section_plane == "xz":
+            _use_yz = False
+        else:
+            raise ValueError(
+                f"cross_section_plane must be 'auto', 'xz', or 'yz', "
+                f"got {cross_section_plane!r}"
+            )
+
+        if _use_yz:
+            x_cut = float(port_info.center[0])
+            if y_span is None:
+                raise ValueError(
+                    "y_span is required for YZ cross-section with port. "
+                    "Pass y_span explicitly."
+                )
+            _span = y_span
+        else:
+            y_cut = float(port_info.center[1])
+            if x_span is None:
+                raise ValueError(
+                    "x_span is required for XZ cross-section with port. "
+                    "Pass x_span explicitly."
+                )
+            _span = x_span
+    elif position is not None:
+        if cross_section_plane == "auto":
+            _use_yz = False  # default to XZ for position mode backward compat
+        else:
+            _use_yz = cross_section_plane == "yz"
+        if _use_yz:
+            if y_span is None:
+                raise ValueError(
+                    "y_span is required for YZ cross-section with position"
+                )
+            x_cut = float(position[0])
+            _span = y_span
+        else:
+            if x_span is None:
+                raise ValueError(
+                    "x_span is required for XZ cross-section with position"
+                )
+            y_cut = float(position[1])
+            _span = x_span
+    else:
+        raise ValueError("Either port or position must be specified")
+
+    used_materials: set[str] = set()
+    for layer in stack.layers.values():
+        used_materials.add(layer.material)
+    for diel in stack.dielectrics:
+        used_materials.add(diel["material"])
+    if background_material != "air":
+        used_materials.add(background_material)
+
+    material_data = _resolve_materials_cached(
+        used_materials,
+        overrides={},
+        wavelength_um=wavelength,
+    )
+
+    if _use_yz:
+        sim, cell_size = _build_component_yz_cell(
+            component,
+            stack,
+            x_cut,
+            _span,
+            material_data,
+            resolution,
+            z_margin=z_margin,
+            pml_thickness=pml_thickness,
+            background_material=background_material,
+        )
+    else:
+        sim, cell_size = _build_component_xz_cell(
+            component,
+            stack,
+            y_cut,
+            _span,
+            material_data,
+            resolution,
+            z_margin=z_margin,
+            pml_thickness=pml_thickness,
+            background_material=background_material,
+        )
+    sim.init_sim()
+
+    # Convert field_z_grid from absolute to MEEP frame
+    z_min = min(layer.zmin for layer in stack.layers.values())
+    z_max = max(layer.zmax for layer in stack.layers.values())
+    if isinstance(z_margin, (tuple, list)):
+        zm_bottom, zm_top = z_margin
+    else:
+        zm_bottom = zm_top = z_margin
+    z_cell_center = (z_min + z_max) / 2.0 + (zm_top - zm_bottom) / 2.0
+    field_z_grid_meep = (
+        field_z_grid - z_cell_center if field_z_grid is not None else None
+    )
+
+    try:
+        result = _compute_eigenmode(
+            sim,
+            cell_size,
+            wavelength,
+            band_num=band_num,
+            parity=parity,
+            eigensolver_tol=eigensolver_tol,
+            field_x_grid=field_x_grid,
+            field_y_grid=field_y_grid,
+            field_z_grid=field_z_grid_meep,
+            x_grid=field_x_grid,
+            y_grid=field_y_grid,
+            z_grid=field_z_grid,
+            stack=stack,
+            component=component,
+            port_or_position=port if port is not None else position,
+            cross_section_plane="yz" if _use_yz else "xz",
+        )
+    finally:
+        sim.reset_meep()
+
+    _validate_mode(result, material_data, stack, is_slab=False)
+    return result
+
+
+# ------------------------------------------------------------------
+# Batch slab mode solver — reuses simulation across bands
+# ------------------------------------------------------------------
+
+
+def solve_slab_modes(
+    stack: LayerStack,
+    wavelength: float,
+    *,
+    band_nums: list[int] | None = None,
+    parity: str = "NO_PARITY",
+    resolution: float = 32,
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+    background_material: str = "air",
+    eigensolver_tol: float = 1e-6,
+    field_z_grid: np.ndarray | None = None,
+) -> dict[int, ModeResult]:
+    """Solve multiple slab mode bands with a single simulation setup.
+
+    Builds the MEEP cell once, then loops over *band_nums* reusing the
+    same grid. Material resolution, geometry, and PML are computed once.
+
+    Args:
+        stack: Layer stack defining the vertical material profile.
+        wavelength: Free-space wavelength in µm.
+        band_nums: Mode band indices (default ``[1]`` — fundamental only).
+        parity: Parity of the modes.
+        resolution: Pixels per µm (default 32).
+        z_margin: Extra distance (µm) added below and above the stack.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+        eigensolver_tol: MPB convergence tolerance (default 1e-6).
+        field_z_grid: 1D array of *z* coordinates for field sampling.
+            ``None`` skips extraction for all bands.
+
+    Returns:
+        Dict mapping ``band_num`` to :class:`ModeResult`. Bands that fail
+        to converge are omitted from the dict.
+    """
+    _import_meep()
+    import numpy as np
+
+    if band_nums is None:
+        band_nums = [1]
+
+    if stack is None:
+        raise ValueError("stack must be a LayerStack, got None")
+
+    used_materials: set[str] = set()
+    for layer in stack.layers.values():
+        used_materials.add(layer.material)
+    for diel in stack.dielectrics:
+        used_materials.add(diel["material"])
+    if background_material != "air":
+        used_materials.add(background_material)
+
+    material_data = _resolve_materials_cached(
+        used_materials,
+        overrides={},
+        wavelength_um=wavelength,
+    )
+
+    _z_margin_cell = z_margin
+    sim, cell_size = _build_slab_xz_cell(
+        stack,
+        material_data,
+        resolution,
+        z_margin=_z_margin_cell,
+        pml_thickness=pml_thickness,
+        background_material=background_material,
+    )
+    sim.init_sim()
+
+    field_x_grid: np.ndarray | None = None
+    field_z_grid_meep: np.ndarray | None = None
+    if field_z_grid is not None:
+        field_x_grid = np.array([0.0])
+        z_min = min(layer.zmin for layer in stack.layers.values())
+        z_max = max(layer.zmax for layer in stack.layers.values())
+        if isinstance(z_margin, (tuple, list)):
+            zm_bottom, zm_top = z_margin
+        else:
+            zm_bottom = zm_top = z_margin
+        z_cell_center = (z_min + z_max) / 2.0 + (zm_top - zm_bottom) / 2.0
+        field_z_grid_meep = field_z_grid - z_cell_center
+    else:
+        field_z_grid_meep = None
+
+    results: dict[int, ModeResult] = {}
+    try:
+        for band_num in band_nums:
+            try:
+                result = _compute_eigenmode(
+                    sim,
+                    cell_size,
+                    wavelength,
+                    band_num=band_num,
+                    parity=parity,
+                    eigensolver_tol=eigensolver_tol,
+                    field_x_grid=field_x_grid,
+                    field_z_grid=field_z_grid_meep,
+                    z_grid=field_z_grid,
+                    stack=stack,
+                )
+                _validate_mode(result, material_data, stack, is_slab=True)
+                results[band_num] = result
+            except RuntimeError:
+                pass
+    finally:
+        sim.reset_meep()
+
+    return results
+
+
+# ------------------------------------------------------------------
+# Wavelength-sweep slab mode solver — reuses geometry across lambda
+# ------------------------------------------------------------------
+
+
+def solve_slab_wavelength_sweep(
+    stack: LayerStack,
+    wavelengths: list[float],
+    *,
+    band_num: int = 1,
+    parity: str = "NO_PARITY",
+    resolution: float = 32,
+    z_margin: float | tuple[float, float] = 0.0,
+    pml_thickness: float = 0.0,
+    eigensolver_tol: float = 1e-6,
+    field_z_grid: np.ndarray | None = None,
+    background_material: str = "air",
+) -> dict[float, ModeResult]:
+    """Solve slab mode at multiple wavelengths reusing cell geometry.
+
+    The cell size, grid, PML, and layer positions are computed once.
+    Per-wavelength material epsilon values are resolved and a fresh
+    simulation is built (required for correct dispersion), but the
+    geometry coordinates and setup overhead are shared.
+
+    This is 2-3x faster than calling :func:`solve_slab_mode` in a loop
+    for moderate wavelength counts (5-30).
+
+    Args:
+        stack: Layer stack defining the vertical material profile.
+        wavelengths: List of free-space wavelengths in µm.
+        band_num: Mode band index (1 = fundamental).
+        parity: Parity of the mode.
+        resolution: Pixels per µm (default 32).
+        z_margin: Extra distance (µm) below and above the stack.
+        pml_thickness: PML absorber thickness in µm (default 0.0).
+        eigensolver_tol: MPB convergence tolerance (default 1e-6).
+        field_z_grid: 1D array of *z* coordinates for field sampling.
+            ``None`` skips field extraction for all wavelengths.
+
+    Returns:
+        Dict mapping wavelength to :class:`ModeResult`.
+    """
+    import logging
+
+    import numpy as np
+
+    mp = _import_meep()
+    logger = logging.getLogger(__name__)
+
+    if stack is None:
+        raise ValueError("stack must be a LayerStack, got None")
+
+    # --- pre-compute geometry meta-data (wavelength-independent) ---
+    z_min = min(layer.zmin for layer in stack.layers.values())
+    z_max = max(layer.zmax for layer in stack.layers.values())
+    if isinstance(z_margin, (tuple, list)):
+        z_margin_bottom, z_margin_top = z_margin
+    else:
+        z_margin_bottom = z_margin_top = z_margin
+    z_center = (z_min + z_max) / 2.0 + (z_margin_top - z_margin_bottom) / 2.0
+    x_span = 2.0 / resolution
+    z_span = (z_max - z_min) + z_margin_bottom + z_margin_top
+    if pml_thickness > 0:
+        x_span += 2 * pml_thickness
+        z_span += 2 * pml_thickness
+    x_span = round(x_span * resolution) / resolution
+    z_span = round(z_span * resolution) / resolution
+    cell_size = mp.Vector3(x_span, 0.0, z_span)
+
+    # Layer geometric descriptors (wavelength-independent)
+    _layer_specs: list[dict] = []
+    for layer in stack.layers.values():
+        if layer.material == "air":
+            continue
+        z_size = layer.zmax - layer.zmin
+        if z_size <= 0:
+            continue
+        _layer_specs.append(
+            {
+                "name": layer.material,
+                "center_z": layer.zmin + z_size / 2.0 - z_center,
+                "z_size": z_size,
+            }
+        )
+
+    used_materials: set[str] = {s["name"] for s in _layer_specs}
+    if background_material != "air":
+        used_materials.add(background_material)
+
+    field_x_grid: np.ndarray | None = None
+    field_z_grid_meep: np.ndarray | None = None
+    if field_z_grid is not None:
+        field_x_grid = np.array([0.0])
+        field_z_grid_meep = field_z_grid - z_center
+    else:
+        field_z_grid_meep = None
+
+    results: dict[float, ModeResult] = {}
+
+    for wl in wavelengths:
+        material_data = _resolve_materials_cached(
+            used_materials,
+            overrides={},
+            wavelength_um=wl,
+        )
+
+        geometry: list[object] = []
+        for spec in _layer_specs:
+            mat_data = material_data.get(spec["name"])
+            if mat_data is None:
+                continue
+            medium = _meep_medium(mat_data)
+            geometry.append(
+                mp.Block(
+                    size=mp.Vector3(x_span, mp.inf, spec["z_size"]),
+                    center=mp.Vector3(0.0, 0.0, spec["center_z"]),
+                    material=medium,
+                )
+            )
+
+        bg = material_data.get(background_material)
+        default_medium = _meep_medium(bg) if bg is not None else mp.Medium(epsilon=1.0)
+
+        sim_kwargs: dict = dict(
+            cell_size=cell_size,
+            geometry=geometry,
+            resolution=resolution,
+            default_material=default_medium,
+        )
+        if pml_thickness > 0:
+            sim_kwargs["boundary_layers"] = [
+                mp.PML(thickness=pml_thickness, direction=mp.X),
+                mp.PML(thickness=pml_thickness, direction=mp.Z),
+            ]
+
+        sim = mp.Simulation(**sim_kwargs)
+        sim.init_sim()
+
+        try:
+            result = _compute_eigenmode(
+                sim,
+                cell_size,
+                wl,
+                band_num=band_num,
+                parity=parity,
+                eigensolver_tol=eigensolver_tol,
+                field_x_grid=field_x_grid,
+                field_z_grid=field_z_grid_meep,
+                z_grid=field_z_grid,
+                stack=stack,
+            )
+            _validate_mode(result, material_data, stack, is_slab=True)
+            results[wl] = result
+        except RuntimeError:
+            logger.warning(
+                "solve_slab_wavelength_sweep: band %d failed at lambda=%.4f um",
+                band_num,
+                wl,
+            )
+        finally:
+            sim.reset_meep()
+
+    return results
diff --git a/src/gsim/meep/models/__init__.py b/src/gsim/meep/models/__init__.py
index d7cd302..8c56283 100644
--- a/src/gsim/meep/models/__init__.py
+++ b/src/gsim/meep/models/__init__.py
@@ -5,6 +5,7 @@
     Domain,
     Geometry,
     Material,
+    ModeSolver,
     ModeSource,
     Symmetry,
 )
@@ -22,7 +23,7 @@
     SymmetryEntry,
     WavelengthConfig,
 )
-from gsim.meep.models.results import SParameterResult
+from gsim.meep.models.results import ModeResult, SParameterResult
 
 # Backward compatibility alias
 FDTDConfig = WavelengthConfig
@@ -38,6 +39,8 @@
     "LayerStackEntry",
     "Material",
     "MaterialData",
+    "ModeResult",
+    "ModeSolver",
     "ModeSource",
     "PortData",
     "ResolutionConfig",
diff --git a/src/gsim/meep/models/api.py b/src/gsim/meep/models/api.py
index c9e3b06..edc69d0 100644
--- a/src/gsim/meep/models/api.py
+++ b/src/gsim/meep/models/api.py
@@ -608,3 +608,112 @@ def resolved_cut(self) -> float | str | None:
         if self.x_cut is not None:
             return self.x_cut
         return None
+
+
+# ---------------------------------------------------------------------------
+# ModeSolver
+# ---------------------------------------------------------------------------
+
+
+class ModeSolver(BaseModel):
+    """Eigenmode solver configuration for waveguide cross-section analysis.
+
+    Configure mode-solving parameters declaratively, then solve via
+    ``sim.solve_modes()``.
+
+    Example::
+
+        sim.mode_solver(wavelengths=[1.55], num_bands=3)
+        sim.mode_solver.first(3).at_port("o1")
+        results = sim.solve_modes()
+    """
+
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+
+    where: Literal["auto", "slab", "cross_section"] = Field(default="auto")
+    wavelengths: list[float] = Field(default_factory=list)
+    num_bands: int = Field(default=1, ge=1)
+    band: int | None = Field(default=None, ge=1)
+    parity: Literal[
+        "NO_PARITY", "EVEN_Y", "ODD_Y", "EVEN_Z", "ODD_Z", "EVEN_Y+ODD_Z"
+    ] = Field(default="NO_PARITY")
+    eigensolver_tol: float = Field(default=1e-6, gt=0)
+    port: str | None = Field(default=None)
+    position: tuple[float, float] | None = Field(default=None)
+    x_span: float | None = Field(default=None)
+    y_span: float | None = Field(default=None)
+    n_field_x: int = Field(default=0, ge=0)
+    n_field_y: int = Field(default=0, ge=0)
+    n_field_z: int = Field(default=0, ge=0)
+    background_material: str = Field(
+        default="air",
+        description="MEEP default_material (e.g. 'sio2' for oxide-clad waveguides).",
+    )
+
+    @model_validator(mode="after")
+    def _validate_where_constraints(self) -> ModeSolver:
+        """Enforce cross-field constraints between where and spatial params."""
+        if self.where == "slab":
+            if self.port is not None:
+                raise ValueError(
+                    "port must be None when where='slab' — slab mode does "
+                    "not use a component port."
+                )
+            if self.position is not None:
+                raise ValueError(
+                    "position must be None when where='slab' — slab mode "
+                    "does not use a spatial position."
+                )
+            if self.x_span is not None:
+                raise ValueError(
+                    "x_span must be None when where='slab' — slab mode "
+                    "spans the full x-extent automatically."
+                )
+            if self.y_span is not None:
+                raise ValueError(
+                    "y_span must be None when where='slab' — slab mode "
+                    "spans the full y-extent automatically."
+                )
+        if self.port is not None and self.position is not None:
+            raise ValueError("Cannot set both port and position — use exactly one.")
+        return self
+
+    def fundamental(self) -> ModeSolver:
+        """Solve only the fundamental mode (num_bands=1, band=None)."""
+        self.num_bands = 1
+        self.band = None
+        return self
+
+    def first(self, n: int) -> ModeSolver:
+        """Solve the first *n* bands (num_bands=n, band=None)."""
+        self.num_bands = n
+        self.band = None
+        return self
+
+    def at_port(self, name: str) -> ModeSolver:
+        """Set the port name for cross-section mode solving."""
+        self.port = name
+        return self
+
+    def at_slab(self) -> ModeSolver:
+        """Set solver mode to slab (1D vertical)."""
+        self.where = "slab"
+        return self
+
+    def at_cross_section(self) -> ModeSolver:
+        """Set solver mode to cross-section (2D transverse)."""
+        self.where = "cross_section"
+        return self
+
+    def sweep_wavelength(self, start: float, stop: float, num: int) -> ModeSolver:
+        """Populate wavelengths from a linear sweep (start, stop, num)."""
+        import numpy as np
+
+        self.wavelengths = list(np.linspace(start, stop, num))
+        return self
+
+    def __call__(self, **kwargs: Any) -> ModeSolver:
+        """Update fields in place, return self for fluent chaining."""
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+        return self
diff --git a/src/gsim/meep/models/config.py b/src/gsim/meep/models/config.py
index 42e8ea5..dc20544 100644
--- a/src/gsim/meep/models/config.py
+++ b/src/gsim/meep/models/config.py
@@ -440,6 +440,15 @@ class SimConfig(BaseModel):
     verbose_interval: float = Field(
         ge=0, description="MEEP time units between progress prints (0=off)"
     )
+    meep_verbosity: int = Field(
+        default=0,
+        ge=0,
+        le=3,
+        description=(
+            "Meep C++ verbosity level (0=minimal, 3=debugging). "
+            "Set via `meep.native` logger level or `run(verbose='full')`."
+        ),
+    )
     diagnostics: DiagnosticsConfig
     symmetries: list[SymmetryEntry]
     split_chunks_evenly: bool = Field(default=False)
diff --git a/src/gsim/meep/models/results.py b/src/gsim/meep/models/results.py
index 9a8bd6b..db94592 100644
--- a/src/gsim/meep/models/results.py
+++ b/src/gsim/meep/models/results.py
@@ -9,6 +9,7 @@
 from pathlib import Path
 from typing import Any
 
+import numpy as np
 from pydantic import BaseModel, ConfigDict, Field
 
 logger = logging.getLogger(__name__)
@@ -215,8 +216,6 @@ def plot(
         import matplotlib.pyplot as plt
 
         fig, ax = plt.subplots()
-        plt.close(fig)  # prevent double display in notebooks
-
         ylabel = "|S| (dB)" if db else "|S|"
         names = self._resolve_keys(keys)
         for name in names:
@@ -366,3 +365,824 @@ def _is_reflection(name: str) -> bool:
             ),
         )
         return fig
+
+
+class ModeResult(BaseModel):
+    """Eigenmode solution from standalone mode solving.
+
+    Returned by :func:`solve_slab_mode` and :func:`solve_cross_section_mode`.
+    Contains the effective index, field profiles over the cross-section,
+    the dominant wavevector, and metadata about the mode.
+
+    Attributes:
+        n_eff: Effective index (real part of propagation constant / k0).
+        wavelength: Free-space wavelength in µm.
+        frequency: Frequency in MEEP units (1/µm = 1/wavelength).
+        fields: Complex field arrays keyed by component name
+            (e.g. ``{"Ex": array, "Ey": array, "Ez": array, ...}``).
+        kdom: Dominant wavevector [kx, ky, kz] in MPB k-units (``k*a/(2*pi)``,
+            equivalent to ``n_eff/lambda`` in 1/um).  The true propagation
+            constant is ``beta = 2*pi*|kdom|`` rad/um; ``n_eff = |kdom|*lambda``.
+        n_group: Group index, if computable.
+        band_num: Mode band index (1 = fundamental).
+        parity: Parity of the mode (``"NO_PARITY"``, ``"EVEN_Y"``, etc.).
+        x_grid: X-axis grid coordinates in µm (absolute frame).  Populated
+            for XZ cross-section modes.  ``None`` when unavailable.
+        y_grid: Y-axis grid coordinates in µm (absolute frame).  Populated
+            for YZ cross-section modes.  ``None`` when unavailable.
+        z_grid: Z-axis grid coordinates in µm (absolute frame).  Populated
+            for both slab and cross-section modes.  ``None`` when
+            unavailable.
+        stack: :class:`LayerStack` used for mode solving.  Provides
+            material boundary context for index profile reconstruction.
+            ``None`` when unavailable.
+        component: GDSFactory :class:`Component` for cross-section modes.
+            ``None`` for slab modes.
+        port_or_position: Port name (``str``) or position ``(x, y)`` used
+            for cross-section mode extraction.  ``None`` for slab modes.
+        cross_section_plane: ``"xz"`` or ``"yz"`` for cross-section modes.
+            ``None`` for slab modes.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    n_eff: float
+    wavelength: float
+    frequency: float
+    fields: dict[str, np.ndarray] = Field(default_factory=dict)
+    kdom: list[float] = Field(default_factory=list)
+    n_group: float | None = None
+    band_num: int = 1
+    parity: str = "NO_PARITY"
+    x_grid: np.ndarray | None = None
+    y_grid: np.ndarray | None = None
+    z_grid: np.ndarray | None = None
+    stack: Any | None = Field(default=None, exclude=True)
+    component: Any | None = Field(default=None, exclude=True)
+    domain_config: Any | None = Field(default=None, exclude=True)
+    port_or_position: str | tuple[float, float] | None = None
+    cross_section_plane: str | None = None
+
+    # ------------------------------------------------------------------
+    # plot_mode
+    # ------------------------------------------------------------------
+
+    _VALID_NORMS = frozenset({"abs", "real", "imag", "phase"})
+
+    def _auto_component(self) -> str:
+        """Return the field component with the largest ``max(|field|)``."""
+        best: str | None = None
+        best_val = -1.0
+        for name, arr in self.fields.items():
+            v = float(np.max(np.abs(arr)))
+            if v > best_val:
+                best_val = v
+                best = name
+        if best is None:
+            raise ValueError("No field components available.")
+        return best
+
+    @staticmethod
+    def _apply_norm(field: np.ndarray, norm: str) -> np.ndarray:
+        """Transform complex field array for display."""
+        if norm == "abs":
+            return np.abs(field)
+        if norm == "real":
+            return field.real
+        if norm == "imag":
+            return field.imag
+        if norm == "phase":
+            return np.angle(field)
+        raise ValueError(
+            f"Unknown norm {norm!r}. Must be one of: abs, real, imag, phase."
+        )
+
+    def _get_ndim(self) -> int:
+        """Return dimensionality from the first available field component."""
+        for arr in self.fields.values():
+            return arr.ndim
+        return 0
+
+    def _get_horizontal_grid(self) -> tuple[np.ndarray, str]:
+        """Return ``(horizontal_grid, axis_label)``.
+
+        Raises ``ValueError`` if both ``x_grid`` and ``y_grid`` are
+        populated (ambiguous geometry) or if no horizontal grid is set.
+        """
+        has_x = self.x_grid is not None
+        has_y = self.y_grid is not None
+        if has_x and has_y:
+            raise ValueError(
+                "Ambiguous geometry: both x_grid and y_grid are populated."
+            )
+        if has_y:
+            return self.y_grid, "y (µm)"
+        if has_x:
+            return self.x_grid, "x (µm)"
+        raise ValueError(
+            "No horizontal grid available. Set x_grid or y_grid on ModeResult."
+        )
+
+    def plot_mode(
+        self,
+        components: str | list[str] = "auto",
+        *,
+        norm: str = "abs",
+        index: bool = False,
+        geometry: bool = False,
+        geom_kwargs: dict[str, Any] | None = None,
+        ax: Any | None = None,
+        figsize: tuple[float, float] = (8, 6),
+        cmap: str | None = None,
+        aspect: str = "equal",
+        title: str | None = "auto",
+        suptitle: str | None = "auto",
+        show: bool = True,
+        shared_colorbar: bool = False,
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        """Plot eigenmode field profiles.
+
+        Args:
+            components: ``"auto"`` (dominant), ``"all"`` (every field), or
+                list of component names e.g. ``["Ey", "Hx"]``.
+            norm: ``"abs"`` (magnitude), ``"real"``, ``"imag"``, or
+                ``"phase"`` (angle in radians).
+            index: Overlay refractive index profile (twin-axis for 1D,
+                greyscale underlay for 2D).
+            geometry: Overlay structural geometry boundaries (material
+                interfaces).  1D: horizontal lines at dielectric
+                z-interfaces.  2D: prism outline rectangles at the
+                cross-section plane.  Requires ``stack`` (and
+                ``component`` + ``domain_config`` for 2D).
+            geom_kwargs: Forwarded to the geometry overlay's matplotlib
+                artist.  Defaults: ``color="white"``, ``linestyle="-"``,
+                ``linewidth=1.0``, ``zorder=50``.  User values override
+                defaults.  Only used when ``geometry=True``.
+            ax: Existing matplotlib ``Axes``.  Only valid when
+                ``components`` resolves to a single component.
+            figsize: ``(width, height)`` tuple in inches.
+            cmap: Matplotlib colormap name for field data.  When ``None``
+                (default), auto-selected: ``"inferno"`` for ``abs``,
+                ``"RdBu_r"`` for ``real``/``imag``, ``"twilight"`` for
+                ``"phase"``.
+            aspect: ``"equal"`` or ``"auto"`` for ``pcolormesh`` subplots.
+            title: Per-subplot title. ``"auto"`` generates
+                ``|comp|  n_eff=...`` for single-component, component name
+                only for multi-component.  ``None`` suppresses.
+            suptitle: Figure-level suptitle.  ``"auto"`` generates
+                descriptive text for multi-component.  ``None`` suppresses.
+            show: Call ``plt.show()`` (default ``True``).  Set ``False``
+                for customisation before display.
+            shared_colorbar: Use a single colour bar for all subplots
+                instead of per-subplot colour bars.
+            **kwargs: Forwarded to the underlying matplotlib call
+                (``ax.plot`` for 1D, ``ax.pcolormesh`` for 2D).
+
+        Returns:
+            ``(fig, ax)`` for single-component, ``(fig, axes)`` for
+            multi-component.
+
+        Raises:
+            ValueError: If ``fields`` is empty, ``ax`` is passed with
+                multi-component, ``norm`` is invalid, or horizontal axis
+                is ambiguous.
+        """
+        if not self.fields:
+            raise ValueError(
+                "ModeResult has no field data. "
+                "Pass field grids to the solver to enable plotting."
+            )
+        if self.x_grid is not None and self.y_grid is not None:
+            raise ValueError(
+                "Ambiguous geometry: both x_grid and y_grid are populated."
+            )
+        if norm not in self._VALID_NORMS:
+            raise ValueError(
+                f"Unknown norm {norm!r}. Must be one of: "
+                f"{', '.join(sorted(self._VALID_NORMS))}."
+            )
+
+        resolved = self._resolve_components(components)
+        if cmap is None:
+            cmap = self._colormap_for_norm(norm)  # type: ignore[assignment]
+        is_single = len(resolved) == 1
+        if ax is not None and not is_single:
+            raise ValueError(
+                "ax may only be passed when components resolves to a single component."
+            )
+
+        ndim = self._get_ndim()
+        if ndim == 0:
+            raise ValueError(
+                "ModeResult has no field data. "
+                "Pass field grids to the solver to enable plotting."
+            )
+
+        if ndim == 1:
+            return self._plot_mode_1d(
+                resolved,
+                norm=norm,
+                index=index,
+                geometry=geometry,
+                geom_kwargs=geom_kwargs,
+                ax=ax,
+                figsize=figsize,
+                title=title,
+                suptitle=suptitle,
+                show=show,
+                **kwargs,
+            )
+        return self._plot_mode_2d(
+            resolved,
+            norm=norm,
+            index=index,
+            geometry=geometry,
+            geom_kwargs=geom_kwargs,
+            ax=ax,
+            figsize=figsize,
+            cmap=cmap,
+            aspect=aspect,
+            title=title,
+            suptitle=suptitle,
+            show=show,
+            shared_colorbar=shared_colorbar,
+            **kwargs,
+        )
+
+    def _resolve_components(self, components: str | list[str]) -> list[str]:
+        """Resolve ``components`` to a concrete list of field names."""
+        if isinstance(components, str):
+            if components == "auto":
+                return [self._auto_component()]
+            if components == "all":
+                return [
+                    c for c in ("Ex", "Ey", "Ez", "Hx", "Hy", "Hz") if c in self.fields
+                ]
+            if components not in self.fields:
+                available = sorted(self.fields)
+                raise ValueError(
+                    f"Unknown component: {components!r}. Available: {available}."
+                )
+            return [components]
+        missing = [c for c in components if c not in self.fields]
+        if missing:
+            available = sorted(self.fields)
+            raise ValueError(
+                f"Unknown component(s): {missing}. Available: {available}."
+            )
+        return list(components)
+
+    @staticmethod
+    def _colormap_for_norm(norm: str) -> str:
+        """Return a sensible colormap for a given field *norm*."""
+        if norm == "abs":
+            return "inferno"
+        if norm in ("real", "imag"):
+            return "RdBu_r"
+        if norm == "phase":
+            return "twilight"
+        return "inferno"
+
+    # -- 1D helpers -------------------------------------------------------
+
+    def _make_title(
+        self, comp: str, user_title: str | None, is_single: bool
+    ) -> str | None:
+        """Build a per-subplot title from *user_title* and component info."""
+        if user_title is None:
+            return None
+        if user_title == "auto":
+            if is_single:
+                return f"|{comp}|  n_eff={self.n_eff:.4f}"
+            return comp
+        return user_title
+
+    def _plot_mode_1d(
+        self,
+        comps: list[str],
+        *,
+        norm: str,
+        index: bool,
+        geometry: bool,
+        geom_kwargs: dict[str, Any] | None,
+        ax: Any | None,
+        figsize: tuple[float, float],
+        title: str | None,
+        suptitle: str | None,
+        show: bool,
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        """1D line-plot path: one subplot per component stacked vertically."""
+        import matplotlib.pyplot as plt
+
+        is_single = len(comps) == 1
+        z = self.z_grid
+        if z is None:
+            raise ValueError("z_grid must be set on ModeResult for 1D plotting.")
+
+        if ax is not None:
+            fig = ax.figure
+            axes = [ax]
+        else:
+            ncols = 1
+            fig, axes_arr = plt.subplots(
+                nrows=len(comps),
+                ncols=ncols,
+                figsize=figsize,
+                squeeze=False,
+            )
+            axes = [axes_arr[i, 0] for i in range(len(comps))]
+
+        for i, comp in enumerate(comps):
+            ax_i = axes[i]
+            data = self._apply_norm(self.fields[comp], norm)
+
+            ax_i.plot(z, data, **kwargs)
+            if geometry and self.stack is not None:
+                self._draw_geometry_overlay_1d(ax_i, **(geom_kwargs or {}))
+            if index:
+                ax_i_twin = ax_i.twinx()
+                n_prof = self._compute_index_profile_1d()
+                ax_i_twin.plot(z, n_prof, color="gray", linestyle="--", alpha=0.7)
+                ax_i_twin.set_ylabel("n", color="gray")
+            t = self._make_title(comp, title, is_single)
+            if t is not None:
+                ax_i.set_title(t)
+            ax_i.set_xlabel("z (µm)")
+
+        if suptitle == "auto" and not is_single:
+            norm_label = "|field|" if norm == "abs" else norm
+            fig.suptitle(f"Mode fields ({norm_label})", fontsize=12)
+        elif suptitle is not None and suptitle != "auto":
+            fig.suptitle(suptitle, fontsize=12)
+
+        fig.tight_layout()
+        if show:
+            plt.show()
+
+        if is_single:
+            return (fig, axes[0])
+        return (fig, axes_arr)  # Always return array for multi-component
+
+    def _compute_index_profile_1d(self) -> np.ndarray:
+        """Compute 1D refractive index profile from stored context."""
+        if self.stack is None:
+            raise ValueError(
+                "No stack stored on ModeResult. Cannot compute index profile."
+            )
+        if self.z_grid is None:
+            raise ValueError("z_grid must be set on ModeResult for index profile.")
+        from gsim.meep.mode_solver import refractive_index_profile
+
+        return refractive_index_profile(
+            self.stack,
+            self.wavelength,
+            z_grid=self.z_grid,
+        )
+
+    # -- 2D helpers -------------------------------------------------------
+
+    def _plot_mode_2d(
+        self,
+        comps: list[str],
+        *,
+        norm: str,
+        index: bool,
+        geometry: bool,
+        geom_kwargs: dict[str, Any] | None,
+        ax: Any | None,
+        figsize: tuple[float, float],
+        cmap: str,
+        aspect: str,
+        title: str | None,
+        suptitle: str | None,
+        show: bool,
+        shared_colorbar: bool,
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        """2D pcolormesh path: subplot grid with optional index overlay."""
+        import matplotlib.pyplot as plt
+
+        is_single = len(comps) == 1
+        h_grid, h_label = self._get_horizontal_grid()
+        z = self.z_grid
+        if z is None:
+            raise ValueError("z_grid must be set on ModeResult for 2D plotting.")
+
+        if ax is not None:
+            fig = ax.figure
+            axes = [ax]
+            nrows = ncols = 1
+        else:
+            ncols = min(len(comps), 3)
+            nrows = (len(comps) + ncols - 1) // ncols
+            fig, axes_arr = plt.subplots(
+                nrows=nrows,
+                ncols=ncols,
+                figsize=figsize,
+                squeeze=False,
+            )
+            axes = [axes_arr.flat[i] for i in range(len(comps))]
+
+        index_overlay: np.ndarray | None = None
+        if index:
+            index_overlay = self._compute_index_profile_2d()
+
+        images: list[Any] = []
+        vmin = vmax = None
+        if shared_colorbar:
+            vmin = min(
+                float(self._apply_norm(self.fields[c], norm).min()) for c in comps
+            )
+            vmax = max(
+                float(self._apply_norm(self.fields[c], norm).max()) for c in comps
+            )
+
+        for i, comp in enumerate(comps):
+            ax_i = axes[i]
+            data = self._apply_norm(self.fields[comp], norm)
+            im = ax_i.pcolormesh(
+                h_grid,
+                z,
+                data,
+                cmap=cmap,
+                shading="auto",
+                vmin=vmin,
+                vmax=vmax,
+                **kwargs,
+            )
+            if index_overlay is not None:
+                ax_i.pcolormesh(
+                    h_grid,
+                    z,
+                    index_overlay,
+                    cmap="Greys",
+                    alpha=0.25,
+                    shading="auto",
+                )
+            if geometry:
+                self._draw_geometry_overlay_2d(ax_i, **(geom_kwargs or {}))
+            images.append(im)
+            ax_i.set_aspect(aspect)
+            t = self._make_title(comp, title, is_single)
+            if t is not None:
+                ax_i.set_title(t)
+            ax_i.set_xlabel(h_label)
+            ax_i.set_ylabel("z (µm)")
+            if not shared_colorbar:
+                fig.colorbar(im, ax=ax_i)
+
+        if shared_colorbar and images:
+            for ax_i in axes[len(comps) :]:
+                ax_i.set_visible(False)
+            fig.colorbar(images[-1], ax=axes, shrink=0.6)
+
+        if suptitle == "auto" and not is_single:
+            norm_label = "|field|" if norm == "abs" else norm
+            fig.suptitle(
+                f"Mode fields ({norm_label})  n_eff={self.n_eff:.4f}",
+                fontsize=12,
+            )
+        elif suptitle is not None and suptitle != "auto":
+            fig.suptitle(suptitle, fontsize=12)
+
+        fig.tight_layout()
+        if show:
+            plt.show()
+
+        if is_single:
+            return (fig, axes[0])
+        return (fig, axes_arr)
+
+    def _compute_index_profile_2d(self) -> np.ndarray:
+        """Compute 2D refractive index profile from stored context."""
+        if self.stack is None:
+            raise ValueError(
+                "No stack stored on ModeResult. Cannot compute index profile."
+            )
+        if self.z_grid is None:
+            raise ValueError("z_grid must be set on ModeResult.")
+        from gsim.meep.mode_solver import refractive_index_profile
+
+        h_grid, _ = self._get_horizontal_grid()
+        if self.y_grid is not None:
+            return refractive_index_profile(
+                self.stack,
+                self.wavelength,
+                z_grid=self.z_grid,
+                y_grid=h_grid,
+                component=self.component,
+                port=self.port_or_position
+                if isinstance(self.port_or_position, str)
+                else None,
+            )
+        return refractive_index_profile(
+            self.stack,
+            self.wavelength,
+            z_grid=self.z_grid,
+            x_grid=h_grid,
+            component=self.component,
+            port=self.port_or_position
+            if isinstance(self.port_or_position, str)
+            else None,
+        )
+
+    # ------------------------------------------------------------------
+    # geometry overlay helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _geom_default_kwargs() -> dict[str, Any]:
+        """Return default matplotlib kwargs for geometry overlay lines."""
+        return {"color": "white", "linestyle": "-", "linewidth": 1.0, "zorder": 50}
+
+    def _draw_geometry_overlay_1d(self, ax: Any, **geom_kwargs: Any) -> None:
+        """Draw horizontal lines at dielectric z-interfaces.
+
+        Each unique z-boundary from ``stack.dielectrics`` gets a line
+        across the full x-span.
+        """
+        if self.stack is None or not self.stack.dielectrics:
+            return
+
+        cfg = self._geom_default_kwargs()
+        cfg.update(geom_kwargs)
+
+        z_vals: set[float] = set()
+        for diel in self.stack.dielectrics:
+            z_vals.add(diel["zmin"])
+            z_vals.add(diel["zmax"])
+
+        for z in sorted(z_vals):
+            ax.axhline(y=z, **cfg)
+
+    def _draw_geometry_overlay_2d(self, ax: Any, **geom_kwargs: Any) -> None:
+        """Draw prism outline rectangles at the cross-section slice plane.
+
+        Requires ``component`` and ``stack`` on this result.
+        For an XZ view (``cross_section_plane == "xz"``) the slice is at
+        the port y-coordinate; for YZ it is at the port x-coordinate.
+
+        Uses :func:`gsim.meep.viz.build_cross_section_rectangles` which
+        extracts polygon intersections from the *gsim* :class:`LayerStack`
+        directly — no PDK layer stack dependency.
+        """
+        import math
+
+        from matplotlib.patches import Rectangle
+
+        import gsim.meep.viz as meep_viz
+
+        if self.component is None or self.stack is None:
+            logger.info(
+                "Geometry overlay requires component and stack "
+                "on ModeResult — skipping geometry boundaries."
+            )
+            return
+
+        if self.cross_section_plane == "xz":
+            slice_axis = "y"
+            if isinstance(self.port_or_position, tuple):
+                slice_coord = self.port_or_position[1]
+            elif isinstance(self.port_or_position, str):
+                port = next(
+                    (
+                        p
+                        for p in self.component.ports
+                        if p.name == self.port_or_position
+                    ),
+                    None,
+                )
+                if port is None:
+                    logger.info(
+                        "Port %r not found on component — "
+                        "skipping geometry boundaries.",
+                        self.port_or_position,
+                    )
+                    return
+                slice_coord = port.center[1]
+            else:
+                logger.info(
+                    "Cannot determine slice coordinate — skipping geometry boundaries."
+                )
+                return
+        elif self.cross_section_plane == "yz":
+            slice_axis = "x"
+            if isinstance(self.port_or_position, tuple):
+                slice_coord = self.port_or_position[0]
+            elif isinstance(self.port_or_position, str):
+                port = next(
+                    (
+                        p
+                        for p in self.component.ports
+                        if p.name == self.port_or_position
+                    ),
+                    None,
+                )
+                if port is None:
+                    return
+                slice_coord = port.center[0]
+            else:
+                return
+        else:
+            return
+
+        try:
+            rects = meep_viz.build_cross_section_rectangles(
+                self.component, self.stack, slice_axis, slice_coord
+            )
+        except Exception:
+            logger.info(
+                "Could not build cross-section geometry — "
+                "skipping geometry boundaries.",
+                exc_info=True,
+            )
+            return
+
+        if not rects:
+            return
+
+        h_min_geom: float = float("inf")
+        h_max_geom: float = -float("inf")
+        z_min_geom: float = float("inf")
+        z_max_geom: float = -float("inf")
+
+        cfg = self._geom_default_kwargs()
+        cfg.update(geom_kwargs)
+        rect_kwargs: dict[str, Any] = {k: v for k, v in cfg.items() if k != "color"}
+        rect_kwargs.setdefault("edgecolor", cfg["color"])
+        rect_kwargs.setdefault("facecolor", "none")
+
+        layer_drawn: set[str] = set()
+        for rect in rects:
+            h_min = rect["h_min"]
+            h_max = rect["h_max"]
+            z_min = rect["z_min"]
+            z_max = rect["z_max"]
+            layer_name = rect["layer_name"]
+
+            if math.isinf(h_min) or math.isinf(h_max):
+                ax_h_min, ax_h_max = ax.get_xlim()
+                h_min = ax_h_min
+                h_max = ax_h_max
+
+            if h_max - h_min < 1e-12:
+                continue
+
+            label = layer_name if layer_name not in layer_drawn else None
+            layer_drawn.add(layer_name)
+
+            ax.add_patch(
+                Rectangle(
+                    (h_min, z_min),
+                    h_max - h_min,
+                    z_max - z_min,
+                    label=label,
+                    **rect_kwargs,
+                )
+            )
+            h_min_geom = min(h_min_geom, h_min)
+            h_max_geom = max(h_max_geom, h_max)
+            z_min_geom = min(z_min_geom, z_min)
+            z_max_geom = max(z_max_geom, z_max)
+
+        if h_min_geom < float("inf"):
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
+            ax.set_xlim(min(xlim[0], h_min_geom), max(xlim[1], h_max_geom))
+            ax.set_ylim(min(ylim[0], z_min_geom), max(ylim[1], z_max_geom))
+
+    # ------------------------------------------------------------------
+    # plot_index
+    # ------------------------------------------------------------------
+
+    def plot_index(
+        self,
+        *,
+        ax: Any | None = None,
+        figsize: tuple[float, float] = (7, 5),
+        cmap: str = "RdYlBu",
+        show: bool = True,
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        """Plot the refractive index profile from stored context.
+
+        Zero-argument when grid and stack fields are populated.
+        Auto-detects 1D vs 2D from the available grid arrays.
+
+        Args:
+            ax: Existing matplotlib ``Axes`` (optional).
+            figsize: ``(width, height)`` in inches.
+            cmap: Colormap name for 2D ``pcolormesh`` (default
+                ``"RdYlBu"``).
+            show: Call ``plt.show()`` (default ``True``).
+            **kwargs: Forwarded to ``ax.plot`` (1D) or ``ax.pcolormesh``
+                (2D).
+
+        Returns:
+            ``(fig, ax)``.
+
+        Raises:
+            ValueError: If ``stack``, ``wavelength``, or ``z_grid`` are
+                missing.
+        """
+        if self.stack is None:
+            raise ValueError(
+                "No stack stored on ModeResult. Cannot compute index profile."
+            )
+        if self.z_grid is None:
+            raise ValueError(
+                "No z_grid stored on ModeResult. Cannot compute index profile."
+            )
+
+        ndim = self._get_ndim()
+        if ndim <= 1 and self.y_grid is None and self.x_grid is None:
+            return self._plot_index_1d(
+                ax=ax,
+                figsize=figsize,
+                show=show,
+                cmap=cmap,
+                **kwargs,
+            )
+
+        return self._plot_index_2d(
+            ax=ax,
+            figsize=figsize,
+            cmap=cmap,
+            show=show,
+            **kwargs,
+        )
+
+    def _plot_index_1d(
+        self,
+        *,
+        ax: Any | None,
+        figsize: tuple[float, float],
+        show: bool,
+        cmap: str,  # noqa: ARG002
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        """1D line-plot of n(z) from stored context."""
+        if self.z_grid is None:
+            raise ValueError("z_grid must be set on ModeResult.")
+        import matplotlib.pyplot as plt
+
+        n_prof = self._compute_index_profile_1d()
+        if ax is not None:
+            fig = ax.figure
+        else:
+            fig, ax = plt.subplots(figsize=figsize)
+
+        ax.plot(self.z_grid, n_prof, **kwargs)
+        ax.set_xlabel("z (µm)")
+        ax.set_ylabel("n")
+        ax.set_title(f"Refractive index  (lambda={self.wavelength:.2f} um)")
+
+        fig.tight_layout()
+        if show:
+            plt.show()
+
+        return (fig, ax)
+
+    def _plot_index_2d(
+        self,
+        *,
+        ax: Any | None,
+        figsize: tuple[float, float],
+        cmap: str,
+        show: bool,
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        """2D pcolormesh of n(y,z) or n(x,z) from stored context."""
+        if self.z_grid is None:
+            raise ValueError("z_grid must be set on ModeResult.")
+        import matplotlib.pyplot as plt
+
+        n_prof = self._compute_index_profile_2d()
+        h_grid, h_label = self._get_horizontal_grid()
+
+        if ax is not None:
+            fig = ax.figure
+        else:
+            fig, ax = plt.subplots(figsize=figsize)
+
+        im = ax.pcolormesh(
+            h_grid,
+            self.z_grid,
+            n_prof,
+            cmap=cmap,
+            shading="auto",
+            **kwargs,
+        )
+        ax.set_aspect("equal")
+        ax.set_xlabel(h_label)
+        ax.set_ylabel("z (µm)")
+        ax.set_title(f"Refractive index  (lambda={self.wavelength:.2f} um)")
+        fig.colorbar(im, ax=ax)
+
+        fig.tight_layout()
+        if show:
+            plt.show()
+
+        return (fig, ax)
diff --git a/src/gsim/meep/results.py b/src/gsim/meep/results.py
new file mode 100644
index 0000000..a5cfa66
--- /dev/null
+++ b/src/gsim/meep/results.py
@@ -0,0 +1,104 @@
+"""Aggregated eigenmode sweep result wrapper."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from gsim.meep.models.results import ModeResult
+
+
+class ModeSweepResult:
+    """Collection of :class:`ModeResult` items from an eigenmode sweep.
+
+    Provides fluent accessors for filtering and key-based lookup.
+
+    Example::
+
+        result = sim.solve_modes()
+        mode_at_1550 = result.at(1.55).band(3)
+        df = pd.DataFrame(result.to_dict())
+    """
+
+    def __init__(self, results: list[ModeResult]) -> None:
+        """Create a sweep result from a flat list of mode results."""
+        self.results: list[ModeResult] = results
+
+    def at(self, wavelength: float) -> ModeSweepResult:
+        """Filter results to those at a specific wavelength."""
+        return ModeSweepResult([r for r in self.results if r.wavelength == wavelength])
+
+    def band(self, n: int) -> ModeResult | None:
+        """Return the result for a specific band number, or None."""
+        for r in self.results:
+            if r.band_num == n:
+                return r
+        return None
+
+    def _find_result(self, wavelength: float, band: int | None = None) -> ModeResult:
+        """Return the ModeResult matching wavelength and optional band, or error."""
+        candidates = [r for r in self.results if r.wavelength == wavelength]
+        if not candidates:
+            available = sorted({r.wavelength for r in self.results})
+            raise ValueError(
+                f"No mode result found at wavelength={wavelength} µm. "
+                f"Available: {available}"
+            )
+        if band is not None:
+            for r in candidates:
+                if r.band_num == band:
+                    return r
+            available_bands = sorted({r.band_num for r in candidates})
+            raise ValueError(
+                f"No mode result found at wavelength={wavelength} µm, "
+                f"band={band}. Available bands: {available_bands}"
+            )
+        return candidates[0]
+
+    def plot_mode(
+        self,
+        wavelength: float,
+        band: int | None = None,
+        *,
+        components: str | list[str] = "auto",
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        """Delegate to ModeResult.plot_mode for mode at wavelength and optional band.
+
+        Args:
+            wavelength: Free-space wavelength in µm.
+            band: Mode band index (``None`` = first match).
+            components: ``"auto"``, ``"all"``, or list of component names.
+            **kwargs: Forwarded to :meth:`ModeResult.plot_mode`.
+
+        Returns:
+            ``(fig, ax)`` or ``(fig, axes)`` as from
+            :meth:`ModeResult.plot_mode`.
+        """
+        result = self._find_result(wavelength, band=band)
+        return result.plot_mode(components=components, **kwargs)
+
+    def plot_index(self, wavelength: float, **kwargs: Any) -> tuple[Any, Any]:
+        """Delegate to ModeResult.plot_index for the mode at wavelength.
+
+        Args:
+            wavelength: Free-space wavelength in µm.
+            **kwargs: Forwarded to :meth:`ModeResult.plot_index`.
+
+        Returns:
+            ``(fig, ax)`` as from :meth:`ModeResult.plot_index`.
+        """
+        result = self._find_result(wavelength)
+        return result.plot_index(**kwargs)
+
+    def to_dict(self) -> dict[str, list]:
+        """Convert results to a dict-of-lists suitable for ``pd.DataFrame``."""
+        return {
+            "wavelength": [r.wavelength for r in self.results],
+            "frequency": [r.frequency for r in self.results],
+            "band_num": [r.band_num for r in self.results],
+            "n_eff": [r.n_eff for r in self.results],
+            "n_group": [r.n_group for r in self.results],
+            "parity": [r.parity for r in self.results],
+            "kdom": [r.kdom for r in self.results],
+            "fields": [r.fields for r in self.results],
+        }
diff --git a/src/gsim/meep/script.py b/src/gsim/meep/script.py
index 8dfc123..e939312 100644
--- a/src/gsim/meep/script.py
+++ b/src/gsim/meep/script.py
@@ -1532,6 +1532,8 @@ def main():
     config_path = "%%CONFIG_FILENAME%%"
     config = load_config(config_path)
 
+    mp.verbosity(config.get("meep_verbosity", 0))
+
     logger.info("Building materials...")
     materials = build_materials(config)
 
diff --git a/src/gsim/meep/simulation.py b/src/gsim/meep/simulation.py
index f30662d..87f9fcd 100644
--- a/src/gsim/meep/simulation.py
+++ b/src/gsim/meep/simulation.py
@@ -19,6 +19,7 @@
     FiberSource,
     Geometry,
     Material,
+    ModeSolver,
     ModeSource,
 )
 
@@ -101,6 +102,7 @@ class Simulation(BaseModel):
     )
     domain: Domain = Field(default_factory=Domain)
     solver: FDTD = Field(default_factory=FDTD)
+    mode_solver: ModeSolver = Field(default_factory=ModeSolver)
 
     # Private: kwargs captured from geometry.stack when it's a string/path
     _stack_kwargs: dict[str, Any] = PrivateAttr(default_factory=dict)
@@ -610,6 +612,223 @@ def _material_overrides(self) -> dict[str, Any]:
             )
         return overrides
 
+    def _resolve_stack_and_materials(
+        self, *, wavelength: float
+    ) -> tuple[Any, dict[str, Any]]:
+        """Resolve layer stack and material data for mode solving.
+
+        Lighter than :meth:`build_config` — no port extension, no domain
+        config, no FDTD source/monitor setup. Resolves the layer stack,
+        applies z-crop if configured, and resolves material optical
+        properties at the given wavelength via the three-tier pipeline
+        (user override > PDK overlay > built-in database).
+
+        Args:
+            wavelength: Free-space wavelength in µm for material evaluation.
+
+        Returns:
+            ``(stack, materials_dict)`` where ``stack`` is the resolved
+            ``LayerStack`` and ``materials_dict`` maps material name to
+            ``MaterialData``.
+        """
+        from gsim.meep.materials import resolve_materials
+
+        self._ensure_stack()
+        stack = self.geometry.stack
+        if stack is None:
+            raise ValueError("Stack resolution failed.")
+
+        # Collect material names from stack layers and dielectrics.
+        used_materials: set[str] = set()
+        for layer in stack.layers.values():
+            used_materials.add(layer.material)
+        for diel in stack.dielectrics:
+            used_materials.add(diel["material"])
+
+        material_data = resolve_materials(
+            used_materials,
+            overrides=self._material_overrides(),
+            wavelength_um=wavelength,
+            overlay=self._pdk_overlay,
+        )
+
+        return stack, material_data
+
+    # -------------------------------------------------------------------------
+    # solve_modes — eigenmode solving from mode_solver configuration
+    # -------------------------------------------------------------------------
+
+    def solve_modes(self) -> Any:
+        """Solve eigenmodes from ``self.mode_solver`` configuration.
+
+        Reads wavelengths, band count, and geometry context from the
+        :class:`ModeSolver` model and dispatches to the appropriate
+        low-level solvers with shared-cell optimizations where applicable.
+
+        Returns:
+            :class:`ModeSweepResult` wrapping all solved :class:`ModeResult`
+            objects.
+
+        Raises:
+            ValueError: If ``wavelengths`` is empty, or if cross-section
+                mode is requested without a component, port, or position.
+        """
+        from gsim.meep.mode_solver import (
+            mode_x_grid,
+            mode_y_grid,
+            mode_z_grid,
+            solve_cross_section_mode,
+            solve_slab_mode,
+            solve_slab_modes,
+            solve_slab_wavelength_sweep,
+        )
+        from gsim.meep.models.results import ModeResult
+        from gsim.meep.results import ModeSweepResult
+
+        ms = self.mode_solver
+
+        if not ms.wavelengths:
+            raise ValueError("mode_solver.wavelengths must not be empty")
+
+        resolution = self.solver.resolution
+        pml_thickness = self.domain.pml
+        z_margin = self.domain.resolved_margin_z()
+
+        component = self.geometry.component
+        where = ms.where
+
+        if where == "auto":
+            has_port_or_pos = ms.port is not None or ms.position is not None
+            if component is not None and has_port_or_pos:
+                where_effective = "cross_section"
+            else:
+                where_effective = "slab"
+        else:
+            where_effective = where
+
+        if where_effective == "cross_section":
+            if component is None:
+                raise ValueError(
+                    "cross_section mode requires a component — "
+                    "set sim.geometry.component first."
+                )
+            if ms.port is None and ms.position is None:
+                raise ValueError(
+                    "cross_section mode requires port or position — "
+                    "set mode_solver.port or mode_solver.position."
+                )
+
+        if ms.band is not None:
+            band_nums = [ms.band]
+        else:
+            band_nums = list(range(1, ms.num_bands + 1))
+
+        first_wavelength = ms.wavelengths[0]
+        _stack, _materials = self._resolve_stack_and_materials(
+            wavelength=first_wavelength
+        )
+        stack = self.geometry.stack
+        if stack is None:
+            raise ValueError("Stack resolution failed.")
+
+        background_material = ms.background_material
+
+        n_field_x = ms.n_field_x
+        n_field_y = ms.n_field_y
+        n_field_z = ms.n_field_z
+        field_x_grid = (
+            mode_x_grid(n_field_x, ms.x_span or 0.0, pml_thickness)
+            if n_field_x > 0 and ms.x_span is not None
+            else None
+        )
+        field_y_grid = (
+            mode_y_grid(n_field_y, ms.y_span or 0.0, pml_thickness)
+            if n_field_y > 0 and ms.y_span is not None
+            else None
+        )
+        field_z_grid = (
+            mode_z_grid(stack, n_field_z, z_margin, pml_thickness)
+            if n_field_z > 0
+            else None
+        )
+
+        results: list[ModeResult] = []
+
+        if where_effective == "slab":
+            if len(ms.wavelengths) > 1 and len(band_nums) == 1:
+                sweep_results = solve_slab_wavelength_sweep(
+                    stack=stack,
+                    wavelengths=ms.wavelengths,
+                    band_num=band_nums[0],
+                    parity=ms.parity,
+                    resolution=resolution,
+                    z_margin=z_margin,
+                    pml_thickness=pml_thickness,
+                    eigensolver_tol=ms.eigensolver_tol,
+                    field_z_grid=field_z_grid,
+                    background_material=background_material,
+                )
+                results.extend(sweep_results.values())
+            elif len(ms.wavelengths) == 1 and len(band_nums) > 1:
+                band_results = solve_slab_modes(
+                    stack=stack,
+                    wavelength=ms.wavelengths[0],
+                    band_nums=band_nums,
+                    parity=ms.parity,
+                    resolution=resolution,
+                    z_margin=z_margin,
+                    pml_thickness=pml_thickness,
+                    eigensolver_tol=ms.eigensolver_tol,
+                    field_z_grid=field_z_grid,
+                    background_material=background_material,
+                )
+                results.extend(band_results.values())
+            else:
+                for wl in ms.wavelengths:
+                    for bn in band_nums:
+                        mode_result = solve_slab_mode(
+                            stack=stack,
+                            wavelength=wl,
+                            band_num=bn,
+                            parity=ms.parity,
+                            resolution=resolution,
+                            z_margin=z_margin,
+                            pml_thickness=pml_thickness,
+                            eigensolver_tol=ms.eigensolver_tol,
+                            field_z_grid=field_z_grid,
+                            background_material=background_material,
+                        )
+                        results.append(mode_result)
+        else:
+            for wl in ms.wavelengths:
+                for bn in band_nums:
+                    mode_result = solve_cross_section_mode(
+                        component=component,
+                        stack=stack,
+                        port=ms.port,
+                        position=ms.position,
+                        x_span=ms.x_span,
+                        y_span=ms.y_span,
+                        wavelength=wl,
+                        band_num=bn,
+                        parity=ms.parity,
+                        resolution=resolution,
+                        z_margin=z_margin,
+                        pml_thickness=pml_thickness,
+                        eigensolver_tol=ms.eigensolver_tol,
+                        field_x_grid=field_x_grid,
+                        field_y_grid=field_y_grid,
+                        field_z_grid=field_z_grid,
+                        background_material=background_material,
+                    )
+                    results.append(mode_result)
+
+        domain_cfg = self._domain_config()
+        for r in results:
+            r.domain_config = domain_cfg
+
+        return ModeSweepResult(results)
+
     # -------------------------------------------------------------------------
     # build_config — single source of truth
     # -------------------------------------------------------------------------
@@ -847,6 +1066,20 @@ def build_config(self) -> BuildResult:
         else:
             monitor_z_span = None
 
+        # Compute meep verbosity from `meep.native` logger level, with
+        # `run(verbose="full")` override.
+        _run_verbose = getattr(self, "_run_verbose", None)
+        if _run_verbose == "full":
+            meep_verbosity = 2
+        else:
+            _level = logging.getLogger("meep.native").getEffectiveLevel()
+            if _level == logging.NOTSET or _level >= logging.WARNING:
+                meep_verbosity = 0
+            elif _level >= logging.INFO:
+                meep_verbosity = 1
+            else:
+                meep_verbosity = 2
+
         # Build SimConfig
         sim_config = SimConfig(
             is_3d=is_3d,
@@ -870,6 +1103,7 @@ def build_config(self) -> BuildResult:
             accuracy=accuracy_cfg,
             diagnostics=diagnostics_cfg,
             verbose_interval=diagnostics_cfg.verbose_interval,
+            meep_verbosity=meep_verbosity,
             symmetries=symmetry_entries,
         )
         # Forward any private hints into the config
@@ -1026,6 +1260,7 @@ def run(
             ``SParameterResult`` when ``wait=True``, or ``job_id`` string
             when ``wait=False``.
         """
+        self._run_verbose = verbose
         self.upload(verbose=False)
         self.start(verbose=verbose != "quiet")
         if not wait:
@@ -1070,6 +1305,7 @@ def run_local(
         from gsim.meep.models.results import SParameterResult
 
         # Always regenerate config to reflect current settings
+        self._run_verbose = "quiet" if not verbose else "status"
         if output_dir is None:
             output_dir = Path(tempfile.mkdtemp(prefix="meep_local_"))
         output_dir = Path(output_dir)
diff --git a/src/gsim/meep/viz.py b/src/gsim/meep/viz.py
index 539eb99..271e9d5 100644
--- a/src/gsim/meep/viz.py
+++ b/src/gsim/meep/viz.py
@@ -232,6 +232,180 @@ def build_overlay(
     )
 
 
+# ---------------------------------------------------------------------------
+# Cross-section geometry from gsim LayerStack (no PDK dependency)
+# ---------------------------------------------------------------------------
+
+
+def build_cross_section_rectangles(
+    component: Component,
+    stack: LayerStack,
+    slice_axis: str,
+    slice_coord: float,
+) -> list[dict[str, Any]]:
+    """Build rectangle outlines for a cross-section of a gsim LayerStack.
+
+    Extracts GDS polygons from *component* for each layer in *stack*,
+    intersects them with a horizontal or vertical slice line, and returns
+    rectangle data suitable for ``ax.add_patch(Rectangle(...))``.
+
+    Unlike :func:`build_geometry_model`, this function does **not** rely on
+    the active PDK's layer stack — it uses the *gsim* :class:`LayerStack`
+    directly so cross-section geometry for custom material stacks
+    (e.g. TFLN) is rendered correctly.
+
+    Layers that have no GDS polygons at all (``_layer_has_any_polygon``
+    returns ``False``) are skipped, since their boundaries are already
+    implicit from adjacent layers.
+
+    Args:
+        component: gdsfactory Component with GDS polygons.
+        stack: gsim :class:`LayerStack` defining z-extents and materials.
+        slice_axis: ``"y"`` for an XZ cross-section (horizontal slice),
+            ``"x"`` for a YZ cross-section (vertical slice).
+        slice_coord: Coordinate of the slice line (µm).
+
+    Returns:
+        List of dicts with keys ``h_min``, ``h_max``, ``z_min``, ``z_max``,
+        ``layer_name``, ``material``.
+    """
+    import numpy as np
+    from shapely.geometry import LineString, MultiLineString, Polygon
+
+    if not stack.layers:
+        return []
+
+    def _has_any_polygon(layer: object) -> bool:
+        gds = getattr(layer, "gds_layer", None)
+        if gds is None:
+            return False
+        try:
+            polys = component.get_polygons_points(layers=(gds,), merge=True)
+        except Exception:
+            return False
+        else:
+            if not isinstance(polys, dict):
+                return False
+            for v in polys.values():
+                items = v if isinstance(v, list) else [v]
+                if len(items) > 0:
+                    return True
+            return False
+
+    if slice_axis == "y":
+        cut_line = LineString([(-1e6, slice_coord), (1e6, slice_coord)])
+    elif slice_axis == "x":
+        cut_line = LineString([(slice_coord, -1e6), (slice_coord, 1e6)])
+    else:
+        raise ValueError(f"slice_axis must be 'x' or 'y', got {slice_axis!r}")
+
+    rectangles: list[dict[str, Any]] = []
+    for layer in stack.layers.values():
+        if layer.material == "air":
+            continue
+        gds_layer = layer.gds_layer
+        if gds_layer is None:
+            continue
+        thickness = layer.zmax - layer.zmin
+        if thickness <= 0:
+            continue
+
+        try:
+            polys = component.get_polygons_points(layers=(gds_layer,), merge=True)
+        except Exception:
+            try:
+                polys = component.dup().get_polygons_points(
+                    layers=(gds_layer,), merge=True
+                )
+            except Exception:
+                polys = {}
+
+        poly_items: list = []
+        if isinstance(polys, dict):
+            for poly_list in polys.values():
+                items = poly_list if isinstance(poly_list, list) else [poly_list]
+                poly_items.extend(items)
+
+        if not poly_items:
+            if _has_any_polygon(layer):
+                continue
+            rectangles.append(
+                {
+                    "h_min": -float("inf"),
+                    "h_max": float("inf"),
+                    "z_min": layer.zmin,
+                    "z_max": layer.zmax,
+                    "layer_name": layer.name,
+                    "material": layer.material,
+                }
+            )
+            continue
+
+        for poly in poly_items:
+            if isinstance(poly, np.ndarray):
+                coords = poly.reshape(-1, 2)
+                if len(coords) >= 3:
+                    spoly = Polygon(coords)
+                else:
+                    continue
+            elif isinstance(poly, (tuple, list)):
+                spoly = Polygon(poly)
+            elif hasattr(poly, "to_simple_polygon"):
+                sp = poly.to_simple_polygon()
+                coords = [
+                    (sp.point(i).x, sp.point(i).y) for i in range(sp.num_points())
+                ]
+                if len(coords) >= 3:
+                    spoly = Polygon(coords)
+                else:
+                    continue
+            else:
+                continue
+
+            if spoly.is_empty or not spoly.is_valid:
+                continue
+
+            intersection = spoly.intersection(cut_line)
+            if intersection.is_empty:
+                continue
+
+            segments: list[LineString] = []
+            if isinstance(intersection, LineString):
+                segments.append(intersection)
+            elif isinstance(intersection, MultiLineString):
+                segments.extend(intersection.geoms)
+            else:
+                segments.extend(
+                    g
+                    for g in getattr(intersection, "geoms", [])
+                    if isinstance(g, LineString)
+                )
+
+            for seg in segments:
+                coords = list(seg.coords)
+                if len(coords) < 2:
+                    continue
+                if slice_axis == "y":
+                    h_vals = [c[0] for c in coords]
+                else:
+                    h_vals = [c[1] for c in coords]
+                h_min, h_max = min(h_vals), max(h_vals)
+                if h_max - h_min < 1e-9:
+                    continue
+                rectangles.append(
+                    {
+                        "h_min": h_min,
+                        "h_max": h_max,
+                        "z_min": layer.zmin,
+                        "z_max": layer.zmax,
+                        "layer_name": layer.name,
+                        "material": layer.material,
+                    }
+                )
+
+    return rectangles
+
+
 # ---------------------------------------------------------------------------
 # Public plot functions
 # ---------------------------------------------------------------------------
diff --git a/src/gsim/palace/mesh/generator.py b/src/gsim/palace/mesh/generator.py
index ad5c556..11c1590 100644
--- a/src/gsim/palace/mesh/generator.py
+++ b/src/gsim/palace/mesh/generator.py
@@ -59,7 +59,12 @@ def _collect_pec_surface_lines(groups: dict) -> list[int]:
     pipeline may merge the conductor's boundary curves into the volume edges.
     This helper queries the live gmsh model for the boundary curves of each
     PEC surface and returns those that are valid dim-1 entities.
+
+    Requires an active gmsh session.  Silently returns an empty list when
+    gmsh has not been initialized (e.g. during unit tests with mocked geometry).
     """
+    if not gmsh.isInitialized():
+        return []
     lines: list[int] = []
     for surface_info in groups.get("pec_surfaces", {}).values():
         for stag in surface_info.get("tags", []):
@@ -85,8 +90,11 @@ def _get_domain_bbox(tol: float = 1e-3) -> tuple[float, float, float, float]:
     Uses the overall bounding box of all entities; any volume that spans
     the full domain (airbox, vacuum, substrate) determines the extents.
 
-    If gmsh is empty (e.g. unit tests), falls back to a zero-sized box.
+    If gmsh has not been initialized (e.g. unit tests), falls back to a
+    zero-sized box without emitting gmsh error noise.
     """
+    if not gmsh.isInitialized():
+        return (0.0, 0.0, 0.0, 0.0)
     try:
         xmin, ymin, _zmin, xmax, ymax, _zmax = gmsh.model.getBoundingBox(-1, -1)
     except Exception:
@@ -105,7 +113,12 @@ def _line_on_domain_boundary(
     endpoints sit on the same domain wall (x=xmin, x=xmax, y=ymin,
     or y=ymax).  This filters out large planar ground-plane sheets whose
     outer perimeter is just the simulation box outline.
+
+    Silently returns False when gmsh has not been initialized (e.g.
+    during unit tests with mocked geometry).
     """
+    if not gmsh.isInitialized():
+        return False
     try:
         tmin, tmax = gmsh.model.getParametrizationBounds(1, line_tag)
         p1 = gmsh.model.getValue(1, line_tag, tmin)
diff --git a/tests/meep/conftest.py b/tests/meep/conftest.py
index 2696018..c6285c3 100644
--- a/tests/meep/conftest.py
+++ b/tests/meep/conftest.py
@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import contextlib
+
 import gdsfactory as gf
 import pytest
 
 
 @pytest.fixture(autouse=True)
 def activate_generic_pdk():
-    """Activate the generic PDK before each test to prevent IHP PDK bleed-through."""
-    gf.gpdk.PDK.activate()
+    """Ensure the generic PDK is active before each test."""
+    with contextlib.suppress(AttributeError):
+        gf.gpdk.PDK.activate()
diff --git a/tests/meep/test_mode_result_plots.py b/tests/meep/test_mode_result_plots.py
new file mode 100644
index 0000000..48c9536
--- /dev/null
+++ b/tests/meep/test_mode_result_plots.py
@@ -0,0 +1,330 @@
+"""Unit tests for ModeResult.plot_mode() and ModeResult.plot_index()."""
+
+from __future__ import annotations
+
+import matplotlib as mpl
+import numpy as np
+import pytest
+
+mpl.use("Agg")
+import matplotlib.pyplot as plt
+
+from gsim.meep.models.results import ModeResult
+
+
+def _make_1d_result(**overrides):
+    z = np.linspace(-2, 2, 50)
+    rng_e = np.random.default_rng(42)
+    rng_x = np.random.default_rng(43)
+    defaults: dict[str, object] = {
+        "n_eff": 2.5,
+        "wavelength": 1.55,
+        "frequency": 1.0 / 1.55,
+        "fields": {
+            "Ey": rng_e.random(50) + 1j * rng_x.random(50),
+            "Ex": np.linspace(0, 1, 50) + 0j,
+        },
+        "z_grid": z,
+        "x_grid": None,
+        "y_grid": None,
+        "stack": None,
+        "component": None,
+        "port_or_position": None,
+        "cross_section_plane": None,
+        "kdom": [],
+        "n_group": None,
+        "band_num": 1,
+        "parity": "NO_PARITY",
+    }
+    defaults.update(overrides)
+    return ModeResult(**defaults)  # type: ignore[arg-type]
+
+
+def _make_2d_result(**overrides):
+    z = np.linspace(-2, 2, 30)
+    y = np.linspace(-1, 1, 20)
+    rng = np.random.default_rng(42)
+    defaults: dict[str, object] = {
+        "n_eff": 2.5,
+        "wavelength": 1.55,
+        "frequency": 1.0 / 1.55,
+        "fields": {
+            "Ey": rng.random((30, 20)) + 1j * rng.random((30, 20)),
+            "Ex": np.linspace(0, 1, 30)[:, None] * np.ones(20) + 0j,
+            "Ez": rng.random((30, 20)) + 1j * rng.random((30, 20)),
+        },
+        "z_grid": z,
+        "y_grid": y,
+        "x_grid": None,
+        "stack": None,
+        "component": None,
+        "port_or_position": None,
+        "cross_section_plane": "yz",
+        "kdom": [],
+        "n_group": None,
+        "band_num": 1,
+        "parity": "NO_PARITY",
+    }
+    defaults.update(overrides)
+    return ModeResult(**defaults)  # type: ignore[arg-type]
+
+
+def _make_2d_result(**overrides):
+    z = np.linspace(-2, 2, 30)
+    y = np.linspace(-1, 1, 20)
+    rng = np.random.default_rng(42)
+    fields = {
+        "Ey": rng.random((30, 20)) + 1j * rng.random((30, 20)),
+        "Ex": np.linspace(0, 1, 30)[:, None] * np.ones(20) + 0j,
+        "Ez": rng.random((30, 20)) + 1j * rng.random((30, 20)),
+    }
+    kwargs = dict(
+        n_eff=2.5,
+        wavelength=1.55,
+        frequency=1.0 / 1.55,
+        fields=fields,
+        z_grid=z,
+        y_grid=y,
+        cross_section_plane="yz",
+    )
+    kwargs.update(overrides)
+    return ModeResult(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# Error handling
+# ---------------------------------------------------------------------------
+
+
+class TestModeResultPlotErrors:
+    def test_plot_mode_empty_fields_raises(self):
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+        )
+        with pytest.raises(ValueError, match="no field data"):
+            result.plot_mode()
+
+    def test_plot_mode_invalid_norm_raises(self):
+        result = _make_1d_result()
+        with pytest.raises(ValueError, match="Unknown norm"):
+            result.plot_mode(norm="invalid_norm")
+
+    def test_plot_mode_unknown_component_raises(self):
+        result = _make_1d_result()
+        with pytest.raises(ValueError, match="Unknown component"):
+            result.plot_mode(components="Hz")
+
+    def test_plot_mode_ax_with_multi_component_raises(self):
+        result = _make_1d_result()
+        fig, ax = plt.subplots()
+        with pytest.raises(ValueError, match="ax may only be passed"):
+            result.plot_mode(components="all", ax=ax)
+        plt.close(fig)
+
+    def test_plot_mode_both_x_and_y_grid_raises(self):
+        result = _make_1d_result(
+            x_grid=np.array([0.0]),
+            y_grid=np.array([0.0]),
+        )
+        with pytest.raises(ValueError, match="Ambiguous geometry"):
+            result.plot_mode()
+
+    def test_plot_index_no_stack_raises(self):
+        result = _make_1d_result()
+        with pytest.raises(ValueError, match="No stack"):
+            result.plot_index()
+
+    def test_plot_index_no_z_grid_raises(self):
+        from unittest.mock import MagicMock
+
+        mock_stack = MagicMock()
+        result = _make_1d_result(z_grid=None, stack=mock_stack)
+        with pytest.raises(ValueError, match="No z_grid"):
+            result.plot_index()
+
+
+# ---------------------------------------------------------------------------
+# Auto-component detection
+# ---------------------------------------------------------------------------
+
+
+class TestAutoComponent:
+    def test_auto_component_picks_largest_amplitude(self):
+        z = np.linspace(-2, 2, 50)
+        fields = {
+            "Ex": np.ones(50) * 0.1,
+            "Ey": np.ones(50) * 5.0,
+            "Ez": np.ones(50) * 0.05,
+        }
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            fields=fields,
+            z_grid=z,
+        )
+        assert result._auto_component() == "Ey"
+
+    def test_auto_component_complex_magnitude(self):
+        z = np.linspace(-2, 2, 50)
+        fields = {
+            "Ex": np.ones(50) * (1 + 1j),
+            "Ey": np.ones(50) * (2 - 1j),
+        }
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            fields=fields,
+            z_grid=z,
+        )
+        assert result._auto_component() == "Ey"
+
+
+# ---------------------------------------------------------------------------
+# norm transforms
+# ---------------------------------------------------------------------------
+
+
+class TestNormTransforms:
+    def test_abs_norm(self):
+        field = np.array([1 + 2j, -3 - 4j])
+        out = ModeResult._apply_norm(field, "abs")
+        np.testing.assert_allclose(out, np.array([np.sqrt(5), 5.0]))
+
+    def test_real_norm(self):
+        field = np.array([1 + 2j, -3 - 4j])
+        out = ModeResult._apply_norm(field, "real")
+        np.testing.assert_allclose(out, np.array([1.0, -3.0]))
+
+    def test_imag_norm(self):
+        field = np.array([1 + 2j, -3 - 4j])
+        out = ModeResult._apply_norm(field, "imag")
+        np.testing.assert_allclose(out, np.array([2.0, -4.0]))
+
+    def test_phase_norm(self):
+        field = np.array([1 + 1j])
+        out = ModeResult._apply_norm(field, "phase")
+        np.testing.assert_allclose(out, np.array([np.pi / 4]))
+
+
+# ---------------------------------------------------------------------------
+# 1D plot_mode smoke tests
+# ---------------------------------------------------------------------------
+
+
+class TestPlotMode1D:
+    def test_plot_mode_auto_1d(self):
+        result = _make_1d_result()
+        fig, ax = result.plot_mode(show=False)
+        assert isinstance(fig, plt.Figure)
+        assert ax is not None
+        assert "n_eff=2.5000" in ax.get_title()
+        plt.close(fig)
+
+    def test_plot_mode_specific_component_1d(self):
+        result = _make_1d_result()
+        fig, ax = result.plot_mode(components="Ex", show=False)
+        assert isinstance(fig, plt.Figure)
+        assert "Ex" in ax.get_title()
+        plt.close(fig)
+
+    def test_plot_mode_all_1d(self):
+        result = _make_1d_result()
+        fig, axes = result.plot_mode(components="all", show=False)
+        assert isinstance(fig, plt.Figure)
+        assert axes.shape == (2, 1)
+        plt.close(fig)
+
+    def test_plot_mode_list_components_1d(self):
+        result = _make_1d_result()
+        fig, _ax = result.plot_mode(components=["Ey"], show=False)
+        assert isinstance(fig, plt.Figure)
+        plt.close(fig)
+
+    def test_plot_mode_with_ax_1d(self):
+        result = _make_1d_result()
+        fig, ax = plt.subplots()
+        fig2, ax2 = result.plot_mode(components="Ey", ax=ax, show=False)
+        assert fig is fig2
+        assert ax is ax2
+        plt.close(fig)
+
+    def test_plot_mode_title_none_1d(self):
+        result = _make_1d_result()
+        fig, ax = result.plot_mode(title=None, show=False)
+        assert ax.get_title() == ""
+        plt.close(fig)
+
+    def test_plot_mode_custom_title_1d(self):
+        result = _make_1d_result()
+        fig, ax = result.plot_mode(title="Custom Title", show=False)
+        assert ax.get_title() == "Custom Title"
+        plt.close(fig)
+
+
+# ---------------------------------------------------------------------------
+# 2D plot_mode smoke tests
+# ---------------------------------------------------------------------------
+
+
+class TestPlotMode2D:
+    def test_plot_mode_auto_2d(self):
+        result = _make_2d_result()
+        fig, ax = result.plot_mode(show=False)
+        assert isinstance(fig, plt.Figure)
+        assert ax is not None
+        assert "n_eff=2.5000" in ax.get_title()
+        plt.close(fig)
+
+    def test_plot_mode_all_2d(self):
+        result = _make_2d_result()
+        fig, axes = result.plot_mode(components="all", show=False)
+        assert isinstance(fig, plt.Figure)
+        assert axes.shape[0] * axes.shape[1] >= 3
+        plt.close(fig)
+
+    def test_plot_mode_shared_colorbar_2d(self):
+        result = _make_2d_result()
+        fig, _axes = result.plot_mode(
+            components="all", shared_colorbar=True, show=False
+        )
+        assert isinstance(fig, plt.Figure)
+        plt.close(fig)
+
+    def test_plot_mode_xz_grid_2d(self):
+        x = np.linspace(-1, 1, 10)
+        z = np.linspace(-2, 2, 15)
+        rng = np.random.default_rng(42)
+        fields = {"Ey": rng.random((15, 10)) + 1j * rng.random((15, 10))}
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            fields=fields,
+            z_grid=z,
+            x_grid=x,
+            cross_section_plane="xz",
+        )
+        fig, ax = result.plot_mode(show=False)
+        assert ax.get_xlabel() == "x (µm)"
+        plt.close(fig)
+
+
+# ---------------------------------------------------------------------------
+# plot_index smoke tests
+# ---------------------------------------------------------------------------
+
+
+class TestPlotIndex:
+    def test_plot_index_1d_raises_without_stack(self):
+        result = _make_1d_result()
+        with pytest.raises(ValueError, match="No stack"):
+            result.plot_index()
+
+    def test_plot_index_2d_raises_without_stack(self):
+        result = _make_2d_result()
+        with pytest.raises(ValueError, match="No stack"):
+            result.plot_index()
diff --git a/tests/meep/test_mode_solver.py b/tests/meep/test_mode_solver.py
new file mode 100644
index 0000000..31094c3
--- /dev/null
+++ b/tests/meep/test_mode_solver.py
@@ -0,0 +1,1298 @@
+"""Tests for the standalone Meep mode solver."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+import numpy as np
+import pytest
+from pydantic import ValidationError
+
+
+def _fake_import_error():
+    raise ImportError("pymeep")
+
+
+class TestModeResult:
+    """ModeResult model validation — no meep required."""
+
+    def test_minimal_construction(self):
+        """ModeResult can be constructed with minimal required fields."""
+        from gsim.meep.models.results import ModeResult
+
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            band_num=1,
+            parity="NO_PARITY",
+        )
+        assert result.n_eff == 2.5
+        assert result.wavelength == 1.55
+        assert result.band_num == 1
+        assert result.parity == "NO_PARITY"
+        assert result.n_group is None
+        assert result.kdom == []
+        assert result.fields == {}
+
+    def test_requires_n_eff(self):
+        """ModeResult requires n_eff."""
+        from gsim.meep.models.results import ModeResult
+
+        with pytest.raises(ValidationError):
+            ModeResult(
+                wavelength=1.55,
+                frequency=1.0 / 1.55,
+                band_num=1,
+                parity="NO_PARITY",
+            )
+
+    def test_requires_wavelength(self):
+        """ModeResult requires wavelength."""
+        from gsim.meep.models.results import ModeResult
+
+        with pytest.raises(ValidationError):
+            ModeResult(
+                n_eff=2.5,
+                frequency=1.0 / 1.55,
+                band_num=1,
+                parity="NO_PARITY",
+            )
+
+    def test_full_construction_with_fields(self):
+        """ModeResult stores field arrays by component name."""
+        from gsim.meep.models.results import ModeResult
+
+        ex = np.array([[1.0, 0.0], [0.0, 1.0]])
+        ey = np.array([[0.0, 1.0], [-1.0, 0.0]])
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            fields={"Ex": ex, "Ey": ey},
+            kdom=[1.0, 0.0, 0.0],
+            n_group=4.2,
+            band_num=2,
+            parity="EVEN_Y",
+        )
+        assert result.n_group == 4.2
+        assert result.band_num == 2
+        assert result.parity == "EVEN_Y"
+        assert list(result.kdom) == [1.0, 0.0, 0.0]
+        np.testing.assert_array_equal(result.fields["Ex"], ex)
+        np.testing.assert_array_equal(result.fields["Ey"], ey)
+
+    def test_defaults(self):
+        """Optional fields have correct defaults."""
+        from gsim.meep.models.results import ModeResult
+
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+        )
+        assert result.band_num == 1
+        assert result.parity == "NO_PARITY"
+        assert result.n_group is None
+        assert result.kdom == []
+        assert result.fields == {}
+
+    def test_model_dump(self):
+        """ModeResult serializes to dict including numpy arrays."""
+        from gsim.meep.models.results import ModeResult
+
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            band_num=1,
+            parity="NO_PARITY",
+        )
+        d = result.model_dump()
+        assert d["n_eff"] == 2.5
+        assert d["wavelength"] == 1.55
+        assert d["band_num"] == 1
+        assert d["parity"] == "NO_PARITY"
+        assert d["n_group"] is None
+
+    def test_new_grid_fields_default_to_none(self):
+        """x_grid, y_grid, z_grid default to None."""
+        from gsim.meep.models.results import ModeResult
+
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+        )
+        assert result.x_grid is None
+        assert result.y_grid is None
+        assert result.z_grid is None
+
+    def test_new_context_fields_default(self):
+        """stack, component, port_or_position, cross_section_plane default."""
+        from gsim.meep.models.results import ModeResult
+
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+        )
+        assert result.stack is None
+        assert result.component is None
+        assert result.port_or_position is None
+        assert result.cross_section_plane is None
+
+    def test_grid_fields_stored(self):
+        """x_grid, y_grid, z_grid are stored when provided."""
+        from gsim.meep.models.results import ModeResult
+
+        x = np.array([1.0, 2.0])
+        y = np.array([3.0, 4.0])
+        z = np.array([5.0, 6.0])
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            x_grid=x,
+            y_grid=y,
+            z_grid=z,
+            cross_section_plane="xz",
+        )
+        np.testing.assert_array_equal(result.x_grid, x)
+        np.testing.assert_array_equal(result.y_grid, y)
+        np.testing.assert_array_equal(result.z_grid, z)
+        assert result.cross_section_plane == "xz"
+
+    def test_model_dump_excludes_stack_and_component(self):
+        """stack and component are excluded from model_dump."""
+        from unittest.mock import MagicMock
+
+        from gsim.meep.models.results import ModeResult
+
+        mock_stack = MagicMock()
+        mock_comp = MagicMock()
+        result = ModeResult(
+            n_eff=2.5,
+            wavelength=1.55,
+            frequency=1.0 / 1.55,
+            stack=mock_stack,
+            component=mock_comp,
+        )
+        d = result.model_dump()
+        assert "stack" not in d
+        assert "component" not in d
+        assert "n_eff" in d
+
+
+class TestResolveStackAndMaterials:
+    """_resolve_stack_and_materials() — no meep required."""
+
+    def test_resolves_stack_and_materials(self):
+        """Resolves a layer stack and material data from a Simulation."""
+        import gdsfactory as gf
+
+        from gsim.meep import Simulation
+
+        c = gf.components.straight(length=10, width=0.5)
+
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.materials = {
+            "si": 12.0,
+            "SiO2": 2.1,
+        }
+
+        stack, materials = sim._resolve_stack_and_materials(wavelength=1.55)
+        assert stack is not None
+        assert len(stack.layers) > 0
+        assert isinstance(materials, dict)
+        assert len(materials) > 0
+
+    def test_materials_contain_epsilon(self):
+        """Resolved materials have epsilon_diag entries."""
+        import gdsfactory as gf
+
+        from gsim.meep import Simulation
+
+        c = gf.components.straight(length=10, width=0.5)
+
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.materials = {
+            "si": 12.0,
+            "SiO2": 2.1,
+        }
+
+        _stack, materials = sim._resolve_stack_and_materials(wavelength=1.55)
+        for name, mat in materials.items():
+            assert mat.epsilon_diag is not None, f"{name} missing epsilon_diag"
+
+    def test_wavelength_affects_dispersive_materials(self):
+        """Different wavelengths produce different epsilon for dispersive materials."""
+        import gdsfactory as gf
+
+        from gsim.meep import Simulation
+
+        c = gf.components.straight(length=10, width=0.5)
+
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.materials = {}
+
+        _stack, mats_1550 = sim._resolve_stack_and_materials(wavelength=1.55)
+        _stack, mats_1310 = sim._resolve_stack_and_materials(wavelength=1.31)
+
+        # si should be present in both (from default PDK stack)
+        if "si" in mats_1550 and "si" in mats_1310:
+            eps_1550 = mats_1550["si"].epsilon_diag
+            eps_1310 = mats_1310["si"].epsilon_diag
+            # si has material dispersion — eps at 1.31 != eps at 1.55
+            if isinstance(eps_1550, list):
+                eps_1550 = eps_1550[0]
+            if isinstance(eps_1310, list):
+                eps_1310 = eps_1310[0]
+            assert eps_1550 != eps_1310, (
+                f"Expected different epsilon at different wavelengths, "
+                f"got {eps_1550} at 1.55 and {eps_1310} at 1.31"
+            )
+
+
+class TestModeSolverImport:
+    """Lazy import behavior — no meep required."""
+
+    def test_solve_slab_mode_import_error_without_meep(self, monkeypatch):
+        """Raises ImportError with clear message when meep not installed."""
+        from gsim.meep import mode_solver
+
+        monkeypatch.setattr(mode_solver, "_import_meep", _fake_import_error)
+
+        with pytest.raises(ImportError, match="pymeep"):
+            mode_solver.solve_slab_mode(
+                stack=cast(Any, None),
+                wavelength=1.55,
+            )
+
+    def test_solve_cross_section_mode_import_error_without_meep(self, monkeypatch):
+        """Raises ImportError with clear message when meep not installed."""
+        from gsim.meep import mode_solver
+
+        monkeypatch.setattr(mode_solver, "_import_meep", _fake_import_error)
+
+        with pytest.raises(ImportError, match="pymeep"):
+            mode_solver.solve_cross_section_mode(
+                component=cast(Any, None),
+                stack=cast(Any, None),
+                wavelength=1.55,
+                x_span=2.0,
+            )
+
+
+class TestModeSolverUnit:
+    """Unit tests for mode solver — no meep required."""
+
+    def test_mode_solver_module_exports(self):
+        """Public functions are importable from mode_solver module."""
+        from gsim.meep.mode_solver import (
+            solve_cross_section_mode,
+            solve_slab_mode,
+        )
+
+        assert callable(solve_slab_mode)
+        assert callable(solve_cross_section_mode)
+
+
+class TestModeZGrid:
+    """Unit tests for mode_z_grid — no meep required."""
+
+    def test_z_grid_bounds_and_length(self):
+        """Z-grid spans stack extent in absolute coordinates."""
+        from gsim.common.stack.extractor import Layer, LayerStack
+        from gsim.meep.mode_solver import mode_z_grid
+
+        layers = {
+            "box": Layer(
+                name="box",
+                gds_layer=(0, 0),
+                zmin=-2.0,
+                zmax=0.0,
+                thickness=2.0,
+                material="sio2",
+                layer_type="dielectric",
+            ),
+            "core": Layer(
+                name="core",
+                gds_layer=(1, 0),
+                zmin=0.0,
+                zmax=0.22,
+                thickness=0.22,
+                material="si",
+                layer_type="dielectric",
+            ),
+        }
+        stack = LayerStack(layers=layers)
+        z_grid = mode_z_grid(stack, n_points=100)
+
+        assert len(z_grid) == 100
+        assert z_grid[0] < -1.9  # near z_min = -2.0
+        assert z_grid[-1] > 0.2  # near z_max = 0.22
+
+    def test_z_grid_absolute_coords(self):
+        """Z-grid values match absolute layer extents + margins."""
+
+        from gsim.common.stack.extractor import Layer, LayerStack
+        from gsim.meep.mode_solver import mode_z_grid
+
+        layers = {
+            "box": Layer(
+                name="box",
+                gds_layer=(0, 0),
+                zmin=-2.0,
+                zmax=0.0,
+                thickness=2.0,
+                material="sio2",
+                layer_type="dielectric",
+            ),
+            "core": Layer(
+                name="core",
+                gds_layer=(1, 0),
+                zmin=0.0,
+                zmax=0.22,
+                thickness=0.22,
+                material="si",
+                layer_type="dielectric",
+            ),
+        }
+        stack = LayerStack(layers=layers)
+        z_grid = mode_z_grid(stack, n_points=200, z_margin=(0.5, 0.5))
+
+        z_min = -2.0
+        z_max = 0.22
+        zm_bottom, zm_top = 0.5, 0.5
+        expected_bottom = z_min - zm_bottom
+        expected_top = z_max + zm_top
+        assert z_grid[0] < -2.4  # below z_min - zm_bottom
+        assert z_grid[-1] > 0.6  # above z_max + zm_top
+        assert abs(z_grid[0] - expected_bottom) < 0.05
+        assert abs(z_grid[-1] - expected_top) < 0.05
+
+    def test_asymmetric_z_margin_grid_coverage(self):
+        """Asymmetric z_margin gives correct start/end bounds."""
+
+        from gsim.common.stack.extractor import Layer, LayerStack
+        from gsim.meep.mode_solver import mode_z_grid
+
+        layers = {
+            "box": Layer(
+                name="box",
+                gds_layer=(0, 0),
+                zmin=-2.0,
+                zmax=0.0,
+                thickness=2.0,
+                material="sio2",
+                layer_type="dielectric",
+            ),
+            "core": Layer(
+                name="core",
+                gds_layer=(1, 0),
+                zmin=0.0,
+                zmax=0.22,
+                thickness=0.22,
+                material="si",
+                layer_type="dielectric",
+            ),
+        }
+        stack = LayerStack(layers=layers)
+        z_grid = mode_z_grid(stack, n_points=200, z_margin=(0, 0.5))
+
+        z_min, z_max = -2.0, 0.22
+        expected_bottom = z_min  # margin_bottom = 0
+        expected_top = z_max + 0.5
+        assert abs(z_grid[0] - expected_bottom) < 0.05
+        assert abs(z_grid[-1] - expected_top) < 0.05
+
+
+class TestRefractiveIndexProfile:
+    """Unit tests for refractive_index_profile — no meep required."""
+
+    def test_profile_length_matches_grid(self):
+        """Profile has same length as input z_grid."""
+        import numpy as np
+
+        from gsim.common.stack.extractor import Layer, LayerStack
+        from gsim.meep.mode_solver import (
+            mode_z_grid,
+            refractive_index_profile,
+        )
+
+        layers = {
+            "box": Layer(
+                name="box",
+                gds_layer=(0, 0),
+                zmin=-2.0,
+                zmax=0.0,
+                thickness=2.0,
+                material="sio2",
+                layer_type="dielectric",
+            ),
+            "core": Layer(
+                name="core",
+                gds_layer=(1, 0),
+                zmin=0.0,
+                zmax=0.22,
+                thickness=0.22,
+                material="si",
+                layer_type="dielectric",
+            ),
+        }
+        stack = LayerStack(layers=layers)
+        z_grid = mode_z_grid(stack, n_points=50)
+        n_profile = refractive_index_profile(stack, 1.55, z_grid=z_grid)
+
+        assert len(n_profile) == 50
+        assert isinstance(n_profile, np.ndarray)
+
+    def test_si_layer_higher_index(self):
+        """Si core region has higher index than SiO2 cladding."""
+        import numpy as np
+
+        from gsim.common.stack.extractor import Layer, LayerStack
+        from gsim.meep.mode_solver import (
+            mode_z_grid,
+            refractive_index_profile,
+        )
+
+        layers = {
+            "box": Layer(
+                name="box",
+                gds_layer=(0, 0),
+                zmin=-2.0,
+                zmax=0.0,
+                thickness=2.0,
+                material="sio2",
+                layer_type="dielectric",
+            ),
+            "core": Layer(
+                name="core",
+                gds_layer=(1, 0),
+                zmin=0.0,
+                zmax=0.22,
+                thickness=0.22,
+                material="si",
+                layer_type="dielectric",
+            ),
+        }
+        stack = LayerStack(layers=layers)
+        z_grid = mode_z_grid(stack, n_points=200)
+        n_profile = refractive_index_profile(stack, 1.55, z_grid=z_grid)
+
+        core_mask = (z_grid >= 0.0) & (z_grid < 0.22)
+        box_mask = ~core_mask
+
+        assert np.mean(n_profile[core_mask]) > np.mean(n_profile[box_mask])
+
+
+class TestModeXGrid:
+    """Unit tests for mode_x_grid — no meep required."""
+
+    def test_x_grid_bounds_and_length(self):
+        """X-grid spans cell extent and has correct length."""
+
+        from gsim.meep.mode_solver import mode_x_grid
+
+        x_grid = mode_x_grid(n_points=100, x_span=4.0)
+
+        assert len(x_grid) == 100
+        assert x_grid[0] > -2.1
+        assert x_grid[0] < -1.9
+        assert x_grid[-1] > 1.9
+        assert x_grid[-1] < 2.1
+
+    def test_x_grid_centred(self):
+        """X-grid is centred on origin (zero-mean)."""
+        import numpy as np
+
+        from gsim.meep.mode_solver import mode_x_grid
+
+        x_grid = mode_x_grid(n_points=200, x_span=6.0)
+
+        assert abs(np.mean(x_grid)) < 0.1
+
+
+class TestModeSolver:
+    """ModeSolver model validation — no meep required."""
+
+    def test_default_wavelengths_empty(self):
+        """ModeSolver defaults to empty wavelengths list."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver()
+        assert ms.wavelengths == []
+
+    def test_minimal_construction(self):
+        """ModeSolver with wavelengths uses correct defaults."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        assert ms.wavelengths == [1.55]
+        assert ms.where == "auto"
+        assert ms.num_bands == 1
+        assert ms.band is None
+        assert ms.parity == "NO_PARITY"
+        assert ms.eigensolver_tol == 1e-6
+        assert ms.port is None
+        assert ms.position is None
+        assert ms.x_span is None
+        assert ms.y_span is None
+        assert ms.n_field_x == 0
+        assert ms.n_field_y == 0
+        assert ms.n_field_z == 0
+
+    def test_slab_forbids_port(self):
+        """where='slab' forbids port."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError, match="slab"):
+            ModeSolver(wavelengths=[1.55], where="slab", port="o1")
+
+    def test_slab_forbids_position(self):
+        """where='slab' forbids position."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError, match="slab"):
+            ModeSolver(wavelengths=[1.55], where="slab", position=(0, 0))
+
+    def test_slab_forbids_x_span(self):
+        """where='slab' forbids x_span."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError, match="slab"):
+            ModeSolver(wavelengths=[1.55], where="slab", x_span=5.0)
+
+    def test_slab_forbids_y_span(self):
+        """where='slab' forbids y_span."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError, match="slab"):
+            ModeSolver(wavelengths=[1.55], where="slab", y_span=5.0)
+
+    def test_cross_section_without_port_or_position_is_allowed(self):
+        """where='cross_section' without port/position allowed at model level.
+
+        Port/position validation for cross-section is deferred to
+        solve_modes() call time (Issue 2).
+        """
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55], where="cross_section")
+        assert ms.where == "cross_section"
+        assert ms.port is None
+        assert ms.position is None
+
+    def test_cross_section_allows_port(self):
+        """where='cross_section' with port is valid."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55], where="cross_section", port="o1")
+        assert ms.where == "cross_section"
+        assert ms.port == "o1"
+
+    def test_cross_section_allows_position(self):
+        """where='cross_section' with position is valid."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55], where="cross_section", position=(0, 0))
+        assert ms.where == "cross_section"
+        assert ms.position == (0, 0)
+
+    def test_cross_section_forbids_both_port_and_position(self):
+        """where='cross_section' forbids both port and position."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError, match="port"):
+            ModeSolver(
+                wavelengths=[1.55],
+                where="cross_section",
+                port="o1",
+                position=(0, 0),
+            )
+
+    def test_parity_rejects_invalid(self):
+        """parity rejects invalid strings."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError):
+            ModeSolver(wavelengths=[1.55], parity="EVEN_Z")  # ty: ignore[invalid-argument-type]
+
+    def test_fundamental_sets_bands(self):
+        """fundamental() sets num_bands=1, band=None."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55], num_bands=5, band=3)
+        result = ms.fundamental()
+        assert result is ms
+        assert ms.num_bands == 1
+        assert ms.band is None
+
+    def test_first_sets_num_bands(self):
+        """first(n) sets num_bands=n, band=None."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55], band=3)
+        result = ms.first(4)
+        assert result is ms
+        assert ms.num_bands == 4
+        assert ms.band is None
+
+    def test_call_sets_band(self):
+        """__call__(band=n) sets band."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        result = ms(band=2)
+        assert result is ms
+        assert ms.band == 2
+
+    def test_at_port_sets_port(self):
+        """at_port(name) sets port."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        result = ms.at_port("o2")
+        assert result is ms
+        assert ms.port == "o2"
+
+    def test_at_slab_sets_where(self):
+        """at_slab() sets where='slab'."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        result = ms.at_slab()
+        assert result is ms
+        assert ms.where == "slab"
+
+    def test_at_cross_section_sets_where(self):
+        """at_cross_section() sets where='cross_section'."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        result = ms.at_cross_section()
+        assert result is ms
+        assert ms.where == "cross_section"
+
+    def test_sweep_wavelength_populates(self):
+        """sweep_wavelength(start, stop, num) populates wavelengths."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        result = ms.sweep_wavelength(1.50, 1.60, 5)
+        assert result is ms
+        assert len(ms.wavelengths) == 5
+        assert ms.wavelengths[0] == 1.50
+        assert ms.wavelengths[-1] == 1.60
+
+    def test_call_updates_fields(self):
+        """__call__ updates fields in place, returns self."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        result = ms(num_bands=3, port="o1")
+        assert result is ms
+        assert ms.num_bands == 3
+        assert ms.port == "o1"
+
+    def test_fluent_chaining(self):
+        """Fluent chaining produces correct field values."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55]).first(3).at_port("o1")
+        assert ms.num_bands == 3
+        assert ms.band is None
+        assert ms.port == "o1"
+
+    def test_band_zero_raises(self):
+        """band=0 raises ValidationError — bands are 1-indexed."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError):
+            ModeSolver(wavelengths=[1.55], band=0)
+
+    def test_num_bands_zero_raises(self):
+        """num_bands=0 raises ValidationError — must be at least 1."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError):
+            ModeSolver(wavelengths=[1.55], num_bands=0)
+
+    def test_port_and_position_both_set_raises(self):
+        """Both port and position set raises ValidationError."""
+        from gsim.meep.models.api import ModeSolver
+
+        with pytest.raises(ValidationError, match="port"):
+            ModeSolver(wavelengths=[1.55], port="o1", position=(0, 0))
+
+    def test_sweep_wavelength_single_point(self):
+        """sweep_wavelength with num=1 produces a single-element wavelengths list."""
+        from gsim.meep.models.api import ModeSolver
+
+        ms = ModeSolver(wavelengths=[1.55])
+        ms.sweep_wavelength(1.50, 1.60, 1)
+        assert len(ms.wavelengths) == 1
+        assert ms.wavelengths[0] == 1.50
+
+
+class TestModeSweepResult:
+    """ModeSweepResult wrapper tests — no meep required."""
+
+    @staticmethod
+    def _make_result(
+        n_eff=2.5, wavelength=1.55, frequency=1.0, band_num=1, parity="NO_PARITY"
+    ):
+        from gsim.meep.models.results import ModeResult
+
+        return ModeResult(
+            n_eff=n_eff,
+            wavelength=wavelength,
+            frequency=frequency,
+            band_num=band_num,
+            parity=parity,
+        )
+
+    def test_construction(self):
+        """ModeSweepResult stores list of ModeResult."""
+        from gsim.meep.results import ModeSweepResult
+
+        r1 = self._make_result(n_eff=2.5, wavelength=1.55)
+        r2 = self._make_result(n_eff=2.3, wavelength=1.60)
+        result = ModeSweepResult([r1, r2])
+        assert len(result.results) == 2
+        assert result.results[0] is r1
+
+    def test_at_filters_by_wavelength(self):
+        """at(wavelength) returns new ModeSweepResult filtered to that wavelength."""
+        from gsim.meep.results import ModeSweepResult
+
+        r1 = self._make_result(n_eff=2.5, wavelength=1.55)
+        r2 = self._make_result(n_eff=2.3, wavelength=1.60)
+        result = ModeSweepResult([r1, r2])
+        filtered = result.at(1.55)
+        assert isinstance(filtered, ModeSweepResult)
+        assert len(filtered.results) == 1
+        assert filtered.results[0].n_eff == 2.5
+
+    def test_at_no_match_returns_empty(self):
+        """at(wavelength) with no match returns empty ModeSweepResult."""
+        from gsim.meep.results import ModeSweepResult
+
+        r1 = self._make_result(n_eff=2.5, wavelength=1.55)
+        result = ModeSweepResult([r1])
+        filtered = result.at(1.60)
+        assert len(filtered.results) == 0
+
+    def test_band_lookup(self):
+        """band(n) returns first ModeResult matching band_num."""
+        from gsim.meep.results import ModeSweepResult
+
+        r1 = self._make_result(n_eff=2.5, wavelength=1.55, band_num=1)
+        r2 = self._make_result(n_eff=2.3, wavelength=1.55, band_num=2)
+        result = ModeSweepResult([r1, r2])
+        found = result.band(2)
+        assert found is not None
+        assert found.n_eff == 2.3
+        assert found.band_num == 2
+
+    def test_band_no_match_returns_none(self):
+        """band(n) returns None when no match."""
+        from gsim.meep.results import ModeSweepResult
+
+        r1 = self._make_result(n_eff=2.5, wavelength=1.55, band_num=1)
+        result = ModeSweepResult([r1])
+        assert result.band(5) is None
+
+    def test_to_dict_format(self):
+        """to_dict() returns dict of lists."""
+        from gsim.meep.results import ModeSweepResult
+
+        r1 = self._make_result(n_eff=2.5, wavelength=1.55, band_num=1)
+        r2 = self._make_result(n_eff=2.3, wavelength=1.60, band_num=1)
+        result = ModeSweepResult([r1, r2])
+        d = result.to_dict()
+        assert "wavelength" in d
+        assert "band_num" in d
+        assert "n_eff" in d
+        assert "n_group" in d
+        assert "parity" in d
+        assert d["wavelength"] == [1.55, 1.60]
+        assert d["n_eff"] == [2.5, 2.3]
+        assert d["band_num"] == [1, 1]
+        assert d["n_group"] == [None, None]
+
+    def test_at_chaining(self):
+        """at(wavelength) can be chained for further queries."""
+        from gsim.meep.results import ModeSweepResult
+
+        r1 = self._make_result(n_eff=2.5, wavelength=1.55, band_num=1)
+        r2 = self._make_result(n_eff=2.3, wavelength=1.55, band_num=2)
+        result = ModeSweepResult([r1, r2])
+        found = result.at(1.55).band(1)
+        assert found is not None
+        assert found.n_eff == 2.5
+
+    def test_empty_at_returns_empty_wrapper(self):
+        """at() on empty ModeSweepResult returns empty wrapper."""
+        from gsim.meep.results import ModeSweepResult
+
+        result = ModeSweepResult([])
+        filtered = result.at(1.55)
+        assert isinstance(filtered, ModeSweepResult)
+        assert len(filtered.results) == 0
+
+    def test_empty_band_returns_none(self):
+        """band() on empty ModeSweepResult returns None."""
+        from gsim.meep.results import ModeSweepResult
+
+        result = ModeSweepResult([])
+        assert result.band(1) is None
+
+    def test_empty_to_dict_empty_lists(self):
+        """to_dict() on empty ModeSweepResult returns dict of empty lists."""
+        from gsim.meep.results import ModeSweepResult
+
+        result = ModeSweepResult([])
+        d = result.to_dict()
+        assert d["wavelength"] == []
+        assert d["n_eff"] == []
+        assert d["band_num"] == []
+
+
+class TestSimulationSolveMode:
+    """Simulation.solve_mode() replaced by solve_modes()."""
+
+    def test_solve_mode_gone(self):
+        """solve_mode is removed from Simulation."""
+        import gdsfactory as gf
+
+        from gsim.meep import Simulation
+
+        c = gf.components.straight(length=10, width=0.5)
+        sim = Simulation()
+        sim.geometry.component = c
+
+        assert not hasattr(sim, "solve_mode")
+
+
+class TestSimulationModeSolverField:
+    """Simulation.mode_solver field — no meep required."""
+
+    def test_mode_solver_field_exists(self):
+        """sim.mode_solver exists and is a ModeSolver instance by default."""
+        from gsim.meep import Simulation
+        from gsim.meep.models.api import ModeSolver
+
+        sim = Simulation()
+        assert hasattr(sim, "mode_solver")
+        assert isinstance(sim.mode_solver, ModeSolver)
+
+    def test_mode_solver_configurable(self):
+        """sim.mode_solver can be configured and re-read."""
+        from gsim.meep import Simulation
+
+        sim = Simulation()
+        sim.mode_solver(wavelengths=[1.55], num_bands=3, port="o1")
+        assert sim.mode_solver.wavelengths == [1.55]
+        assert sim.mode_solver.num_bands == 3
+        assert sim.mode_solver.port == "o1"
+
+
+class TestSimulationSolveModes:
+    """Simulation.solve_modes() tests — no meep required for error paths."""
+
+    def test_solve_modes_exists(self):
+        """sim.solve_modes exists and is callable."""
+        from gsim.meep import Simulation
+
+        sim = Simulation()
+        assert hasattr(sim, "solve_modes")
+        assert callable(sim.solve_modes)
+
+    def test_solve_modes_requires_wavelengths(self):
+        """sim.solve_modes raises ValueError when wavelengths is empty."""
+        from gsim.meep import Simulation
+
+        sim = Simulation()
+        sim.mode_solver.wavelengths = []
+
+        with pytest.raises(ValueError, match="wavelengths"):
+            sim.solve_modes()
+
+    def test_solve_modes_cross_section_no_component(self):
+        """sim.solve_modes raises ValueError when cross_section but no component."""
+        from gsim.meep import Simulation
+
+        sim = Simulation()
+        sim.mode_solver(wavelengths=[1.55], where="cross_section", port="o1")
+
+        with pytest.raises(ValueError, match="component"):
+            sim.solve_modes()
+
+    def test_solve_modes_cross_section_no_port_or_position(self):
+        """solve_modes raises ValueError for cross_section without port/position."""
+        import gdsfactory as gf
+
+        from gsim.meep import Simulation
+
+        c = gf.components.straight(length=10, width=0.5)
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.mode_solver(wavelengths=[1.55], where="cross_section")
+
+        with pytest.raises(ValueError, match="port"):
+            sim.solve_modes()
+
+    def test_band_overrides_num_bands(self):
+        """band field overrides num_bands — correct band_nums computed."""
+        import gdsfactory as gf
+
+        from gsim.meep import Simulation
+
+        c = gf.components.straight(length=10, width=0.5)
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.mode_solver(wavelengths=[1.55], num_bands=3, band=2)
+
+        assert sim.mode_solver.band == 2
+        assert sim.mode_solver.num_bands == 3
+
+
+class TestSimulationSolveModesIntegration:
+    """Simulation.solve_modes() integration tests (meep_local)."""
+
+    @pytest.mark.meep_local
+    def test_solve_modes_slab_single(self):
+        """solve_modes() slab: single wavelength, single band."""
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.55])
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) >= 1
+        assert result.results[0].n_eff > 1.0
+
+    @pytest.mark.meep_local
+    def test_solve_modes_multi_band_slab(self):
+        """solve_modes() multi-band slab: num_bands=3, single wavelength."""
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.55], num_bands=3)
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) == 3
+        for r in result.results:
+            assert r.n_eff > 1.0
+
+    @pytest.mark.meep_local
+    def test_solve_modes_multi_wavelength_slab(self):
+        """solve_modes() multi-wavelength slab: 2 wavelengths, single band."""
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.50, 1.55])
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) == 2
+        n_effs = [r.n_eff for r in result.results]
+        assert n_effs[0] > n_effs[1]
+
+    @pytest.mark.meep_local
+    def test_solve_modes_cross_section_at_port(self):
+        """solve_modes() cross-section at port."""
+        import gdsfactory as gf
+
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        c = gf.components.straight(length=10, width=0.5)
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.55], port="o1", y_span=2.5)
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) >= 1
+        assert result.results[0].n_eff > 1.0
+
+    @pytest.mark.meep_local
+    def test_solve_modes_cross_section_at_position(self):
+        """solve_modes() cross-section at position."""
+        import gdsfactory as gf
+
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        c = gf.components.straight(length=10, width=0.5)
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.55], position=(5.0, 0.0), x_span=4.0)
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) >= 1
+
+    @pytest.mark.meep_local
+    def test_solve_modes_with_fields(self):
+        """solve_modes() with n_field_z returns populated fields."""
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.55], n_field_z=200)
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) >= 1
+        assert result.results[0].n_eff > 1.0
+        assert len(result.results[0].fields) > 0
+
+    @pytest.mark.meep_local
+    def test_solve_modes_first_at_port(self):
+        """mode_solver.first(3).at_port('o1') -> 3 results."""
+        import gdsfactory as gf
+
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        c = gf.components.straight(length=10, width=0.5)
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.geometry.stack = stack
+        sim.mode_solver.first(3).at_port("o1")
+        sim.mode_solver(wavelengths=[1.55], y_span=2.5)
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) == 3
+
+    @pytest.mark.meep_local
+    def test_solve_modes_uses_solver_resolution(self):
+        """solve_modes() reads resolution from sim.solver."""
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.stack = stack
+        sim.solver.resolution = 16
+        sim.mode_solver(wavelengths=[1.55])
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) >= 1
+        assert result.results[0].n_eff > 1.0
+
+    @pytest.mark.meep_local
+    def test_solve_modes_cartesian_product(self):
+        """solve_modes() slab: 2 wavelengths x 2 bands = 4 results."""
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.50, 1.55], num_bands=2)
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) == 4
+
+        wavelengths = sorted({r.wavelength for r in result.results})
+        assert wavelengths == [1.50, 1.55]
+
+        band_nums = sorted({r.band_num for r in result.results})
+        assert band_nums == [1, 2]
+
+
+class TestModeSolverIntegration:
+    """Integration tests requiring a local MEEP installation.
+
+    These are deselected by default. Run with::
+
+        pytest -m meep_local tests/meep/test_mode_solver.py
+    """
+
+    @pytest.mark.meep_local
+    def test_solve_slab_mode_si_sio2(self):
+        """solve_slab_mode returns n_eff for a simple Si/SiO2 slab."""
+        from gsim.common.stack import get_stack
+        from gsim.meep.mode_solver import solve_slab_mode
+
+        stack = get_stack()
+        result = solve_slab_mode(
+            stack=stack,
+            wavelength=1.55,
+            band_num=1,
+            parity="NO_PARITY",
+        )
+        assert result.n_eff > 1.0
+        assert result.wavelength == 1.55
+        assert result.band_num == 1
+        assert len(result.kdom) == 3
+
+    @pytest.mark.meep_local
+    def test_solve_slab_mode_compute_group_index(self):
+        """solve_slab_mode returns n_group (always computed if available)."""
+        from gsim.common.stack import get_stack
+        from gsim.meep.mode_solver import solve_slab_mode
+
+        stack = get_stack()
+        result = solve_slab_mode(
+            stack=stack,
+            wavelength=1.55,
+            band_num=1,
+            parity="NO_PARITY",
+        )
+        assert result.n_eff > 1.0
+        assert result.n_group is not None
+        assert result.n_group > 0.0
+
+    @pytest.mark.meep_local
+    def test_solve_slab_mode_returns_fields(self):
+        """solve_slab_mode returns field profile arrays when field_z_grid is given."""
+
+        from gsim.common.stack import get_stack
+        from gsim.meep.mode_solver import mode_z_grid, solve_slab_mode
+
+        stack = get_stack()
+        z_grid = mode_z_grid(stack, n_points=135)
+        result = solve_slab_mode(
+            stack=stack,
+            wavelength=1.55,
+            field_z_grid=z_grid,
+        )
+        assert len(result.fields) > 0
+        assert len(result.fields) >= 1
+        for arr in result.fields.values():
+            assert arr is not None
+            assert arr.ndim == 2
+            assert arr.shape[0] == len(z_grid)
+            assert arr.shape[1] == 1
+
+    @pytest.mark.meep_local
+    def test_solve_cross_section_mode_straight_wg(self):
+        """solve_cross_section_mode returns n_eff for a straight waveguide."""
+        import gdsfactory as gf
+
+        from gsim.common.stack import get_stack
+        from gsim.meep.mode_solver import (
+            mode_x_grid,
+            mode_z_grid,
+            solve_cross_section_mode,
+        )
+
+        c = gf.components.straight(length=10, width=0.5)
+        stack = get_stack()
+
+        x_span = 2.5
+        z_grid = mode_z_grid(stack, n_points=135)
+        x_grid = mode_x_grid(n_points=80, x_span=x_span)
+        result = solve_cross_section_mode(
+            component=c,
+            stack=stack,
+            port="o1",
+            y_span=x_span,
+            wavelength=1.55,
+            band_num=1,
+            parity="NO_PARITY",
+            field_x_grid=x_grid,
+            field_z_grid=z_grid,
+        )
+        assert result.n_eff > 1.0
+        assert result.wavelength == 1.55
+        assert len(result.fields) > 0
+
+    @pytest.mark.meep_local
+    def test_solve_cross_section_mode_position(self):
+        """solve_cross_section_mode works with explicit position + x_span."""
+        import gdsfactory as gf
+
+        from gsim.common.stack import get_stack
+        from gsim.meep.mode_solver import solve_cross_section_mode
+
+        c = gf.components.straight(length=10, width=0.5)
+        stack = get_stack()
+
+        result = solve_cross_section_mode(
+            component=c,
+            stack=stack,
+            position=(5.0, 0.0),
+            x_span=2.0,
+            wavelength=1.55,
+        )
+        assert result.n_eff > 1.0
+
+    @pytest.mark.meep_local
+    def test_simulation_solve_modes_slab(self):
+        """Simulation.solve_modes() slab mode without port."""
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        stack = get_stack()
+        sim = Simulation()
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.55])
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) >= 1
+        assert result.results[0].n_eff > 1.0
+
+    @pytest.mark.meep_local
+    def test_simulation_solve_modes_cross_section(self):
+        """Simulation.solve_modes() with port -> cross-section mode."""
+        import gdsfactory as gf
+
+        from gsim.common.stack import get_stack
+        from gsim.meep import Simulation
+        from gsim.meep.results import ModeSweepResult
+
+        c = gf.components.straight(length=10, width=0.5)
+        stack = get_stack()
+
+        sim = Simulation()
+        sim.geometry.component = c
+        sim.geometry.stack = stack
+        sim.mode_solver(wavelengths=[1.55], port="o1", y_span=2.5)
+
+        result = sim.solve_modes()
+        assert isinstance(result, ModeSweepResult)
+        assert len(result.results) >= 1
+        assert result.results[0].n_eff > 1.0
diff --git a/tests/meep/test_mode_sweep_plots.py b/tests/meep/test_mode_sweep_plots.py
new file mode 100644
index 0000000..9f6d323
--- /dev/null
+++ b/tests/meep/test_mode_sweep_plots.py
@@ -0,0 +1,107 @@
+"""Unit tests for ModeSweepResult.plot_mode() and plot_index() delegation."""
+
+from __future__ import annotations
+
+import matplotlib as mpl
+import numpy as np
+import pytest
+
+mpl.use("Agg")
+import matplotlib.pyplot as plt
+
+from gsim.meep.models.results import ModeResult
+from gsim.meep.results import ModeSweepResult
+
+
+def _make_result(n_eff=2.5, wavelength=1.55, band_num=1, **kwargs):
+    z = np.linspace(-2, 2, 50)
+    rng = np.random.default_rng(42)
+    fields = {"Ey": rng.random(50) + 1j * rng.random(50)}
+    return ModeResult(
+        n_eff=n_eff,
+        wavelength=wavelength,
+        frequency=1.0 / wavelength,
+        band_num=band_num,
+        fields=fields,
+        z_grid=z,
+        **kwargs,
+    )
+
+
+# ---------------------------------------------------------------------------
+# _find_result
+# ---------------------------------------------------------------------------
+
+
+class TestFindResult:
+    def test_find_by_wavelength(self):
+        r1 = _make_result(n_eff=2.5, wavelength=1.55)
+        r2 = _make_result(n_eff=2.3, wavelength=1.60)
+        sweep = ModeSweepResult([r1, r2])
+        found = sweep._find_result(1.55)
+        assert found is r1
+
+    def test_find_by_wavelength_and_band(self):
+        r1 = _make_result(n_eff=2.5, wavelength=1.55, band_num=1)
+        r2 = _make_result(n_eff=2.3, wavelength=1.55, band_num=2)
+        sweep = ModeSweepResult([r1, r2])
+        found = sweep._find_result(1.55, band=2)
+        assert found is r2
+
+    def test_find_no_match_wavelength_raises(self):
+        sweep = ModeSweepResult([_make_result(wavelength=1.55)])
+        with pytest.raises(ValueError, match="No mode result found"):
+            sweep._find_result(1.60)
+
+    def test_find_no_match_band_raises(self):
+        sweep = ModeSweepResult([_make_result(wavelength=1.55, band_num=1)])
+        with pytest.raises(ValueError, match="No mode result found"):
+            sweep._find_result(1.55, band=5)
+
+
+# ---------------------------------------------------------------------------
+# plot_mode delegation
+# ---------------------------------------------------------------------------
+
+
+class TestSweepPlotMode:
+    def test_plot_mode_delegates(self):
+        r1 = _make_result(n_eff=2.5, wavelength=1.55)
+        sweep = ModeSweepResult([r1])
+        fig, ax = sweep.plot_mode(wavelength=1.55, show=False)
+        assert isinstance(fig, plt.Figure)
+        assert ax is not None
+        assert "n_eff=2.5000" in ax.get_title()
+        plt.close(fig)
+
+    def test_plot_mode_with_band(self):
+        r1 = _make_result(n_eff=2.3, wavelength=1.55, band_num=2)
+        sweep = ModeSweepResult([r1])
+        fig, _ax = sweep.plot_mode(wavelength=1.55, band=2, show=False)
+        assert isinstance(fig, plt.Figure)
+        plt.close(fig)
+
+    def test_plot_mode_forwards_kwargs(self):
+        r1 = _make_result(n_eff=2.5, wavelength=1.55)
+        sweep = ModeSweepResult([r1])
+        fig, _ax = sweep.plot_mode(
+            wavelength=1.55,
+            components="Ey",
+            norm="real",
+            show=False,
+        )
+        assert isinstance(fig, plt.Figure)
+        plt.close(fig)
+
+
+# ---------------------------------------------------------------------------
+# plot_index delegation
+# ---------------------------------------------------------------------------
+
+
+class TestSweepPlotIndex:
+    def test_plot_index_raises_without_stack(self):
+        r1 = _make_result(n_eff=2.5, wavelength=1.55)
+        sweep = ModeSweepResult([r1])
+        with pytest.raises(ValueError, match="No stack"):
+            sweep.plot_index(wavelength=1.55)
diff --git a/tests/palace/test_mesh_integration.py b/tests/palace/test_mesh_integration.py
index 3d7e136..6902325 100644
--- a/tests/palace/test_mesh_integration.py
+++ b/tests/palace/test_mesh_integration.py
@@ -523,8 +523,9 @@ def test_validate_mesh_passes(self, pec_block_sim):
 class TestShapedDielectric:
     """Test mesh generation with shaped dielectric volumes."""
 
+    @classmethod
     @pytest.fixture(scope="class")
-    def shaped_dielectric_sim(self, tmp_path_factory):
+    def shaped_dielectric_sim(cls, tmp_path_factory):
         """Create and mesh a component with a shaped dielectric core."""
         from gsim.common.stack.materials import MATERIALS_DB
 
diff --git a/tests/palace/test_workflow.py b/tests/palace/test_workflow.py
index aa3d7f4..c948b16 100644
--- a/tests/palace/test_workflow.py
+++ b/tests/palace/test_workflow.py
@@ -72,8 +72,9 @@ def cpw_component():
 class TestDrivenSimWorkflow:
     """End-to-end DrivenSim: configure -> validate -> mesh -> write_config."""
 
+    @classmethod
     @pytest.fixture(scope="class")
-    def driven_sim(self, tmp_path_factory, cpw_component):
+    def driven_sim(cls, tmp_path_factory, cpw_component):
         """Create and mesh a DrivenSim with CPW ports."""
         tmp_path = tmp_path_factory.mktemp("driven")
         sim = DrivenSim()
@@ -170,8 +171,9 @@ def _validate_mesh_should_not_run(_self):
 class TestDrivenSimInplanePorts:
     """DrivenSim with single-element inplane lumped ports."""
 
+    @classmethod
     @pytest.fixture(scope="class")
-    def inplane_sim(self, tmp_path_factory, cpw_component):
+    def inplane_sim(cls, tmp_path_factory, cpw_component):
         """Create and mesh a DrivenSim with inplane lumped ports."""
         tmp_path = tmp_path_factory.mktemp("inplane")
         sim = DrivenSim()
@@ -284,8 +286,9 @@ def test_reactive_port_parameters_go_to_lumped_element(tmp_path, cpw_component):
 class TestEigenmodeSimWorkflow:
     """End-to-end EigenmodeSim: configure -> mesh -> write_config."""
 
+    @classmethod
     @pytest.fixture(scope="class")
-    def eigenmode_sim(self, tmp_path_factory, cpw_component):
+    def eigenmode_sim(cls, tmp_path_factory, cpw_component):
         """Create and mesh an EigenmodeSim."""
         tmp_path = tmp_path_factory.mktemp("eigenmode")
         sim = EigenmodeSim()
@@ -357,8 +360,9 @@ def test_config_has_floquet_periodic_boundary(self, tmp_path, cpw_component):
 class TestElectrostaticSimWorkflow:
     """End-to-end ElectrostaticSim: configure -> mesh -> write_config."""
 
+    @classmethod
     @pytest.fixture(scope="class")
-    def electrostatic_sim(self, tmp_path_factory, cpw_component):
+    def electrostatic_sim(cls, tmp_path_factory, cpw_component):
         """Create and mesh an ElectrostaticSim with terminals."""
         tmp_path = tmp_path_factory.mktemp("electrostatic")
         sim = ElectrostaticSim()
@@ -496,8 +500,9 @@ def test_electrostatic_needs_terminals(self, tmp_path):
 class TestMaterialOverrides:
     """Test material override configuration flows through to config."""
 
+    @classmethod
     @pytest.fixture(scope="class")
-    def material_sim(self, tmp_path_factory, cpw_component):
+    def material_sim(cls, tmp_path_factory, cpw_component):
         """Create a DrivenSim with material overrides."""
         tmp_path = tmp_path_factory.mktemp("materials")
         sim = DrivenSim()
diff --git a/tests/test_viz_mesh.py b/tests/test_viz_mesh.py
index bfaeb90..fdeded7 100644
--- a/tests/test_viz_mesh.py
+++ b/tests/test_viz_mesh.py
@@ -133,7 +133,10 @@ def _write_minimal_msh(
             ]
         )
         cells = [("tetra", np.array([[0, 1, 2, 3]]))]
-        cell_data: dict[str, list[np.ndarray]] = {"gmsh:physical": [np.array([1])]}
+        cell_data: dict[str, list[np.ndarray]] = {
+            "gmsh:physical": [np.array([1])],
+            "gmsh:geometrical": [np.array([1])],
+        }
         field_data = {"bulk": np.array([1, 3])}
     else:
         pts = np.array(
@@ -150,7 +153,13 @@ def _write_minimal_msh(
             # Add an unsupported cell block to exercise the skip-path.
             cells.append(("line", np.array([[0, 1]])))
             phys.append(np.array([99]))
-        cell_data = {"gmsh:physical": phys}
+        geom: list[np.ndarray] = [np.array([1, 1])]
+        if extra_cells:
+            geom.append(np.array([1]))
+        cell_data = {
+            "gmsh:physical": phys,
+            "gmsh:geometrical": geom,
+        }
         field_data = {
             "metal": np.array([1, 2]),
             "air_boundary": np.array([2, 2]),