diff --git a/.github/workflows/build-test-publish.yaml b/.github/workflows/build-test-publish.yaml
index e896e7b..b2319d3 100644
--- a/.github/workflows/build-test-publish.yaml
+++ b/.github/workflows/build-test-publish.yaml
@@ -18,7 +18,7 @@ permissions:
   contents: write
 
 jobs:
-  
+
   check-version-txt:
     runs-on: ubuntu-latest
     steps:
diff --git a/.github/workflows/ci-test.yaml b/.github/workflows/ci-test.yaml
new file mode 100644
index 0000000..13b75cd
--- /dev/null
+++ b/.github/workflows/ci-test.yaml
@@ -0,0 +1,42 @@
+name: CI
+
+on:
+    push:
+        branches:
+            - main
+    pull_request:
+        branches:
+            - main
+    workflow_dispatch: {}
+
+permissions:
+    contents: read
+
+jobs:
+    ci:
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Install uv
+              uses: astral-sh/setup-uv@v7
+              with:
+                  version: "0.7.19"
+                  enable-cache: true
+                  cache-dependency-glob: |
+                      pyproject.toml
+                      uv.lock
+
+            - name: Install Python
+              run: uv python install
+
+            - name: Install the project
+              run: uv sync --locked --all-extras --dev
+
+            - name: Lint (run.sh lint:ci)
+              run: /bin/bash -x run.sh lint:ci
+
+            - name: Tests (run.sh test:ci)
+              run: /bin/bash -x run.sh test:ci
diff --git a/.gitignore b/.gitignore
index 9a63d91..3d2d568 100644
--- a/.gitignore
+++ b/.gitignore
@@ -218,4 +218,4 @@ src/cosinor_lite/states_info.py
 src/cosinor_lite/cities.json
 "README 2.md"
 
-.DS_Store
\ No newline at end of file
+.DS_Store
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3f07032..bcb4e3b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,106 +1,40 @@
-# See https://pre-commit.com for more information
-# See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v6.0.0
     hooks:
-      # Fails if there are any ">>>>>" lines in files due to merge conflicts.
-      - id: check-merge-conflict
-      # Trims trailing whitespace. Allow a single space on the end of .md lines for hard line breaks.
       - id: trailing-whitespace
-        args: [--markdown-linebreak-ext=md]
-      # Makes sure files end in a newline and only a newline;
       - id: end-of-file-fixer
-      # Attempts to load all TOML files to verify syntax.
-      - id: check-toml
-      # Attempts to load all yaml files to verify syntax; unsafe: only check syntax, do not load yaml
       - id: check-yaml
-        args: ["--unsafe"]
-      # Check for symlinks that do not point to anything.
-      - id: check-symlinks
-      # Fail if staged files are above a certain size.
-      # To add a large file, use 'git lfs track <file>; git add <file> to track large files with
-      # git-lfs rather than commiting them directly to the git history
+      - id: check-toml
       - id: check-added-large-files
-        args: ["--maxkb=500"]
-
-        # HALT! Before you exclude a large file and commit it, forever
-        # bloating our repo size, did you:
-        # (1) use a CLI tool like imageoptim to compress them if they are images
-        # (2) think hard about whether using DVC or git-lfs is more appropriate
-        #     for the file--such as in the case of CSV files or other data
-        # This can be confusing. Reach out for help in our chat to help decide
-        # how to deal adding these large files you have :)
-        exclude: |
-          (?x)(
-              ^example/large/file.csv|
-              ^example/large/sklearn-model.pkl
-          )
-      # Sort requirements in requirements.txt files.
-      - id: requirements-txt-fixer
-      # Prevent addition of new git submodules.
-      - id: forbid-new-submodules
-      # Prevent committing directly to trunk (since Bitbucket wants us to pay for this feature)
-      - id: no-commit-to-branch
-        args: ["--branch=main"]
-      # Detects the presence of private keys
-      - id: detect-private-key
 
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.0.261"
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.6
     hooks:
       - id: ruff
-        args: [--exit-non-zero-on-fix, --config=./pyproject.toml]
-
-  # - repo: https://github.com/pre-commit/mirrors-mypy
-  #   rev: "v1.2.0"
-  #   hooks:
-  #     - id: mypy
-  #       args:
-  #         [
-  #           --no-strict-optional,
-  #           --ignore-missing-imports,
-  #           --config-file=./pyproject.toml,
-  #         ]
-
-  # - repo: https://github.com/psf/black
-  #   rev: 23.1.0
-  #   hooks:
-  #     - id: black
-  #       args:
-  #         - --config=./pyproject.toml
+        args: [--fix]
+        exclude: ^app\.py$
+      - id: ruff-format
 
-  # - repo: https://github.com/PyCQA/pylint
-  #   rev: v2.16.3
-  #   hooks:
-  #     - id: pylint
-  #       args:
-  #         - --rcfile=./pyproject.toml
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.18.2
+    hooks:
+      - id: mypy
+        exclude: ^app\.py$
 
-  # - repo: https://github.com/PyCQA/flake8
-  #   rev: 6.0.0
-  #   hooks:
-  #     - id: flake8
-  #       args:
-  #         - --toml-config=./pyproject.toml
-  #       additional_dependencies:
-  #         - radon
-  #         - flake8-docstrings
-  #         - Flake8-pyproject
+  - repo: https://github.com/kynan/nbstripout
+    rev: 0.8.2
+    hooks:
+      - id: nbstripout
 
-  # - repo: https://github.com/pycqa/isort
-  #   rev: 5.12.0
-  #   hooks:
-  #     - id: isort
-  #       args:
-  #         - --settings-path=./pyproject.toml
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.5.0
+    hooks:
+      - id: detect-secrets
 
-  # - repo: https://github.com/PyCQA/autoflake
-  #   rev: v2.0.1
-  #   hooks:
-  #     - id: autoflake
-  #       args:
-  #         - --in-place
-  #         - --remove-all-unused-imports
-  #         - --remove-unused-variable
-  #         - --ignore-init-module-imports
+  - repo: https://github.com/econchick/interrogate
+    rev: 1.7.0
+    hooks:
+      - id: interrogate
+        args: ["--fail-under=70", "-vvv"]
+        files: "^src/"
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 7c2ca5c..399162f 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -9,14 +9,23 @@
     "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
     // ─── Ruff: formatter, linter, import sorter ────────
     // Formatting + code actions on save
+    // "[python]": {
+    //     "editor.defaultFormatter": "charliermarsh.ruff", // Ruff formats & sorts imports
+    //     "editor.formatOnSave": true,
+    //     "editor.codeActionsOnSave": {
+    //         "source.organizeImports": "explicit", // Ruff handles import‑sorting:contentReference[oaicite:0]{index=0}
+    //         "source.fixAll": "explicit" // Ruff auto‑fixes lint on save:contentReference[oaicite:1]{index=1}
+    //     }
+    // },
     "[python]": {
-        "editor.defaultFormatter": "charliermarsh.ruff", // Ruff formats & sorts imports
+        "editor.defaultFormatter": "charliermarsh.ruff",
         "editor.formatOnSave": true,
         "editor.codeActionsOnSave": {
-            "source.organizeImports": "explicit", // Ruff handles import‑sorting:contentReference[oaicite:0]{index=0}
-            "source.fixAll": "explicit" // Ruff auto‑fixes lint on save:contentReference[oaicite:1]{index=1}
+            "source.fixAll": true,
+            "source.fixAll.ruff": true,
+            "source.organizeImports": true
         }
-    },
+    }
     // ─── Ty: super‑fast type checking / language server ─
     // After installing the “ty” VS Code extension:
     // "python.languageServer": "None",          // disable Pylance’s LS to avoid clashing:contentReference[oaicite:2]{index=2}
@@ -38,4 +47,4 @@
             "color": "lightgreen"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/Makefile b/Makefile
index c6733ef..0cad278 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,3 @@
-# Execute the "targets" in this file with `make <target>` e.g., `make test`.
-#
 # You can also run multiple in sequence, e.g. `make clean lint test serve-coverage-report`
 
 build:
@@ -20,18 +18,6 @@ lint:
 lint-ci:
 	bash run.sh lint:ci
 
-publish-prod:
-	bash run.sh publish:prod
-
-publish-test:
-	bash run.sh publish:test
-
-release-prod:
-	bash run.sh release:prod
-
-release-test:
-	bash run.sh release:test
-
 serve-coverage-report:
 	bash run.sh serve-coverage-report
 
@@ -43,6 +29,3 @@ test-quick:
 
 test:
 	bash run.sh run-tests
-
-test-wheel-locally:
-	bash run.sh test:wheel-locally
diff --git a/README 2.md b/README 2.md
deleted file mode 100644
index 041130f..0000000
--- a/README 2.md	
+++ /dev/null
@@ -1,26 +0,0 @@
-# cosinor-lite
-
-## Quick start
-
-```bash
-pip install cosinor-lite
-```
-
-```python
-from cosinor_lite import ...
-```
-
-## Contributing
-
-```bash
-# clone the repo
-git clone https://github.com/nick-e-p/cosinor-lite.git
-
-# install the dev dependencies
-make install
-
-# run the tests
-make test
-```
-
-
diff --git a/README.md b/README.md
index 7dc5482..3f75e8e 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,147 @@
 # cosinor-lite
-A simplified package for cosinor analysis of circadian bioluminescent, fluorescent and omics datasets
 
-## Installing
+`cosinor-lite` is a lightweight toolkit for exploring circadian oscillations across multiomics and live-cell imaging experiments. It relies on widely used statistical models and offers two modes of use.
+
+- **Interactive Gradio dashboard** to drag & drop your data files.
+- **Python package** for fine-grained customisation beyond the settings offered in the Gradio UI.
+
+🚀 Try the interactive analysis pipeline on  
+**[Hugging Face Spaces → cosinor-lite](https://huggingface.co/spaces/nick-e-p/cosinor-lite)**.
+
+## Why `cosinor-lite?`
+
+- **Unified workflow for live cell data**: Perform detrending and fit cosinor models with either a fixed 24 h, free-period or damped oscillation with consistent APIs across data modalities (i.e. bioluminescence, cytokines etc.).
+- **Differential rhythmicity across any omics type**: Compare two conditions for differential rhythmicity for any type of omics data using BIC model-selection strategies with widespread use in the circadian literature.
+- **Create publication-ready analysis with a simple UI**: Launch a browser-based analysis console for visual quality control, plots, and parameter export.
+
+## Extracting circadian parameters from live-cell data
+
+For live-cell data (see tutorial in [`notebooks/live_cell_tutorial`](./notebooks/live_cell_tutorial.ipynb)), `cosinor-lite` offers the choice between three different cosinor models:
+
+- a) Fixed 24-h period
+
+- b) Free period
+
+- c) Free period with damped amplitude
+
+<div style="text-align: center;">
+  <img src="./images/live_cell_fitting-01.png" alt="Model selection" style="width:100%;"/>
+</div>
+
+Once a model is chosen, it is fitted independently to each sample. The fitted parameters can be exported for downstream statistical analysis.
+
+## Differential rhytmicity analysis of omics datasets
+
+`cosinor-lite` includes a toolbox for performing differential rhytmicity analysis of omics datasets (ee [`notebooks/omics_tutorial`](./notebooks/omics_tutorial.ipynb)) for tutorial. The details of the method are nicely explained in the article:
+
+> Pelikan A, Herzel H, Kramer A, Ananthasubramaniam B. 2022. Venn diagram analysis overestimates the extent of circadian rhythm reprogramming. The FEBS Journal 289:6605–6621. doi:10.1111/febs.16095
+
+Here is an adaptation of their figure explaining the methdology:
+
+<div style="text-align: center;">
+  <img src="./images/model_selection.png" alt="Model selection" style="width:60%;"/>
+</div>
+
+For condition 1 (i.e. alpha cells) and condition 2 (i.e. beta cells), we fit 5 different models:
+
+- Model 1) Arrhythmic in alpha and beta cells
+
+- Model 2) Rhythmic in beta cells only
+
+- Model 3) Rhythmic in alpha cells only
+
+- Model 4) Rhythmic in alpha and beta cells with the same rhythmic parameters (i.e. phase and amplitude)
+
+- Model 5) Rhythmic in both but with differential rhythmicity in alpha vs beta cells
+
+## Installation
 
 ```bash
-# clone the repo
-git clone https://github.com/nick-e-p/cosinor-lite.git && cd cosinor-lite
+# clone the repository
+git clone https://github.com/nick-e-p/cosinor-lite.git
+cd cosinor-lite
 
-# install the dev dependencies
+# create and populate the local uv environment
 uv sync
 
+# activate the environment
+source .venv/bin/activate
+```
+
+> **Tip:** The project targets Python 3.11+. Using `uv` keeps package resolution reproducible via `uv.lock`.
+
+## Quick Start
+
+### Launch the interactive app
+
+```bash
+uv run python app.py
+```
+
+Open the printed local URL to explore:
+
+- **Live cell**: Upload CSVs with participant, replicate, and time-series data, then compare detrending strategies or cosinor fits across groups.
+- **Omics**: Load expression matrices, build time vectors automatically or manually, compute differential rhythmicity, and download publication-ready plots.
+
+### Use the Python API
+
+```python
+from cosinor_lite.livecell_dataset import LiveCellDataset
+from cosinor_lite.livecell_cosinor_analysis import CosinorAnalysis
+
+dataset = LiveCellDataset(
+    ids=["mouse_a", "mouse_b"],
+    group=["treated", "control"],
+    replicate=[1, 1],
+    time_series=my_expression_matrix,
+    time=my_timepoints,
+)
+
+analysis = CosinorAnalysis(dataset=dataset)
+fit = analysis.fit(group="treated", model="damped")
+print(fit.parameters)
+```
+
+## Repository Layout
+
+```
+src/cosinor_lite/        # Core library modules and models
+app.py                   # Gradio application entry point
+tests/                   # Pytest suites (unit, integration, fixtures)
+data/                    # Example datasets for the app
+images/                  # Illustration assets used in the UI
+```
+
+## Development Workflow
+
+```bash
+# run style, type, and security hooks
+pre-commit run --all-files
+
+# execute unit tests
+uv run pytest
+```
+
+## Sample Datasets
+
+The `data/` directory includes curated examples to help you get started:
+
+- `bioluminescence_example.csv`: Bioluminescence time series for live-cell analysis.
+- `cytokine_example.csv`: An alternative CSV with the same schema for cosinor fitting using cytokine data.
+- `GSE95156_Alpha_Beta.txt`: RNA-seq data used in the omics differential rhythmicity workflow.
+
+Each file is formatted to drag & drop into `app.py` as well as the library APIs.
+
+## Contributing
+
+1. Fork the repository and create a feature branch.
+2. Install dependencies with `uv sync` and activate the environment.
+3. Implement your changes with tests.
+4. Verify via `pre-commit run --all-files` and `uv run pytest`.
+5. Open a pull request describing the motivation and results.
+
+Bug reports and feature proposals are welcome through GitHub issues. Please include reproducible examples whenever possible.
+
+## License
+
+Licensed under the Apache License 2.0. See `LICENSE` for details.
diff --git a/app.py b/app.py
new file mode 100644
index 0000000..75a866b
--- /dev/null
+++ b/app.py
@@ -0,0 +1,869 @@
+from __future__ import annotations
+
+import re
+import tempfile
+from collections.abc import Sequence
+from pathlib import Path
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+from cosinor_lite.livecell_cosinor_analysis import CosinorAnalysis
+from cosinor_lite.livecell_dataset import LiveCellDataset
+from cosinor_lite.omics_dataset import OmicsDataset
+from cosinor_lite.omics_differential_rhytmicity import DifferentialRhythmicity, OmicsHeatmap
+
+plt.rcParams.update(
+    {
+        "font.size": 8,
+        "axes.titlesize": 8,
+        "axes.labelsize": 8,
+        "xtick.labelsize": 8,
+        "ytick.labelsize": 8,
+        "legend.fontsize": 8,
+        "figure.titlesize": 8,
+        "pdf.fonttype": 42,
+    },
+)
+plt.style.use("seaborn-v0_8-ticks")
+
+# --- (your rcParams / styles as-is) ---
+
+APP_DIR = Path(__file__).parent
+bioluminescence_file = str(APP_DIR / "data" / "bioluminescence_example.csv")
+cytokine_file = str(APP_DIR / "data" / "cytokine_example.csv")
+omics_example = str(APP_DIR / "data" / "GSE95156_Alpha_Beta.txt")
+method_img = str(APP_DIR / "images" / "live_cell_fitting-01.png")
+model_selection_img = str(APP_DIR / "images" / "model_selection.png")
+
+with gr.Blocks(title="Cosinor Analysis — Live Cell & Omics") as demo:
+    gr.Markdown(
+        """
+    # Cosinor Analysis App
+
+    A simple app for circadian cosinor analysis & biostatistics.
+
+    Choose between:
+    - inferring rhythmic properties of live cell data using three different cosinor models
+    - differential rhythmicity analysis of omics datasets
+
+    """,
+    )
+
+    with gr.Tabs() as tabs:
+        with gr.Tab("Live cell", id=0):
+            gr.Image(
+                value=method_img,
+                label="Choosing a cosinor model and fitting parameters",
+                interactive=False,
+                show_label=True,
+                height=600,  # adjust as needed; or remove to use natural size
+            )
+
+            gr.Markdown(
+                """
+            # Fitting live cell data
+
+            This section allows the use to infer parameters describing circadian oscillations in live cell data.
+            Once inferred, the extracted parameters can be compared between groups in downstream analyses. There are three types of cosinor model to choose from:
+            - 24h period cosinor
+            - Free period (constrained within 20-28h) cosinor
+            - Damped cosinor (equivalent to Chronostar analysis), with an additional dampening coefficient
+
+            There are many valid ways to organise the underlying live cell data file. Here we assume a specific format to facilitate data processing
+
+            - Row 1: contains a unique identifier for the participant, mouse etc.
+            - Row 2: replicate number. If there's only one replicate per unique ID, this can just be a row of 1's
+            - Row 3: the group to which each measurement belongs
+            - Left column; the left column contains the time (going down)
+
+            """,
+            )
+
+            file = gr.File(label="Upload CSV", file_types=[".csv"], type="filepath")
+
+            gr.Examples(
+                examples=[bioluminescence_file, cytokine_file],
+                inputs=file,
+                label="Example input",
+            )
+
+            status = gr.Textbox(label="CSV status", interactive=False)
+
+            with gr.Row():
+                group1_label = gr.Textbox(label="Group 1 label", value="Group 1")
+                group2_label = gr.Textbox(label="Group 2 label", value="Group 2")
+
+            # State (values will be pandas / numpy objects, not components)
+            st_participant_id = gr.State()
+            st_replicate = gr.State()
+            st_group = gr.State()
+            st_time = gr.State()
+            st_time_rows = gr.State()
+
+            def process_csv(
+                fpath: str | Path,
+            ) -> tuple[
+                str,
+                pd.Series,
+                pd.Series,
+                pd.Series,
+                np.ndarray,
+                pd.DataFrame,
+            ]:
+                # If needed, normalize FileData dict -> str path here
+                df_data = pd.read_csv(fpath, index_col=0, header=None)
+
+                participant_id = df_data.iloc[0, :].astype(str)
+                replicate = df_data.iloc[1, :].astype(int)
+                group = df_data.iloc[2, :].astype(str)
+
+                time_index = df_data.index[3:]
+                try:
+                    time = time_index.astype(float).to_numpy()
+                except (TypeError, ValueError) as error:
+                    msg = f"Time index not numeric from row 4 onward: {list(time_index)}"
+                    raise ValueError(msg) from error
+
+                time_rows = df_data.iloc[3:].apply(pd.to_numeric, errors="raise")
+
+                shape_info = (
+                    f"Loaded shape: {df_data.shape} | participants: {len(participant_id)} | time points: {len(time)}"
+                )
+                return shape_info, participant_id, replicate, group, time, time_rows
+
+            # Trigger on both upload and change (Examples sets the value via change)
+            for evt in (file.upload, file.change):
+                evt(
+                    process_csv,
+                    inputs=file,
+                    outputs=[
+                        status,
+                        st_participant_id,
+                        st_replicate,
+                        st_group,
+                        st_time,
+                        st_time_rows,
+                    ],
+                )
+
+            group_choice = gr.Radio(
+                choices=[("Group 1", "group1"), ("Group 2", "group2")],
+                value="group1",
+                label="Select group to analyse",
+            )
+            m_slider = gr.Slider(
+                1,
+                10,
+                value=5,
+                step=1,
+                label="Number of columns for plot",
+            )
+
+            def make_plot(  # noqa: PLR0913
+                ids_series: pd.Series | None,
+                group_series: pd.Series | None,
+                repl_series: pd.Series | None,
+                time_array: np.ndarray | None,
+                time_rows_df: pd.DataFrame | None,
+                g1: str,
+                g2: str,
+                which_group: str,
+                method: str,
+                window: float,
+                m: float,
+                plot_style: str,
+            ) -> tuple[plt.Figure | None, str | None]:
+                if (
+                    ids_series is None
+                    or group_series is None
+                    or repl_series is None
+                    or time_array is None
+                    or time_rows_df is None
+                ):
+                    return None, None
+                ds = LiveCellDataset(
+                    ids=list(ids_series),
+                    group=list(group_series),
+                    replicate=[int(x) for x in list(repl_series)],
+                    time_series=time_rows_df.to_numpy(dtype=float),
+                    time=np.asarray(time_array, dtype=float),
+                    group1_label=g1,
+                    group2_label=g2,
+                )
+                if method == "moving_average":
+                    fig, pdf_path = ds.plot_group_data(
+                        which_group,
+                        method=method,
+                        m=int(m),
+                        window=int(window),
+                        plot_style=plot_style,
+                    )
+                else:
+                    fig, pdf_path = ds.plot_group_data(
+                        which_group,
+                        method=method,
+                        m=int(m),
+                        plot_style=plot_style,
+                    )
+                return fig, pdf_path
+
+            method_choice = gr.Radio(
+                choices=[
+                    ("None (no detrending)", "none"),
+                    ("Linear", "linear"),
+                    ("Linear + quadratic", "poly2"),
+                    ("Moving average", "moving_average"),
+                ],
+                value="none",
+                label="Detrending method",
+            )
+
+            window_slider = gr.Slider(
+                1,
+                1000,
+                value=144,
+                step=1,
+                label="Window size for moving average (if used)",
+            )
+            gr.Markdown(
+                "⚠️ Note: Window size is in **data points** (measurement intervals), not hours.",
+            )
+
+            plot_style_choice = gr.Radio(
+                choices=[("Line", "line"), ("Scatter", "scatter")],
+                value="line",
+                label="Plot style for raw data",
+            )
+
+            build_btn = gr.Button("Plot raw data and trend", variant="primary")
+            plot = gr.Plot(label="Preview")
+            download = gr.File(label="Download plot")
+
+            build_btn.click(
+                make_plot,
+                inputs=[
+                    st_participant_id,
+                    st_group,
+                    st_replicate,
+                    st_time,
+                    st_time_rows,
+                    group1_label,
+                    group2_label,
+                    group_choice,
+                    method_choice,
+                    window_slider,
+                    m_slider,
+                    plot_style_choice,
+                ],
+                outputs=[plot, download],
+            )
+
+            cosinor_model = gr.Radio(
+                choices=[
+                    ("24h period cosinor", "cosinor_24"),
+                    ("Free period (20-28h) cosinor", "cosinor_free_period"),
+                    ("Damped cosinor (Chronostar)", "cosinor_damped"),
+                ],
+                value="cosinor_24",  # must match one of the VALUES above
+                label="Cosinor model",
+            )
+
+            t_lower_slider = gr.Slider(
+                0,
+                1000,
+                value=0,
+                step=1,
+                label="Remove data below this time limit (hours)",
+            )
+            t_upper_slider = gr.Slider(
+                0,
+                1000,
+                value=1000,
+                step=1,
+                label="Remove data above this time limit (hours)",
+            )
+
+            build_btn_cosinor = gr.Button("Build cosinor fits", variant="primary")
+            plot_cosinor = gr.Plot(label="Model fit preview")
+            pdf_export = gr.File(label="Download figure")
+            table_export = gr.Dataframe()
+            download_export = gr.File(label="Download fitted parameters")
+
+            def make_cosinor_fits(  # noqa: PLR0913
+                ids_series: pd.Series | None,
+                group_series: pd.Series | None,
+                repl_series: pd.Series | None,
+                time_array: np.ndarray | None,
+                time_rows_df: pd.DataFrame | None,
+                g1: str,
+                g2: str,
+                which_group: str,
+                method: str,
+                window: float,
+                cosinor_model: str,
+                t_lower: float,
+                t_upper: float,
+                m: float,
+                plot_style: str,
+            ) -> tuple[
+                plt.Figure | None,
+                str | None,
+                pd.DataFrame | None,
+                str | None,
+            ]:
+                if (
+                    ids_series is None
+                    or group_series is None
+                    or repl_series is None
+                    or time_array is None
+                    or time_rows_df is None
+                ):
+                    return None, None, None, None
+                ds = CosinorAnalysis(
+                    ids=list(ids_series),
+                    group=list(group_series),
+                    replicate=[int(x) for x in list(repl_series)],
+                    time_series=time_rows_df.to_numpy(dtype=float),
+                    time=np.asarray(time_array, dtype=float),
+                    group1_label=g1,
+                    group2_label=g2,
+                    t_lower=t_lower,
+                    t_upper=t_upper,
+                )
+                if method == "moving_average":
+                    df_export, csv_path, fig, pdf_path = ds.fit_cosinor(
+                        which_group,
+                        method=method,
+                        window=int(window),
+                        cosinor_model=cosinor_model,
+                        m=int(m),
+                        plot_style=plot_style,
+                    )
+                else:
+                    df_export, csv_path, fig, pdf_path = ds.fit_cosinor(
+                        which_group,
+                        method=method,
+                        cosinor_model=cosinor_model,
+                        m=int(m),
+                        plot_style=plot_style,
+                    )
+                return fig, pdf_path, df_export, csv_path
+
+            build_btn_cosinor.click(
+                make_cosinor_fits,
+                inputs=[
+                    st_participant_id,
+                    st_group,
+                    st_replicate,
+                    st_time,
+                    st_time_rows,
+                    group1_label,
+                    group2_label,
+                    group_choice,
+                    method_choice,
+                    window_slider,
+                    cosinor_model,
+                    t_lower_slider,
+                    t_upper_slider,
+                    m_slider,
+                    plot_style_choice,  # <-- add
+                ],
+                outputs=[plot_cosinor, pdf_export, table_export, download_export],
+            )
+        with gr.Tab("Omics", id=1):
+            gr.Markdown(
+                """
+            # Differential rhytmicity analysis of omics datasets
+
+            Here we perform differential rhythmicity analysis on omics data using a model selection approach.
+            The example data includes published RNA-seq data, but in theory any types of omics data (RNA-seq, proteomics, metabolomics, lipidomics) could be used. The dataset is from the following publication:
+
+            Petrenko V, Saini C, Giovannoni L, Gobet C, Sage D, Unser M, Heddad Masson M, Gu G, Bosco D, Gachon F, Philippe J, Dibner C. 2017. Pancreatic alpha- and beta-cellular clocks have distinct molecular properties and impact on islet hormone secretion and gene expression. Genes Dev 31:383-398. doi:10.1101/gad.290379.116.
+                """,
+            )
+
+            gr.Image(
+                value=model_selection_img,
+                label="Differential rhytmicity analysis with model selection",
+                interactive=False,
+                show_label=True,
+                height=600,  # adjust as needed; or remove to use natural size
+            )
+
+            gr.Markdown(
+                """
+            ## How does the method actually work?
+
+            The details of the method are nicely explained in the article:
+
+            Pelikan A, Herzel H, Kramer A, Ananthasubramaniam B. 2022. Venn diagram analysis overestimates the extent of circadian rhythm reprogramming. The FEBS Journal 289:6605-6621. doi:10.1111/febs.16095
+
+            See the above adaptation of their figure explaining the methodology.
+
+            For condition 1 (i.e. alpha cells) and condition 2 (i.e. beta cells), we fit five different models:
+
+            - Model 1) Arrhythmic in alpha and beta cells
+            - Model 2) Rhythmic in beta cells only
+            - Model 3) Rhythmic in alpha cells only
+            - Model 4) Rhythmic in alpha and beta cells with the same rhythmic parameters (i.e. phase and amplitude)
+            - Model 5) Rhythmic in both but with differential rhythmicity in alpha vs beta cells
+
+            A degree of confidence is calculated for each model (called model weight, which sums to 1 across all models), and a model is chosen if the model weight exceeds a threshold (for this tutorial we will use 0.5). If no model exceeds this threshold, then the model is unclassified, which we define as Model 0.
+
+            - Model 0) unclassified
+
+                """,
+            )
+
+            # File input + example
+            omics_file = gr.File(
+                label="Upload Omics TXT/TSV",
+                file_types=[".txt", ".tsv", ".csv"],
+                type="filepath",
+            )
+            gr.Examples(
+                examples=[omics_example],
+                inputs=omics_file,
+                label="Example input",
+            )
+
+            omics_status = gr.Textbox(label="File status", interactive=False)
+
+            # Multiselects for choosing columns by header names
+            columns_cond1_dd = gr.Dropdown(
+                choices=[],
+                multiselect=True,
+                label="Condition A columns (e.g., ZT_*_a_*)",
+            )
+            columns_cond2_dd = gr.Dropdown(
+                choices=[],
+                multiselect=True,
+                label="Condition B columns (e.g., ZT_*_b_*)",
+            )
+
+            # Optional manual time vectors
+            override_time = gr.Checkbox(
+                label="Override time vectors manually?",
+                value=False,
+            )
+            t_cond1_tb = gr.Textbox(label="t_cond1 (comma-separated)", visible=False)
+            t_cond2_tb = gr.Textbox(label="t_cond2 (comma-separated)", visible=False)
+
+            # Hidden state to stash the DataFrame
+            st_df_rna = gr.State()
+
+            # Preview planned inputs for your class
+            omics_preview = gr.Code(label="Planned class inputs", language="python")
+            build_omics_btn = gr.Button("Build Omics inputs", variant="primary")
+
+            # Sample dropdowns for replicate scatterplot
+            sample1_dd = gr.Dropdown(choices=[], label="Sample 1 (x-axis)")
+            sample2_dd = gr.Dropdown(choices=[], label="Sample 2 (y-axis)")
+            scatter_btn = gr.Button(
+                "Generate replicate scatterplot",
+                variant="secondary",
+            )
+            scatter_plot = gr.Plot(label="Replicate scatterplot")
+            scatter_download = gr.File(label="Download scatterplot")
+
+            # Histogram outputs
+            hist_btn = gr.Button("Generate histogram", variant="primary")
+            omics_plot = gr.Plot(label="Expression histogram")
+            omics_download = gr.File(label="Download histogram")
+
+            # ---------- helpers ----------
+            def _guess_cols(cols: Sequence[str]) -> tuple[list[str], list[str]]:
+                cols = [str(c) for c in cols]
+                a_guess = [c for c in cols if re.search(r"_a_", str(c))]
+                b_guess = [c for c in cols if re.search(r"_b_", str(c))]
+
+                def zt_key(col: str) -> int:
+                    m = re.search(r"ZT_(\d+)", str(col))
+                    return int(m.group(1)) if m else 0
+
+                a_guess = sorted(a_guess, key=zt_key)
+                b_guess = sorted(b_guess, key=zt_key)
+                return a_guess, b_guess
+
+            def _pick_default_samples(
+                cols: Sequence[str],
+            ) -> tuple[str | None, str | None]:
+                # Try ZT_0 ... _1 and ZT_0 ... _2 as a sensible default pair
+                s1 = next((c for c in cols if re.search(r"ZT_0_.*_1$", str(c))), None)
+                s2 = next((c for c in cols if re.search(r"ZT_0_.*_2$", str(c))), None)
+                if s1 and s2 and s1 != s2:
+                    return s1, s2
+                cols = [str(c) for c in cols]
+                return (cols[0] if cols else None, cols[1] if len(cols) > 1 else None)
+
+            def _build_time_vec(n_cols: int, manual_text: str | None) -> list[float]:
+                if manual_text:
+                    try:
+                        return [float(x.strip()) for x in manual_text.split(",") if x.strip()]
+                    except (AttributeError, ValueError):
+                        pass
+                base = [0, 4, 8, 12, 16, 20]
+                reps = max(1, (n_cols + len(base) - 1) // len(base))
+                return [float(value) for value in (base * reps)[:n_cols]]
+
+            # ---------- loaders & toggles ----------
+            def load_omics(
+                fpath: str | Path,
+            ) -> tuple[object, object, object, pd.DataFrame, object, object, object, object]:
+                # Read TSV (tab-separated). Pandas also handles CSV if present.
+                dataframe = pd.read_csv(fpath, sep="\t")
+                # Drop first column by index (your pipeline)
+                if dataframe.shape[1] > 0:
+                    dataframe = dataframe.drop(dataframe.columns[0], axis=1)
+                # Create Genes column from gene_name if present
+                if "gene_name" in dataframe.columns:
+                    dataframe["Genes"] = dataframe["gene_name"].astype(str).str.split("|").str[1]
+
+                status = f"Loaded {dataframe.shape[0]} rows x {dataframe.shape[1]} columns."
+                choices = dataframe.columns.tolist()
+                a_guess, b_guess = _guess_cols(choices)
+                s1, s2 = _pick_default_samples(choices)
+                default_cycle = "0,4,8,12,16,20"
+
+                return (
+                    status,
+                    gr.update(choices=choices, value=a_guess),
+                    gr.update(choices=choices, value=b_guess),
+                    dataframe,
+                    gr.update(value=default_cycle),
+                    gr.update(value=default_cycle),
+                    gr.update(choices=choices, value=s1),
+                    gr.update(choices=choices, value=s2),
+                )
+
+            for evt in (omics_file.upload, omics_file.change):
+                evt(
+                    load_omics,
+                    inputs=omics_file,
+                    outputs=[
+                        omics_status,
+                        columns_cond1_dd,
+                        columns_cond2_dd,
+                        st_df_rna,
+                        t_cond1_tb,
+                        t_cond2_tb,
+                        sample1_dd,
+                        sample2_dd,
+                    ],
+                )
+
+            def toggle_time_fields(checked: object) -> tuple[object, object]:
+                is_checked = bool(checked)
+                return gr.update(visible=is_checked), gr.update(visible=is_checked)
+
+            override_time.change(
+                toggle_time_fields,
+                inputs=override_time,
+                outputs=[t_cond1_tb, t_cond2_tb],
+            )
+
+            # ---------- preview inputs for your future class ----------
+            def build_omics_inputs(  # noqa: PLR0913
+                df: pd.DataFrame | None,
+                cols_a: Sequence[str] | None,
+                cols_b: Sequence[str] | None,
+                use_manual_time: object,
+                t_a_text: str | None,
+                t_b_text: str | None,
+            ) -> str:
+                if df is None:
+                    return "# Upload or select an example file first."
+
+                cols_a = list(cols_a or [])
+                cols_b = list(cols_b or [])
+
+                manual_flag = bool(use_manual_time)
+
+                t_a = _build_time_vec(
+                    len(cols_a),
+                    t_a_text if manual_flag else None,
+                )
+                t_b = _build_time_vec(
+                    len(cols_b),
+                    t_b_text if manual_flag else None,
+                )
+
+                snippet = f"""# Planned inputs for your Omics class
+        columns_cond1 = {cols_a}
+        columns_cond2 = {cols_b}
+        t_cond1 = {t_a}
+        t_cond2 = {t_b}
+
+        # Example construction (later):
+        # rna_data = OmicsDataset(
+        #     df=df_rna,
+        #     columns_cond1=columns_cond1,
+        #     columns_cond2=columns_cond2,
+        #     t_cond1=t_cond1,
+        #     t_cond2=t_cond2,
+        #     deduplicate_on_init=True,
+        # )
+        """
+                return snippet
+
+            build_omics_btn.click(
+                build_omics_inputs,
+                inputs=[
+                    st_df_rna,
+                    columns_cond1_dd,
+                    columns_cond2_dd,
+                    override_time,
+                    t_cond1_tb,
+                    t_cond2_tb,
+                ],
+                outputs=omics_preview,
+            )
+
+            # ---------- histogram ----------
+            def run_histogram(  # noqa: PLR0913
+                df: pd.DataFrame | None,
+                cols_a: Sequence[str] | None,
+                cols_b: Sequence[str] | None,
+                use_manual_time: object,
+                t_a_text: str | None,
+                t_b_text: str | None,
+            ) -> tuple[plt.Figure | None, str | None]:
+                if df is None:
+                    return None, None
+
+                cols_a = list(cols_a or [])
+                cols_b = list(cols_b or [])
+                manual_flag = bool(use_manual_time)
+
+                t_a = _build_time_vec(len(cols_a), t_a_text if manual_flag else None)
+                t_b = _build_time_vec(len(cols_b), t_b_text if manual_flag else None)
+
+                t_a_array = np.asarray(t_a, dtype=float)
+                t_b_array = np.asarray(t_b, dtype=float)
+
+                rna_data = OmicsDataset(
+                    df=df,
+                    columns_cond1=cols_a,
+                    columns_cond2=cols_b,
+                    t_cond1=t_a_array,
+                    t_cond2=t_b_array,
+                    deduplicate_on_init=True,
+                )
+
+                fig = rna_data.expression_histogram()
+
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmpfile:
+                    fig.savefig(tmpfile.name)
+                    tmp_path = tmpfile.name
+                plt.close(fig)
+                return fig, tmp_path
+
+            hist_btn.click(
+                run_histogram,
+                inputs=[
+                    st_df_rna,
+                    columns_cond1_dd,
+                    columns_cond2_dd,
+                    override_time,
+                    t_cond1_tb,
+                    t_cond2_tb,
+                ],
+                outputs=[omics_plot, omics_download],
+            )
+
+            # ---------- replicate scatterplot ----------
+            def run_replicate_scatter(  # noqa: PLR0913
+                df: pd.DataFrame | None,
+                cols_a: Sequence[str] | None,
+                cols_b: Sequence[str] | None,
+                use_manual_time: object,
+                t_a_text: str | None,
+                t_b_text: str | None,
+                sample1: str | None,
+                sample2: str | None,
+            ) -> tuple[plt.Figure | None, str | None]:
+                if df is None or not sample1 or not sample2:
+                    return None, None
+
+                cols_a = list(cols_a or [])
+                cols_b = list(cols_b or [])
+                manual_flag = bool(use_manual_time)
+
+                t_a = _build_time_vec(len(cols_a), t_a_text if manual_flag else None)
+                t_b = _build_time_vec(len(cols_b), t_b_text if manual_flag else None)
+
+                t_a_array = np.asarray(t_a, dtype=float)
+                t_b_array = np.asarray(t_b, dtype=float)
+
+                rna_data = OmicsDataset(
+                    df=df,
+                    columns_cond1=cols_a,
+                    columns_cond2=cols_b,
+                    t_cond1=t_a_array,
+                    t_cond2=t_b_array,
+                    deduplicate_on_init=True,
+                )
+
+                fig = rna_data.replicate_scatterplot(sample1=sample1, sample2=sample2)
+
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+                    fig.savefig(tmp.name)
+                    tmp_path = tmp.name
+                plt.close(fig)
+                return fig, tmp_path
+
+            scatter_btn.click(
+                run_replicate_scatter,
+                inputs=[
+                    st_df_rna,
+                    columns_cond1_dd,
+                    columns_cond2_dd,
+                    override_time,
+                    t_cond1_tb,
+                    t_cond2_tb,
+                    sample1_dd,
+                    sample2_dd,
+                ],
+                outputs=[scatter_plot, scatter_download],
+            )
+
+            # ------------------------------------------------------------
+            # Differential rhythmicity + heatmap
+            # (Paste this inside your existing `with gr.Tab("Omics", id=1):` block)
+            # Re-uses helpers: _build_time_vec, and states/components you already created.
+            # ------------------------------------------------------------
+
+            # Labels for the heatmap and expressed-threshold
+            with gr.Row():
+                cond1_label_tb = gr.Textbox(
+                    label="Condition 1 label",
+                    value="Alpha cells",
+                )
+                cond2_label_tb = gr.Textbox(
+                    label="Condition 2 label",
+                    value="Beta cells",
+                )
+                mean_min_num = gr.Number(
+                    label="mean_min (for is_expressed)",
+                    value=0,
+                    precision=0,
+                )
+
+            compute_dr_btn = gr.Button(
+                "Compute differential rhythmicity & heatmap",
+                variant="primary",
+            )
+
+            # Outputs
+            heatmap_plot = gr.Plot(label="Heatmap preview")
+            heatmap_download = gr.File(label="Download heatmap (PDF)")
+            params_preview = gr.Dataframe(
+                label="Rhythmic parameters (preview)",
+                interactive=False,
+            )
+            params_download = gr.File(label="Download rhythmic parameters (CSV)")
+
+            def run_dr_and_heatmap(  # noqa: PLR0913
+                df: pd.DataFrame | None,
+                cols_a: Sequence[str] | None,
+                cols_b: Sequence[str] | None,
+                use_manual_time: object,
+                t_a_text: str | None,
+                t_b_text: str | None,
+                cond1_label: str,
+                cond2_label: str,
+                mean_min: float | None,
+            ) -> tuple[plt.Figure | None, str | None, pd.DataFrame | None, str | None]:
+                if df is None or not cols_a or not cols_b:
+                    # Nothing to do yet
+                    return None, None, None, None
+
+                cols_a = list(cols_a or [])
+                cols_b = list(cols_b or [])
+                manual_flag = bool(use_manual_time)
+
+                # Build time vectors (reuse your helper)
+                t_a = _build_time_vec(len(cols_a), t_a_text if manual_flag else None)
+                t_b = _build_time_vec(len(cols_b), t_b_text if manual_flag else None)
+
+                t_a_array = np.asarray(t_a, dtype=float)
+                t_b_array = np.asarray(t_b, dtype=float)
+
+                # Construct dataset
+                rna_data = OmicsDataset(
+                    df=df,
+                    columns_cond1=cols_a,
+                    columns_cond2=cols_b,
+                    t_cond1=t_a_array,
+                    t_cond2=t_b_array,
+                    deduplicate_on_init=True,
+                )
+
+                # Mark expressed genes
+                try:
+                    mean_min_value = float(mean_min) if mean_min is not None else 0.0
+                except (TypeError, ValueError):
+                    mean_min_value = 0.0
+                rna_data.add_is_expressed(mean_min=mean_min_value)
+
+                # Differential rhythmicity
+                dr = DifferentialRhythmicity(dataset=rna_data)
+                rhythmic_all = dr.extract_all_circadian_params()  # pandas DataFrame
+
+                # Build heatmap
+                heatmap = OmicsHeatmap(
+                    df=rhythmic_all,
+                    columns_cond1=cols_a,
+                    columns_cond2=cols_b,
+                    t_cond1=t_a_array,
+                    t_cond2=t_b_array,
+                    cond1_label=cond1_label or "Condition 1",
+                    cond2_label=cond2_label or "Condition 2",
+                    show_unexpressed=False,
+                )
+                fig = heatmap.plot_heatmap()  # should return a Matplotlib Figure
+
+                # Save outputs for download
+
+                # Heatmap PDF
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_pdf:
+                    fig.savefig(tmp_pdf.name)
+                    tmp_pdf_path = tmp_pdf.name
+
+                # Rhythmic params CSV
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as tmp_csv:
+                    rhythmic_all.to_csv(tmp_csv.name, index=False)
+                    tmp_csv_path = tmp_csv.name
+
+                # For preview table, show up to 200 rows to keep UI snappy
+                preview_df = rhythmic_all.head(20)
+
+                return fig, tmp_pdf_path, preview_df, tmp_csv_path
+
+            compute_dr_btn.click(
+                run_dr_and_heatmap,
+                inputs=[
+                    st_df_rna,
+                    columns_cond1_dd,
+                    columns_cond2_dd,
+                    override_time,
+                    t_cond1_tb,
+                    t_cond2_tb,
+                    cond1_label_tb,
+                    cond2_label_tb,
+                    mean_min_num,
+                ],
+                outputs=[
+                    heatmap_plot,
+                    heatmap_download,
+                    params_preview,
+                    params_download,
+                ],
+            )
+
+
+if __name__ == "__main__":
+    demo.launch()
diff --git a/data/bioluminescence_example.csv b/data/bioluminescence_example.csv
new file mode 100644
index 0000000..6104417
--- /dev/null
+++ b/data/bioluminescence_example.csv
@@ -0,0 +1,583 @@
+Participant ID,1,1,1,2,3,3,4,4,5,5,6,6,7,7,7,8,8,8,9,9,10,10,11,11,11,12,12,12,12,13,13,13,14,14,14,15,15,15,16,16,17,17,18,18,18,19,19,19,19,20,20,20,21,21,22,22,23,23,24,24
+Replicate,1,2,3,1,1,2,1,2,1,2,1,2,1,2,3,1,2,3,1,2,1,2,1,2,3,1,2,3,4,1,2,3,1,2,3,1,2,3,1,2,1,2,1,2,3,1,2,3,4,1,2,3,1,2,1,2,1,2,1,2
+Group,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 1,Group 1,Group 2,Group 2
+0,919.123,834.821,1227.032,152.91,186,131,540,406,307,189,140,282,564.071,298.783,506.62,295.221,342.331,293.212,564.754,578.906,193.281,287.944,441.721,479.457,558.449,133.5,390.942,407.189,406.213,94.713,124.118,73.916,1112.212,747.835,1086.323,595.233,491.795,408.985,800.394,1221.799,258.223,352.672,95.439,102.981,73.726,1480.701,526.498,574.276,1155.453,345.919,358.793,505.006,106,161,747,444,704,538,159.523,158.988
+0.1668,920.718,838.938,1222.663,156.901,203,121,685,510,288,193,148,302,563.009,303.439,506.763,294.169,343.17,294.523,581.508,582.121,203.778,314.142,445.127,483.091,563.356,123.5,397.305,409.621,412.28,94.812,127.433,75.856,1134.266,756.197,1097.5,597.067,488.03,405.678,826.948,1302.709,282.085,355.342,94.344,103.773,72.361,1479.018,528.973,583.327,1166.273,351.159,357.759,504.341,37,210,725,482,727,537,161.031,157.595
+0.3336,926.536,829.957,1225.876,157.411,203,122,742,519,282,187,153,308,573.158,309.183,509.595,295.857,341.492,293.326,600.822,571.641,218.427,343.226,448.68,487.388,561.829,176.5,402.113,409.225,410.455,99.068,128.184,77.698,1141.821,772.681,1107.573,592.63,484.517,405.846,851.039,1328.244,297.13,359.474,94.557,102.584,71.28,1498.607,528.648,585.689,1170.658,346.882,361.077,505.984,103,250,704,472,696,509,161.23,156.396
+0.5004,922.005,832.11,1218.498,162.01,201,125,763,506,274,179,157,325,576.119,315.781,520.51,295.43,346.911,293.589,626.038,569.885,225.011,372.495,448.767,493.572,568.015,185.5,404.248,416.833,419.251,102.236,127.844,80.446,1150.813,779.686,1113.342,592.573,485.683,405.848,884.628,1349.927,311.976,365.494,97.5,103.264,71.707,1515.381,536.766,590.626,1176.598,352.448,363.184,514.34,104,267,691,456,667,489,162.415,156.561
+0.6672,917.688,836.875,1213.635,165.166,198,127,779,499,266,172,161,329,580.757,323.214,527.845,299.789,343.682,298.941,642.972,563.413,239.726,405.118,462.399,492.359,563.074,185,404.403,420.142,420.241,103.862,131.612,82.953,1171.562,799.399,1122.771,588.15,479.08,398.337,906.121,1358.807,328.748,365.732,96.69,100.899,71.565,1515.961,538.351,593.341,1176.725,353.099,365.362,516.903,107,263,690,444,646,486,165.882,159.958
+0.834,914.059,838.414,1203.028,168.563,187,127,795,495,262,170,165,336,585.023,325.576,531.391,298.163,342.744,296.591,663.599,558.696,249.968,423.106,456.528,499.031,559.504,185.5,408.179,424.271,425.854,110.055,132.093,85.815,1183.079,806.467,1135.094,589.473,475.982,400.34,942.986,1355.804,340.594,367.998,99.491,100.616,73.342,1528.492,540.119,592.676,1179.172,358.779,366.139,521.024,115,256,684,429,646,488,167.077,156.236
+1.0008,911.542,822.959,1209.939,171.833,178,128,817,487,259,164,166,351,584.569,340.437,539.817,296.678,349.058,301.699,681.921,555.637,261.562,452.134,464.054,507.088,563.144,186.5,412.52,431.03,421.81,112.021,136.286,86.92,1189.657,820.118,1145.487,583.755,475.936,398.012,978.761,1339.758,352.907,377.969,101.354,99.271,73.243,1541.674,545.366,592.012,1182.793,364.769,370.396,524.848,127,246,685,418,653,485,170,157.105
+1.1676,903.943,820.438,1207.446,172.37,171,128,830,484,250,160,171,356,594.352,342.274,545.283,301.93,347.238,303.913,695.492,556.459,270.14,471.92,471.965,512.072,570.423,185,427.58,432.345,427.283,113.562,132.249,87.982,1205.764,827.091,1165.166,585.433,469.054,396.772,995.489,1323.429,371.419,385.206,99.477,99.88,73.072,1548.803,545.111,591.701,1183.5,362.957,372.446,527.043,133,237,676,406,682,484,166.323,155.67
+1.3344,904.455,815.071,1188.23,176.234,166,125,827,475,247,161,171,366,599.442,342.441,552.027,303.919,350.169,304.612,709.077,562.52,278.988,495.032,476.712,513.546,574.728,181.5,423.083,439.472,432.826,114.538,137.604,89.639,1220.81,854.657,1162.175,579.61,469.352,393.897,1006.066,1301.916,384.369,400.516,100.586,99.271,73.157,1556.03,547.176,604.203,1187.22,371.879,377.282,532.468,139,224,680,399,703,484,169.765,156.859
+1.5012,899.353,811.06,1191.886,179.475,162,121,829,472,239,156,172,380,595.643,342.374,561.503,306.479,354.79,307.003,715.436,574.049,285.672,510.148,475.733,513.868,578.042,177,423.931,437.068,440.32,116.263,138.128,92.132,1234.006,865.305,1184.913,570.884,464.113,395.212,1020.843,1281.975,395.465,397.786,100.557,97.005,73.157,1567.897,549.779,597.316,1184.349,373.585,381.581,542.973,140,214,673,391,717,483,167.162,158.11
+1.668,892.033,809.514,1179.736,183.721,154,118,829,473,237,156,172,389,606.961,351.523,567.975,303.814,353.311,304.961,721.254,572.703,294.991,532.495,485.425,525.202,578.971,174,429.248,443.785,439.726,118.695,143.624,93.705,1241.761,889.096,1197.378,570.116,458.646,401.175,1025.538,1265.108,414.926,414.027,102.591,96.609,75.02,1564.573,548.972,597.584,1186.994,375.396,382.415,540.454,141,207,670,390,728,482,172.895,152.431
+1.8348,889.904,805.21,1168.767,186.382,149,116,811,471,231,152,176,392,602.009,355.255,577.91,308.855,356.483,307.116,726.333,568.724,307.339,548.078,490.688,524.843,580.677,168.5,432.458,446.881,442.173,122.824,141.471,92.756,1257.578,891.527,1204.669,561.725,466.081,395.665,1034.757,1242.703,424.38,428.26,101.866,95.221,74.167,1582.535,551.829,596.99,1191.519,381.155,387.056,545.775,144,193,663,385,729,481,170.696,156.17
+2.0016,879.028,799.729,1162.092,186.637,144,113,814,469,227,153,175,396,605.204,360.45,570.345,308.119,363.921,310.683,726.091,572.703,315.433,569.18,496.16,530.57,586.015,161.5,431.143,443.544,440.476,121.636,144.743,94.725,1261.385,906.515,1222.524,559.663,461.248,401.458,1033.895,1224.532,447.237,437.805,103.003,93.692,78.02,1592.012,552.226,595.208,1180.784,385.57,388.938,546.44,140,183,652,387,732,481,176.266,151.921
+2.1684,880.114,793.934,1151.403,187.91,142,112,801,471,225,152,177,399,607.399,361.924,579.423,306.493,365.357,308.063,721.254,581.031,327.525,579.823,494.923,539.609,592.545,154,433.83,449.116,446.697,118.709,144.814,94.626,1267.46,911.078,1218.845,553.462,466.379,400.458,1037.812,1200.598,460.032,450.566,103.643,95.108,77.011,1591.884,553.513,595.972,1179.398,387.141,393.168,557.576,134,174,643,382,726,484,178.138,152.488
+2.3352,871.843,789.265,1150.842,195.68,136,109,789,474,223,148,171,397,605.068,367.432,587.311,314.592,364.703,313.147,723.9,579.94,341.053,600.926,497.574,538.302,591.884,151,430.888,443.261,450.346,117.903,149.064,92.487,1286.76,922.727,1233.709,556.975,464.727,408.34,1034.531,1190.174,477.709,466.258,102.278,94.471,80.594,1578.519,553.343,586.354,1169.328,391.216,397.711,556.982,133,169,636,385,729,491,179.254,153.957
+2.502,862.042,784.338,1137.759,195.964,138,109,785,476,222,149,178,403,607.775,368.765,590.419,319.095,369.681,317.115,720.728,590.803,348.351,613.041,508.165,548.675,601.793,143.5,438.524,446.867,445.708,119.784,150.452,95.532,1285.943,937.756,1235.66,555.453,469.239,414.457,1024.859,1180.558,498.769,486.581,104.254,92.319,80.679,1573.936,558.095,592.62,1169.116,392.687,399.409,563.292,127,160,646,392,727,488,177.86,151.594
+2.6688,853.289,777.43,1123.476,198.539,138,108,771,480,215,148,175,403,608.87,365.187,590.587,316.433,376.323,315.555,715.763,590.987,361.794,634.214,510.7,552.819,605.858,143,437.11,450.119,453.301,117.338,150.679,96.297,1289.188,941.206,1239.169,555.254,466.579,414.527,1020.207,1162.699,514.733,498.846,104.354,91.936,81.774,1563.894,552.254,593.836,1163.204,398.08,402.833,570.862,127,159,658,401,724,502,178.827,149.783
+2.8356,853.599,776.242,1126.252,198.992,135,109,768,492,215,151,176,398,616.34,369.878,591.67,316.606,373.222,315.361,714.444,600.589,378.949,651.636,517.668,561.037,613.548,141,434.565,448.14,452.028,119.303,150.126,96.099,1298.102,949.698,1239.359,559.663,465.968,418.162,1012.953,1144.458,528.264,512.867,102.491,91.837,83.509,1571.956,547.318,583.837,1166.457,402.852,407.785,575.111,125,157,664,407,740,511,179.467,148.749
+3.0024,844.109,771.66,1104.307,205.772,134,105,760,496,218,149,174,406,608.839,368.627,592.4,321.999,378.172,317.948,708.423,603.79,390.813,653.165,522.269,566.018,618.078,138,436.813,447.447,448.875,122.131,148.313,96.609,1303.836,960.382,1257.768,560.53,471.062,422.4,1008.654,1144.698,550.781,527.553,105.292,94.329,85.371,1548.845,547.841,583.384,1154.279,404.651,407.115,574.19,121,155,674,414,744,524,183.92,150.306
+3.1692,839.212,764.927,1094.728,206.125,139,108,764,505,220,153,174,407,615.397,374.292,596.453,322.999,382.381,324.739,703.771,607.529,402.165,670.063,534.549,570.641,623.646,137,438.326,445.481,451.109,118.214,151.826,94.838,1307.857,962.444,1254.555,557.515,477.508,431.44,1004.214,1129.035,570.157,545.497,106.984,92.149,84.575,1543.131,547.403,586.439,1156.882,404.339,411.817,576.881,120,154,678,430,750,530,182.511,149.004
+3.336,835.581,754.72,1089.648,206.493,141,108,761,514,218,155,179,397,612.738,371.786,602.396,322.778,385.553,322.268,702.633,609.455,414.114,681.075,534.546,575.21,629.181,135.5,439.019,447.716,455.861,116.008,149.049,94.994,1308.786,968.404,1256.086,565.266,481.059,436.347,988.136,1114.334,576.412,552.89,110.155,92.446,84.646,1533.174,542.155,578.108,1141.974,403.32,416.406,578.227,118,153,688,440,776,548,184.998,148.919
+3.5028,824.097,758.182,1086.076,213.443,140,109,756,519,225,160,183,409,617.661,374.071,602.893,330.693,389.194,321.061,689.702,614.78,426.675,700.238,540.271,578.787,634.253,134.5,436.248,444.732,451.138,114.806,151.968,92.685,1311.726,968.082,1253.403,562.749,488.127,448.889,982.777,1113.088,599.383,574.913,108.492,91.781,85.4,1522.128,539.143,574.756,1131.366,407.2,417.454,580.507,114,155,707,450,791,567,180.932,148.451
+3.6696,817.201,749.494,1071.026,213.895,141,109,758,534,228,162,179,407,609.2,375.265,604.62,329.986,386.534,326.559,687.768,616.083,436.263,707.258,546.964,586.653,636.423,135.5,438.722,445.496,450.699,114.368,149.418,91.693,1301.176,970.688,1249.148,564.669,495.652,450.733,979.935,1099.647,614.513,583.481,108.335,91.228,87.988,1515.155,535.055,568.873,1128.212,404.396,419.437,582.56,116,155,715,459,804,574,185.186,149.23
+3.8364,812.192,738.601,1060.732,213.216,144,109,763,537,235,168,181,407,613.95,378.494,607.711,329.647,390.09,325.488,686.331,624.382,451.84,719.316,547.197,594.204,644.436,136.5,434.141,445.199,445.241,109.659,149.545,93.082,1292.184,971.361,1259.636,574.411,498.067,458.759,962.344,1098.458,625.736,593.324,109.259,92.743,88.073,1504.476,527.7,564.63,1115.2,409.622,419.564,581.583,116,157,734,471,829,604,183.564,145.918
+4.0032,805.481,738.917,1046.257,215.608,144,110,758,546,242,168,180,406,608.419,374.97,611.378,329.42,388.497,326.162,680.072,626.124,459.906,727.596,558.703,600.688,649.477,137.5,430.804,437.591,445.948,112.275,145.806,92.926,1305.052,978.66,1246.279,577.341,505.578,461.097,957.197,1084.352,639.691,604.413,110.255,89.628,87.305,1481.521,527.616,554.432,1107.308,406.365,416.59,582.192,114,161,740,478,850,617,181.018,146.414
+4.17,806.835,730.615,1039.375,219.274,145,108,766,540,246,176,183,402,604.749,372.878,610.093,330.311,387.857,332.928,670.541,619.425,469.807,737.05,553.81,606.537,651.9,141.5,430.874,445.142,446.655,109.659,146.811,91.325,1294.537,975.841,1240.225,584.708,511.264,471.74,950.862,1077.384,650.277,618.349,109.515,90.577,91.031,1471.819,518.012,552.282,1099.826,404.863,422.099,583.028,119,164,748,488,870,627,185.869,144.008
+4.3368,795.421,725.972,1032.356,224.793,143,107,766,549,251,180,182,403,605.204,385.141,613.116,335.85,392.565,329.873,670.526,632.554,481.315,741.763,561.631,606.637,653.565,141,431.666,433.504,444.859,108.429,150.877,92.317,1293.401,975.84,1237.263,585.419,510.81,480.057,941.713,1065.119,663.68,620.346,111.378,92.644,91.855,1457.081,513.373,556.002,1094.154,405.033,424.294,589.896,116,166,753,489,894,647,183.92,142.663
+4.5036,786.458,724.707,1020.774,225.558,143,110,768,557,256,183,185,405,603.349,377.793,607.265,336.252,388.426,339.745,660.569,624.58,488.698,744.452,566.033,610.384,662.607,144.5,418.516,435.484,439.118,108.358,145.664,90.291,1285.802,970.546,1235.655,590.482,515.738,482.445,941.416,1056.239,669.964,629.127,107.255,91.639,92.495,1448.397,505.551,538.987,1078.526,411.959,420.895,587.376,118,171,757,492,902,665,185.171,146.015
+4.6704,783.953,709.908,1010.572,228.148,142,106,767,553,258,190,184,404,603.165,378.728,610.72,340.183,391.356,339.688,661.55,622.98,496.991,749.448,570.372,614.511,661.542,146,427.169,432.755,439.783,107.114,146.273,90.22,1275.415,969.658,1230.25,597.892,522.01,485.862,923.755,1049.838,672.356,638.162,109.828,92.219,91.358,1433.192,504.844,540.529,1067.805,405.685,423.515,584.288,120,172,756,494,919,673,185.42,141.71
+4.8372,767.346,698.827,995.68,229.337,144,105,767,554,265,189,184,400,601.131,374.367,609.149,334.399,390.232,338.43,655.832,627.512,508.03,753.468,578.708,623.269,673.597,148.5,426.349,436.205,431.68,106.209,147.817,89.71,1277.415,969.686,1227.236,609.014,522.011,490.717,921.252,1036.624,678.428,639.734,112.217,89.642,94.073,1416.121,497.589,521.477,1056.561,402.427,422.212,582.419,121,176,755,501,940,681,182.119,140.959
+5.004,761.799,693.519,992.018,230.214,137,103,767,552,271,195,183,398,593.768,379.378,611.518,337.691,393.418,345.168,655.505,621.762,519.098,755.52,578.462,630.104,673.635,149,426.392,423.281,433.278,105.417,143.341,89.299,1271.945,964.348,1224.646,609.569,530.706,496.807,908.822,1026.328,679.291,640.966,111.293,91.681,91.756,1405.81,491.365,519.851,1041.469,404.665,422.991,583.608,121,177,760,492,956,699,182.782,138.962
+5.1708,747.922,689.52,969.25,230.143,134,99,767,550,273,197,185,404,589.409,375.683,605.347,341.994,395.549,346.166,647.609,627.724,532.782,755.222,583.977,632.703,681.712,150,420.142,428.739,435.017,105.403,141.754,87.798,1265.816,961.873,1216.095,610.147,525.536,499.795,899.815,1020.564,690.401,641.122,110.042,90.265,93.149,1386.575,486.698,521.604,1033.86,404.523,422.043,583.028,123,177,756,492,963,698,184.247,139.161
+5.3376,740.385,681.443,960.302,238.734,133,99,763,539,269,199,182,395,581.64,374.544,605.138,335.728,389.322,349.49,646.671,625.501,532.37,758.633,581.63,636.18,674.031,153.5,412.718,426.208,424.511,105.389,143.497,88.421,1258.956,954.144,1212.031,618.742,534.103,500.488,890.539,1014.216,694.336,648.458,110.539,93.154,95.012,1365.784,479.244,507.687,1029.292,398.759,417.199,581.045,127,180,750,485,970,691,178.656,138.552
+5.5044,738.261,674.604,954.635,233.413,131,97,768,540,276,203,182,391,575.384,371.724,601.426,341.401,396.149,347.378,640.116,625.926,536.026,768.031,591.256,631.147,689.048,151,410.427,417.257,422.022,103.636,142.321,86.622,1249.807,955.37,1201.795,620.236,539.742,502.046,882.081,1005.211,692.071,642.935,111.463,90.634,95.211,1356.35,475.213,501.294,1014.837,393.647,415.981,582.235,125,177,749,490,973,703,180.349,136.668
+5.6712,731.339,667.351,937.108,236.923,129,99,768,530,273,202,180,386,573.436,368.488,602.322,344.497,393.759,349.363,648.168,620.601,540.749,755.435,586.948,642.482,694.85,150.5,409.013,414.683,417.639,103.381,137.689,86.679,1243.495,955.432,1195.858,617.547,540.46,500.587,878.287,1011.496,694.902,647.92,110.169,91.596,94.728,1333.451,469.245,491.351,1000.82,399.397,411.987,576.541,123,178,737,481,971,699,179.979,134.7
+5.838,721.399,662.057,933.997,243.433,127,95,766,523,275,203,179,382,569.689,367.65,596.623,344.12,391.597,347.888,640.443,623.694,543.736,753.963,594.91,639.591,698.112,150,400.501,412.591,412.039,105.191,139.53,87.685,1235.473,942.491,1187.394,627.617,539.374,504.524,872.029,993.736,697.167,648.713,113.156,91.214,93.107,1319.364,456.855,486.33,986.974,390.418,412.695,574.261,122,178,730,479,973,701,182.298,132.434
+6.0048,707.467,643.127,916.59,242.272,124,94,766,520,276,203,182,382,562.678,365.541,600.169,344.441,391.569,347.496,645.39,621.544,542.384,750.495,601.672,640.712,699.702,150,402.155,406.341,409.748,103.636,136.286,86.169,1234.452,940.446,1178.574,626.536,535.419,501.902,863.389,992.407,701.158,640.683,110.497,90.251,94.301,1300.242,444.083,478.452,977.002,389.639,407.894,565.905,126,174,721,476,973,706,177.12,132.264
+6.1716,703.272,637.465,903.127,243.631,120,94,770,509,276,202,181,380,555.446,362.249,602.748,344.29,392.351,349.134,635.344,622.704,547.875,754.119,602.6,644.428,698.098,152.5,397.588,406.468,404.927,101.514,137.065,86.948,1224.749,935.583,1169.81,630.39,535.867,508.205,866.288,977.276,703.705,640.981,110.155,91.016,95.424,1278.772,444.889,466.953,953.68,386.013,404.467,566.188,124,181,717,469,969,699,177.641,131.031
+6.3384,690.3,629.536,895.505,247.368,122,92,760,506,276,201,174,373,548.482,362.774,589.008,344.427,390.758,354.667,630.895,623.863,543.281,756.355,604.925,646.221,706.25,148.5,391.946,406.185,402.664,102.391,136.612,86.735,1214.412,928.294,1175.469,629.722,543.674,511.136,857.351,975.438,698.822,640.372,111.535,89.232,94.912,1262.153,432.612,460.688,944.147,387.684,400.912,560.665,121,176,707,467,975,691,175.171,128.865
+6.5052,678.366,621.852,883.95,247.948,119,91,757,506,274,200,177,372,548.629,358.137,584.491,347.151,387.345,345.777,632.659,622.718,549.07,750.354,603.082,656.45,710.462,150,391.125,398.733,394.095,102.787,133.836,87.359,1209.014,924.668,1161.746,634.131,537.607,506.874,857.351,953.492,696.799,639.366,111.179,89.119,95.197,1235.973,431.594,452.258,924.925,381.283,399.184,554.009,122,178,695,467,965,692,176.892,125.876
+6.672,673.141,619.749,872.896,249.448,118,92,752,505,272,197,178,368,535.724,351.896,585.584,343.281,395.708,346.181,627.68,625.009,557.89,745.075,610.837,646.886,715.415,150,380.789,395.127,386.699,100.397,135.281,86.027,1201.016,912.823,1157.621,637.416,534.358,507.275,859.769,953.973,698.313,627.314,108.378,90.846,97.017,1219.708,422.005,445.766,911.05,378.634,395.828,558.172,121,179,696,470,956,693,171.928,127.717
+6.8388,662.003,609.655,854.927,250.651,121,93,758,494,272,195,175,369,530.622,349.909,577.644,344.489,392.792,348.95,627.106,616.581,590.295,752.293,609.837,650.142,712.997,148.5,381.595,392.568,387.35,103.112,137.618,86.013,1197.656,902.218,1150.212,632.509,535.966,503.023,852.854,950.664,694.223,634.324,110.724,89.019,97.259,1195.197,407.182,430.491,898.788,372.261,392.485,555.737,121,176,693,458,955,696,170.121,128.015
+7.0056,649.861,600.278,848.924,251.897,121,91,750,495,260,195,175,364,528.545,343.758,571.629,349.943,390.801,347.312,622.957,618.561,643.043,752.632,612.308,658.245,716.264,147,374.284,381.27,379.686,103.324,134.275,87.968,1193.943,899.339,1147.379,629.722,537.373,504.97,851.567,938.079,699.459,630.175,108.676,90.648,95.396,1174.618,402.939,420.124,885.832,368.522,386.934,550.751,119,175,684,459,958,687,169.396,125.694
+7.1724,636.388,592.571,826.753,256.001,120,89,759,490,261,188,175,362,514.462,344.263,564.397,348.058,393.631,348.341,628.682,623.015,696.815,752.859,615.771,662.193,717.132,148.5,374.086,376.872,373.733,103.155,134.601,84.341,1193.597,897.351,1135.094,627.233,537.776,509.961,840.354,925.621,690.5,626.039,108.349,88.75,96.676,1152.921,393.831,419.558,875.776,362.404,383.124,543.344,121,176,687,459,951,690,170.548,123.624
+7.3392,625.478,577.698,814.323,254.784,119,90,756,490,257,186,175,364,511.078,337.971,562.942,347.524,390.573,349.716,620.226,618.631,745.807,747.24,620.525,653.741,721.073,148.5,364.753,373.591,368.628,103.381,132.547,87.203,1176.702,883.582,1136.286,629.196,534.018,509.227,847.226,924.518,699.162,621.875,111.279,88.524,95.538,1129.698,387.084,407.606,848.875,358.779,383.407,537.708,118,179,687,454,958,689,164.506,121.146
+7.506,616.184,568.489,804.229,254.303,119,91,753,493,256,183,171,355,507.693,339.077,558.153,345.324,390.246,346.995,617.873,624.797,781.043,746.504,623.632,654.725,722.288,148,357.697,367.525,361.897,102.193,133.737,86.99,1170.285,882.739,1121.58,629.708,527.468,507.073,841.104,915.412,686.495,617.089,110.312,88.694,95.382,1113.291,380.578,397.904,839.455,353.921,373.054,536.192,120,176,683,463,957,698,167.356,121.628
+7.6728,603.684,559.637,783.47,255.109,123,93,756,497,250,179,168,352,504.122,333.667,544.128,354.356,390.147,342.008,620.695,625.659,809.423,752.519,621.176,659.236,722.261,148.5,359.423,358.814,359.536,101.316,134.615,87.6,1159.124,867.391,1119.178,621.046,524.007,498.848,834.062,897.863,691.534,617.924,108.037,88.821,93.491,1085.838,373.11,393.321,823.176,349.644,366.086,527.114,120,177,683,460,966,696,161.805,118.526
+7.8396,595.893,544.451,779.567,256.638,122,95,754,498,242,179,168,351,496.565,326.077,541.729,351.598,394.57,344.63,613.669,629.661,828.627,742.258,627.13,655.757,726.281,148,351.829,352.847,350.882,101.246,133,88.945,1155.147,863.272,1102.775,622.084,520.355,493.494,827.656,898.387,684.132,612.486,108.079,88.864,95.197,1059.262,366.208,380.663,804.138,343.356,365.308,519.849,120,176,689,461,969,706,158.001,116.147
+8.0064,582.633,534.779,762.61,256.779,127,94,758,497,240,172,171,352,487.333,313.53,540.06,349.462,389.777,343.338,621.193,625.009,839.595,741.324,620.653,661.261,724.114,148,342.609,352.409,346.13,104.583,132.787,87.43,1137.844,848.602,1095.798,616.282,519.604,496.288,827.458,888.46,678.442,612.769,108.591,89.487,94.329,1051.03,355.162,380.012,791.678,338.569,357.901,515.005,119,177,674,466,975,711,157.717,112.988
+8.1732,574.951,520.328,746.47,262.044,125,95,754,502,241,173,167,352,485.237,316.759,531.322,350.706,387.274,343.681,615.502,626.14,843.052,742.371,625.189,668.331,721.395,149.5,338.41,344.603,340.418,101.684,134.091,88.393,1129.373,840.706,1090.797,612.086,519.097,493.055,828.716,881.885,673.588,613.548,110.497,89.062,96.05,1016.096,350.508,368.103,780.349,337.705,356.088,505.7,119,180,682,470,984,721,156.308,115.835
+8.34,555.507,518.288,732.722,257.062,127,98,756,508,237,171,168,348,475.09,314.971,525.934,349.603,386.662,338.854,617.807,631.216,838.855,745.344,626.282,661.106,725.542,149.5,331.764,340.389,331.17,104.625,130.988,88.364,1120.005,839.948,1080.866,608.843,505.034,484,817.927,879.311,676.786,607.302,107.567,88.467,94.671,999.279,341.23,359.221,768.369,329.93,343.511,501.381,117,182,683,472,993,724,155.284,112.903
+8.5068,551.972,508.131,712.298,261.138,130,99,761,517,229,170,164,344,461.472,299.624,511.772,349.601,392.394,340.027,617.035,628.332,842.17,739.767,623.065,661.188,728.321,151,322.403,332.598,328.709,103.395,131.867,88.733,1102.981,828.052,1079.318,609.355,510.429,475.823,815.184,875.875,673.545,609.497,111.307,88.821,90.945,980.425,335.361,351.909,753.943,325.298,338.512,487.969,120,182,689,481,1010,736,152.567,110.368
+8.6736,536.992,498.805,701.402,263.063,133,100,765,520,229,169,163,346,458.788,298.765,508.101,349.335,388.234,339.307,621.577,633.281,829.324,748.132,624.585,666.742,726.108,151.5,321.074,327.465,321.696,104.102,134.615,89.172,1105.739,813.651,1062.129,599.878,507.809,478.258,804.847,861.466,672.399,603.053,110.027,88.906,92.964,954.288,328.713,344.568,736.786,317.92,335.765,486.354,121,182,697,478,1014,738,148.968,109.207
+8.8404,523.476,486.922,686.423,260.063,134,100,768,525,225,161,163,343,451.244,298.426,500.995,351.088,386.719,337.807,614.067,633.776,823.762,743.928,625.175,659.138,732.244,151,313.749,318.189,313.975,105.7,133.581,91.58,1090.84,806.403,1055.689,598.76,501.494,475.205,809.712,856.799,664.643,602.204,108.364,91.257,90.362,937.938,323.862,336.266,721.907,308.275,330.794,468.085,120,182,692,481,1037,753,147.232,106.771
+9.0072,516.754,475.667,673.185,262.851,137,105,779,538,222,163,164,344,444.532,290.294,493.516,348.638,382.41,334.249,618.533,637.665,803.79,743.207,626.381,667.351,729.007,152,305.307,319.207,307.272,106.138,133.51,88.294,1075.195,801.677,1042.278,590.895,495.312,467.427,799.884,844.95,669.228,604.144,105.563,88.793,91.67,916.864,314.951,328.713,702.403,303.828,317.877,468.524,123,181,701,482,1050,763,145.44,109.207
+9.174,505.363,467.596,655.311,260.119,140,102,775,536,241,159,162,342,439.93,282.997,485.072,344.116,382.78,336.266,618.072,636.18,799.778,748.443,624.85,657.907,731.876,152.5,300.089,302.507,303.299,105.163,132.816,88.336,1064.026,787.251,1027.909,583.556,491.497,462.111,798.965,845.727,666.822,605.277,109.274,88.51,91.884,894.559,305.136,324.329,686.067,299.806,315.243,461.57,124,181,708,489,1067,768,143.765,103.188
+9.3408,491.072,457.926,645.978,258.506,142,106,780,546,221,160,161,339,431.653,285.015,479.985,343.526,381.898,332.096,616.029,635.43,793.988,744.325,630.129,660.001,725.556,155,297.855,293.896,294.263,101.529,132.702,90.291,1054.1,776.084,1020.739,574.653,486.673,452.446,788.628,838.671,665.959,607.458,106.686,90.874,91.827,878.011,294.98,312.66,673.309,291.507,308.728,455.622,124,186,715,494,1074,779,142.552,105.157
+9.5076,479.987,443.465,628.143,262.242,141,106,781,555,214,161,161,343,426.703,274.825,469.958,340.565,378.783,331.259,611.411,638.513,776.036,748.755,631.095,663.777,726.919,153.5,292.496,299.34,289.809,103.409,133.326,88.577,1043.052,766.554,1012.924,574.71,476.998,452.311,784.938,825.507,656.377,605.319,109.331,91.611,92.922,858.493,296.734,307.37,660.014,284.284,298.928,448.087,124,183,719,496,1102,794,141.291,101.007
+9.6744,469.818,435.915,613.996,264.04,143,107,787,562,220,157,162,339,424.889,271.29,464.952,342.393,378.029,325.228,620.226,627.865,763.859,753.694,624.203,650.002,724.439,157.5,285.85,283.799,288.338,106.266,135.238,92.699,1022.442,747.982,997.939,574.852,477.015,444.106,779.847,820.996,652.627,605.249,106.544,89.458,91.585,838.479,285.561,292.534,648.105,279.554,293.263,435.653,126,189,732,503,1118,806,137.63,100.214
+9.8412,459.14,425.532,600.938,259.129,147,105,802,571,219,157,159,339,414.999,264.828,449.984,345.162,373.521,327.214,608.016,636.18,753.702,744.282,626.719,655.418,727.953,155,279.684,277.012,275.654,106.167,130.181,91.183,1019.336,739.623,984.643,564.569,468.673,440.136,774.417,817.178,655.372,604.286,106.928,89.317,92.552,822.242,282.859,291.02,637.144,272.656,291.493,427.028,124,186,732,510,1131,813,136.529,100.639
+10.008,452.142,417.215,588.31,258.35,147,108,804,577,216,155,160,334,408.272,262.246,448.439,335.977,369.78,323.032,608.646,642.981,741.611,742.442,624.118,651.772,724.976,157,271.61,273.335,267.623,106.52,132.646,90.872,997.71,730.056,975.298,560.146,465.335,429.579,762.468,812.045,660.935,607.061,106.942,89.515,92.467,810.517,273.638,285.844,628.135,268.252,281.692,415.287,125,189,737,507,1150,817,136.025,97.741
+10.1748,444.405,408.533,574.409,255.789,148,110,799,589,216,157,158,332,397.077,256.195,434.562,337.567,370.292,322.108,603.272,638.683,732.265,745.91,624.495,650.284,724.469,153.5,264.483,266.93,267.835,105.714,133.907,89.03,983.77,721.851,966.238,552.665,454.712,423.606,759.442,800.223,653.193,607.741,107.695,89.119,89.637,785.412,267.697,274.359,616.098,258.862,275.956,410.826,122,185,735,513,1161,835,134.344,96.227
+10.3416,430.78,395.806,565.726,255.251,152,110,810,593,213,159,157,326,397.514,253.592,430.892,336.218,364.049,314.464,611.847,630.778,713.587,749.533,624.712,645.626,722.586,155.5,259.534,260.496,264.13,101.783,129.997,91.368,970.76,712.229,946.443,546.507,453.245,416.311,752.372,799.997,646.725,609.696,107.852,88.736,89.836,774.408,264.176,268.885,598.065,256.823,268.932,400.048,126,185,740,512,1184,831,128.441,94.953
+10.5084,426.202,388.081,550.124,252.703,154,108,806,603,211,157,157,332,392.329,246.307,426.735,334.54,364.319,313.905,611.993,637.311,713.757,748.769,625.076,642.024,726.678,156.5,255.745,257.682,256.098,104.696,131.243,89.115,947.19,691.179,925.47,534.048,448.354,410.894,741.71,793.082,647.433,616.154,108.534,87.66,91.358,762.726,258.674,264.388,590.894,248.283,261.766,390.418,126,187,752,512,1198,842,127.573,92.858
+10.6752,413.945,384.905,541.177,253.736,148,111,812,612,217,155,157,324,387.797,242.418,417.484,324.789,352.714,309.224,607.978,633.437,701.31,746.405,623.439,646.178,720.04,157.5,251.135,250.145,248.363,106.662,132.844,89.894,936.137,691.575,924.94,529.511,440.419,402.478,736.605,792.39,644.659,619.199,107.809,85.805,92.012,746.758,252.366,258.674,585.944,244.7,255.067,383.96,127,188,749,519,1214,854,127.36,92.934
+10.842,401.525,373.061,526.737,252.335,155,111,826,621,215,158,153,324,379.487,237.735,412.434,322.702,350.068,305.15,598.756,631.754,685.719,741.055,621.72,643.41,719.583,156.5,245.083,244.616,244.673,104.639,129.657,88.634,920.611,669.062,901.49,524.221,432.396,397.616,736.464,776.524,641.219,612.995,106.06,88.283,92.353,736.744,251.008,255.562,572.083,234.361,253.58,369.542,125,188,755,516,1215,864,122.287,94.775
+11.0088,399.886,363.765,511.488,251.429,154,110,827,620,215,156,154,323,374.086,230.969,405.055,320.327,348.347,304.536,592.714,630.863,677.568,735.253,616.82,632.341,717.876,158.5,239.738,240.006,239.243,104.272,128.382,88.18,903.452,657.898,893.381,517.309,432.642,387.158,727.57,777.585,641.686,619.468,107.041,89.416,89.751,720.394,243.738,252.804,563.654,227.974,246.215,360.577,128,189,745,518,1231,869,125.768,90.456
+11.1756,389.789,356.633,504.943,250.17,152,109,827,627,215,157,154,325,368.086,230.435,396.98,317.921,345.965,299.011,588.615,629.619,667.041,738.734,621.762,634.103,708.04,156.5,237.956,235.962,232.3,102.264,130.124,86.92,884.347,646.873,875.182,514.686,420.8,382.966,719.015,771.278,641.418,619.029,107.511,86.088,92.41,707.792,240.103,250.06,556.115,225.566,238.227,352.448,126,187,745,520,1237,870,118.469,92.198
+11.3424,383.107,347.076,489.589,248.033,153,113,832,635,216,157,150,323,363.285,225.439,382.376,309.152,341.876,291.996,594.051,631.669,660.085,740.447,621.049,633.956,710.62,157,235.326,230.009,229.189,103.126,130.323,88.988,874.422,638.587,862.144,504.722,417.982,375.147,715.338,766.442,634.086,625.147,105.491,86.74,90.732,697.014,238.236,243.78,545.847,220.227,229.602,344.701,125,189,736,523,1256,874,119.237,89.776
+11.5092,375.034,342.335,481.673,247.594,153,114,841,641,217,156,153,320,358.598,222.485,380.53,306.462,330.641,282.825,586.129,627.356,650.127,738.366,615.29,622.463,711.014,157,226.106,223.024,224.749,99.874,127.844,90.447,850.864,619.9,847.574,496.971,404.304,363.427,700.42,754.168,638.177,621.111,105.207,87.731,88.77,694.186,238.476,242.408,537.417,213.556,226.048,343.016,126,188,728,520,1254,877,119.28,87.169
+11.676,365.127,331.676,466.166,244.084,155,112,838,642,216,158,152,315,355.799,216.666,372.03,300.779,326.63,283.34,577.592,618.476,650.341,729.379,611.134,625.402,705.345,155,222.331,219.064,221.298,103.126,128.92,88.988,830.929,612.521,831.654,493.06,401.175,358.616,703.842,749.94,635.148,626.591,105.747,86.131,89.737,680.268,233.455,238.123,531.76,210.696,218.91,332.309,125,185,725,526,1270,884,116.989,87.496
+11.8428,359.05,326.489,463.863,246.66,156,111,851,649,219,158,149,312,353.447,213.846,373.261,298.772,322.463,278.52,577.619,617.981,632.004,730.398,610.05,617.725,703.182,157.5,217.731,216.363,216.049,102.688,126.583,85.744,822.905,591.631,816.339,485.223,392.723,353.175,690.253,745.698,629.232,633.474,105.235,86.188,87.518,669.59,226.412,232.564,529.327,199.153,215.723,318.217,127,188,716,528,1278,890,113.541,85.966
+12.0096,349.587,321.144,451.212,240.546,154,112,844,656,220,161,146,309,345.026,211.221,366.47,288.191,313.744,273.524,570.65,611.462,633.398,731.176,607.259,616.196,707.551,154.5,214.761,209.662,216.59,102.151,125.195,87.968,798.537,579.057,791.727,473.874,389.182,345.706,685.742,733.014,628.453,627.328,106.885,87.858,90.121,660.227,224.531,227.586,521.208,198.544,208.939,316.319,124,185,718,529,1281,891,112.703,87.027
+12.1764,343.666,310.921,444.815,239.767,153,112,843,648,219,158,148,305,343.185,204.299,359.449,284.751,307.913,263.918,560.364,607.588,625.816,723.548,605.447,604.203,699.061,156,211.471,203.98,212.531,100.991,127.985,92.076,782.095,567.703,778.201,468.483,381.637,335.108,678.799,722.988,626.939,634.636,105.008,90.69,89.267,651.967,220.585,226.412,515.098,196.122,204.931,309.04,126,186,718,526,1278,889,114.386,86.164
+12.3432,336.031,307.124,434.478,238.366,155,107,848,654,222,158,145,300,343.543,203.034,350.651,278.984,301.328,257.74,556.61,605.721,620.894,723.321,597.782,602.544,689.377,154,206.889,202.933,203.595,99.69,124.586,87.529,759.493,550.635,767.046,461.714,373.593,331.806,670.598,714.603,623.91,627.781,106.003,87.561,88.684,645.418,214.333,224.955,507.022,191.024,199.451,300.812,122,186,713,527,1278,887,111.968,85.046
+12.51,329.19,304.301,425.225,237.446,151,111,846,658,220,157,145,299,337.694,201.517,349.85,276.155,297.716,255.095,545.422,602.554,610.481,720.264,598.677,596.085,689.246,152.5,208.445,197.771,205.037,101.189,127.475,89.059,747.885,546.466,750.304,450.094,369.123,324.602,667.869,709.003,625.297,635.174,105.477,84.956,89.239,632.052,213.287,219.354,501.832,185.741,194.975,297.328,123,182,717,531,1286,887,108.595,83.176
+12.6768,320.484,296.698,418.175,236.894,153,110,850,662,221,157,144,296,334.392,198.028,336.854,272.336,294.658,249.791,541.019,594.762,602.216,717.321,595.929,588.381,686.378,152.5,203.205,195.188,198.047,101.175,126.356,88.974,725.035,532.44,736.472,439.811,356.404,312.519,659.794,699.473,622.382,634.14,103.799,85.465,89.097,628.432,210.373,217.94,497.603,181.478,193.885,290.317,122,183,713,524,1279,885,109.579,84.097
+12.8436,312.757,287.612,405.626,230.172,153,108,850,658,221,156,143,293,333.281,195.812,334.159,259.74,284.077,242.32,531.162,593.999,593.624,714.094,587.616,587.613,683.454,151.5,199.672,193.301,193.175,97.513,125.379,83.931,718.53,523.842,723.507,436.426,349.241,310.188,654.562,700.066,613.522,640.485,104.567,85.281,86.708,621.544,209.397,212.212,489.371,177.909,185.189,281.48,120,183,711,531,1273,878,107.97,83.984
+13.0104,310.243,288.79,401.074,231.573,153,107,853,654,221,159,141,288,328.916,189.529,331.554,259.692,275.174,235.068,526.182,586.08,587.337,712.254,589.734,584.316,671.966,150.5,197.189,190.671,193.597,97.88,123.353,85.503,698.45,510.806,709.109,428.846,343.25,299.792,649.118,681.302,613.465,636.987,101.496,87.292,87.604,621.671,206.045,210.896,491.903,175.233,185.387,278.123,121,180,713,529,1276,871,105.595,84.168
+13.1772,303.503,278.743,393.293,223.76,153,107,840,659,222,158,142,282,327.16,189.671,323.064,251.073,269.243,228.073,518.72,574.754,589.428,705.956,585.789,576.27,665.751,151,193.995,189.255,190.558,99.309,123.622,85.744,680.401,505.847,693.764,417.681,334.394,290.605,640.097,686.576,610.663,639.876,103.117,86.343,87.632,611.954,204.235,214.63,494.109,170.573,182.045,271.24,120,182,708,528,1281,866,105.31,83.743
+13.344,300.441,280.351,384.143,223.534,148,105,849,660,220,156,135,275,321.907,187.734,319.761,245.718,261.549,219.354,511.032,566.227,578.944,694.477,577.995,569.262,663.225,150.5,189.991,187.828,191.009,97.428,124.047,84.356,668.165,495.499,685.481,411.025,328.297,282.951,633.196,678.064,599.256,641.236,103.6,85.112,85.187,609.097,203.358,210.373,481.125,170.403,181.195,263.635,120,181,710,526,1270,862,103.162,83.587
+13.5108,292.805,272.247,381.432,222.699,148,106,837,653,218,155,134,276,320.547,184.566,315.526,236.443,257.509,216.403,499.006,560.769,575.544,693.925,572.038,561.475,662.465,150,188.297,183.968,186.714,95.321,122.9,83.01,653.013,484.729,665.822,405.251,325.033,275.03,627.073,658.592,600.374,638.431,102.633,87.674,87.575,596.835,202.424,209.043,482.738,168.208,172.712,258.012,121,179,706,533,1271,853,105.332,82.029
+13.6776,291.784,263.34,368.2,218.198,149,105,837,648,219,154,138,269,317.075,182.142,311.158,229.41,248.72,211.08,492.71,555.169,554.561,692.171,575.478,553.272,658.063,147,183.104,178.317,186.909,95.109,121.285,84.639,645.064,474.67,650.646,397.798,317.494,270.154,618.702,653.276,594.981,649.294,102.989,85.451,85.826,596.764,199.115,205.904,480.277,162.77,171.494,256.03,117,177,704,527,1258,850,106.662,83.191
+13.8444,282.096,263.171,365.175,218.807,147,106,835,648,214,159,132,264,313.683,181.506,305.777,229.503,239.703,202,478.567,549.188,558.061,690.911,568.964,545.649,650.993,147,183.492,175.073,183.111,90.923,121.597,81.608,628.193,464.957,641.744,385.482,311.868,262.4,618.999,646.488,588.428,644.663,102.79,86.485,86.239,593.751,199.199,208.068,478.792,160.079,168.123,250.804,118,176,705,524,1250,840,100.378,83.46
+14.0112,285.337,258.903,361.276,216.075,145,103,829,647,218,157,133,262,317.972,177.273,302.157,222.296,233.957,195.494,473.064,538.611,551.716,676.163,567.26,538.742,642.448,146.5,179.837,176.39,182.326,94.289,117.404,82.783,611.691,457.299,626.197,378.086,299.979,255.957,606.23,641.157,581.125,643.176,101.083,86.839,85.67,592.903,196.144,204.22,470.899,157.402,164.993,249.614,116,177,698,523,1246,840,99.222,81.718
+14.178,277.002,255.333,357.968,211.504,144,102,822,638,215,152,132,259,318.291,176.258,299.828,216.899,227.074,192.383,460.983,528.189,548.444,669.243,557.011,532.778,637.638,144,181.846,174.434,178.552,90.556,116.143,80.97,604.045,446.237,612.297,371.601,298.364,249.317,603.529,633.281,581.522,642.255,103.814,85.253,84.262,595.845,194.094,205.295,470.503,154.739,162.685,242.859,116,172,697,516,1242,827,99.679,82.525
+14.3448,272.483,246.51,347.922,208.263,142,101,826,634,214,154,129,250,315.524,177.255,297.633,213.315,226.462,187.092,446.392,519.266,543.153,668.591,554.248,526.972,630.935,145,183.605,173.707,177.147,92.182,117.687,80.871,592.707,438.561,604.403,368.259,290.45,241.689,595.865,630.085,578.351,647.849,102.875,87.32,83.466,587.132,196.173,203.527,473.714,152.417,160.05,235.763,115,175,692,520,1235,820,100.876,84.309
+14.5116,269.817,249.307,344.99,202.248,141,99,813,627,213,153,126,250,315.838,172.709,293.322,202.892,217.146,185.741,437.306,506.441,534.802,671.663,543.174,519.143,621.082,142,175.969,173.099,176.097,89.877,115.888,79.284,577.88,433.353,596.173,362.726,281.763,234.28,587.72,616.708,573.355,641.505,102.576,87.377,85.115,581.885,194.193,204.956,471.649,151.496,156.283,233.186,114,170,695,518,1226,806,100.072,83.219
+14.6784,266.096,241.338,341.016,204.526,140,99,818,625,209,150,126,240,315.49,172.405,293.038,202.707,212.254,173.783,429.008,495.68,527.263,657.396,544.461,514.439,615.179,143.5,178.462,171.257,177.952,88.519,112.956,78.392,565.417,418.589,590.642,349.855,275.158,230.829,588.031,607.517,568.557,645.442,99.377,86.188,82.129,583.794,197.347,203.315,472.413,152.261,158.365,232.548,112,175,683,512,1212,805,99.137,84.041
+14.8452,261.242,239.81,339.673,198.723,137,98,811,617,211,154,127,237,315.313,173.525,287.04,196.901,204.901,169.568,418.189,491.014,518.713,649.598,539.875,503.854,609.936,140,175.65,172.444,177.22,88.618,114.741,80.928,560.484,417.132,576.874,348.376,275.909,227.016,575.8,600.164,560.122,634.65,101.283,84.814,83.836,587.599,193.811,200.557,470.051,145.307,154.895,227.691,111,169,681,508,1210,793,100.673,83.474
+15.012,257.737,235.53,332.451,195.581,138,98,801,618,207,149,126,230,316.623,169.973,284.912,189.228,198.316,165.212,407.685,484.495,510.833,641.559,532.269,492.529,603.143,135.5,174.816,169.059,172.908,87.544,112.984,75.318,546.013,412.092,568.229,340.411,267.214,220.62,570.61,591.991,562.472,639.848,101.254,86.527,83.978,586.213,198.605,202.396,467.392,146.469,151.921,225.991,109,162,675,509,1192,782,101.142,86.703
+15.1788,254.067,237.173,330.113,199.006,136,97,804,607,206,151,121,224,317.447,171.99,284.877,190.386,195.287,163.719,391.014,482.247,510.904,640.073,528.63,483.742,597.445,137.5,172.627,168.922,174.425,86.865,113.622,76.225,537.784,404.036,561.557,335.263,262.871,218.152,565.987,590.407,556.74,636.434,101.083,83.922,86.438,584.219,194.362,203.655,470.362,147.063,152.941,221.912,110,165,671,494,1178,774,91.701,83.126
+15.3456,254.351,233.119,328.053,192.737,134,97,789,599,206,148,119,220,312.495,173.291,284.687,185.07,189.541,161.125,380.543,471.952,500.377,629.713,517.97,477.914,590.187,135.5,176.677,173.614,173.873,86.045,109.839,76.876,527.256,401.311,554.015,329.46,260.361,210.905,560.472,588.866,550.88,633.404,99.363,83.073,84.376,582.564,192.227,205.267,469.16,145.959,152.148,222.195,108,163,659,494,1164,764,88.006,75.068
+15.5124,250.43,230.647,321.916,191.562,131,95,785,597,199,144,118,217,322.15,170.212,279.108,180.26,187.735,158.549,375.281,462.874,492.411,630.831,508.519,475.567,583.58,134,176.483,170.446,173.996,86.978,113.267,75.955,519.242,392.612,541.369,325.009,252.817,204.927,554.504,581.216,545.304,631.279,100.046,85.324,82.812,584.388,198.026,206.271,469.909,144.911,148.536,223.314,104,164,656,488,1162,753,89.345,72.745
+15.6792,248.668,229.765,318.379,189.312,130,93,769,588,200,146,116,208,316.898,169.517,279.265,176.98,181.847,151.846,361.395,458.038,488.428,619.579,508.649,461.343,577.543,132.5,177.994,168.81,176.691,85.734,109.344,72.91,513.155,392.4,534.693,316.361,249.586,198.886,548.311,573.778,542.304,618.859,101.055,84.927,82.229,584.459,195.918,204.305,470.121,146.369,146.808,218.726,104,161,648,479,1139,739,89.043,75.905
+15.846,248.285,227.555,313.407,184.882,130,93,767,579,197,140,116,201,326.879,172.809,280.701,174.355,174.906,150.023,356.007,444.789,477.503,604.888,500.163,457.222,563.115,130,178.741,172.47,176.378,85.833,112.545,73.094,512.387,378.714,526.693,313.588,245.436,197.72,539.586,565.124,536.458,622.47,98.723,84.814,81.746,591.573,198.266,209.114,470.871,145.307,144.528,219.689,102,158,630,474,1133,726,92.232,77.683
+16.0128,245.699,226.318,307.213,181.782,127,90,760,573,195,140,114,201,323.513,172.499,277.685,173.331,174.451,147.985,342.319,433.886,466.578,607.436,490.87,450.863,560.881,127.5,175.43,166.264,175.289,82.001,108.522,75.106,504.125,380.392,521.884,306.093,242.209,191.731,536.574,563.045,527.457,616.338,98.78,84.064,81.916,591.092,198.266,207.714,473.601,145.081,149.938,215.058,99,156,623,468,1113,714,93.435,79.646
+16.1796,242.499,220.486,309.74,182.391,127,90,754,572,190,138,112,192,326.635,173.408,280.024,168.137,172.303,144.472,331.264,422.97,461.599,601.987,483.012,439.953,552.139,125.5,177.13,172.5,174.075,81.845,104.23,73.491,497.96,376.782,521.705,306.548,237.645,193.288,531.809,559.242,516.757,612.854,97.187,83.667,79.015,595.406,201.236,211.264,475.468,144.344,148.14,218.372,98,153,614,461,1106,712,96.917,80.767
+16.3464,242.513,221.161,302.989,179.73,124,87,735,558,192,138,112,189,328.548,175.927,278.274,166.117,166.501,142.865,322.816,412.902,454.984,595.42,477.688,435.596,542.862,126,178.085,170.035,177.378,81.704,106.61,71.607,488.808,372.887,511.157,295.469,239.844,188.111,528.217,551.507,510.176,611.622,97.372,81.954,79.641,599.281,200.826,210.274,478.41,147.786,147.715,218.032,100,152,604,451,1082,688,95.297,82.324
+16.5132,238.275,219.684,303.214,179.277,121,86,733,554,186,138,106,182,334.226,171.845,276.7,164.087,164.851,137.362,313.496,405.167,443.319,586.079,473.169,426.22,537.948,122.5,181.394,170.449,176.289,82.227,107.403,70.233,482.582,373.084,517.417,295.511,235.213,183.773,522.052,545.624,508.138,605.404,98.254,83.158,78.361,603.737,200.798,212.325,482.441,143.438,145.279,214.477,96,149,591,437,1071,683,98.026,84.814
+16.68,239.965,215.892,301.594,176.673,119,84,724,547,183,136,106,178,334.855,170.753,281.398,161.577,160.513,133.05,301.009,391.267,436.804,584.805,466.062,417.85,526.074,118,179.966,169.837,175.71,78.522,105.986,70.7,482.634,368.695,509.725,289.595,230.584,181.182,516.679,537.536,499.66,598.309,94.742,83.724,79.982,605.25,201.83,211.434,486.033,146.072,146.893,215.553,92,144,580,435,1058,667,99.547,87.248
+16.8468,238.247,217.586,296.409,172.3,117,85,718,538,181,131,104,174,335.49,170.703,282.441,158.875,159.105,131.102,297.475,380.209,426.334,576.073,460.848,407.748,516.974,115.5,180.857,168.564,179.117,77.843,103.975,69.765,478.624,362.28,504.694,284.887,227.803,182.457,515.279,535.486,491.621,596.978,98.02,81.175,77.768,606.664,201.095,215.861,488.777,146.115,145.506,214.675,90,141,567,421,1039,655,99.092,87.828
+17.0136,237.845,216.083,294.503,173.106,115,80,709,528,177,130,103,168,340.995,177.057,283.95,159.427,158.041,132.852,288.901,377.268,426.448,562.259,448.722,401.153,513.981,113.5,182.85,170.771,179.202,79.837,102.204,67.329,476.755,366.4,506.312,285.373,227.058,177.812,509.623,526.973,488.295,591.27,93.903,82.52,79.129,615.448,204.178,219.722,498.069,145.265,148.211,213.939,88,139,557,416,1025,639,100.414,91.833
+17.1804,236.107,215.741,294.835,170.955,112,81,699,521,173,126,102,165,343.867,178.044,282.467,156.655,155.18,131.564,282.985,363.863,414.698,559.684,445.156,396.037,507.697,111,182.257,172.496,181.139,79.243,99.612,68.731,474.288,363.699,503.349,281.389,220.8,176.548,502.863,526.068,484.672,585.874,95.524,81.94,79.257,618.375,205.097,220.316,497.009,147.106,150.222,219.25,86,136,548,404,1008,635,101.593,91.21
+17.3472,236.419,215.786,293.087,166.907,109,79,691,511,192,125,99,161,345.551,178.75,283.136,155.891,152.433,127.787,271.71,357.047,407.3,554.178,439.599,388.123,497.136,107,184.136,173.108,180.346,75.864,102.02,68.179,472.055,366.777,500.179,278.6,218.564,175.006,498.89,521.387,478.544,585.407,94.713,81.317,78.987,630.935,209.27,222.678,502.85,150.123,152.473,219.788,81,133,535,396,986,617,104.166,90.191
+17.514,233.439,213.813,293.674,164.898,109,76,676,506,168,121,98,156,351.142,176.695,284.528,154.053,150.651,128.17,263.041,347.05,402.876,541.978,438.273,383.067,489.499,107.5,184.293,175.431,187.686,76.401,99.739,67.994,468.949,363.021,505.027,278.751,221.26,175.599,503.627,512.847,471.623,575.394,96.59,81.855,75.233,622.746,209.284,228.364,511.647,150.448,152.983,216.233,81,134,532,385,974,604,104.619,95.328
+17.6808,233.794,210.545,294.057,163.992,109,73,663,499,166,122,97,152,352.164,179.338,288.311,153.084,148.414,125.635,258.955,339.739,393.388,540.308,429.204,378.719,484.746,104,183.571,178.419,186.965,73.771,99.824,67.612,465.787,363.074,502.29,272.745,216.395,172.945,497.193,514.869,464.179,575.21,93.405,81.133,77.764,630.101,214.079,231.885,516.866,153.252,151.666,214.689,81,127,514,377,963,591,105.971,96.213
+17.8476,237.406,211.405,291.301,161.246,106,74,651,494,164,119,95,149,355.213,179.67,290.352,151.417,152.087,126.285,249.581,326.009,389.291,527.485,422.595,362.163,473.24,103,190.049,179.667,188.535,77.08,100.731,67.499,464.426,363.037,494.239,273.291,215.994,171.9,494.676,505.635,458.701,566.174,97.557,80.453,78.575,645.715,213.753,234.12,521.364,153.606,156.892,222.394,79,127,509,365,943,585,105.843,95.144
+18.0144,233.36,215.095,291.249,162.223,104,73,644,478,160,114,91,149,357.006,183.575,293.044,151.343,146.48,123.668,240.764,323.336,385.009,521.541,417.606,355.649,467.095,100,192.395,181.577,186.88,74.421,97.317,64.368,470.896,365.833,497.064,272.205,217.061,170.213,492.145,498.89,453.889,561.331,93.249,79.943,76.001,658.289,221.419,240.103,532.156,155.094,153.946,222.238,76,124,495,356,921,564,104.891,97.747
+18.1812,232.922,216.731,289.452,158.84,100,73,638,475,156,114,91,140,364.51,185.757,292.196,149.574,148.973,122.599,238.843,311.529,381.353,517.819,407.243,353.549,460.522,99,192.268,182.156,191.646,74.648,97.062,64.382,465.732,364.473,501.725,270.205,216.546,169.929,485.951,496.062,448.95,558.088,91.614,81.487,76.556,662.461,223.894,242.465,537.53,157.36,159.512,226.458,76,122,483,347,913,547,106.468,96.969
+18.348,231.801,209.83,287.744,157.156,98,71,623,468,152,110,90,137,367.626,187.857,296.526,150.805,146.452,123.724,233.267,307.683,370.926,512.073,402.967,346.783,450.25,95,195.648,183.231,192.692,74.902,95.348,64.481,469.845,373.456,502.011,264.77,214.807,174.969,480.677,492.103,442.029,550.086,92.154,79.476,75.916,668.784,226.129,240.994,540.642,160.928,159.88,229.348,71,119,466,333,881,539,107.762,98.61
+18.5148,237.62,212.537,293.739,154.467,97,70,614,462,149,106,90,134,372.751,186.968,298.071,149.319,146.826,125.831,224.086,305.293,363.998,505.081,393.703,339.717,449.688,93,198.971,187.025,193.993,72.526,97.841,63.646,465.922,373.418,503.821,266.352,211.704,171.29,481.073,487.507,433.82,552.366,92.993,81.26,75.546,680.197,225.478,248.787,550.656,160.759,160.079,228.087,70,116,450,327,867,531,111.684,99.247
+18.6816,236.29,212.947,286.288,151.707,93,67,598,454,145,102,89,131,371.953,191.083,299.699,151.711,144.362,124.276,219.227,294.758,360.314,498.599,389.46,332.224,443.22,90.5,198.603,189.03,197.896,74.577,93.252,63.688,466.166,375.726,499.041,267.599,211.476,168.882,474.681,488.822,432.943,541.291,91.116,78.046,77.025,692.531,228.279,251.036,558.024,161.254,165.262,231.557,67,114,442,321,848,515,112.054,101.384
+18.8484,238.468,213.103,283.545,149.98,91,69,592,440,141,106,87,129,381.628,192.741,302.585,151.544,143.442,122.698,218.646,284.054,346.772,489.314,380.929,325.799,435.044,89,206.239,188.394,202.251,74.04,94.838,62.569,471.762,375.816,513.804,269.48,212.667,165.974,465.617,488.808,423.389,532.963,89.922,78.414,76.769,694.087,232.847,256.807,561.334,169.129,165.517,234.531,66,112,430,313,836,497,111.727,102.756
+19.0152,239,216.505,286.613,149.216,92,66,585,439,141,101,87,126,395.142,196.556,300.839,147.733,145.67,124.63,211.616,285.581,347.355,488.961,380.022,318.544,420.06,88,206.766,192.934,206.13,71.013,91.892,61.903,476.291,371.266,507.743,267.67,211.278,169.137,467.979,486.149,412.251,526.944,92.41,79.873,75.048,702.912,237.953,257.896,576.821,169.653,171.437,233.256,66,110,418,305,821,492,111.755,106.591
+19.182,238.735,214.93,291.226,147.985,88,63,574,429,137,98,86,124,393.136,198.517,306.226,150.977,144.366,123.421,205.522,278.893,341.722,478.586,371.045,313.529,421.085,85,209.411,197.462,208.407,73.361,93.096,61.181,480.907,382.648,521.526,265.428,209.354,172.949,465.83,480.606,408.84,525.67,87.817,79.377,73.314,722.614,238.194,268.348,591.559,172.613,172.783,241.024,64,106,414,294,808,477,116.9,104.171
+19.3488,242.432,218.869,291.088,146.951,85,62,560,421,136,96,83,122,397.155,199.176,310.902,151.201,148.939,124.743,203.195,271.61,334.111,475.232,360.917,312.151,415.23,83,204.528,200.699,208.445,72.258,92.033,61.974,483.197,388.017,520.868,267.599,215.19,174.856,472.631,477.538,402.273,517.328,88.94,80.991,75.375,729.149,245.859,271.87,593.044,175.983,176.117,243.963,62,104,405,290,782,463,115.223,107.157
+19.5156,245.331,218.665,293.498,145.918,84,62,556,414,134,94,82,120,405.347,199.453,309.632,151.814,146.073,126.029,199.585,263.988,327.98,465.764,359.447,307.85,400.888,81.5,214.609,206.196,210.751,70.943,93.096,62.272,488.793,387.683,530.356,267.859,215.965,173.629,466.48,471.981,402.089,509.383,91.144,79.731,73.655,746.22,246.227,273.256,600.965,177.371,179.74,247.702,60,103,393,278,764,451,117.085,108.742
+19.6824,244.007,217.3,294.537,145.847,84,59,538,406,130,93,81,119,403.561,206.028,319.212,154.33,144.902,126.598,198.543,260.92,320.44,462.579,351.315,298.078,396.281,79.5,220.261,209.846,217.958,71.424,91.75,60.742,487.648,393.947,533.122,270.286,213.177,177.815,462.733,472.362,391.021,505.559,90.746,79.094,75.361,758.667,250.81,285.094,615.999,183.504,184.335,253.849,57,102,381,272,749,442,119.7,110.765
+19.8492,244.574,222.71,292.493,141.05,81,59,530,402,128,89,82,116,417.948,205.567,319.045,151.332,146.229,123.634,196.034,253.44,321.337,458.333,345.487,294.297,396.688,79,219.644,211.745,216.038,71.211,91.736,62.059,493.053,401.74,535.251,270.376,213.445,175.812,462.393,474.936,392.875,501.905,90.462,78.428,74.124,773.588,257.471,288.743,621.827,186.024,188.69,255.123,58,100,371,264,738,429,117.924,110.171
+20.016,248.005,219.119,296.826,142.918,80,59,520,400,124,90,82,112,416.617,211.848,327.895,153.947,147.049,127.49,192.697,251.149,309.572,451.71,343.681,288.064,388.987,76,227.204,212.466,217.897,70.476,91.552,59.665,500.079,400.63,540.269,271.907,216.962,179.527,461.616,474.172,385.219,492.09,88.457,78.088,71.024,780.533,259.749,295.659,640.355,189.494,190.387,260.222,56,96,364,259,716,417,120.98,110.199
+20.1828,252.802,222.592,300.763,139.974,81,59,514,386,123,86,78,112,427.033,210.952,333.476,152.225,146.727,126.837,187.995,246.949,304.01,445.723,337.411,282.924,381.115,74.5,228.406,216.441,226.27,71.056,88.818,60.062,513.317,404.248,538.866,272.466,216.687,181.95,459.466,476.873,377.562,491.056,87.831,75.781,73.513,802.908,265.491,301.232,637.37,192.058,194.629,263.437,54,95,356,249,705,406,123.055,114.543
+20.3496,253.543,225.436,302.236,137.936,78,56,502,383,120,88,76,111,430.112,213.933,337.422,153.126,146.196,129.457,185.726,244.772,302.332,449.006,327.919,285.504,374.017,74,228.929,219.353,227.869,69.302,87.486,57.668,510.534,417.438,557.887,277.394,220.335,182.741,463.044,473.805,377.562,482.616,92.794,76.871,72.887,809.117,267.895,305.928,658.006,197.17,201.714,269.328,53,95,344,242,689,392,124.346,115.831
+20.5164,250.309,226.587,303.47,137.809,77,56,497,372,117,86,77,109,436.288,220.692,341.606,157.64,147.608,128.765,183.734,240.19,295.56,438.477,330.679,278.152,372.304,71.5,235.141,226.856,231.495,70.787,88.945,59.778,523.559,424.587,560.075,276.135,221.26,182.347,463.765,477.594,370.443,477.234,88.229,77.791,70.64,827.405,277.202,312.024,675.855,203.133,202.506,274.186,51,92,342,239,674,383,127.191,119.314
+20.6832,252.088,230.322,302.713,138.488,76,55,488,370,115,82,77,105,443.81,221.461,340.566,157.331,151.911,130.647,184.773,239.426,294.806,435.193,324.52,275.448,367.758,71.5,239.474,226.345,237.788,67.591,89.696,59.042,526.908,424.412,566.174,281.005,222.419,188.106,457.812,470.199,363.762,478.381,87.419,77.154,71.494,845.049,278.002,314.173,677.329,206.503,208.685,280.12,53,90,332,233,665,374,128.114,120.599
+20.85,256.538,232.133,305.735,139.323,75,53,475,363,115,81,77,106,446.94,223.253,347.626,159.128,153.296,132.437,179.147,236.669,292.559,427.621,314.895,272.543,363.096,70,242.701,230.461,239.183,69.642,87.345,60.033,536.696,434.585,574.334,282.562,225.195,191.674,458.533,469.605,362.333,467.688,88.94,76.998,71.067,861.222,287.838,329.519,690.763,212.976,212.277,284.015,50,90,324,228,649,369,131.639,121.562
+21.0168,258.192,235.252,305.403,137.327,74,54,469,355,115,80,77,105,452.54,226.588,354.157,158.76,153.659,133.464,178.315,228.27,287.509,429.999,312.127,266.255,360.705,68.5,247.478,238.496,244.807,68.242,87.614,59.141,540.919,440.796,583.075,287.686,228.33,191.787,451.35,470.807,350.827,466.994,90.035,78.442,71.934,877.954,290.949,333.126,698.853,213.131,218.06,291.238,49,88,319,220,629,358,132.193,125.156
+21.1836,262.752,239.388,312.298,134.836,73,52,463,357,111,79,75,104,457.27,230.352,357.36,161.821,155.102,133.585,177.229,229.344,282.274,420.29,309.888,259.216,359.377,67,254.105,244.05,248.122,70.292,88.534,58.9,552.316,452.226,587.794,288.363,228.338,198.01,451.661,471.288,352.001,465.026,85.613,75.851,71.579,887.261,298.672,338.034,716.533,222.167,222.557,291.847,49,85,315,216,621,350,134.595,125.481
+21.3504,267.195,241.065,311.142,132.19,73,53,458,344,108,78,74,103,464.787,236.278,361.552,166.178,157.227,137.71,174.033,230.56,278.561,420.997,304.848,260.71,348.78,67.5,251.602,241.717,255.124,66.955,83.973,57.384,563.465,455.137,602.92,288.639,233.759,198.143,449.497,465.024,349.199,456.302,88.585,77.72,71.835,901.489,304.216,347.623,725.188,225.453,231.069,298.673,48,87,305,211,603,342,133.032,127.122
+21.5172,270.858,243.908,317.867,133.817,73,52,446,342,108,75,74,101,476.535,235.716,366.983,163.82,155.855,137.851,173.522,224.381,274.052,417.006,303.778,252.532,349.009,66.5,257.906,247.509,255.787,69.161,87.09,55.203,571.641,466.603,606.297,295.985,238.162,202.22,451.802,461.927,344.189,454.701,86.921,76.743,72.93,929.211,307.597,355.105,743.321,228.753,231.041,304.919,49,84,301,207,592,332,135.667,128.085
+21.684,272.741,246.878,321.462,131.482,68,52,446,336,106,75,73,100,478.503,240.239,375.866,166.107,161.933,139.905,175.143,223.9,269.556,412.01,293.291,252.083,340.254,65,265.122,251.152,258.749,66.856,86.183,57.88,574.855,474.475,614.732,295.917,238.125,204.768,450.911,453.23,340.948,450.509,88.045,76.772,70.911,947.287,312.448,360.522,755.781,235.976,240.133,318.43,46,84,294,204,581,331,140.067,130.793
+21.8508,278.672,247.627,324.729,131.553,71,51,432,335,104,74,73,99,485.394,243.126,382.19,171.347,159.396,143.252,172.173,218.428,269.073,412.392,291.869,251.583,338.232,64,264.74,256.38,267.388,64.565,86.055,57.002,588.129,483.004,630.731,301.573,245.098,211.859,450.614,454.899,335.98,447.79,86.822,76.163,68.977,954.698,323.409,368.711,774.55,243,246.553,319.69,46,82,290,198,574,320,141.076,133.688
+22.0176,280.629,251.084,329.162,130.322,71,50,429,328,103,74,72,100,496.828,246.132,385.799,172.817,165.558,143.755,169.595,223.151,263.937,407.184,289.751,245.478,332.564,64.5,270.376,259.277,274.267,66.814,87.245,57.838,597.885,491.362,635.446,306.536,248.841,211.987,447.8,461.008,332.895,452.733,86.637,75.497,69.361,972.505,325.898,373.308,776.742,250.62,248.589,331.587,46,83,287,194,563,314,141.105,133.886
+22.1844,286.147,256.384,332.04,132.968,70,50,421,329,102,73,73,99,494.436,254.208,390.806,172.693,167.913,145.86,171.676,213.719,262.387,403.702,286.268,244.983,337.482,63.5,273.448,266.721,272.444,68.44,84.596,56.549,615.434,500.444,649.75,310.303,253.394,219.329,450.105,458.533,327.177,454.46,87.646,75.299,68.749,998.614,330.283,381.328,789.174,251.512,254.005,332.975,45,82,280,192,548,304,145.042,137.622
+22.3512,287.85,257.46,341.437,128.51,68,50,419,323,102,72,72,100,493.982,256.165,398.753,176.116,167.022,147.69,172.198,216.307,255.046,402.811,284.964,242.055,331.006,61.5,281.509,271.601,280.674,67.676,86.82,56.96,627.222,506.596,651.947,311.341,256,221.118,460.371,457.671,326.823,454.73,84.447,75.441,68.707,1005.87,339.929,391.483,803.403,258.692,262.207,341.515,44,79,274,187,546,303,147.444,137.013
+22.518,290.97,261.207,341.741,128.991,67,50,412,318,100,72,72,98,506.72,255.703,405.138,180.504,172.15,150.878,171.15,216.533,257.564,396.923,281.544,239.587,327.511,62.5,283.361,271.557,283.163,67.832,84.554,57.427,632.265,517.668,672.706,321.579,257.301,222.83,465.434,453.98,323.44,449.093,87.817,73.43,71.565,1023.691,346.152,398.512,817.221,267.161,265.516,348.78,45,80,267,183,528,297,146.492,140.876
+22.6848,296.125,264.893,345.581,128.552,67,48,404,314,98,71,72,99,505.961,261.182,408.433,178.933,172.765,152.617,172.155,214.186,251.106,397.433,279.2,240.018,326.856,61.5,286.642,277.697,283.842,67.422,85.744,58.291,648.48,529.468,680.717,324.576,261.57,228.083,455.083,461.121,319.704,449.886,87.206,73.288,67.811,1044.864,348.401,404.919,830.036,268.578,272.034,358.24,45,78,273,183,528,286,150.869,142.843
+22.8516,300.178,266.842,353.62,128.284,66,49,405,311,98,71,73,98,516.302,265.79,415.02,182.687,176.402,153.982,171.122,212.305,249.114,393.993,276.537,236.273,322.334,61,292.609,281.035,290.191,70.391,85.574,56.166,667.716,544.048,695.542,326.001,269.73,236.693,454.249,458.024,311.608,441.969,85.229,74.506,69.318,1062.685,355.897,407.522,840.643,275.022,282.682,360.067,44,78,268,176,521,281,153.442,144.484
+23.0184,305.238,271.378,355.045,128.312,65,47,396,305,95,71,70,100,519.228,265.315,418.684,189.791,179.347,162.087,169.879,214.483,248.688,389.691,274.837,233.356,317.183,61.5,295.875,284.641,294.928,67.167,86.027,57.611,669.939,546.308,706.43,332.964,272.74,241.517,445.623,460.852,312.458,438.174,86.907,75.922,70.285,1080.279,364.016,417.592,853.981,277.769,286.288,364.628,45,78,263,179,516,277,154.181,145.998
+23.1852,306.758,277.838,365.913,129.855,65,49,394,302,96,67,71,100,522.325,268.997,427.024,189.817,183.327,163.763,172.215,211.612,248.474,389.238,268.942,232.506,318.629,62,298.421,291.911,296.724,69.359,84.738,56.775,682.644,558.51,715.099,338.77,274.133,245.581,444.492,466.494,308.523,434.605,84.888,74.195,67.555,1100.151,370.706,420.732,864.631,282.669,293.754,376.836,44,80,254,174,500,273,154.479,149.182
+23.352,313.747,277.133,365.885,129.6,65,48,393,296,97,68,71,98,525.92,270.216,433.117,194.25,189.156,165.952,171.216,217.749,244.178,390.979,267.459,234.7,316.73,60.5,303.044,297.625,296.384,70.547,86.112,57.739,706.527,565.924,729.672,342.446,279.275,254.314,444.393,462.846,305.395,438.858,83.665,73.912,69.745,1115.398,376.391,427.181,876.893,292.902,296.738,379.316,43,78,253,170,500,268,157.208,148.927
+23.5188,318.35,282.849,375.758,129.189,65,47,388,302,96,66,70,99,535.056,276.423,433.07,197.23,188.417,166.442,173.025,210.75,233.523,389.266,263.808,232.902,318.077,62,307.88,298.813,305.208,70.193,86.084,57.668,711.689,579.155,743.465,348.837,287.751,257.545,444.859,458.066,301.008,434.307,84.973,73.529,68.934,1130.631,376.731,433.843,886.653,295.874,307.194,389.645,46,78,249,172,492,263,160.889,153.753
+23.6856,322.728,286.88,376.696,126.288,66,48,385,297,95,67,73,99,543.21,279.337,440.804,198.935,194.743,173.37,171.231,212.39,231.105,389.323,265.391,229.255,310.881,59.5,312.561,304.338,309.28,68.511,86.367,58.121,724.002,588.41,763.231,356.434,293.818,262.482,452.453,468.587,296.903,435.214,86.48,76.998,69.873,1152.37,384.736,448.057,898.929,300.246,306.953,396.409,43,76,250,169,487,262,159.724,151.842
+23.8524,324.675,293.487,389.599,127.448,67,47,382,294,94,67,71,99,543.551,279.541,446.308,205.197,197.901,177.13,174.247,210.537,229.597,383.945,262.082,227.251,311.939,60,317.397,307.227,314.823,67.323,86.183,57.427,746.057,597.991,770.949,364.393,298.481,266.943,446.613,468.643,297.201,429.209,84.646,74.591,70.015,1174.618,394.326,451.353,914.233,302.638,315.91,405.252,44,76,245,166,479,259,161.699,156.866
+24.0192,331.69,297.038,392.479,124.972,66,47,380,291,93,69,73,98,547.811,286.103,454.357,206.721,200.742,177.715,174.161,215.996,229.185,382.091,256.313,229.976,313.062,61.5,321.682,314.261,315.997,68.468,85.715,56.35,755.657,602.393,782.787,369.882,301.558,275.138,451.392,472.758,299.026,427.977,86.267,75.568,69.46,1182.595,394.227,459.188,930.13,312.146,320.863,409.865,44,79,248,163,477,250,166.83,158.677
+24.186,336.207,297.504,396.387,126.373,65,45,375,289,94,66,70,102,554.775,286.528,461.826,213.446,206.419,182.687,175.312,212.701,226.453,387.158,257.924,231.514,318.162,61,323.875,318.331,322.716,69.345,85.517,56.846,769.294,616.044,795.881,374.076,310.117,281.77,446.853,476.619,291.483,433.103,86.153,73.912,66.105,1200.628,402.501,462.243,931.361,316.448,324.428,417.195,45,77,248,163,476,254,167.583,160.063
+24.3528,337.941,307.249,406.16,124.476,65,48,373,290,96,68,71,103,552.957,288.693,454.601,212.115,208.305,189.408,176.067,213.21,225.956,381.553,262.771,227.982,311.037,62.5,326.009,320.821,324.34,69.515,84.993,58.419,787.695,626.963,816.511,382.122,311.565,289.563,445.679,469.506,286.84,426.433,83.58,76.05,69.147,1222.565,404.495,467.576,938.475,318.924,325.362,422.402,45,80,244,162,476,250,167.868,160.969
+24.5196,349.968,307.195,411.183,126.458,64,48,369,286,94,65,73,101,559.224,291.469,466.774,218.946,212.305,193.842,180.766,210.495,225.913,384.567,257.203,228.469,311.939,62,330.039,324.125,328.313,68.044,85.276,57.115,800.209,630.117,826.738,388.821,321.202,299.914,448.833,472.419,290.704,420.683,84.49,74.591,68.308,1238.321,412.613,471.847,946.82,324.018,336.201,431.939,45,79,241,160,471,248,169.843,162.54
+24.6864,347.303,312.297,415.209,125.609,64,47,375,282,95,67,71,105,559.196,297.146,471.118,221.514,212.811,193.556,177.518,214.483,227.606,382.345,261.865,227.897,310.881,60,326.758,329.83,328.158,71.098,86.225,58.107,820.464,644.869,844.553,396.452,329.412,304.865,456.525,476.392,285.807,422.085,86.239,72.906,68.963,1245.138,414.961,478.834,958.149,331.857,343.092,439.283,44,76,243,161,464,247,169.687,163.218
+24.8532,354.288,315.015,416.215,125.467,66,48,373,285,92,68,73,106,560.314,298.908,473.415,227.012,222.301,202.645,179.076,212.616,226.852,383.591,257.698,232.392,313.537,61,332.952,338.034,336.161,71.848,86.155,57.682,833.193,659.926,847.842,399.94,333.234,310.502,458.59,480.974,284.576,423.459,87.718,75.37,66.773,1257.995,417.45,484.138,975.616,335.211,344.663,449.81,44,78,246,161,470,244,174.064,163.275
+25.02,358.025,317.708,428.362,129.345,66,50,369,282,93,68,72,107,565.71,303.612,473.827,233.377,224.824,204.145,183.977,215.642,227.919,384.086,256.2,231.829,312.453,63,338.622,337.765,341.21,72.484,86.027,59.254,845.444,660.599,869.835,409.019,340.085,314.661,453.824,480.408,283.882,422.666,85.656,73.274,67.91,1279.507,419.94,489.795,984.131,342.682,351.157,454.607,46,80,246,161,462,240,176.736,166.035
+25.1868,366.936,323.902,433.251,126.203,65,47,367,286,95,67,73,107,564.849,302.772,476.964,236.155,229.567,203.609,186.532,215.331,229.996,387.582,257.245,231.217,313.452,62.5,343.394,340.361,340.608,72.032,87.727,58.574,854.035,668.394,883.466,417.416,343.243,324.663,454.857,483.632,278.844,422.453,84.063,73.713,66.915,1292.802,422.924,492.044,988.841,347.026,352.105,455.272,45,80,240,161,463,240,176.04,167.761
+25.3536,370.598,327.592,439.479,128.977,64,47,365,286,94,67,73,108,569.098,303.492,486.382,243.018,234.021,210.996,186.324,217.028,231.034,385.176,258.437,236.454,312.637,64,342.892,344.78,343.613,71.579,88.35,58.815,869.497,679.233,893.133,421.713,353.225,326.071,458.42,483.887,278.434,425.852,84.092,75.129,68.223,1310.92,431.127,494.35,999.25,346.743,360.992,467.017,46,82,243,162,462,240,181.029,171.001
+25.5204,374.451,333.564,449.864,129.076,64,49,371,284,94,67,72,112,568.897,303.96,483.977,246.899,238.596,218.337,192.342,217.565,236.553,385.035,259.084,234.701,313.933,63.5,347.512,346.413,346.452,70.716,88.223,59.014,883.039,693.163,904.02,432.218,360.386,334.855,457.161,484.028,279.821,424.62,84.575,74.067,67.242,1313.961,434.663,501.535,1005.672,348.922,359.591,470.115,45,82,241,164,461,242,181.782,170.336
+25.6872,377.832,340.411,452.828,128.835,62,48,368,283,93,66,74,114,573.376,308.56,493.008,249.303,245.536,221.302,189.937,217.495,237.35,390.667,253.48,236.426,313.742,63.5,352.57,347.349,350.974,70.716,88.534,58.461,898.52,698.039,920.25,434.707,364.736,340.341,457.769,483.675,279.778,424.521,83.054,73.727,68.792,1329.293,445.893,508.394,1008.84,355.105,365.788,476.851,45,82,242,162,461,242,183.26,172.784
+25.854,380.844,345.78,470.458,128.68,63,49,365,283,95,67,73,115,581.927,314.884,497.547,258.041,253.939,232.937,192.029,224.141,234.633,389.62,258.674,240.876,314.386,64,353.323,350.86,350.141,70.999,90.22,58.39,909.146,705.74,929.424,444.745,370.139,350.405,461.149,488.723,280.372,425.994,85.585,72.807,68.891,1336.761,443.772,505.707,1010.608,357.893,369.213,481.69,47,81,246,165,464,241,183.345,174.949
+26.0208,384.855,348.008,471.393,126.882,64,48,364,280,95,70,74,116,578.603,312.671,502.04,256.395,253.852,230.9,194.774,223.547,239.527,391.941,260.703,237.84,318.812,65,356.439,358.585,350.585,71.876,91.141,59.438,921.513,715.271,942.307,447.97,375.608,354.836,465.518,492.216,269.545,424.663,85.187,73.742,65.251,1349.094,445.427,509.738,1019.476,358.445,374.448,481.704,47,83,246,165,460,241,184.383,170.548
+26.1876,391.126,350.62,472.514,130.548,66,49,365,285,96,68,74,118,583.093,316.836,503.328,267.084,262.826,237.076,197.27,222.967,237.948,392.097,257.754,240.678,319.463,66.5,362.333,358.558,353.224,73.191,88.591,59.353,934.035,721.971,957.879,458.381,385.116,361.22,464.585,497.476,275.207,422.991,84.902,72.736,68.394,1356.958,447.449,512.949,1024.03,359.945,378.679,487.421,48,85,243,165,465,240,183.715,172.218
+26.3544,390.05,357.311,485.147,130.463,63,49,365,286,96,67,76,121,583.524,317.256,503.905,270.41,264.557,242.083,199.525,227.025,237.137,399.089,257.842,245.138,322.367,65.5,359.196,358.005,360.936,73.078,87.557,59.07,949.333,723.196,974.752,467.972,390.817,367.237,472.179,488.115,279,429.478,86.566,73.812,67.427,1367.933,450.434,517.404,1028.203,364.982,378.014,496.689,49,82,247,166,466,242,184.497,174.312
+26.5212,402.515,358.515,482.6,129.288,64,49,369,288,98,71,75,124,589.678,315.753,504.895,274.923,273.931,245.383,201.687,231.536,241.874,399.329,261.432,245.167,324.668,68,364.751,364.673,359.325,74.209,88.279,60.473,962.945,741.305,985.859,478.686,396.356,374.403,472.801,502.439,272.815,431.716,84.959,76.29,67.1,1378.584,451.735,520.53,1025.345,371.151,383.603,502.165,50,86,250,172,471,243,185.861,170.464
+26.688,399.423,363.753,499.51,130.138,68,50,373,287,97,70,74,125,590.315,321.12,513.325,280.729,279.896,251.539,205.334,233.275,247.208,398.353,263.21,249.593,329.675,69.5,365.095,361.642,357.66,74.605,88.067,60.728,984.056,750.369,990.454,482.728,396.615,386.093,473.282,503.118,275.532,438.499,83.85,75.639,67.74,1385.868,453.446,517.022,1042.813,372.312,384.098,503.934,52,87,253,171,465,245,187.439,176.18
+26.8548,405.606,366.342,494.268,130.024,66,49,371,294,98,69,75,127,586.449,318.72,511.414,287.978,282.946,262.265,207.918,238.521,243.709,397.362,265.208,251.328,328.458,68.5,366.582,367.027,363.353,74.987,90.149,61.209,992.142,748.805,997.868,489.151,406.803,391.285,481.398,507.304,271.102,433.727,85.826,73.841,67.996,1388.187,459.033,528.549,1042.714,377.49,386.872,501.5,50,87,250,171,470,241,186.415,174.369
+27.0216,411.875,370.317,502.753,134.383,68,48,376,291,100,71,77,131,591.327,323.489,515.221,291.389,293.316,263.473,211.417,237.857,246.682,404.566,267.431,255.406,326.332,71,368.751,370.444,370.065,73.827,92.246,60.175,1005.997,767.919,1009.16,497.342,416.375,393.114,479.744,512.012,271.555,436.092,84.319,74.11,66.46,1397.494,461.282,526.442,1050.96,377.501,386.079,512.159,53,89,254,176,472,248,185.818,176.534
+27.1884,412.186,374.097,512.415,134.001,69,47,374,294,100,70,77,134,594.179,321.35,519.851,296.171,296.326,265.539,213.864,240.388,248.033,402.315,267.429,259.344,331.952,70,365.317,374.434,370.475,75.128,91.665,61.577,1018.879,766.973,1033.745,504.607,414.745,395.85,482.487,506.54,271.47,440.992,84.888,75.143,67.484,1402.076,460.674,529.27,1046.858,374.57,390.084,510.048,50,90,256,175,480,247,190.892,179.392
+27.3552,419.947,374.109,518.072,135.926,69,52,379,300,98,71,77,137,597.163,325.243,520.102,303.577,304.66,275.591,216.587,247.402,253.354,403.688,265.221,261.417,336.345,71.5,370.264,373.167,369.287,76.514,92.161,61.988,1025.934,773.187,1037.813,516.547,429.317,402.089,486.814,513.172,273.678,441.403,86.338,75.455,68.38,1394.792,464.422,528.86,1054.411,376.807,390.262,515.345,53,90,259,182,481,249,189.045,178.515
+27.522,421.197,379.869,521.696,136.025,71,52,383,300,100,73,79,139,594.838,319.617,525.319,305.102,308.028,282.578,220.379,246.525,256.981,404.622,271.276,266.652,342.022,73,372.106,375.745,371.596,78.225,92.841,61.733,1045.26,774.449,1040.804,513.266,431.336,406.013,485.867,512.521,273.508,449.518,85.841,72.623,68.294,1411.326,465.058,526.611,1053.477,383.492,396.394,523.347,54,92,268,184,476,248,191.29,178.727
+27.6888,421.441,385.044,527.867,137.285,70,51,389,302,101,74,79,144,600.919,323.587,525.82,312.411,319.8,288.529,224.114,251.87,258.29,408.09,273.209,266.863,342.662,74.5,373.394,371.69,371.822,77.589,90.73,62.286,1043.738,775.685,1053.137,525.745,437.099,411.461,486.998,512.493,274.513,455.622,87.732,73.869,68.536,1414.494,464.818,531.604,1048.994,383.733,395.672,522.766,56,93,266,189,487,252,189.983,176.214
+27.8556,424.497,388.343,534.679,136.138,72,50,390,305,102,73,80,147,603.859,325.428,527.751,317.108,323.001,290.445,226.112,254.316,260.253,411.444,278.461,269.682,343.578,76,375.42,374.629,372.587,76.684,93.606,62.158,1057.452,790.361,1070.357,525.765,441.783,417.041,492.159,518.998,275.037,454.871,86.936,76.135,68.465,1418.837,464.195,524.094,1060.351,379.272,395.644,528.884,56,96,268,192,488,258,190.523,179.831
+28.0224,427.015,390.377,541.206,139.974,74,52,390,305,101,73,82,149,593.817,326.669,527.737,322.957,328.884,297.674,231.614,260.34,262.116,417.204,279.355,275.49,346.188,76,376.443,376.532,371.08,79.229,95.617,64.921,1065.608,795.021,1071.76,540.387,444.98,421.681,487.38,528.034,274.81,455.055,89.339,74.166,68.038,1412.712,466.444,526.017,1058.951,387.288,400.119,526.179,56,96,273,197,497,258,187.154,178.628
+28.1892,432.697,390.505,536.446,138.997,72,53,397,315,103,76,84,150,597.762,332.012,531.387,327.597,336.552,306.221,237.236,258.46,266.74,422.017,281.714,279.015,351.654,76.5,373.238,376.787,372.05,77.447,93.407,65.246,1074.024,800.086,1076.973,545.97,448.536,425.178,489.218,529.872,276.24,458.483,86.353,75.016,69.261,1417.96,467.18,526.074,1054.213,380.376,398.476,529.408,57,96,276,199,507,262,191.035,180.142
+28.356,435.098,392.514,551.133,144.022,74,54,400,313,104,76,83,158,599.742,324.035,528.538,337.778,344.777,308.065,237.821,265.883,270.893,424.295,287.145,282.902,358.311,77.5,378.498,378.091,370.961,78.197,96.694,64.113,1085.617,802.739,1083.414,551.234,454.279,427.726,494.492,524.555,277.768,468.326,85.613,74.237,69.787,1410.407,465.935,524.532,1053.689,384.441,393.349,529.961,58,97,281,204,511,263,192.57,181.699
+28.5228,430.24,397.201,558.338,140.752,76,52,405,319,106,77,85,160,597.226,327.871,535.98,342.438,347.998,315.563,245.046,267.425,271.761,428.074,289.648,284.638,367.339,79.5,376.985,378.103,372.771,78.126,94.654,63.575,1095.353,804.918,1093.23,552.085,455.769,432.123,498.89,531.795,273.664,468.113,85.329,75.781,67.853,1408.087,465.369,523.726,1050.182,380.306,395.842,526.477,58,101,288,207,517,269,190.509,181.925
+28.6896,434.762,395.686,563.119,143.272,76,53,407,324,106,78,84,165,608.235,329.259,531.386,350.675,352.638,315.355,248.786,275.683,273.127,427.805,289.765,294.74,366.483,81,372.149,381.384,370.947,77.603,97.714,65.43,1094.819,813.58,1104.513,560.645,461.919,438.598,494.577,529.193,273.041,471.073,87.575,77.579,69.247,1407.635,463.432,519.723,1050.493,381.835,397.556,532.453,61,101,289,211,516,271,190.523,178.331
+28.8564,439.128,397.985,564.369,140.767,79,55,413,328,110,79,85,167,599.173,329.932,533.033,350.206,360.582,327.073,257.65,279.387,279.045,442.34,296.791,298.291,372.884,81,374.228,378.966,372.319,80.134,96.368,65.473,1106.147,807.817,1110.445,568.323,466.018,438.913,503.57,533.916,277.471,485.349,83.878,75.894,68.607,1400.676,467.307,521.251,1046.321,379.782,394.482,526.165,60,102,290,219,521,272,190.395,179.703
+29.0232,441.861,399.496,565.911,145.465,77,56,419,331,106,78,86,173,597.123,329.021,531.169,357.554,367.835,335.046,258.671,282.074,281.022,455.842,298.206,302.349,371.836,84,373.167,378.244,375.43,79.088,96.878,66.436,1110.718,814.198,1115.857,571.89,470.254,442.279,507.77,539.544,277.768,482.771,89.083,75.214,68.849,1395.33,460.872,518.648,1046.448,381.75,394.242,530.244,63,105,300,226,526,275,188.149,182.604
+29.19,439.915,397.937,565.585,148.565,81,57,420,332,108,82,90,175,600.218,326.912,532.94,362.836,374.204,339.462,261.932,288.692,285.332,468.311,304.853,305.004,376.901,85,372.22,381.087,371.385,79.894,100.561,68.207,1115.506,822.819,1118.18,568.92,473.309,441.706,514.459,533.873,282.906,492.6,88.485,74.166,68.323,1397.027,462.88,515.905,1034.553,372.488,393.647,535.187,63,107,302,228,536,279,188.263,177.694
+29.3568,441.17,398.102,574.454,151.608,79,58,428,338,112,80,88,182,601,333.267,531.329,366.19,381.013,341.671,266.043,288.466,291.805,474.241,307.949,315.121,388.492,86,370.749,378.711,370.565,82.382,98.082,66.309,1127.601,822.501,1125.148,585.125,476.817,444.614,519.054,541.934,282.821,496.254,88.016,75.455,67.029,1379.673,460.122,511.803,1030.847,373.338,390.743,532.765,63,109,311,235,542,288,187.808,178.216
+29.5236,447.673,400.753,575.972,147.249,81,59,433,343,113,83,90,184,599.711,323.739,534.615,376.345,381.541,353.778,273.354,297.699,295.375,478.431,309.888,318.373,391.242,87,370.551,375.331,370.014,79.823,99.598,66.833,1119.894,823.25,1128.252,585.94,478.32,455.455,521.656,549.244,281.066,501.65,86.907,73.926,69.176,1377.792,456.699,512.015,1032.078,375.349,389.568,530.442,64,110,319,240,551,286,190.082,176.124
+29.6904,447.032,406.144,580.551,150.787,83,57,432,347,114,83,91,189,593.322,331.592,530.371,380.884,390.268,354.256,275.758,301.786,301.663,478.983,315.3,316.804,403.688,88.5,368.501,380.32,370.82,82.524,98.946,67.654,1129.281,823.455,1129.619,596.739,480.715,451.565,526.45,551.563,284.505,511.861,86.879,76.205,68.294,1368.414,457.081,506.994,1019.476,372.644,390.432,535.371,66,111,325,248,559,289,184.298,176.76
+29.8572,442.812,402.012,578.682,151.877,83,58,441,351,115,86,93,193,592.323,326.588,534.865,384.439,393.556,355.338,283.042,303.469,302.872,477.949,316.507,327.55,397.678,89.5,369.194,373.578,364.64,82.283,101.028,66.465,1135.513,819.737,1136.439,585.841,485.823,451.841,523.296,551.973,283.642,521.69,89.566,75.639,68.038,1373.365,456.006,503.402,1017.1,373.55,389.568,530.003,67,112,328,254,563,293,188.888,181.401
+30.024,445.142,399.842,581.168,156.377,86,60,450,360,114,86,93,200,588.405,328.085,527.329,388.868,399.451,363.769,287.618,313.07,306.087,479.988,322.608,329.251,410.401,90,368.556,377.99,368.273,82.184,99.371,67.031,1133.736,821.722,1143.37,605.581,485.747,450.758,520.496,556.915,285.269,528.559,88.457,76.899,68.636,1359.235,454.224,500.488,1009.094,371.312,385.39,523.177,68,112,332,264,574,302,185.378,174.992
+30.1908,446.293,400.62,581.58,155.599,87,62,458,360,117,87,95,200,593.396,327.136,533.985,389.896,405.983,368.067,292.686,315.936,310.027,479.436,326.874,336.416,410.76,92.5,367.108,372.63,365.751,83.655,101.921,68.887,1137.785,821.867,1143.636,600.387,493.991,455.81,526.119,558.414,293.676,541.248,90.192,73.529,71.295,1351.244,451.89,494.335,999.434,370.647,384.639,519.65,70,115,342,270,579,302,186.813,175.982
+30.3576,441.798,404.17,581.679,153.448,86,62,464,368,118,89,96,205,587.276,324.403,530.994,397.701,407.242,373.409,296.366,326.304,316.742,480.157,334.433,345.855,418.035,92.5,370.523,375.048,368.6,82.665,104.046,68.079,1143.152,825.701,1151.128,606.917,488.398,455.302,523.205,558.684,294.865,547.027,89.637,77.919,68.849,1337.426,441.679,497.942,989.802,367.021,383.421,527.256,69,116,350,275,594,311,184.951,177.142
+30.5244,443.508,397.055,589.663,152.047,89,62,467,371,118,92,96,210,588.086,322.881,529.841,397.862,413.278,374.658,302.338,330.156,315.348,477.228,344.37,352.122,423.561,96,365.432,370.248,365.531,84.447,103.422,69.85,1139.876,819.791,1149.535,608.349,490.296,455.739,525.743,562.819,298.913,559.475,89.139,76.885,68.963,1332.065,440.392,489.527,994.498,364.274,379.413,520.614,73,119,355,286,595,315,185.52,175.034
+30.6912,441.164,399.32,585.188,156.236,91,64,473,375,118,90,100,213,585.911,325.524,527.2,405.289,419.012,384.309,308.355,335.172,321.877,476.633,342.279,354.539,426.362,97,361.671,373.767,360.144,85.578,105.717,70.658,1154.363,829.457,1155.067,614.295,490.708,452.598,530.664,563.427,302.197,568.709,88.514,74.563,70.029,1305.97,438.044,485.227,978.912,359.388,380.589,521.647,72,122,364,288,602,319,184.596,175.275
+30.858,439.389,402.614,588.427,158.161,91,62,480,384,121,91,100,220,586.589,321.675,530.42,413.455,425.535,384.595,310.971,335.75,325.448,475.954,346.746,361.512,438.086,98.5,357.924,368.146,362.364,85.79,105.788,69.269,1149.522,828.35,1157.297,615.758,493.311,451.104,532.064,560.839,303.895,570.097,90.078,78.754,70.584,1307.045,436.87,480.644,973.155,354.034,375.065,514,73,124,375,297,613,321,181.611,172.699
+31.0248,440.417,405.691,583.41,158.826,89,64,482,389,122,93,101,222,574.514,321.798,530.792,411.305,425.552,391.968,316.674,344.701,328.748,480.752,350.069,365.218,437.281,99,357.98,369.956,358.814,85.465,104.032,70.346,1142.391,827.895,1161.352,613.741,491.942,453.802,531.668,570.724,310.703,584.826,90.149,75.299,72.503,1298.799,433.942,472.979,976.62,356.385,370.562,512.088,76,122,373,304,625,325,183.516,171.638
+31.1916,440.359,401.115,587.24,163.808,93,66,495,393,123,95,101,226,584.408,318.892,525.059,415.765,433.526,392.759,321.78,351.131,332.034,473.944,357.184,372.856,447.209,100,355.657,366.581,352.729,84.928,105.986,70.884,1143.387,822.104,1152.309,619.241,495.647,445.519,527.906,565.435,312.925,590.066,89.395,77.904,69.873,1282.746,430.944,470.079,962.137,352.561,367.843,508.094,74,126,385,308,624,324,180.389,174.242
+31.3584,441.831,398.144,580.029,161.218,95,66,498,396,125,96,104,232,578.648,321.621,522.006,420.974,435.389,397.446,330.712,353.85,334.666,481.021,359.529,375.684,458.582,102.5,349.532,359.762,352.132,88.067,105.703,70.119,1154.368,821.865,1162.919,622.825,489.447,456.166,526.308,569.267,315.84,593.72,89.211,78.867,70.811,1271.36,428.327,462.201,949.861,347.576,363.197,503.519,76,129,391,320,635,333,179.835,171.695
+31.5252,437.67,397.522,578.675,163.426,95,66,505,402,126,98,108,234,574.968,320.223,524.788,425.659,439.796,398.741,331.892,360.167,341.906,483.653,365.868,381.41,457.618,101,349.694,359.857,348.138,84.815,105.023,72.131,1148.179,819.448,1157.259,616.141,496.27,450.366,525.531,574.061,320.171,610.305,88.045,76.531,72.233,1257.542,426.898,457.647,946.254,345.551,362.872,499.752,75,127,402,328,641,338,175.642,169.77
+31.692,429.329,395.699,580.391,169.299,96,65,511,404,128,97,108,240,572.492,316.732,524.439,426.438,444.019,402.019,339.922,364.174,347.71,486.215,371.426,388.215,466.159,102.5,352.457,353.623,348.374,86.37,106.355,75.7,1148.86,811.224,1155.362,620.876,488.115,449.091,529.646,574.344,323.044,616.621,88.258,77.805,71.735,1247.274,419.204,460.702,938.079,342.237,355.295,498.152,76,129,405,336,650,346,180.119,170.124
+31.8588,434.544,394.409,572.545,167.898,95,68,522,414,129,102,110,242,570.58,319.889,519.012,429.892,447.202,401.721,342.715,371.95,348.976,490.418,378.4,392.301,468.806,103,343.253,350.563,349.236,85.79,109.485,72.797,1148.074,810.4,1156.304,624.744,490.297,442.548,529.165,574.372,323.794,623.476,89.154,76.658,70.754,1238.349,415.753,446.445,922.804,336.048,352.405,494.923,77,129,415,342,662,351,175.614,168.935
+32.0256,430.652,393.009,580.955,168.591,99,70,526,416,130,102,111,248,572.005,314.245,518.146,434.179,445.057,401.661,343.469,376.708,355.947,490.319,379.527,399.969,474.713,105,345.024,353.936,345.194,89.594,109.074,72.853,1136.314,801.892,1151.369,623.55,488.102,442.414,534.75,577.483,323.2,631.817,89.452,76.984,71.437,1221.844,406.121,448.708,912.564,334.277,349.516,490.051,77,133,419,346,663,356,176.143,167.223
+32.1924,426.532,388.114,577.091,170.828,99,70,537,429,131,98,111,248,567.791,315.07,517.719,435.583,447.998,402.542,357.435,384.172,356.487,499.561,385.061,405.614,481.253,106.5,346.011,350.478,337.949,88.307,110.222,72.853,1138.745,803.171,1153.53,616.669,489.206,443.015,526.365,577.186,325.974,640.159,90.86,76.531,69.816,1211.745,407.083,438.737,911.333,334.802,344.999,483.621,80,133,430,355,678,361,173.226,166.237
+32.3592,427.462,382.512,577.378,171.847,100,71,538,428,134,104,113,256,565.937,313.892,517.625,439.745,448.329,409.507,356.042,393.604,366.403,502.448,389.256,411.157,490.221,107,340.983,349.072,342.467,88.449,112.276,73.887,1143.463,793.811,1156.648,623.886,483.621,439.377,527.185,581.004,331.932,650.314,89.907,80.099,70.285,1200.925,401.242,437.775,901.206,327.395,345.395,483.876,78,136,439,360,678,367,170.994,162.879
+32.526,422.298,383.46,569.292,173.871,103,71,546,434,139,107,113,256,568.051,311.913,516.352,435.539,455.196,411.825,360.621,395.842,370.414,505.463,398.342,411.775,496.16,108.5,337.228,343.103,337.595,86.073,112.517,72.981,1140.952,793.156,1148.541,618.047,489.263,434.731,532.318,582.008,328.479,657.253,90.547,77.437,71.152,1176.782,396.928,427.648,898.859,320.087,339.702,474.939,80,137,450,369,688,368,169.644,164.266
+32.6928,417.814,378.65,574.013,173.913,102,71,552,438,138,107,114,259,561.692,306.464,510.441,441.624,455.11,415.389,362.43,405.436,370.315,508.478,401.79,418.78,499.724,110.5,332.773,342.208,339.443,87.346,110.845,73.207,1137.715,795.165,1152.829,616.653,482.605,430.025,530.451,576.154,334.593,662.168,92.367,77.31,70.626,1167.376,394.255,421.538,879.736,317.268,336.374,468.368,82,139,451,377,693,371,167.825,162.95
+32.8596,416.9,379.008,562.373,176.418,101,75,561,450,139,110,116,265,565.051,313.787,509.933,444.303,461.851,406.761,369.439,405.656,370.841,507.345,405.046,423.289,507.602,110,333.988,337.701,336.136,86.695,113.126,72.641,1137.089,791.205,1137.259,620.071,479.474,427.174,523.919,588.739,335.754,666.416,90.604,78.258,72.475,1158.098,394,418.822,876.144,311.037,329.93,465.691,81,139,458,384,710,380,165.849,161.917
+33.0264,414.517,376.787,560.341,176.362,104,72,562,458,141,110,116,270,557.823,308.296,505.689,442.661,465.928,407.61,376.337,408.645,378.494,510.884,406.053,430.76,517.894,110.5,327.932,336.221,332.414,91.263,113.395,74.369,1131.125,782.041,1139.888,618.333,477.236,427.868,528.783,581.654,339.433,677.392,88.585,77.933,71.508,1147.151,386.773,416.616,868.577,311.079,329.023,457.491,82,139,465,393,721,378,166.546,158.691
+33.1932,409.157,374.59,552.315,176.461,105,74,574,461,140,112,116,271,554.115,303.945,508.423,449.13,468.768,414.943,378.513,411.902,382.733,511.69,415.909,433.5,522.184,111.5,324.017,331.352,328.062,88.35,113.267,74.171,1131.075,783.417,1141.806,620.821,475.706,418.846,527.539,591.312,341.641,689.062,91.67,78.556,72.29,1135.68,380.663,410.195,863.33,310.102,324.463,458.823,82,141,475,400,721,385,163.661,156.116
+33.36,404.121,365.055,554.93,179.32,106,73,578,466,142,111,119,272,553.886,302.155,500.243,448.95,468.32,417.198,381.599,421.334,389.49,517.224,420.244,437.987,526.42,112,325.27,333.319,324.463,87.742,114.061,73.094,1123.556,777.158,1135.707,615.06,471.499,416.78,527.128,590.096,341.047,694.09,92.851,77.819,72.745,1124.875,376.137,405.641,842.326,303.262,320.058,454.432,83,141,478,405,723,392,160.591,159.271
+33.5268,401.541,360.61,548.391,180.891,105,76,589,471,143,115,116,277,548.585,298.725,494.64,449.725,466.165,412.197,381.997,428.911,392.022,514.549,424.72,444.15,529.185,111,322.749,327.7,320.228,89.933,112.332,74.511,1122.927,769.644,1136.654,618.003,475.494,413.426,523.254,592.429,346.453,699.882,92.524,77.055,71.735,1108.878,374.963,399.375,835.113,302.539,316.801,442.621,81,141,486,409,732,393,160.761,157.573
+33.6936,395.968,356.379,545.297,180.99,108,75,590,477,145,114,121,277,548.499,301.845,501.03,449.007,462.645,408.583,390.428,424.949,398.723,525.759,430.427,448.482,537.254,112,315.9,325.917,319.362,87.925,111.922,75.7,1116.836,770.264,1125.263,608.556,468.801,411.03,518.446,589.785,347.246,703.324,91.77,78.358,71.465,1100.038,370.677,396.164,831.747,293.249,310.428,434.463,83,141,493,410,740,404,157.165,153.767
+33.8604,394.238,357.567,537.616,180.508,109,76,598,488,145,115,120,281,547.638,295.363,492.901,454.571,468.604,409.539,388.725,433.882,399.661,522.093,435.866,444.788,541.901,114.5,315.342,321.256,312.184,89.424,115.69,72.754,1115.459,765.914,1127.08,610.369,467.199,409.312,519.903,586.448,347.67,709.385,92.438,77.239,71.494,1087.479,367.849,388.597,825.283,291.054,308.969,437.607,83,146,507,422,745,403,159.269,151.941
+34.0272,386.868,348.604,536.475,183.721,107,76,605,489,147,115,122,282,540.763,296.775,491.327,445.817,466.323,408.08,389.564,435.624,401.24,527.386,438.641,458.198,546.333,115,315.417,317.524,312.42,88.208,112.531,74.511,1107.516,757.764,1112.575,608.053,463.484,406.322,521.204,581.244,350.204,722.174,93.675,78.428,71.067,1075.57,358.839,389.587,814.18,284.85,304.777,423.912,84,146,509,429,749,407,154.749,150.243
+34.194,386.328,345.398,533.108,181.726,108,76,615,499,150,119,119,285,540.785,297.457,485.008,452.305,463.639,407.57,396.504,443.046,403.972,523.905,442.145,462.278,549.807,114,309.118,314.569,311.255,88.166,116.058,72.726,1105.224,762.867,1109.616,599.422,458.091,398.915,521.006,580.523,355.893,727.301,90.405,81.104,72.247,1053.958,358.811,381.455,806.43,283.746,295.203,425.994,84,144,510,432,754,409,153.527,152.451
+34.3608,381.455,342.406,526.346,185.264,108,78,621,506,150,119,125,283,539.104,289.37,482.611,448.098,468.882,407.924,399.263,444.618,408.083,531.533,449.433,471.253,554.037,115.5,304.614,310.389,306.763,89.255,115.605,76.423,1100.245,747.667,1111.668,604.848,454.713,397.46,515.618,583.096,352.695,729.949,91.13,79.547,72.19,1051.921,350.805,373.987,802.823,275.248,289.708,414.664,83,148,520,439,767,416,155.701,147.116
+34.5276,380.887,337.101,520.72,181.867,107,76,621,506,151,122,123,284,535.881,291.617,481.436,450.452,460.371,407.875,400.657,444.079,414.072,529.679,447.506,466.428,560.938,113.5,307.004,309.358,304.444,90.23,115.421,75.332,1095.004,755.704,1107.188,591.539,453.131,392.314,509.283,582.503,353.501,733.334,94.045,79.207,73.2,1040.182,349.448,371.809,790.645,275.248,283.689,410.599,83,144,523,439,773,416,149.846,148.574
+34.6944,377.876,334.027,520.611,184.146,111,79,632,510,152,123,124,287,531.335,290.54,483.805,442.219,458.013,405.417,401.362,444.803,416.59,527.768,458.511,469.428,567.024,114,302.264,304.157,302.122,89.933,117.673,74.071,1085.102,748.311,1097.867,591.411,444.441,389.689,514.034,582.531,352.709,735.742,93.761,78.612,71.494,1026.307,340.693,369.546,784.408,267.062,285.02,403.872,83,145,523,448,770,421,150.158,143.098
+34.8612,373.059,332.786,505.548,184.33,110,78,638,517,155,121,123,291,533.798,287.123,473.107,443.125,458.551,399.991,403.118,455.31,416.604,532.326,454.634,474.897,567.501,113.5,301.192,303.253,297.035,87.996,114.882,76.168,1067.828,736.221,1095.12,587.846,441.597,377.979,504.108,580.565,363.21,745.033,92.652,80.17,73.584,1007.595,335.983,365.472,776.671,267.487,280.389,399.383,83,144,534,451,772,423,149.618,146.579
+35.028,367.036,330.321,507.366,186.75,110,80,636,519,154,124,126,293,534.17,287.37,478.209,444.569,454.646,398.869,402.819,456.202,418.652,529.523,461.669,479.697,573.737,114.5,296.257,302.264,299.255,90.358,118.282,75.205,1076.128,737.838,1085.348,586.467,439.179,377.77,507.53,575.998,360.182,759.747,94.059,78.612,75.134,1000.509,335.148,359.136,768.072,264.881,279.724,391.721,83,146,533,457,781,426,147.131,143.706
+35.1948,365.02,320.014,500.54,184.231,111,78,649,528,159,124,125,291,525.862,283.498,468.755,445.464,453.347,396.201,403.061,460.734,417.785,534.519,467.236,482.8,571.517,114,295.748,296.706,292.92,90.329,117.588,76.225,1071.032,731.52,1082.245,579.997,431.438,369.604,502.708,583.832,360.705,749.862,95.851,78.046,73.086,989.364,330.269,352.305,758.044,258.069,268.365,392.641,81,147,543,460,788,425,145.909,139.801
+35.3616,358.025,319.478,500.803,186.75,109,79,655,526,155,123,127,291,518.112,283.684,469.173,445.251,447.332,394.763,403.814,457.76,420.573,535.921,472.419,485.637,576.966,113,296.554,294.118,286.656,87.6,118.395,75.87,1058.279,724.559,1075.568,577.522,427.841,369.346,500.233,576.677,369.99,749.125,94.457,79.66,74.067,972.052,327.426,354.186,753.433,256.879,264.683,381.637,82,144,541,463,787,428,144.8,140.777
+35.5284,356.296,315.598,493.387,189.326,111,77,657,534,157,126,125,296,520.968,286.24,469.265,438.98,446.337,391.416,403.772,459.913,431.91,532.793,470.928,481.313,580.866,115.5,286.203,291.487,292.609,89.438,115.364,75.304,1049.628,722.491,1075.7,570.868,422.456,361.886,494.69,577.582,364.456,756.447,94.031,79.094,73.2,972.462,324.809,344.271,750.916,250.28,262.757,379.937,84,147,545,469,787,432,147.003,141.923
+35.6952,356.234,313.42,485.484,183.919,109,78,665,536,162,125,128,288,516.545,282.615,463.227,436.283,443.697,387.6,406.438,462.096,424.897,536.034,477.035,491.62,589.231,115,287.32,289.397,286.387,86.412,120.577,74.766,1053.687,722.057,1059.604,567.195,418.464,355.73,493.333,579.971,362.276,759.62,93.547,79.434,74.352,958.007,320.75,345.586,746.008,248.623,261.213,371.171,84,146,549,469,792,434,143.621,138.74
+35.862,344.32,308.445,479.735,185.632,109,80,668,546,159,126,127,292,518.441,281.87,460.441,437.935,444.572,388.255,401.425,467.108,425.737,536.713,481.719,490.759,591.658,113.5,282.279,286.182,282.407,88.958,117.149,75.814,1037.799,705.784,1051.104,564.568,410.965,346.096,494.195,569.635,366.522,764.832,94.941,79.065,72.645,945.123,313.792,338.897,739.799,240.295,255.775,370.661,80,147,553,472,795,435,137.31,139.659
+36.0288,342.43,304.647,478.627,185.052,112,81,677,547,159,125,126,288,515.307,280.67,452.926,430.556,435.915,383.929,408.138,460.196,423.247,539.756,485.236,492.44,589.698,115.5,284.585,282.661,277.188,89.057,119.401,76.324,1028.968,699.314,1050.122,549.798,412.179,345.582,492.329,568.998,367.386,765.611,92.751,81.218,75.006,947.428,312.207,338.048,731.808,241.612,252.971,361.271,83,148,559,476,801,435,140.431,137.296
+36.1956,341.57,305.155,473.634,186.552,109,82,680,550,165,130,131,288,515.071,276.986,448.476,427.417,435.096,375.551,404.54,464.218,429.122,538.312,484.223,494.285,591.517,115,281.802,280.701,278.084,88.859,116.313,75.276,1026.436,699.529,1035.135,547.218,405.968,339.803,491.381,563.922,370.315,775.539,92.154,76.503,72.887,932.337,308.7,331.033,721.935,236.471,254.925,360.025,83,147,565,479,801,442,140.124,134.633
+36.3624,335.909,300.688,468.696,184.471,109,79,681,555,165,130,127,287,511.772,278.587,450.923,428.62,428.89,378.488,403.502,464.7,432.366,535.609,492.458,500.728,597.502,112.5,275.767,280.997,276.248,86.497,118.211,75.205,1015.128,695.058,1038.099,545.117,402.642,333.499,486.574,562.084,369.721,767.523,92.765,79.419,72.418,933.058,303.919,331.655,715.359,240.154,248.963,359.345,79,146,563,481,805,437,138.873,135.018
+36.5292,327.122,296.737,463.153,183.891,110,80,685,553,164,130,128,283,507.321,272.17,444.592,427.169,428.718,367.885,397.997,463.199,428.937,535.906,490.474,495.008,600.399,112.5,278.27,273.663,271.511,88.053,119.826,77.485,1005.839,686.446,1029.755,540.121,396.691,335.17,477.58,558.973,370.386,767.098,93.903,78.145,75.063,922.719,304.952,319.18,719.559,233.384,241.881,350.338,80,145,562,482,803,432,137.424,130.306
+36.696,325.854,295.963,461.627,184.797,107,79,686,562,168,130,126,285,509.603,269.83,448.469,422.415,421.562,365.498,395.916,467.837,430.929,535.694,495.772,493.699,602.374,112.5,278.454,272.405,270.026,85.635,117.687,74.851,1008.988,685.697,1022.04,537.281,389.753,322.877,478.924,549.612,369.141,767.933,96.846,79.773,71.081,910.824,299.026,323.734,702.502,230.735,241.655,346.344,82,143,570,486,807,437,133.544,134.947
+36.8628,326.579,291.582,456.597,187.882,108,83,684,566,164,130,129,283,503.514,271.68,442.127,422.94,419.879,366.122,399.164,458.412,431.441,542.374,491.181,498.591,604.854,112,273.661,268.475,267.806,89.679,117.333,74.921,1002.133,675.144,1012.037,531.496,389.495,317.534,476.619,551.606,376.274,764.251,93.405,78.697,74.494,901.291,297.498,321.995,701.215,228.229,239.304,342.124,81,143,567,484,812,436,133.615,129.358
+37.0296,320.172,284.656,453.105,184.047,106,80,702,569,167,130,126,280,499.857,269.175,440.074,415.092,414.863,358.246,396.589,461.655,431.853,535.326,502.712,501.931,599.569,108.5,266.406,266.976,266.435,87.275,119.812,74.426,987.978,672.664,1012.309,526.181,384.681,314.538,474.484,547.307,372.523,765.087,96.747,77.791,73.015,894.743,295.164,323.239,694.044,225.311,235.324,340.396,77,140,567,485,808,439,134.112,131.056
+37.1964,316.163,285.886,444.616,182.603,109,79,698,565,169,129,128,281,498.51,264.924,438.212,411.602,411.663,352.345,390.929,458.157,431.099,540.096,497.249,501.848,608.786,108.5,269.38,268.027,261.856,88.194,119.104,75.927,977.687,668.565,996.221,521.082,379.86,309.848,470.199,545.016,374.179,763.5,94.273,81.048,72.389,893.357,293.566,313.678,699.447,222.889,232.789,333.541,78,139,567,483,810,440,132.435,127.236
+37.3632,315.566,281.469,443.04,185.66,107,78,706,574,169,131,128,279,500.831,265.295,434.642,412.287,406.46,351.602,388.895,458.823,429.122,539.162,500.843,498.14,605.843,108,264.011,260.298,266.639,86.073,120.095,76.409,977.129,651.381,1002.204,512.055,371.703,302.859,477.566,541.835,374.122,771.233,94.5,78.202,73.57,886.752,287.131,316.875,698.033,221.431,228.455,331.006,76,140,571,481,812,433,133.501,130.448
+37.53,312.284,279.044,437.286,181.244,107,80,706,575,170,135,125,274,500.723,263.493,431.7,401.094,404.419,341.191,384.515,456.514,436.078,538.765,499.173,498.152,605.915,108,264.441,257.542,260.171,86.214,118.707,75.757,963.763,651.48,988.035,511.546,366.345,301.017,466.339,534.863,378.227,759.79,94.898,79.674,75.219,876.738,283.892,312.632,688.429,217.805,227.79,326.361,77,139,568,479,805,435,132.023,128.594
+37.6968,308.25,278.482,430.993,181.188,105,79,704,573,170,131,125,270,495.864,263.965,433.969,402.483,393.94,341.233,378.285,457.19,432.053,531.915,500.559,500.771,602.515,107.5,261.99,258.806,259.743,87.459,116.228,77.089,956.017,643.6,984.027,505.197,356.224,294.418,464.628,533.633,371.165,758.43,94.685,78.57,73.513,881.83,284.429,309.987,683.648,210.894,223.541,322.763,76,139,569,483,805,431,128.882,128.354
+37.8636,304.671,272.714,424.906,182.362,104,81,709,582,167,132,124,269,496.694,261.215,432.501,395.991,390.954,332.162,381.528,456.528,431.853,534.831,501.817,494.555,602.563,106,260.64,257.712,252.069,87.148,115.676,75.261,957.621,639.819,969.085,496.744,363.797,289.986,456.143,529.504,370.018,756.292,93.491,78.088,72.276,874.192,280.257,306.225,682.333,211.007,224.037,320.979,73,139,575,487,804,433,127.972,124.547
+38.0304,304.272,272.739,422.483,180.919,108,78,708,577,170,132,123,268,497.145,262.813,429.673,390.963,385.306,328.591,374.104,449.235,434.556,532.453,505.346,490.517,600.915,107,260.298,257.132,261.387,86.837,115.619,75.12,943.281,630.142,973.263,490.888,357.474,280.121,457.515,524.484,368.391,753.445,94.671,78.598,75.432,860.954,279.139,303.396,679.405,212.31,218.853,314.634,75,139,569,479,807,430,128.598,129.273
+38.1972,300.372,266.566,419.879,179.121,105,77,708,584,168,132,125,262,501.696,256.751,423.728,392.421,381.767,321.244,367.263,450.523,426.576,530.712,499.639,493.365,601.205,105,259.353,256.735,253.935,85.762,118.636,76.083,943.15,631.11,965.968,486.907,352.568,281.296,447.504,513.469,373.811,745.981,95.239,78.018,72.802,857.135,278.022,308.106,677.708,209.52,219.434,307.836,73,137,566,480,800,428,125.229,125.58
+38.364,295.933,266.418,419.656,179.249,103,77,716,579,171,131,126,263,499.098,259.843,423.501,385.632,378.313,318.286,367.405,451.104,432.949,532.34,509.043,486.514,603.719,102.5,260.072,253.907,253.44,86.695,115.775,75.346,938.354,627.551,964.763,482.752,345.04,281.025,452.849,514.331,376.33,744.678,95.439,80.991,73.84,856.145,277.626,303.198,679.504,207.367,218.343,309.819,72,133,569,482,796,431,126.921,125.764
+38.5308,294.952,264.486,407.637,182.66,102,78,716,580,173,133,125,257,495.241,259.638,427.314,380.7,368.475,313.218,361.204,442.196,429.62,524.81,506.23,489.923,596,100,257.285,249.505,253.497,85.225,117.63,73.363,929.352,622.919,953.455,473.118,338.475,269.716,447.122,510.414,368.801,739.424,94.358,78.811,74.849,857.092,277.372,301.02,671.81,208.642,217.394,304.451,69,131,565,475,795,422,129.635,125.127
+38.6976,291.457,258.745,409.294,178.541,103,78,723,577,171,131,121,254,493.81,254.276,421.305,373.283,365.829,306.901,359.444,441.14,425.452,526.537,505.771,491.295,602.714,102,254.557,252.32,254.049,84.532,118.013,73.392,919.434,609.174,950.142,468.547,332.951,272.074,448.451,502.043,373.118,730.204,95.481,77.961,74.536,851.633,273.1,301.416,679.943,206.333,217.904,305.301,71,133,558,469,794,421,123.606,122.425
+38.8644,289.355,259.583,401.486,177.197,100,78,718,581,170,137,122,251,500.115,256.39,425.253,371.173,360.983,302.94,350.651,439.108,424.798,528.603,508.111,488.323,596.509,101,254.854,248.118,252.339,86.243,117.262,72.216,917.129,608.133,942.042,457.708,335.668,264.648,439.684,502.312,372.481,727.131,95.126,79.901,72.29,852.524,273.638,299.676,675.077,206.872,214.817,306.561,70,132,557,473,787,422,123.325,121.213
+39.0312,287.426,255.574,402.678,172.724,101,78,719,578,172,134,122,250,498.397,256.298,420.421,366.775,358.25,297.543,347.167,434.364,422.55,522.829,496.863,486.457,601.283,100.5,254.967,246.472,249.028,84.518,117.205,75.233,907.354,603.747,929.821,460.158,329.794,262.877,435.046,502.991,362.885,724.044,94.514,81.345,73.513,842.142,273.609,294.104,674.314,204.875,211.758,297.143,69,132,556,466,787,413,123.964,120.698
+39.198,282.572,255.39,392.497,172.809,98,76,723,574,167,130,120,242,499.957,256.959,419.032,366.544,347.748,295.296,343.142,429.818,417.173,518.824,501.733,482.049,591.729,98.5,252.366,248.174,250.187,84.164,115.846,73.859,899.811,606.177,935.18,456.116,326.931,259.269,428.456,499.47,365.036,724.596,92.851,79.589,74.295,843.953,269.324,299.521,667.949,203.685,211.503,294.962,69,128,557,462,785,422,123.851,121.972
+39.3648,281.584,255.292,388.643,173.276,98,76,720,581,170,128,121,241,497.674,255.059,418.048,354.005,349.107,285.611,336.6,421.32,413.417,518.158,505.842,481.253,591.638,97,251.177,246.2,250.527,83.061,116.695,75.233,891.297,597.766,923.937,446.735,319.545,256.185,435.682,490.377,363.394,720.956,94.145,78.527,73.243,844.872,269.395,297.017,674.13,202.637,207.127,296.195,67,127,549,464,773,410,123.265,122.312
+39.5316,275.547,251.542,380.972,174.083,98,77,718,579,171,131,118,237,496.78,252.087,416.736,355.332,339.111,285.273,335.505,419.904,415.878,510.091,500.728,477.829,593.412,97.5,251.858,246.787,248.311,84.023,119.146,74.383,890.711,593.674,921.739,442.868,314.84,251.101,426.604,476.647,361.951,712.473,94.301,78.74,73.783,839.483,269.89,296.352,664.597,201.051,209.832,293.164,68,127,547,458,765,407,121.406,119.71
+39.6984,271.596,248.614,381.246,172.441,94,76,723,575,168,130,118,231,497.889,251.846,416.41,347.592,332.414,276.262,326.584,419.944,409.264,512.157,501.098,475.1,586.101,96,253.466,243.493,243.34,82.142,116.001,72.301,885.229,591.602,915.785,438.687,313.416,247.65,427.975,480.338,363.762,709.499,95.296,76.304,74.536,845.466,267.881,297.908,670.848,201.66,207.396,294.198,65,127,542,456,766,405,122.358,122.934
+39.8652,272.346,247.51,380.989,171.21,94,76,722,575,170,129,116,230,498.783,254.258,416.027,349.231,329.509,273.665,326.914,409.353,405.593,519.107,489.385,467.292,585.619,94.5,252.876,246.333,250.346,83.966,114.84,71.805,882.797,587.062,915.328,433.512,315.124,246.16,421.004,473.154,362.475,708.097,93.277,81.642,71.707,841.181,260.003,298.658,675.488,201.093,210.724,294.892,66,123,543,452,763,402,122.486,121.25
+40.032,271.311,245.048,373.06,168.266,94,74,726,571,169,128,116,227,500.107,256.151,412.252,344.047,327.338,268.01,321.254,406.648,411.753,510.94,493.308,465.907,580.351,94,255.589,245.196,247.365,83.358,116.412,71.097,875.657,592.403,912.508,431.052,306.423,243.439,422.8,470.241,355.313,696.243,93.32,77.664,74.337,842.015,265.491,299.818,667.284,200.286,206.574,291.932,65,123,540,449,752,397,121.373,125.424
+40.1988,267.033,241.609,371.106,167.374,95,77,723,572,169,130,117,225,497.724,252.204,417.289,336.915,317.256,267.592,315.92,400.416,404.142,511.917,493.671,465.436,572.776,91,252.547,244.234,250.184,82.439,114.16,73.406,868.454,590.691,913.867,422.278,305.227,238.304,415.518,469.874,354.86,697.602,96.007,79.561,73.726,845.495,269.663,299.987,678.274,200.272,207.651,288.858,64,118,534,444,753,392,122.941,122.913
+40.3656,268.287,238.838,366.638,166.454,94,74,716,569,169,127,114,219,504.823,253.575,414.638,332.96,314.597,264.423,311.341,395.842,398.794,504.331,493.776,454.351,574.488,89.5,251.63,247.118,247.006,81.463,114.429,73.887,867.855,579.206,906.984,426.021,304.384,237.555,420.495,472.362,352.482,689.147,93.803,77.89,73.029,839.54,265.463,299.591,675.855,201.617,208.104,288.788,61,118,530,435,740,387,120.454,123.868
+40.5324,267.232,239.954,366.789,165.251,92,73,713,571,169,127,114,217,501.052,257.002,413.946,332.045,311.228,257.074,304.784,389.568,398.779,505.774,490.503,456.67,573.993,91,251.644,242.73,248.25,81.788,112.106,71.465,862.046,578.499,903.177,413.425,298,237.383,416.621,464.02,351.633,679.885,94.543,80.198,73.285,851.59,269.974,299.422,682.927,204.039,207.721,288.915,62,120,526,433,736,390,122.387,124.618
+40.6992,263.327,238.994,364.389,165.874,89,72,714,566,165,129,113,213,506.653,256.455,413.216,327.158,304.246,251.676,303.336,383.306,392.663,497.877,484.103,453.192,567.137,88,250.247,244.1,246.941,82.425,114.528,72.23,860.981,578.071,902.702,414.23,296.216,235.315,408.349,461.997,345.363,676.968,94.017,78.499,73.911,841.52,261.615,304.16,680.381,205.455,207.75,287.895,62,114,523,428,734,384,121.875,124.519
+40.866,262.963,239.852,357.684,163.298,90,72,717,564,166,128,112,210,507.478,254.279,413.633,319.97,302.312,250.577,294.701,375.476,395.792,494.438,484.746,446.898,563.724,86.5,256.297,242.249,247.316,81.477,114.656,72.556,856.805,578.025,898.928,406.893,295.406,226.894,410.498,459.721,347.331,674.362,91.926,77.522,71.792,851.873,265.279,305.291,686.166,206.234,208.316,290.275,59,114,518,422,722,378,123.382,123.344
+41.0328,260.621,240.055,361.716,161.345,88,69,713,560,166,125,110,204,503.631,252.973,411.352,322.369,295.7,245.679,287.646,371.397,390.088,499.193,485.675,440.42,551.205,86.5,252.224,243.568,250.852,81.081,115.151,70.884,863.029,574.093,898.743,406.78,293.215,233.008,408.631,455.648,346.014,661.091,93.149,77.154,72.574,853.571,269.437,305.334,685.119,203.586,209.647,286.493,60,113,511,419,712,379,120.738,123.585
+41.1996,258.553,233.926,351.559,158.331,86,71,721,558,165,123,112,203,506.775,258.214,416.233,318.031,291.141,243.924,284.361,365.846,386.83,486.3,474.266,439.236,553.682,82.5,251.658,245.251,250.711,82.199,114.372,70.898,853.023,575.748,890.813,399.167,284.939,226.809,405.11,451.873,338.881,655.908,91.997,79.207,72.773,857.955,265.943,306.352,692.389,204.861,211.22,290.799,56,109,507,419,704,374,122.429,122.679
+41.3664,259.427,236.768,359.144,159.335,84,69,709,556,166,125,108,199,508.845,257.095,415.328,312.643,283.571,236.052,279.782,359.756,383.174,492.513,477.871,432.655,544.406,83.5,249.664,244.247,249.933,81.322,113.112,71.026,840.33,580.429,890.733,399.912,284.098,226.879,401.533,447.32,340.254,656.984,94.102,79.589,72.219,851.491,269.564,306.423,694.454,205.824,209.52,294.268,57,110,507,408,702,367,123.168,123.557
+41.5332,259.496,234.629,351.97,158.614,86,69,706,551,166,124,108,197,507.936,259.135,419.142,308.942,285.676,232.457,272.997,353.893,380.187,484.177,475.298,433.188,540.274,81.5,256.637,244.94,246.708,83.33,113.508,69.907,849.561,577.123,884.129,393.087,283.549,226.667,398.238,442.639,336.051,643.955,93.021,78.358,71.949,857.191,270.144,312.844,692.842,206.843,210.441,290.756,55,108,498,404,695,367,122.5,124.08
+41.7,258.872,233.774,353.544,154.962,84,69,712,553,160,127,105,192,514.392,259.643,415.586,307.184,277.863,232.423,271.343,348.322,378.067,482.535,469.303,429.473,542.948,82,252.054,244.12,250.654,82.199,115.236,70.714,845.537,576.839,889.42,393.211,283.858,225.234,395.368,442.102,330.163,640.131,92.822,77.296,72.546,865.706,271.092,311.033,699.192,210.865,213.981,291.478,56,108,487,396,694,361,123.907,123.783
+41.8668,257.337,233.83,351.167,153.858,85,69,702,546,162,122,103,191,511.636,259.811,417.653,296.938,278.162,229.838,264.265,339.801,376.033,473.548,465.27,422.255,534.829,79.5,254.954,247.645,250.654,81.308,112.885,71.592,844.272,580.876,884.053,391.945,279.502,225.478,391.267,437.69,327.247,633.474,93.761,79.179,71.565,871.293,270.653,316.366,702.785,213.641,215.369,292.257,52,107,483,396,682,352,122.685,125.241
+42.0336,259.268,235.604,345.236,155.118,82,67,702,548,163,120,105,187,514.177,260.874,419.62,301.827,271.101,224.942,260.937,337.832,369.532,476.095,458.185,416.772,527.581,78.5,257.401,245.096,249.862,78.932,111.27,70.148,846.67,576.307,880.262,390.229,279.271,220.768,390.956,440.674,324.162,623.971,93.661,76.234,71.28,872.962,268.447,314.683,700.522,216.828,218.372,297.88,53,104,479,382,674,351,121.648,123.868
+42.2004,255.574,234.832,345.378,154.622,83,67,697,546,160,122,103,185,520.739,259.911,417.912,295.975,265.968,223.454,256.599,331.02,368.522,472.614,456.869,412.865,522.184,78,254.147,246.496,255.49,82.708,113.437,70.927,847.689,577.123,881.135,387.47,280.947,220.113,381.538,434.353,322.676,624.609,91.884,78.896,70.953,881.589,273.256,317.115,707.481,215.752,220.609,291.847,54,102,479,380,666,344,125.357,126.585
+42.3672,256.126,232.045,347.331,151.268,79,66,692,542,159,120,101,182,523.795,263.084,419.393,297.132,268.072,218.953,253.47,327.508,359.333,464.688,450.693,404.834,517.002,77,253.976,250.909,253.17,81.053,111.468,71.082,839.187,579.155,890.839,380.745,279.016,221.994,378.413,431.808,320.794,617.032,92.922,76.8,72.816,886.78,273.369,321.231,717.706,216.29,218.938,302.044,51,103,472,376,665,341,125.371,126.033
+42.534,257.675,233.742,342.302,153.306,80,64,686,530,155,116,100,176,524.396,263.837,423.812,292.366,262.126,216.885,248.62,321.545,355.933,471.878,451.183,406.974,515.862,75,258.064,250.357,252.888,80.69,112.875,71.28,837.954,584.846,882.367,380.601,273.483,216.036,372.87,424.313,318.26,614.185,90.362,77.168,71.579,891.546,275.533,324.046,724.609,221.941,219.618,294.764,51,99,461,369,660,339,126.395,127.929
+42.7008,255.743,230.195,345.215,147.022,78,64,686,528,154,115,102,176,522.141,265.17,418.254,288.355,259.015,213.055,242.563,314.654,353.842,463.513,446.884,398.866,512.527,74,260.083,250.563,253.936,80.944,111.657,68.816,841.704,578.123,891.518,378.541,270.084,219.946,375.698,424.624,315.713,605.036,92.296,77.735,71.465,895.888,274.698,325.191,719.22,218.896,222.21,301.378,49,99,455,355,642,333,125.782,126.075
+42.8676,257.622,234.336,346.992,151.891,75,64,681,530,155,116,97,170,524.725,262.52,428.408,287.949,255.503,210.727,238.594,310.286,350.371,459.664,439.147,395.445,504.986,73.5,261.401,253.455,254.118,79.148,112.11,69.028,837.41,582.813,892.93,374.559,271.795,220.863,372.064,426.208,308.212,596.864,93.476,77.862,71.934,901.998,278.093,328.246,725.386,220.482,227.903,304.14,49,98,451,354,634,325,126.565,129.489
+43.0344,256.811,231.565,344.561,148.367,76,64,672,524,155,116,96,168,526.412,267.419,424.801,282.415,252.346,210.049,235.507,303.233,346.089,457.244,436.318,395.259,494.824,73,262.442,252.971,259.334,81.496,108.91,69.708,844.268,580.199,887.292,378.74,273.128,218.804,371.711,419.675,306.414,584.501,94.429,78.258,70.057,906.44,279.295,338.854,735.004,224.249,229.999,302.426,49,97,446,350,628,325,127.247,126.684
+43.2012,260.317,232.17,340.257,146.898,76,63,668,522,155,115,97,165,532.31,272.949,430.937,285.075,249.118,206.919,233.545,298.149,341.522,451.186,434.239,383.308,490.998,71,266.449,258.419,259.548,81.34,111.091,69.41,837.539,579.462,893.641,375.242,271.89,222.307,366.309,419.463,302.635,583.283,91.173,78.004,69.247,916.651,284.401,336.648,745.145,233.455,230.353,312.212,48,94,440,339,622,319,127.077,132.216
+43.368,256.838,234.884,342.773,146.44,74,61,668,521,153,115,96,162,535.788,269.887,431.773,284.619,249.758,209.18,229.264,291.563,339.602,448.087,428.217,381.851,483.734,69,262.917,254.344,259.239,81.171,109.179,67.654,845.444,582.445,891.066,371.019,270.155,219.719,365.347,417.384,303.258,575.663,94.998,77.791,71.024,919.721,284.288,339.802,738.922,231.769,234.758,310.017,47,91,433,335,618,318,126.38,131.65
+43.5348,258.272,231.989,342.743,146.294,75,62,664,516,153,114,94,162,539.13,270.713,435.339,278.663,245.763,205.688,226.775,289.708,334.026,441.774,418.822,377.686,480.305,69.5,265.728,257.57,264.201,80.223,109.901,70.43,842.963,587.6,897.15,374.246,275.036,221.33,371.654,417.865,301.22,570.805,91.827,79.476,69.83,924.374,290.879,350.098,742.458,231.982,237.604,313.359,46,93,432,330,612,312,126.594,131.311
+43.7016,254.424,232.902,339.119,144.732,74,60,656,512,151,111,93,159,538.27,274.027,434.979,278.374,246.602,207.285,221.676,286.67,331.479,444.831,418.714,373.747,477.984,69.5,267.467,258.334,266.124,80.364,110.411,67.527,848.915,588.559,893.803,374.232,276.766,222.051,367.341,416.649,296.479,569.078,93.746,78.103,71.408,932.803,292.152,349.858,752.259,237.59,241.117,315.385,48,91,420,327,604,306,127.503,130.858
+43.8684,257.379,235.487,342.755,145.968,73,60,658,513,149,111,92,157,544.393,271.25,433.519,276.256,243.958,203.508,213.961,285.502,325.69,440.246,417.168,368.338,470.263,68,269.126,263.876,263.94,78.823,109.929,69.665,842.56,593.405,898.625,367.693,273.383,220.141,363.891,416.748,298.573,560.495,91.841,77.225,70.228,940.71,289.662,353.479,758.61,241.1,244.516,317.141,46,90,415,314,602,303,128.826,134.013
+44.0352,261.374,233.335,343.282,141.933,72,59,646,507,150,110,94,153,546.731,274.32,439.981,275.255,245.322,204.038,218.341,279.001,323.101,439.142,413.956,363.563,468.807,67,267.354,258.589,266.067,81.072,110.722,68.462,844.074,597.287,906.437,366.099,277.587,222.455,366.875,415.914,293.308,549.108,91.372,75.667,70.356,941.261,290.652,355.869,767.351,241.951,247.85,324.793,43,91,414,316,593,296,128.797,133.826
+44.202,259.995,239.502,342.799,141.526,71,58,645,506,150,111,91,153,550.472,281.584,443.388,272.604,242.592,201.2,211.728,280.885,322.944,433.098,410.718,359.473,462.979,66,268.221,262.497,273.397,78.101,108.924,68.292,859.799,596.574,907.216,369.497,273.738,223.326,364.683,413.68,284.406,547.069,92.595,77.607,71.863,951.671,298.53,352.743,769.67,244.186,251.103,329.674,44,88,403,311,585,295,131.27,135.457
+44.3688,265.009,237.456,340.647,140.503,73,58,642,503,145,108,90,151,552.035,277.104,444.91,269.428,241.783,200.72,205.37,269.98,317.24,434.287,405.005,358.613,455.424,65.5,273.072,264.082,264.883,79.219,109.193,68.051,850.547,599.439,916.143,364.395,273.425,226.241,364.838,411.219,280.443,537.141,92.083,76.092,69.048,958.135,303.042,364.921,787.817,246.816,256.609,328.206,44,87,399,305,573,290,131.028,132.556
+44.5356,260.523,238.355,347.853,139.529,69,56,639,493,145,106,91,151,550.266,277.119,446.264,276.893,241.499,200.648,206.693,264.471,315.419,426.178,402.048,349.417,454.167,65.5,275.018,270.95,271.271,79.615,107.876,68.164,858.349,597.146,918.066,370.024,276.525,225.223,363.962,411.629,280.882,533.204,89.552,78.981,72.361,969.436,300.553,364.977,785.582,251.299,259.523,336.722,44,87,389,300,570,287,131.838,135.414
+44.7024,264.708,239.508,343.28,139.352,66,57,629,495,144,104,90,146,556.319,283.655,450.615,276.355,240.942,200.037,203.418,260.708,313.072,425.838,397.966,343.635,445.694,64,275.627,267.641,274.92,77.168,107.564,68.447,863.199,604.116,925.062,372.526,273.014,224.951,365.814,406.836,276.254,527.072,91.557,74.45,69.887,979.124,303.254,365.939,790.801,257.372,259.664,341.147,43,85,388,297,561,282,134.041,138.216
+44.8692,263.442,243.761,348.672,138.581,69,56,631,492,144,105,88,145,557.715,282.576,449.183,268.47,239.876,196.869,201.53,257.304,308.221,423.106,392.331,341.826,443.107,63.5,283.583,273.201,274.623,80.619,108.23,68.122,864.004,612.071,927.135,370.905,275.844,230.277,368.868,409.989,275.108,525.117,89.779,74.818,67.1,986.422,307.37,373.93,802.766,257.215,263.226,340.383,43,84,384,295,555,276,133.771,136.914
+45.036,266.483,243.532,347.971,136.589,68,58,631,494,139,105,89,144,559.603,285.487,454.008,271.554,240.374,194.241,200.279,257.687,305.034,419.101,390.078,343.465,441.374,62,281.519,274.104,279.075,81.072,109.589,67.498,872.161,608.455,933.226,367.777,277.247,235.357,371.993,405.167,269.489,519.466,89.509,76.545,70.555,996.931,310.157,376.321,815.029,264.093,273.409,343.12,42,82,378,290,551,277,132.41,136.376
+45.2028,265.766,242.545,355.491,137.003,68,57,617,484,143,104,88,145,564.434,293.435,455.316,270.197,234.629,198.228,196.752,256.426,300.496,415.874,386.985,337.917,435.809,61.5,281.098,273.659,282.23,77.96,107.791,67.513,881.721,610.598,944.916,373.351,279.849,229.442,364.174,405.789,272.546,511.62,92.623,77.423,68.081,1006.11,311.925,384.651,818.579,268.942,279.993,353.317,41,82,373,280,542,269,137.793,139.168
+45.3696,271.474,248.897,347.638,134.954,66,55,617,481,140,106,88,143,571.445,288.585,465.764,270.207,240.589,199.189,196.254,250.931,300.852,417.87,382.996,334.399,432.14,62,285.985,278.32,279.974,76.871,106.573,69.821,881.034,620.413,944.528,374.119,282.57,235.046,363.891,405.436,266.616,507.924,91.272,76.177,69.105,1017.92,322.037,383.944,828.126,275.831,278.385,357.569,41,83,362,277,538,268,136.571,141.541
+45.5364,271.986,245.831,353.52,134.001,65,54,612,478,140,101,86,142,573.164,293.372,463.274,271.613,238.499,198.539,193.808,249.232,293.654,415.365,380.818,333.074,425.908,61.5,283.496,282.425,286.353,78.016,108.726,69.24,883.236,618.429,948.313,371.929,281.415,238.403,366.38,405.322,262.893,499.582,89.509,73.713,69.773,1023.365,319.039,392.275,841.223,276.135,283.683,363.058,41,82,357,270,533,263,137.722,141.018
+45.7032,271.711,247.543,351.934,132.873,63,52,609,476,138,100,88,141,574.027,293.215,464.326,269.948,240.118,200.604,193.479,245.224,297.282,415.251,376,325.121,426.447,59.5,286.352,281.166,289.807,78.681,107.182,69.878,892.599,618.568,959.125,373.336,287.269,241.383,363.679,408.151,258.237,497.132,89.68,76.729,69.474,1027.142,324.838,395.047,838.338,281.338,290.205,366.076,41,78,353,268,529,260,138.632,142.9
+45.87,273.586,254.216,356.409,133.694,64,52,602,473,137,98,86,143,575.3,298.42,462.944,272.561,239.791,200.889,190.508,244.147,290.653,409.166,378.343,322.933,424.664,60,294.014,288.006,289.142,79.487,107.04,67.272,894.129,630.623,961.761,377.702,290.53,241.106,361.317,409.833,258.69,485.83,91.727,78.188,67.47,1041.441,326.648,398.074,850.827,285.112,294.116,370.53,41,79,354,263,522,257,136.003,143.253
+46.0368,275.191,250.018,357.219,133.534,65,53,607,472,135,99,86,142,577.558,297.103,472.435,272.49,240.26,202.478,187.408,239.842,289.258,406.42,367.828,319.803,414.239,60,290.841,283.427,291.365,80.647,108.825,66.705,910.471,634.697,974.935,372.483,289.945,246.984,357.132,408.023,257.218,481.596,91.059,75.738,67.157,1049.135,324.908,405.244,862.297,287.525,293.113,378.226,42,78,351,264,516,254,136.017,147.017
+46.2036,278.419,256.113,356.701,132.759,63,52,600,464,134,99,85,139,589.844,296.203,469.207,273.906,240.317,203.649,190.352,240.182,284.834,406.646,365.656,319.152,413.943,58,292.877,293.379,295.635,79.912,106.714,68.787,909.386,631.691,982.31,375.64,288.469,245.028,361.091,404.304,256.638,480.024,88.812,75.242,68.55,1052.134,334.682,405.089,867.219,294.627,300.151,384.255,40,76,347,258,507,247,139.072,146.197
+46.3704,282.95,259.751,359.315,133.755,64,52,597,465,133,100,84,139,587.691,304.632,474.183,276.205,240.018,206.406,185.203,241.683,282.196,406.052,362.588,318.926,410.174,58,299.849,289.602,298.251,79.12,107.819,67.725,921.424,640.141,998.125,377.19,292.323,252.272,360.398,404.205,251.132,476.647,90.049,73.77,68.621,1076.927,333.607,412.84,873.442,296.372,307.859,388.825,39,77,343,257,509,247,140.153,145.772
+46.5372,285.44,258.332,362.63,131.383,64,52,596,457,133,98,84,138,593.997,301.928,476.413,278.818,239.961,208.477,188.972,236.953,279.03,401.707,359.787,312.382,404.891,56.5,299.523,293.099,298.562,79.473,108.301,68.164,921.626,641.602,992.677,384.285,295.629,249.402,360.851,400.218,249.038,469.246,90.803,75.611,69.048,1084.452,337.836,416.998,882.523,302.993,310.77,395.216,37,76,345,252,502,245,142.1,150.215
+46.704,288.504,259.71,370.002,131.06,61,51,588,453,134,95,85,136,596.997,305.347,484.271,277.282,246.062,203.187,184.948,235.609,280.112,401.169,357.731,307.568,404.084,57,300.964,299.042,299.847,81.015,107.522,68.065,928.396,648.886,1009.589,387.794,302.431,255.533,363.014,403.597,244.99,467.32,87.973,75.497,68.493,1095.809,339.547,417.62,895.832,305.1,318.327,404.234,39,75,338,251,497,243,145.71,155.026
+46.8708,288.092,264.175,364.304,131.949,61,50,584,458,131,94,84,141,599.385,308.111,484.4,279.71,244.811,206.764,185.26,230.707,275.09,397.22,355.176,311.164,397.564,57.5,306.588,299.536,298.265,78.879,110.198,68.745,928.063,650.394,1007.379,389.145,299.233,261.095,368.854,404.969,248.429,461.995,87.76,75.356,70.185,1100.83,346.152,424.225,896.935,305.742,323.311,405.635,38,77,338,247,496,235,143.422,152.309
+47.0376,291.609,268.39,373.306,129.77,62,51,582,453,129,94,84,141,593.623,308.997,486.224,280.962,246.587,207.876,179.543,233.101,271.704,394.064,350.635,305.433,399.921,56.5,306.797,301.769,305.313,79.643,108.485,67.895,940.99,655.131,1009.618,392.674,302.572,262.31,366.464,403.131,243.674,458.936,89.211,73.784,66.688,1100.25,347.68,428.2,908.377,314.534,323.169,410.102,38,75,336,247,486,238,147.43,154.63
+47.2044,294.464,267.74,377.738,127.349,59,50,584,454,131,95,85,140,598.109,311.516,494.017,285.16,244.298,209.425,179.998,227.62,274.265,390.908,348.684,302.384,395.146,56,307.384,307.654,305.56,80.152,106.87,69.566,943.509,656.559,1026.344,395.931,311.381,266.007,366.804,401.349,239.513,447.436,91.429,75.455,68.067,1127.604,358.287,434.253,911.135,322.742,330.661,414.978,37,75,332,246,483,235,142.384,153.413
+47.3712,297.972,272.232,385.61,128.298,61,50,579,451,129,94,83,138,608.516,312.271,495.613,283.691,248.962,212.531,182.359,229.248,268.703,393.088,345.494,305.489,393.448,55,314.838,308.573,304.598,80.096,107.352,70.869,952.168,663.403,1029.561,399.044,312.085,271.223,365.277,402.551,238.31,447.011,89.58,75.568,69.304,1135.482,355.869,432.839,911.446,323.594,335.623,418.596,37,73,332,241,483,233,146.973,156.073
+47.538,300.649,275.032,386.37,128.114,61,49,571,447,128,93,84,137,604.377,313.353,498.497,292.521,251.166,214.323,183.169,227.747,269.073,393.243,340.763,302.412,390.111,55,314.994,308.446,312.349,80.845,107.833,70.416,959.265,670.502,1039.717,405.578,315.975,276.482,369.717,406.949,238.706,443.867,90.86,74.874,67.754,1149.583,358.5,445.738,929.975,327.844,338.868,426.407,37,73,327,241,474,227,148.297,155.579
+47.7048,306.229,275.584,389.716,126.372,61,50,569,447,127,92,82,139,611.57,315.139,502.834,287.278,251.578,215.281,180.526,224.961,265.317,391.163,339.404,301.487,384.611,54.5,317.964,312.179,313.141,80.817,105.794,68.886,972.477,674.376,1053.241,402.457,319.743,278.473,368.812,408.603,235.097,441.233,88.144,73.189,67.398,1161.054,363.436,446.926,931.927,327.034,341.762,431.024,37,72,327,238,472,230,147.955,156.625
+47.8716,305.634,278.913,387.908,126.925,60,49,570,445,128,93,84,140,616.849,311.942,501.038,291.488,253.953,218.712,179.6,224.292,264.136,396.357,337.157,301.265,388.046,53.5,321.922,312.92,318.26,81.015,108.556,69.68,983.283,677.839,1056.161,407.704,323.177,286.944,372.347,407.896,231.459,441.289,91.23,74.818,68.109,1161.125,363.011,449.726,937.315,338.7,350.553,436.269,35,72,331,233,470,223,152.603,160.332
+48.0384,305.82,281.837,392.92,129.359,60,48,571,441,129,93,83,142,613.641,316.583,503.585,296.565,257.707,220.797,179.059,224.915,268.233,390.979,333.782,298.813,382.288,54.5,319.209,317.243,322.433,80.576,107.465,68.277,989.137,679.72,1071.634,412.681,325.632,287.298,370.82,416.434,229.945,433.302,89.765,73.713,69.275,1173.26,372.855,455.893,949.634,339.456,349.18,443.867,37,72,327,236,468,224,149.107,158.38
+48.2052,309.301,284.82,396.514,127.095,58,49,568,436,124,92,83,143,616.13,317.217,507.986,294.602,260.138,225.662,180.668,225.892,262.372,389.252,335.29,296.449,384.029,55,325.091,320.639,322.334,79.077,108.669,68.362,990.139,689.848,1074.621,417.586,327.994,289.28,369.896,414.352,230.002,425.484,89.41,73.996,67.598,1184.745,375.854,458.708,958.997,344.425,354.667,447.221,37,73,332,233,466,224,152.02,156.837
+48.372,315.837,284.999,402.188,128.269,60,49,569,438,128,91,84,143,624.388,318.663,508.709,301.345,261.29,223.553,182.891,226.458,262.614,391.828,331.374,293.707,379.697,53.5,325.362,322.912,322.179,80.209,108.754,68.136,1001.875,691.245,1078.746,422.193,335.428,298.266,370.987,418.247,226.534,422.736,88.855,73.827,68.223,1195.847,375.543,464.323,957.739,349.896,363.468,452.216,36,71,321,234,461,219,151.04,159.95
+48.5388,318.265,290.317,408.348,129.374,59,51,565,444,125,92,84,145,627.671,327.408,519.028,299.529,263.821,233.165,181.029,222.026,256.412,392.847,334.583,299.735,377.876,55,329.65,326.747,324.952,78.285,105.511,68.547,1013.196,692.997,1091.41,428.521,335.167,299.359,375.689,418.799,225.883,423.006,88.158,75.837,68.408,1207.177,379.446,467.137,973.862,349.932,365.567,457.786,37,73,325,231,458,217,152.222,163.403
+48.7056,320.853,295.142,408.753,128.723,58,47,567,437,123,89,83,144,628.811,324.05,517.318,308.659,264.788,232.338,181.171,222.436,260.808,388.276,331.332,295.263,382.019,54,332.843,330.227,324.125,80.845,107.564,69.439,1021.855,701.906,1089.874,429.53,343.894,303.259,377.218,423.374,228.148,425.385,90.817,74.35,67.342,1215.79,382.558,469.103,975.362,351.299,375.273,464.71,37,71,323,228,454,215,162.438,165.146
+48.8724,320.583,297.628,417.059,129.274,59,48,563,432,122,91,82,145,630.659,323.878,527.265,305.191,271.907,234.651,181.171,221.487,255.53,384.794,327.157,294.141,377.297,52,331.241,327.893,332.626,81.482,108.57,69.467,1026.422,711.579,1106.111,434.11,343.792,307.513,379.003,418.134,223.788,421.929,88.841,75.653,67.498,1219.637,389.276,479.371,979.704,356.701,376.042,468.375,35,69,322,231,453,214,150.386,165.539
+49.0392,325.496,296.733,423.094,127.901,59,48,563,433,123,91,84,146,630.738,330.373,524.546,313.068,270.888,238.434,179.494,225.085,255.857,389.719,328.91,293.014,376.439,53,334.168,330.212,333.376,80.619,108.74,70.388,1030.126,709.678,1114.524,439.54,353.633,313.663,377.303,424.294,223.137,412.228,88.912,73.119,69.674,1234.29,386.999,481.832,984.711,365.156,375.297,476.239,36,70,322,226,451,215,152.376,167.676
+49.206,327.091,303.984,414.892,130.833,57,47,556,426,123,89,82,146,635.42,326.554,523.702,313.373,275.822,241.857,180.972,223.824,255.061,389.394,324.824,297.54,375.628,52.5,335.822,332.39,338.735,82.203,108.485,70.543,1040.705,721.419,1116.877,442.555,356.198,317.549,378.309,427.977,221.524,416.576,89.808,75.936,67.953,1238.208,392.713,487.759,991.104,363.23,381.104,482.826,37,68,326,226,451,210,155.701,166.403
+49.3728,330.784,301.432,424.848,126.683,57,48,554,429,124,88,84,147,637.078,331.31,529.491,319.292,284.061,243.949,185.747,222.252,254.008,389.832,325.695,298.332,377.686,51.5,340.319,336.436,334.776,81.807,110.198,70.501,1043.28,727.597,1122.345,449.889,358.715,324.907,383.336,430.498,219.656,412.299,87.59,73.303,68.323,1244.94,396.659,488.141,992.249,368.633,386.903,488.595,35,68,325,227,447,208,157.535,168.001
+49.5396,330.089,306.007,431.503,126.43,57,47,557,432,123,88,84,150,638.881,329.756,529.003,319.63,283.876,247.788,184.127,224.376,255.587,387.837,324.908,295.458,379.036,52,337.844,336.69,338.141,81.708,109.929,70.473,1056.004,730.297,1132.646,455.433,363.687,327.345,389.879,434.817,217.221,409.948,87.604,76.021,68.764,1260.654,404.721,492.171,1001.796,369.204,390.552,492.135,36,68,321,229,446,210,155.194,167.52
+49.7064,336.918,307.017,436.775,131.37,57,49,555,428,123,91,83,149,641.463,335.385,533.354,326.279,287.453,248.629,181.611,224.334,254.89,386.818,326.049,296.055,377.374,51.5,344.615,342.412,341.887,81.27,108.952,71.096,1067.84,726.706,1141.72,461.523,372.39,330.564,381.255,433.387,216.797,406.917,90.49,76.078,67.313,1267.372,402.628,498.055,1004.738,376.863,394.371,493.977,36,67,321,226,447,208,156.966,169.425
+49.8732,341.493,313.533,438.636,130.904,57,48,547,427,119,91,83,151,650.78,331.263,539.76,325.916,291.164,253.72,182.592,221.728,255.8,390.568,322.235,298.489,377.254,51.5,345.547,347.902,344.459,82.132,109.391,72.824,1072.415,735.652,1142.808,464.339,375.055,333.064,390.078,439.009,212.735,409.027,89.623,74.634,65.365,1276.678,410.039,494.364,1007.341,379.23,400.529,499.349,35,68,318,228,448,207,155.247,169.784
+50.04,341.109,316.744,441.832,126.782,56,49,551,425,122,88,84,152,651.41,329.908,541.12,338.234,295.828,260.013,186.188,224.518,256.64,391.177,321.715,297.342,378.38,52,344.092,350.424,346.706,82.033,108.527,68.532,1078.163,740.522,1151.504,474.491,375.717,337.009,389.78,445.17,217.151,407.214,88.016,74.039,66.716,1286.607,409.459,496.91,1014.483,380.617,401.918,510.145,35,69,323,227,445,205,157.45,170.124
+50.2068,345.058,317.355,444.105,128.978,57,47,547,422,121,88,85,154,650.041,333.29,540.26,337.396,295.704,265.087,182.706,227.945,253.61,395.593,324.046,301.109,378.202,52.5,344.54,347.769,345.784,82.132,110.099,70.119,1084.792,745.163,1159.41,475.947,380.953,344.021,398.405,444.051,211.334,403.504,90.121,74.251,69.119,1296.494,410.661,500.813,1023.464,380.191,405.034,510.726,35,70,323,231,441,204,158.061,172.176
+50.3736,346.498,321.005,452.54,127.985,59,48,551,427,122,91,85,156,649.045,337.449,541.957,342.474,301.53,266.535,191.546,226.473,258.589,392.606,321.744,301.784,374.825,52,352.899,348.313,347.651,81.821,110.779,70.912,1097.667,748.998,1164.941,476.794,387.226,348.159,399.298,447.209,215.438,404.269,88.94,73.345,68.508,1302.83,417.153,509.908,1021.696,382.172,402.168,512.96,36,68,320,233,444,202,159.468,169.968
+50.5404,351.56,320.679,456.412,128.694,58,48,555,427,122,88,86,159,657.334,333.834,548.733,347.263,307.744,269.942,187.268,228.923,250.935,391.375,322.843,300.542,376.745,51,348.944,352.573,353.3,82.896,110.439,70.897,1098.198,753.022,1179.193,490.388,392.834,352.911,400.544,454.602,211.178,405.246,87.675,74.195,66.887,1303.707,418.907,514.476,1026.675,388.949,411.839,519.65,35,67,325,229,443,206,160.832,172.303
+50.7072,354.122,327.256,462.019,129.176,55,47,553,425,122,89,87,159,654.992,336.806,542.67,348.598,310.147,277.779,194.105,233.171,253.695,396.598,321.914,302.929,380.815,53,353.469,350.098,353.554,83.236,109.887,70.883,1115.03,751.646,1178.788,493.518,398.168,359.927,403.589,453.554,211.688,406.874,88.201,72.963,66.048,1318.926,424.098,514.108,1035.585,389.659,410.927,527.493,36,70,325,232,440,204,157.904,174.935
+50.874,353.691,328.09,463.398,130.971,56,48,557,426,123,91,86,166,656.008,338.419,545.607,358.106,314.597,277.304,192.413,230.098,253.496,392.111,327.27,307.1,383.336,53,355.312,355.954,350.691,82.514,110.822,71.662,1120.864,760.927,1181.583,497.484,404.652,364.859,396.111,461.131,213.867,400.006,89.95,74.973,67.256,1319.194,427.931,516.598,1038.386,389.933,415.424,526.471,36,70,328,233,431,202,157.222,172.827
+51.0408,364.366,333.008,466.428,127.901,56,47,555,428,123,92,86,165,663.303,336.807,547.752,362.652,318.92,283.003,193.437,232.605,258.461,396.796,326.545,302.194,385.319,53,353.574,357.016,353.786,81.963,110.779,70.6,1119.239,768.928,1189.418,504.465,404.864,366.378,401.634,466.017,211.008,400.955,90.817,75.058,69.389,1327.398,425.159,516.739,1038.697,390.878,416.431,530.457,36,70,333,236,437,201,158.004,176.647
+51.2076,363.336,332.824,473.07,131.411,56,47,558,431,123,93,86,166,663.065,342.245,552.717,367.931,321.977,286.151,196.819,234.191,258.546,397.178,325.715,307.836,385.132,52,355.887,360.485,356.453,83.999,111.855,72.498,1143.814,767.951,1193.144,507.934,412.137,366.713,407.229,475.478,211.15,401.578,90.092,74.492,67.598,1337.963,425.286,514.646,1045.953,395.329,417.381,537.871,37,67,323,233,444,200,162.197,175.628
+51.3744,365.444,335.028,478.484,131.916,56,47,557,428,120,91,87,166,662.144,336.506,556.449,372.248,332.983,292.396,202.248,239.615,258.83,397.631,328.301,308.431,387.628,52.5,361.484,357.111,355.685,84.056,112.45,72.979,1137.815,771.366,1203.879,517.347,416.699,376.302,410.967,475.803,212.537,400.586,89.637,75.455,66.517,1337.482,433.772,527.672,1048.598,396.48,422.146,535.644,36,69,323,233,440,200,161.074,176.477
+51.5412,367.432,336.068,482.6,129.445,57,47,553,433,123,90,86,167,660.737,337.365,552.679,372.517,338.536,297.448,200.443,234.205,261.192,398.89,327.907,311.844,390.606,52,362.985,362.718,361.385,84.593,112.804,71.634,1144.084,773.301,1217.218,519.021,424.92,377.529,414.551,475.506,210.98,398.887,87.76,71.844,66.929,1338.854,430.519,521.039,1050.776,400.411,425.419,545.303,37,67,323,237,439,199,158.373,175.982
+51.708,371.864,339.181,490.627,133.563,57,46,556,431,124,91,88,172,661.557,342.837,562.751,378.996,338.841,303.129,204.523,239.332,261.462,402.372,328.839,315.786,386.92,51.5,356.569,363.524,365.053,85.173,114.079,74.112,1149.511,778.093,1209.4,529.277,425.815,380.797,412.143,469.435,210.57,397.315,87.973,74.336,67.214,1360.211,436.007,523.542,1059.22,402.288,425.062,547.586,35,68,331,236,444,199,159.66,175.572
+51.8748,370.386,344.324,489.637,132.331,55,47,563,431,122,93,88,173,662.282,335.709,556.561,387.707,349.448,307.852,202.959,236.528,262.515,405.203,332.687,315.795,392.133,51.5,361.809,360.738,362.192,85.272,110.51,73.532,1157.707,782.272,1224.913,533.443,433.597,380.048,413.74,477.511,209.904,396.054,87.376,74.733,70.527,1347.369,442.103,528.379,1052.148,401.497,432.55,547.349,36,67,331,237,443,201,158.942,178.807
+52.0416,378.629,346.711,494.764,133.397,55,47,562,437,124,91,88,177,664.711,338.333,563.798,388.765,350.984,311.111,204.025,242.028,260.694,405.231,332.068,323.367,394.61,53.5,366.447,367.414,355.058,81.043,112.153,72.016,1168.93,782.304,1225.341,541.42,429.92,389.443,414.728,475.756,213.16,397.357,88.357,76.135,69.73,1349.504,440.943,530.048,1049.39,395.56,429.314,550.345,37,70,334,242,446,199,159.951,176.152
+52.2084,375.133,346.183,501.456,134.803,57,47,560,435,124,90,89,179,671.775,339.082,556.965,398.961,356.743,315.015,210.094,245.655,262.7,406.448,334.088,320.455,398.88,52.5,365.303,368.079,363.677,84.82,113.881,72.47,1164.446,783.126,1230.893,540.382,442.726,388.231,421.917,476.831,210.796,402.866,89.566,72.765,65.934,1351.838,442.782,535.989,1055.288,403.965,427.514,554.704,36,69,340,246,446,200,163.931,176.987
+52.3752,384.921,344.661,499.837,136.852,56,47,551,435,124,94,90,185,667.959,339.993,564.789,402.016,361.165,321.984,207.237,252.295,263.126,403.462,335.326,325.319,397.032,52.5,361.841,366.38,366.524,85.216,113.626,72.781,1179.175,785.634,1231.236,547.506,440.863,399.3,420.021,476.398,210.301,400.232,88.045,74.917,69.73,1358.669,439.854,525.423,1058.852,398.267,433.029,559.052,36,69,343,244,446,198,154.778,179.647
+52.542,383.927,346.311,506.712,133.067,57,47,556,436,125,92,91,186,670.321,339.321,563.405,407.695,366.412,326.906,212.155,251.713,267.01,410.496,340.042,327.31,401.313,53.5,364.373,367.44,368.717,84.947,114.801,73.928,1174.533,783.434,1243.695,553.421,445.292,396.229,423.8,477.396,213.06,401.436,88.201,71.915,68.636,1362.912,445.37,531.463,1057.381,403.59,430.274,562.486,37,70,350,247,445,204,160.051,179.562
+52.7088,383.872,353.356,510.749,133.718,55,47,552,439,125,93,94,191,673.842,335.456,563.655,409.352,370.151,333.13,209.826,253.467,269.229,412.69,337.025,331.103,405.529,53,366.901,369.717,363.888,83.886,114.051,74.452,1189.082,790.033,1247.9,562.55,451.749,403.079,425.119,483.915,204.993,398.83,90.277,73.926,68.863,1352.984,445.908,530.755,1056.476,403.017,429.725,562.415,37,69,350,254,446,201,158.174,176.166
+52.8756,384.827,346.652,514.065,136.755,57,48,556,440,125,95,93,193,675.145,338.4,563.455,416.09,377.218,336.618,218.11,253.325,267.536,409.859,343.041,333.555,408.823,53,367.889,365.091,363.508,85.145,114.306,74.424,1191.83,795.431,1246.658,566.602,453.659,405.345,425.034,477.114,210.286,405.784,87.319,72.765,68.294,1366.18,445.455,531.802,1057.975,404.24,429.665,565.07,37,69,354,253,449,202,159.937,179.93
+53.0424,386.643,354.686,512.369,139.103,56,48,551,444,126,95,96,198,669.696,339.216,570.531,425.175,382.621,347.011,217.541,263.414,269.229,417.233,341.288,340.481,410.982,53,368.602,366.928,363.007,85.102,115.637,73.9,1190.147,796.665,1254.748,570.74,454.156,408.161,428.571,482.907,208.815,404.481,90.035,75.172,69.361,1360.749,444.267,534.362,1064.806,400.569,427.339,569.108,37,69,357,259,450,201,156.597,181.288
+53.2092,386.74,355.817,520.209,138.276,56,48,563,445,126,95,95,201,671.103,342.474,571.059,425.843,387.2,350.236,222.544,263.561,272.06,413.85,345.544,337.691,410.223,52.5,371.455,370.721,368.909,86.757,114.546,72.979,1197.155,801.111,1257.75,574.124,462.889,409.323,434.479,488.923,209.805,404.014,90.49,74.959,67.754,1361.003,446.36,535.465,1060.379,402.124,430.671,567.717,37,68,366,261,453,199,158.487,182.548
+53.376,391.911,358.448,520.095,138.018,55,49,556,449,125,98,94,202,665.932,340.041,564.68,432.618,393.992,349.917,221.052,271.953,274.037,417.488,345.792,343.125,419.437,53,369.277,374.793,367.481,87.295,118.923,73.631,1198.849,794.576,1262.491,585.636,462.762,409.054,434.061,485.95,207.654,408.064,88.343,75.327,68.764,1368.329,449.627,532.82,1060.054,402.514,432.901,573.364,37,69,366,267,453,200,157.208,183.142
+53.5428,389.652,351.686,525.309,139.356,55,45,559,450,128,96,97,206,668.155,337.112,568.192,444.997,399.764,358.659,223.539,271.783,274.023,421.097,350.749,345.593,418.044,53.5,368.471,368.769,363.026,88.03,116.416,72.909,1204.429,797.227,1265.89,593.526,469.219,414.051,441.335,491.91,212.169,405.869,90.291,75.143,68.067,1361.668,453.573,530.444,1064.467,396.008,429.058,574.114,37,70,366,270,449,200,158.572,182.788
+53.7096,390.746,358.341,528.207,139.065,57,47,563,450,128,96,94,207,671.123,343.553,574.747,446.227,407.107,358.584,225.444,274.938,280.026,428.329,355.663,355.911,430.129,52.5,368.711,370.268,367.552,85.697,117.959,73.503,1207.68,804.368,1271.506,593.903,468.821,414.782,438.378,494.57,214.603,414.112,89.836,73.204,68.906,1355.445,448.595,527.729,1054.326,398.503,427.869,570.141,38,67,375,276,458,201,158.885,180.453
+53.8764,392.118,357.684,531.659,143.007,56,48,567,456,128,97,99,211,665.76,341.668,570.093,452.4,407.249,366.685,226.766,276.412,277.622,428.003,357.524,352.802,426.7,53,370.267,373.096,369.914,88.497,117.039,76.449,1213.401,802.857,1279.548,599.605,472.068,420.195,441.109,492.274,211.475,411.732,90.377,73.529,69.645,1364.355,447.732,525.423,1054.722,397.31,428.731,569.317,36,70,373,282,457,201,157.819,180.34
+54.0432,390.547,359.094,532.17,140.022,57,48,570,451,126,95,101,216,664.801,339.526,570.84,449.048,410.206,369.612,233.04,282.789,282.601,428.442,362.121,361.993,431.786,52.5,368.245,369.032,369.178,87.974,116.926,73.702,1212.813,804.471,1282.807,604.596,476.296,415.264,443.471,500.127,211.9,415.216,91.343,71.547,69.787,1358.782,448.68,531.873,1053.053,398.012,427.213,569.372,36,69,378,286,456,200,155.36,182.052
+54.21,393.89,362.862,533.115,144.605,57,49,569,455,128,98,99,217,669.398,337.923,568.186,459.478,424.795,380.133,234.391,283.512,281.178,425.342,364.299,362.305,442.188,53.5,372.389,373.097,364.315,85.838,116.855,74.82,1208.115,811.439,1284.708,614.464,483.603,420.149,442.07,507.386,217.377,413.446,88.77,75.356,68.323,1364.581,446.304,531.689,1047.523,398.229,424.93,572.389,37,70,380,289,457,201,152.802,177.581
+54.3768,393.25,359.985,534.398,145.284,57,48,570,460,132,100,101,225,665.159,341.482,567.771,462.577,430.243,378.047,239.011,285.65,289.33,428.753,366.426,366.958,439.916,53.5,371.682,372.12,369.024,88.313,120.834,74.452,1230.163,810.399,1285.309,615.859,481.165,422.708,445.396,506.084,213.995,419.323,89.353,74.733,69.958,1347.963,450.278,524.348,1050.083,397.229,426.467,575.645,37,70,386,293,459,201,153.101,179.788
+54.5436,393.449,359.802,541.456,144.605,54,48,575,464,129,99,99,223,664.477,341.243,571.515,473.79,431.252,388.953,240.276,295.718,288.021,437.571,372.912,370.788,448.199,54.5,374.632,370.933,364.359,90.293,119.631,75.628,1226.899,806.54,1283.931,625.185,485.152,423.111,448.663,508.86,213.98,415.91,90.476,74.676,68.365,1355.43,445.398,528.606,1050.267,394.988,424.428,572.007,37,72,390,295,459,205,150.699,180.821
+54.7104,399.341,360.839,535.58,144.81,56,46,573,464,132,99,101,222,670.86,337.756,570.153,478.305,440.891,391.044,239.85,297.207,293.697,432.136,372.63,373.082,453.257,53.5,369.66,368.51,367.864,89.232,118.526,76.534,1220.653,805.13,1291.584,626.422,484.294,421.871,443.161,517.521,215.863,421.278,91.059,73.713,69.247,1357.043,443.857,524.758,1046.349,393.299,423.025,568.395,37,70,389,301,467,205,151.452,181.048
+54.8772,394.369,361.555,543.962,149.356,58,48,574,470,132,102,103,227,668.837,340.222,570.053,485.455,444.986,393.751,242.343,298.46,290.297,440.557,371.441,379.682,457.717,54.5,369.358,370.803,369.782,91.552,121.089,77.54,1229.321,804.477,1305.243,630.034,478.447,424.456,447.053,518.215,214.957,419.663,90.59,75.37,68.721,1344.809,446.134,528.04,1042.573,388.751,421.89,565.046,38,71,397,305,463,204,151.082,178.458
+55.044,393.852,357.868,542.93,147.999,56,49,579,470,131,102,104,232,665.732,335.728,569.781,487.774,451.413,399.195,248.511,304.504,295.262,437.373,379.824,381.031,457.194,53.5,369.278,370.451,364.895,90.944,120.749,76.308,1231.015,802.61,1302.319,633.688,484.549,426.536,452.601,515.738,220.703,422.651,91.073,75.752,69.958,1351.046,445.667,524.674,1050.026,389.702,418.619,567.877,37,70,401,313,468,204,148.396,178.416
+55.2108,393.62,364.418,545.62,149.715,56,47,589,472,132,104,105,231,662.382,337.46,570.809,489.192,454.783,405.827,252.562,309.216,298.462,440.444,387.763,386.367,461.112,53,366.815,369.358,367.945,88.964,120.466,78.432,1242.15,808.825,1299.221,641.224,486.183,427.882,449.941,518.013,218.17,427.481,89.267,73.09,69.958,1345.572,441.24,523.867,1042.191,386.339,419.572,567.704,37,69,404,316,469,202,147.543,177.914
+55.3776,395.874,360.863,549.104,152.087,58,49,586,472,133,102,105,234,663.442,337.794,569.091,499.128,460.594,406.261,255.746,309.896,299.828,441.619,390.446,392.699,474.189,52.5,366.351,369.701,365.729,90.76,123.143,76.194,1240.272,802.928,1297.843,642.5,487.946,426.309,454.437,523.828,222.048,433.344,93.021,74.195,68.778,1335.318,444.21,519.073,1032.403,383.15,418.403,566.844,36,69,411,316,474,204,149.249,178.331
+55.5444,400.44,362.975,545.577,153.345,56,48,587,482,133,103,105,240,661.381,334.431,567.388,505.74,462.143,412.254,255.618,322.235,301.649,443.09,392.36,395.275,475.524,53.5,359.872,372.312,362.177,90.01,123.44,77.809,1239.377,793.895,1298.444,649.551,488.71,422.503,460.635,526.871,218.283,428.571,90.846,75.965,70.257,1345.968,446.148,517.885,1031.017,379.653,417.704,564.531,37,70,418,319,466,204,146.804,177.454
+55.7112,395.363,366.312,548.124,151.751,57,49,593,482,134,106,106,242,664.843,329.894,568.656,514.38,469.656,418.303,259.212,321.216,307.794,448.016,394.553,398.993,473.92,54.5,367.765,368.952,365.22,89.43,121.273,79.253,1243.474,802.385,1305.817,654.59,490.593,426.663,459.121,524.725,223.307,436.276,92.225,73.798,70.484,1335.997,438.595,517.22,1031.611,381.577,410.417,559.548,38,71,420,332,476,207,148.368,178.387
+55.878,396.053,360.739,547.018,154.924,56,50,589,480,136,107,105,247,662.764,334.278,566.83,519.401,472.827,416.854,262.629,324.542,307.367,450.11,398.866,401.323,479.499,55.5,362.392,370.633,363.791,92.825,122.846,80.018,1244.515,797.664,1304.627,651.533,488.908,424.895,459.175,531.618,225.586,441.884,90.832,75.2,68.92,1330.424,440.392,514.419,1026.633,378.084,410.736,569.828,38,73,420,328,481,207,146.818,176.888
+56.0448,395.436,358.963,545.301,154.555,57,50,599,485,136,107,110,249,661.385,333.529,571.083,525.65,480.591,423.916,265.573,329.158,306.059,453.408,404.623,408.625,489.867,54,362.081,366.321,360.808,90.265,120.268,77.71,1247.399,799.765,1306.398,657.036,487.111,425.628,462.522,524.946,228.827,438.938,89.196,74.874,69.318,1326.521,438.157,506.909,1026.519,375.099,407.244,558.368,38,70,418,337,479,204,147.757,175.543
+56.2116,395.349,355.947,546.178,156.151,56,51,597,486,139,107,112,248,661.419,330.738,571.349,518.353,486.421,420.804,269.106,330.838,316.799,450.592,411.524,416.25,488.268,55,365.543,363.734,358.797,90.477,124.602,78.517,1237.018,795.337,1299.87,657.363,493.428,422.97,466.471,530.408,229.421,442.904,91.016,75.596,69.346,1322.363,433.687,505.41,1023.677,374.329,404.369,556.602,38,72,430,344,476,204,144.587,176.336
+56.3784,392.937,361.759,552.155,153.206,56,49,603,491,140,106,109,252,660.742,331.754,562.931,527.031,484.217,427.075,268.978,333.3,315.334,455.913,408.9,422.712,494.597,54,364.315,363.098,360.398,90.505,122.364,77.37,1245.949,798.586,1310.783,653.609,484.393,423.236,463.479,529.319,227.468,446.275,90.775,73.869,71.309,1320.793,435.243,509.978,1016.152,372.588,403.936,554.664,38,70,431,349,480,208,141.517,177.001
+56.5452,386.719,358.231,548.271,157.205,57,50,607,495,141,110,112,252,659.019,329.774,563.168,530.131,491.129,429.425,268.978,338.663,314.38,460.032,416.036,422.453,502.723,55.5,362.293,361.046,359.677,89.643,122.35,75.684,1249.828,796.082,1308.095,660.582,495.769,421.908,461.447,534.611,232.252,445.68,91.528,74.464,69.56,1310.312,433.645,499.639,1009.292,366.172,404.643,551.649,39,72,435,350,481,206,143.091,175.388
+56.712,389.597,354.152,547.326,158.224,58,51,606,497,144,109,114,256,656.987,329.297,559.484,538.974,496.715,434.023,271.707,347.945,321.152,456.805,420.655,422.585,510.756,54,361.374,357.679,360.624,90.279,124.503,78.474,1250.884,799.519,1313.973,663.377,488.781,423.544,464.255,537.082,235.705,453.767,94.443,74.888,69.46,1313.183,432.796,504.208,1010.042,369.142,397.229,548.492,39,69,449,358,481,210,141.631,173.053
+56.8788,387.155,354.728,547.297,158.684,56,51,615,498,141,107,112,257,656.449,330.652,560.543,546.299,502.645,442.231,279.227,353.761,324.025,466.075,421.637,434.406,512.015,55,366.549,360.692,355.336,90.138,125.862,77.271,1246.189,801.431,1302.581,667.387,488.201,419.89,461.484,534.973,236.059,457.505,93.064,75.625,70.811,1298.05,432.485,504.632,1006.153,365.89,394.063,544.496,38,72,448,361,483,207,139.3,172.077
+57.0456,386.33,349.723,547.055,159.604,59,49,616,503,144,111,112,259,653.056,328.582,561.875,551.535,504.705,441.259,279.249,354.907,323.57,464.688,427.92,436.445,515.373,55.5,362.18,357.147,358.717,91.396,125.48,79.848,1249.535,790.753,1306.588,664.847,483.862,417.435,468.842,543.565,241.848,468.056,92.495,74.789,71.167,1302.222,424.183,496.075,989.802,362.962,392.135,540.253,39,72,456,370,484,207,140.289,175.076
+57.2124,386.186,350.392,546.647,160.452,57,49,616,503,143,110,114,262,652.173,329.164,554.705,549.067,508.816,447.517,279.519,353.549,325.448,472.345,430.293,440.142,524.956,55,354.04,356.955,353.432,90.251,123.327,76.633,1244.257,791.799,1312.498,664.828,490.862,414.116,470.186,532.601,243.461,465.507,91.614,75.54,69.688,1300.383,425.583,494.491,992.886,357.331,389.106,538.507,39,71,460,373,485,210,140.281,169.397
+57.3792,382.979,351.992,538.827,161.923,58,49,621,512,142,116,115,262,649.473,330.061,559.455,553.971,506.868,448.467,282.33,360.301,329.858,468.467,432.395,440.222,531.25,55,360.286,356.148,349.744,90.138,124.177,79.211,1243.617,797.513,1310,665.866,486.757,415.916,476.364,534.066,238.168,465.96,91.642,76.135,71.124,1286.607,423.08,492.044,993.833,353.62,382.795,533.281,37,73,463,377,489,209,136.898,168.483
+57.546,386.788,348.344,536.932,162.94,59,49,620,513,147,113,116,264,645.58,322.991,559.196,560.623,512.314,448.734,284.825,366.38,332.475,471.496,444.606,447.45,528.888,54,355.586,353.176,347.453,91.382,124.998,77.993,1231.409,790.067,1309.074,673.914,482.27,414.358,478.869,538.921,242.57,471.073,91.571,75.922,70.171,1289.804,421.213,487.235,981.698,352.581,380.983,527.958,37,71,464,383,491,208,137.495,169.431
+57.7128,386.603,347.216,540.514,164.699,59,51,623,516,144,118,117,263,644.173,325.018,557.249,561.186,517.518,453.46,288.762,370.146,332.93,468.835,438.584,450.702,534.11,55.5,355.125,356.997,349.431,91.835,124.559,79.352,1238.324,793.559,1305.533,670.686,484.534,411.209,483.469,543.379,248.358,472.334,91.941,76.517,71.579,1268.815,420.421,482.738,977.766,348.65,378.523,528.432,39,72,475,382,488,211,137.317,170.209
+57.8796,378.302,341.48,534.735,165.817,57,51,629,508,148,116,116,269,649.96,325.629,562.06,568.862,519.893,460.129,290.453,372.353,331.821,470.095,450.179,454.064,536.144,54,355.705,349.292,346.925,91.609,125.933,79.749,1228.699,790.426,1299.187,668.937,486.198,412.262,476.662,542.544,248.641,476.795,91.557,75.455,70.612,1272.096,415.909,480.305,970.185,349.888,373.187,525.334,37,71,483,391,490,208,134.837,166.308
+58.0464,378.487,346.141,535.446,165.648,57,51,634,518,149,117,119,269,637.593,316.916,552.07,566.347,518.812,455.303,291.036,379.246,335.861,476.011,453.469,465.086,544.548,55.5,350.423,350.784,344.431,93.589,124.488,78.956,1237.686,787.989,1299.274,667.387,483.614,409.635,478.954,544.931,249.391,478.069,90.448,75.101,70.313,1268.9,413.349,477.802,963.877,341.601,371.844,516.375,39,72,488,397,490,210,131,164.04
+58.2132,372.632,339.701,528.589,166.245,57,51,630,520,150,119,118,270,636.768,321.044,556.484,573.958,524.67,462.762,295.783,378.679,337.326,476.393,459.302,461.513,549.114,55.5,346.684,355.043,344.673,89.487,124.092,79.126,1230.729,786.852,1304.026,669.975,483.121,405.02,476.95,540.746,252.01,482.134,92.04,75.2,70.612,1258.73,413.221,477.363,971.076,339.115,367.466,512.312,40,71,485,404,492,210,131.597,166.954
+58.38,372.789,338.289,535.204,167.744,59,50,642,530,148,117,119,272,630.437,317.447,548.19,573.166,528.651,463.995,300.388,379.896,343.77,482.096,461.145,467.392,553.301,53,354.011,348.303,346.057,93.108,125.607,77.044,1224.889,783.759,1293.778,672.165,474.54,399.819,476.327,543.362,254.402,485.915,90.988,76.701,70.285,1252.351,410.124,477.024,961.869,334.498,370.827,515.618,37,69,494,405,496,211,128.555,166.629
+58.5468,372.079,340.283,524.783,166.638,58,50,643,529,153,119,118,271,634.144,318.21,551.612,578.658,522.822,459.662,299.862,384.296,342.874,481.728,466.868,472.192,560.57,55,350.981,348.472,339.697,92.33,128.256,79.466,1213.215,784.128,1301.188,671.397,474.747,400.532,483.954,539.517,256.043,487.091,92.197,77.069,70.612,1246.029,408.809,472.865,959.761,334.885,365.524,509.452,39,71,491,405,493,211,131.042,165.653
+58.7136,372.547,334.017,528.199,170.757,59,50,647,526,149,118,122,272,629.278,314.885,547.907,583.655,522.438,465.537,297.694,392.23,345.719,483.016,463.1,475.128,562.747,54.5,344.17,343.046,339.491,92.683,124.913,81.066,1208.478,782.99,1292.409,669.022,478.3,398.188,480.112,546.793,255.038,491.977,89.865,76.871,70.811,1237.642,403.349,469.23,944.274,330.435,359.409,503.773,37,72,507,415,497,213,128.527,163.856
+58.8804,371.709,332.389,523.138,169.427,59,50,643,530,150,121,119,271,635.796,317.093,542.952,587.633,525.026,463.541,300.154,387.752,344.424,484.757,472.639,474.033,565.308,54,348.275,342.15,341.944,93.659,123.015,81.505,1209.806,774.986,1283.96,671.383,473.707,395.21,477.003,539.828,258.336,492.883,92.438,75.54,68.678,1233.3,403.222,467.038,943.977,328.619,355.799,493.396,39,69,506,414,489,212,127.176,163.091
+59.0472,367.923,332.786,524.153,168.313,59,50,653,534,152,121,121,274,626.732,313.625,545.427,590.038,524.902,467.085,298.299,396.795,349.218,490.659,473.24,481.875,574.997,54,340.997,344.356,339.188,92.669,126.967,82.921,1203.601,773.312,1285.549,666.8,473.535,391.784,472.232,542.461,256.086,498.605,91.585,77.536,69.574,1234.474,398.597,465.497,938.249,328.217,354.398,496.336,38,70,508,419,489,212,123.282,162.709
+59.214,360.927,327.799,521.672,171.961,59,49,658,530,152,123,124,275,627.426,315.433,545.456,584.396,533.33,465.143,301.525,396.002,353.472,487.701,480.687,485.632,578.943,53,342.65,338.326,333.932,90.859,126.33,82.709,1202.128,770.781,1287.745,664.131,465.778,389.899,468.255,546.833,260.954,503.392,93.121,76.078,70.015,1222.183,401.581,455.907,939.762,322.334,355.059,490.859,36,70,517,420,492,212,125.982,160.799
+59.3808,358.412,325.743,517.879,171.026,59,50,655,539,155,122,124,272,617.075,314.961,541.47,590.812,530.614,466.242,299.024,403.037,353.714,486.187,484.358,490.418,576.697,54,334.866,338.184,335.318,90.59,124.658,79.749,1203.987,765.116,1280.355,661.913,464.15,389.985,469.309,545.817,262.271,505.885,91.656,75.582,69.844,1217.827,392.43,458.693,929.579,321.911,349.585,489.883,38,70,515,429,496,212,123.723,158.96
+59.5476,363.498,328.725,513.617,172.857,60,50,656,540,157,124,122,271,627.365,310.896,539.763,593.947,534.197,464.22,301.902,406.145,348.336,488.536,486.373,489.499,588.532,54,337.044,338.297,335.092,91.962,125.451,80.457,1195.366,762.656,1283.158,660.42,463.824,385.824,469.422,541.431,266.503,501.381,95.837,76.956,70.37,1206.215,396.485,452.929,925.027,321.456,345.483,481.279,38,70,523,431,494,210,123.609,159.172
+59.7144,352.043,322.855,509.3,170.701,58,50,661,546,153,123,120,274,625.615,310.8,542.808,586.772,535.695,466.724,301.405,408.552,352.063,495.697,488.281,491.04,588.239,52.5,339.448,337.646,331.287,89.968,127.208,81.349,1189.795,760.528,1276.871,664.023,463.165,377.415,468.616,542.082,265.71,495.957,92.111,77.112,71.11,1206.102,391.525,448.524,920.654,319.786,345.492,475.427,37,68,525,433,494,215,123.04,157.276
+59.8812,352.872,320.919,512.85,170.728,60,52,664,553,152,126,124,278,620.112,308.568,538.607,598.333,532.121,470.701,301.021,407.589,357.227,496.745,493.246,495.702,590.809,55,335.912,334.553,329.194,90.831,128.723,80.84,1186.563,757.357,1271.708,659.994,460.582,378.746,467.894,539.6,265.682,504.242,91.116,75.568,71.138,1190.162,389.471,446.403,912.909,314.481,343.131,477.672,38,72,527,432,496,210,120.335,160.686
+60.048,353.582,316.107,506.031,173.939,58,50,674,551,160,125,123,273,622.055,307.065,537.219,596.268,534.879,464.56,307.176,407.304,355.364,494.523,494.682,494.123,596.185,54.5,334.045,330.385,329.548,92.613,125.182,79.183,1178.059,757.518,1272.553,655.272,451.968,374.989,467.872,539.119,271.513,504.355,94.784,76.474,71.38,1183.09,388.513,448.807,909.693,312.977,337.467,474.096,38,71,530,442,489,213,120.368,156.118
+60.2148,355.116,317.735,509.71,171.65,59,50,671,550,158,127,124,272,619.66,308.191,531.703,597.219,538.335,461.678,307.04,412.228,359.091,496.207,500.884,492.189,596.226,54.5,329.873,326.993,327.355,91.877,128.411,80.939,1169.489,754.018,1270.606,658.728,451.438,378.208,465.646,545.276,272.758,506.012,93.988,76.205,72.276,1183.981,384.665,441.481,906.666,306.281,335.607,468.071,38,71,536,445,490,211,120.837,153.427
+60.3816,346.853,313.788,501.736,176.34,60,51,677,560,161,127,123,277,609.918,310.96,534.629,596.863,536.122,469.529,303.6,414.515,360.684,495.414,504.327,497.857,597.077,55,332.386,332.153,333.503,90.406,125.919,78.97,1173.816,748.24,1261.059,662.843,450.588,371.554,469.189,544.879,273.254,506.168,92.964,77.451,70.37,1177.065,382.077,440.943,904.148,308.016,335.086,463.077,38,72,540,445,494,211,119.175,156.285
+60.5484,345.854,313.292,499.552,171.848,60,52,679,554,161,127,124,271,611.754,306.922,529.562,600.586,535.576,465.367,305.178,418.507,362.491,489.951,503.175,498.506,597.754,53,333.626,327.027,323.749,92.726,126.032,80.981,1164.32,745.667,1261.836,651.561,445.563,367.315,466.5,544.101,276.834,512.838,90.903,77.296,70.271,1169.385,381.412,430.18,893.031,304.689,331.246,462.885,39,67,535,446,490,213,115.636,152.72
+60.7152,347.51,309.967,497.478,173.151,61,50,681,553,160,128,123,271,608.41,306.446,532.635,595.746,539.202,462.381,298.455,421.479,361.068,496.844,511.847,502.652,599.357,54,328.13,324.563,322.275,92.966,127.052,79.593,1165.41,746.991,1249.442,645.177,441.124,365.785,465.58,544.044,274.867,511.804,92.765,74.308,73.314,1168.126,380.62,435.512,892.749,301.055,325.632,459.214,38,70,539,447,487,214,118.35,155.351
+60.882,340.718,307.795,490.202,171.902,59,50,681,559,162,127,124,270,605.605,304.305,532.26,603.063,536.99,460.653,304.851,419.936,361.907,498.146,509.413,499.837,602.874,53,327.762,322.288,321.837,92.712,131.655,79.579,1156.237,740.078,1243.438,642.471,439.835,359.421,464.702,538.128,280.019,521.562,93.519,76.559,72.276,1167.815,375.769,428.483,897.586,298.962,326.296,455.203,37,69,544,447,485,210,113.978,151.729
+61.0488,342.693,302.682,487.858,173.14,58,51,685,560,165,128,124,270,610.668,302.155,526.662,599.272,535.235,458.353,299.585,422.554,360.727,500.637,514.594,505.962,607.5,54.5,327.451,320.679,319.843,92.698,127.052,78.701,1149.251,728.12,1240.933,641.736,434.309,360.625,465.207,541.469,278.349,516.69,94.528,78.287,70.171,1153.049,371.696,431.439,889.637,301.126,319.351,449.751,40,69,541,454,484,210,112.423,152.944
+61.2156,338.765,301.873,479.678,170.86,60,52,685,567,163,131,124,269,607.694,298.789,523.565,598.549,531.089,463.41,303.29,420.792,360.058,497.651,519.087,508.675,609.72,53,321.766,321.118,321.526,92.245,129.573,80.188,1141.493,737.29,1244.061,643.388,429.807,360.584,460.952,541.503,279.141,522.908,91.87,76.319,70.783,1137.83,367.071,427.705,883.371,297.883,318.653,445.735,37,69,546,458,482,210,116.062,149.508
+61.3824,334.513,303.145,486.211,175.374,62,50,696,565,164,131,122,266,605.149,302.996,524.788,602.02,530.114,459.543,302.428,426.149,366.303,496.872,521.024,509.95,610.064,54,322.29,317.681,320.932,90.109,129.941,79.678,1142.638,724.971,1237.575,642.509,433.247,350.717,464.303,534.76,285.595,521.633,93.547,74.846,72.546,1141.932,367.495,425.555,887.897,295.968,320.536,442.04,39,69,548,454,486,210,115.124,149.21
+61.5492,336.474,302.145,478.546,169.1,60,51,692,562,162,131,124,265,605.862,301.274,525.812,599.47,528.535,455.761,299.273,427.146,365.065,501.047,523.075,513.943,613.227,53.5,318.756,317.283,317.964,89.869,130.564,81.094,1142.395,718.348,1238.929,631.906,426.241,348.905,467.2,538.709,284.831,522.497,95.282,76.786,72.617,1132.371,366.689,424.763,879.524,294.431,315.668,443.033,37,70,547,456,486,209,109.638,148.659
+61.716,331.78,295.793,474.146,171.395,59,50,700,563,165,131,124,265,608.313,299.542,524.346,596.651,532.845,453.065,298.771,424.102,365.649,498.429,521.449,511.704,615.375,53.5,322.106,313.509,314.23,92.896,127.307,80.641,1139.218,725.043,1236.729,638.039,421.474,349.176,460.823,543.622,283.727,519.466,94.87,77.027,71.024,1129.556,362.092,419.685,888.661,290.478,314.124,433.897,37,70,545,461,489,210,109.993,146.918
+61.8828,331.665,295.207,470.162,171.719,60,51,699,570,165,131,122,263,599.084,296.898,521.311,589.101,523.306,455.209,295.783,425.119,363.757,501.047,521.322,503.321,613.708,53.5,319.08,314.713,313.777,91.623,129.771,78.786,1133.424,721.396,1216.316,630.635,423.276,343.664,460.304,538.043,281.972,532.963,93.007,74.86,72.304,1126.487,361.838,421.255,875.069,291.941,307.364,436.701,37,70,549,459,482,211,108.955,148.262
+62.0496,331.292,294.081,469.037,170.978,60,50,704,571,165,134,124,260,600.226,296.931,520.467,590.896,521.485,447.32,298.923,427.833,364.667,497.693,527.454,514.405,615.332,54.5,317.553,320.737,311.543,92.669,128.185,81.392,1121.24,719.47,1222.276,625.441,419.115,344.066,459.563,539.388,289.671,526.562,94.6,75.993,70.768,1108.199,359.942,418.158,872.41,291.605,315.054,430.526,37,72,549,458,477,212,109.723,147.06
+62.2164,328.227,294.27,465.563,173.921,59,49,705,574,165,131,122,260,599.121,296.074,518.8,592.147,523.476,445.449,296.807,429.532,367.327,504.416,525.989,511.918,616.961,54.5,316.069,313.901,313.339,89.331,129.219,81.222,1118.232,720.875,1220.169,625.256,412.995,340.992,459.45,538.459,290.874,529.522,93.803,76.97,72.261,1109.939,359.546,419.063,871.971,288.799,312.378,424.199,38,71,546,459,475,210,107.165,147.357
+62.3832,321.533,291.393,459.974,170.365,58,49,707,571,167,131,122,259,593.784,296.558,516.095,594.06,524.473,445.011,292.767,420.379,370.101,503.935,526.179,512.043,612.471,53,313.763,314.615,312.985,89.43,130.168,78.8,1118.983,709.072,1215.246,619.861,415.405,334.919,460.347,534.916,290.662,529.734,96.32,77.819,72.802,1114.833,352.262,417.196,869.157,288.812,305.644,427.684,37,69,556,461,475,206,108.344,147.428
+62.55,318.819,289.993,459.874,171.267,60,50,705,574,162,134,124,262,595.952,293.707,516.659,589.866,516.878,447.602,290.135,420.255,367.171,506.199,529.44,504.426,619.252,52.5,313.721,309.854,309.421,90.321,128.68,79.013,1110.792,705.958,1215.941,608.79,408.442,331.024,460.007,539.97,287.35,527.057,93.576,77.451,71.38,1092.118,348.967,413.943,867.672,289.752,309.498,419.18,37,68,547,462,467,211,105.672,144.796
+62.7168,318.876,286.527,455.229,171.833,62,48,704,579,168,135,121,253,591.573,295.758,512.652,586.139,517.219,438.729,291.918,417.209,364.838,500.099,523.304,505.693,613.406,52,312.137,315.361,310.157,91.948,129.332,79.862,1104.667,709.35,1202.493,613.454,403.03,331.821,460.012,538.482,293.761,532.057,94.145,77.14,72.603,1100.137,348.797,416.46,871.434,287.61,307.377,417.704,36,68,551,458,467,208,108.287,145.178
+62.8836,321.847,284.815,451.936,171.365,63,50,706,576,167,133,120,259,605.562,297.939,513.239,587.591,510.52,434.153,287.133,422,365.876,501.925,525.395,511.932,618.036,52,310.61,309.039,313.07,88.794,126.669,80.514,1104.557,702.878,1207.222,611.79,402.293,326.556,458.426,528.235,290.322,529.196,92.922,74.365,70.825,1093.461,349.434,409.841,864.984,286.768,299.09,410.294,36,68,546,454,475,206,107.52,142.362
+63.0504,320.155,282.166,439.133,169.214,59,48,714,583,168,134,120,252,588.53,292.862,514.548,585.57,510.181,433.976,290.7,419.562,366.445,497.693,535.003,506.739,621.026,53,310.102,311.457,306.859,90.477,128.68,78.772,1099.614,698.836,1205.384,607.844,400.661,326.679,453.578,540.152,291.709,531.462,93.846,77.338,72.034,1095.71,347.934,409.516,870.981,285.925,302.708,409.946,36,70,551,456,468,207,107.165,144.258
+63.2172,313.094,283.768,439.318,165.053,59,49,708,579,169,137,120,249,559.938,292.758,508.738,579.415,505.189,428.409,289.188,416.384,361.281,502.548,529.963,502.018,621.43,52.5,310.417,303.624,310.177,91.778,127.108,78.021,1096.265,707.22,1201.311,604.145,397.158,328.478,455.389,543.379,291.525,529.408,95.268,75.922,72.432,1089.643,342.814,408.78,866.597,281.391,304.931,406.957,36,69,547,453,466,205,106.312,142.051
+63.384,314.245,281.426,442.585,162.704,58,49,716,579,168,135,121,247,568.441,294.461,509.331,579.061,506.072,427.286,280.959,419.412,362.434,498.825,531.349,501.931,617.882,53,310.474,305.055,308.778,90.534,127.349,78.418,1087.589,699.661,1200.673,597.941,392.269,322.095,455.871,536.472,293.209,528.219,93.235,79.434,72.375,1090.845,341.725,410.393,858.408,280.564,300.351,408.125,37,69,547,457,458,202,105.218,143.409
+63.5508,305.324,278.886,434.446,163.893,60,51,709,582,172,136,118,245,579.877,294.918,507.693,579.784,503.105,422.043,277.136,417.997,359.603,495.91,528.804,502.797,614.783,52,307.619,307.038,305.104,88.384,127.632,79.905,1088.009,700.936,1192.609,590.642,393.27,321.105,454.852,535.927,290.973,529.224,96.42,76.644,71.664,1087.691,341.06,414.098,859.638,283.95,301.397,404.276,37,67,550,455,460,207,106.198,144.767
+63.7176,305.337,273.811,430.055,161.685,60,49,716,575,172,139,119,244,585.04,290.819,511.356,575.02,499.389,422.63,279.552,415.857,359.887,495.782,529.734,496.641,618.901,51.5,304.98,294.358,303.283,90.364,129.02,76.959,1087.334,696.873,1188.152,585.561,391.048,318.683,452.573,543.171,291.667,528.403,93.874,76.092,72.162,1087.959,341.174,410.322,861.915,279.031,301.803,406.393,36,67,538,449,455,201,102.403,141.648
+63.8844,303.988,275.808,425.736,163.949,60,49,712,581,170,136,120,238,590.912,290.916,512.988,567.885,496.767,419.204,282.242,416.889,361.651,499.236,531.25,497.67,612.93,52,304.089,300.568,323.353,88.469,128.227,80.84,1085.041,697.872,1188.012,580.163,387.943,315.866,451.129,537.394,289.473,526.817,93.576,77.381,70.882,1082.33,340.056,405.343,858.747,280.062,302.57,399.247,36,68,537,446,457,203,102.801,140.791
+64.0512,307.312,272.097,429.004,160.326,59,48,717,578,168,137,119,236,596.267,291.167,509.961,564.184,492.875,417.836,273.876,414.812,356.544,495.825,528.077,499.088,615.998,52.5,300.725,299.637,299.34,89.742,127.208,79.735,1074.024,695.646,1185.779,578.962,383.193,317.719,453.377,538.189,290.619,526.448,91.656,75.058,70.185,1084.772,338.014,403.074,860.236,281.2,291.045,398.163,36,69,540,446,448,199,104.208,141.669
+64.218,302.056,273.609,422.838,157.311,58,47,714,583,168,134,119,234,593.857,286.924,508.123,562.421,484.014,411.871,274.919,411.01,353.543,491.636,529.454,497.288,614.924,50.5,304.43,299.297,300.994,90.42,128.426,81.151,1081.875,697.82,1181.714,576.144,388.212,316.616,455.098,536.34,288.652,527.284,95.083,75.469,71.295,1081.086,336.337,404.778,853.486,280.368,297.632,398.981,36,65,542,443,450,199,98.196,139.56
+64.3848,299.636,271.63,425.421,160.17,59,47,719,580,174,136,115,239,600.355,288.325,511.965,563.221,492.976,408.385,271.011,411.214,358.052,494.027,530.017,497.97,611.848,51,308.248,292.397,300.796,89.006,126.202,79.749,1072.648,700.813,1193.348,578.077,376.581,311.211,454.495,537.422,291.426,523.573,93.789,76.857,69.602,1085.244,336.294,407.635,857.757,278.329,299.723,392.949,36,66,536,444,442,197,100.399,139.603
+64.5516,297.31,264.999,421.583,160.128,60,48,718,582,170,134,116,232,601.205,288.941,508.101,556.037,483.463,399.94,268.196,408.276,360.172,494.862,532.311,492.685,604.387,50.5,300.895,300.216,300.768,88.073,125.664,77.766,1072.016,690.817,1182.899,568.337,381.761,309.701,459.89,539.97,291.454,523.8,93.576,77.126,73.029,1079.926,332.221,408.95,852.906,281.961,299.374,376.25,34,67,535,442,440,198,102.671,136.504
+64.7184,298.717,262.902,416.46,159.279,59,47,712,583,171,135,115,229,593.989,292.151,502.456,554.706,480.943,401.127,264.586,405.487,354.197,490.093,528.46,487.575,600.278,50.5,302.182,306.268,300.556,87.563,125.451,78.729,1055.19,682.515,1135.29,567.507,380.301,306.051,457.244,537.705,291.27,522.823,93.192,74.45,71.081,1078.257,332.178,407.338,860.558,277.536,296.707,373.565,36,65,530,439,442,196,99.717,141.337
+64.8852,295.45,264.489,412.382,161.048,60,49,718,584,171,137,114,227,595.15,296.831,503.943,553.64,475.686,399.595,261.857,399.287,351.395,489.329,522.962,483.975,602.563,50,299.976,299.764,300.386,89.798,127.647,80.712,1036.497,681.942,1127.308,565.953,373.502,307.582,456.281,538.747,289.614,525.797,93.405,76.191,71.11,1080.492,332.164,407.352,854.801,280.779,295.9,375.136,35,65,529,436,436,193,100.3,141.4
+65.052,295.08,266.41,408.575,160.298,59,47,723,581,169,133,115,225,594.289,296.35,507.371,545.458,470.246,395.908,261.971,403.802,353.102,492.64,517.838,482.342,596.411,50.5,302.846,297.247,295.211,87.761,127.151,80.684,1039.947,685.253,1128.896,553.935,374.494,305.407,453.451,539.71,287.888,522.993,94.045,76.857,70.185,1088.2,335.064,407.14,856.725,278.921,298.085,373.238,35,66,527,434,434,195,101.536,135.796
+65.2188,295.89,264.415,411.928,157.948,59,48,720,579,170,133,115,221,599.545,294.69,506.111,548.959,468.029,388.188,258.473,398.442,345.648,482.974,520.473,476.582,599.31,50,302.238,302.861,300.061,88.822,125.423,78.205,1050.388,678.6,1155.868,554.744,369.031,305.338,452.297,524.262,290.308,518.588,94.059,76.956,71.138,1081.963,333.168,408.554,855.155,276.474,297.614,374.355,35,65,527,438,434,195,98.637,139.603
+65.3856,291.884,263.878,404.896,160.029,58,49,713,581,169,136,116,219,590.812,297.959,509.718,538.515,463.394,386.695,256.542,397.06,346.928,481.007,512.031,475.779,591.27,50,299.184,298.477,299.509,88.271,126.91,79.664,1054.259,682.496,1166.066,548.831,372.786,304.478,449.597,527.978,288.1,521.817,94.13,77.48,70.342,1086.446,328.897,407.479,859.525,275.159,295.73,376.122,35,65,520,431,424,194,102.219,139.617
+65.5524,296.302,261.052,406.614,158.387,58,48,721,580,169,133,112,219,588.327,292.333,504.329,541.706,456.556,384.552,250.046,394.329,345.534,484.106,514.25,474.373,592.563,49,301.503,300.74,300.443,88.935,124.503,78.786,1059.252,682.823,1175.674,552.428,366.428,304.935,453.384,527.539,285.864,519.056,93.348,74.251,71.735,1088.766,332.504,403.915,868.817,283.262,298.677,373.082,34,64,519,428,427,193,98.106,139.857
+65.7192,290.885,259.837,401.236,159.831,59,48,716,577,170,136,111,216,588.57,291.054,510.219,534.139,455.458,380.291,250.515,390.735,345.662,479.011,515.288,475.411,588.424,49.5,300.061,300.075,293.613,90.307,127.208,77.228,1063.512,680.551,1180.872,546.487,365.423,300.055,451.755,526.353,285.354,519.594,92.31,76.701,71.11,1079.021,330.142,410.308,868.068,281.466,302.205,379.219,34,65,521,423,420,188,98.012,136.561
+65.886,293.621,261.795,406.241,158.076,60,47,719,579,171,133,114,211,587.526,296.031,508.695,532.177,450.589,379.087,246.891,390.299,334.367,480.143,511.449,468,588.561,48.5,301.051,295.734,299.566,90.887,126.783,79.31,1061.172,680.105,1183.979,539.302,363.211,297.827,445.397,525.32,284.675,514.665,92.964,76.871,69.432,1078.922,328.02,408.073,861.335,281.706,301.525,375.189,34,63,512,418,419,190,98.111,139.985
+66.0528,288.418,255.517,402.765,155.401,58,46,718,579,170,133,111,212,590.476,292.473,516.682,529.817,451.496,372.886,244.901,384.468,338.236,481.077,509.368,461.593,586.54,49.5,302.804,302.154,300.089,89.317,127.547,77.809,1070.282,682.372,1176.962,539.321,359.915,299.614,448.808,522.97,284.024,511.28,94.486,74.903,71.152,1089.275,328.572,408.879,860.741,285.086,301.227,374.284,33,66,508,417,413,191,99.419,139.744
+66.2196,285.416,256.182,399.313,157.453,59,47,719,577,174,133,110,208,591.003,293.363,510.319,529.678,442.526,373.098,244.588,381.043,336.771,480.228,507.772,461.712,582.677,49,304.501,296.667,300.004,89.812,126.542,77.965,1062.388,681.461,1178.116,544.008,362.609,297.43,441.293,524.386,287.732,506.168,92.453,77.395,70.086,1090.901,330.948,413.702,864.999,282.498,303.452,375.953,33,65,506,408,418,187,98.196,138.471
+66.3864,288.219,255.008,399.17,157.906,58,48,716,578,172,134,109,206,587.769,295.868,509.976,519.98,443.383,363.006,241.803,379.557,337.795,478.459,501.423,454.677,578.595,49,304.982,300.612,302.875,90.746,123.497,80.117,1047.856,679.286,1165.707,532.511,364.842,298.964,439.75,527.935,280.967,508.349,90.106,75.851,70.953,1096.007,329.321,411.623,870.571,286.033,305.733,376.844,34,64,498,409,410,183,97.614,140.169
+66.5532,281.527,253.607,391.101,155.656,58,45,716,574,171,131,108,206,590.084,295.21,515.597,521.458,434.976,360.935,238.57,374.108,333.514,478.601,498.876,455.169,574.643,48.5,305.448,296.512,302.733,89.006,125.621,76.152,1054.244,674.516,1167.053,530.514,360.979,298.152,434.882,523.078,279.849,503.364,91.073,76.149,70.612,1094.494,332.405,410.449,867.092,287.886,306.044,382.57,33,64,499,404,403,187,98.02,141.64
+66.72,286.991,258.686,394.445,150.999,60,45,711,574,170,133,108,202,596.413,291.116,515.249,515.387,438.513,359.562,236.473,375,330.27,480.069,492.855,444.649,564.262,48,302.465,297.94,304.416,87.436,126.542,80.273,1053.624,676.433,1169.121,526.307,364.304,298.213,437.557,523.522,280.392,511.833,94.088,77.621,69.901,1094.791,325.87,411.666,873.683,293.33,309.487,382.401,33,63,495,406,404,185,97.187,140.16
+66.8868,287.687,256.242,395.069,150.384,58,46,717,567,171,129,107,202,588.395,291.37,512.623,512.878,432.104,357.451,234.889,370.004,328.734,475.069,493.444,446.09,560.966,49,308.375,300.853,302.154,88.497,122.633,78.885,1041.147,678.608,1159.052,527.727,356.187,297.561,440.518,522.151,276.936,507.301,93.96,76.772,69.873,1098.765,328.77,418.752,871.293,294.362,307.05,383.673,33,65,497,400,401,185,95.837,141.315
+67.0536,288.148,255.036,390.007,153.877,58,44,717,569,171,131,107,198,592.357,293.331,516.395,509.987,435.005,354.605,232.919,369.231,330.782,473.237,489.725,440.476,560.594,48,310.327,300.457,302.507,88.426,124.63,79.197,1041.362,673.393,1164.208,526.561,360.611,299.076,434.378,519.67,276.452,506.04,93.931,74.818,70.271,1100.745,330.311,413.985,877.671,293.669,313.483,383.716,33,63,489,394,394,186,95.738,139.518
+67.2204,287.417,258.474,389.627,153.118,58,46,715,568,170,132,107,196,594.653,293.807,516.867,504.638,426.602,350.706,232.738,368.087,320.554,470.505,485.383,439.193,555.832,47.5,312.575,297.12,306.905,89.416,123.61,77.171,1040.361,676.757,1143.937,526.188,360.881,295.777,432.977,520.454,274.131,493.648,90.874,76.758,68.266,1108.482,329.746,417.535,879.213,296.865,311.698,385.172,32,63,489,391,394,181,95.695,138.768
+67.3872,283.417,255.801,387.962,150.481,58,45,707,566,168,131,106,194,589.297,295.821,512.652,501.225,427.072,346.874,227.263,361.897,327.084,464.759,480.222,435.003,551.459,46,309.082,295.055,306.565,87.592,124.772,77.752,1032.274,672.516,1142.448,518.873,363.778,300.112,437.486,514.691,273.112,501.99,92.637,73.812,69.048,1115.031,331.273,414.862,882.664,302.479,319.335,384.352,31,61,485,387,392,180,96.377,139.235
+67.554,285.966,257.742,387.723,151.488,56,45,706,564,169,129,105,191,599.158,299.309,517.232,496.141,422.746,345.069,227.765,359.163,325.206,469.797,476.656,427.722,552.876,48.5,308.432,301.616,307.499,87.224,126.202,76.619,1043.01,675.989,1143.082,521.085,359.034,297.019,430.472,515.229,270.649,497.571,91.315,75.54,69.858,1108.242,330.113,421.001,884.955,297.275,319.972,387.124,33,64,479,383,381,182,95.368,138.754
+67.7208,287.284,253.183,388.351,149.475,57,43,716,570,170,129,104,189,597.235,294.162,514.964,498.362,422.069,343.608,225.145,356.054,315.348,462.806,474.585,422.514,544.194,46.5,308.361,304.048,307.131,90.265,122.888,77.171,1037.096,675.024,1138.126,517.514,356.035,299.627,429.411,512.578,270.437,493.577,90.874,75.455,70.868,1110.052,332.871,419.926,891.758,306.466,321.29,387.944,33,60,473,382,384,178,95.539,137.99
+67.8876,287.815,253.565,389.712,150.087,58,45,703,565,166,129,104,188,597.89,295.888,514.999,492.119,412.035,340.707,222.165,355.695,316.244,468.297,466.515,420.47,537.742,47.5,312.476,302.578,311.401,88.752,121.373,78.446,1025.691,678.947,1140.791,516.541,355.073,300.052,424.963,508.671,272.036,491.595,92.723,75.313,67.128,1112.456,332.801,422.203,887.317,307.117,324.393,390.022,32,63,468,379,381,181,97.5,139.362
+68.0544,282.171,254.996,388.682,146.368,57,43,707,557,169,129,105,188,603.509,297.023,520.588,493.211,413.747,341.89,221.789,348.54,316.628,463.499,464.445,418.653,533.884,47.5,308.05,302.281,307.937,87.266,121.84,76.01,1026.119,676.525,1138.447,516.352,356.796,297.986,431.798,513.795,268.951,488.932,93.917,75.611,67.427,1112.584,331.994,423.15,887.827,312.405,325.937,389.57,33,62,467,372,381,180,98.509,139.56
+68.2212,285.747,255.418,384.794,147.796,58,43,709,564,168,127,102,188,604.844,296.33,516.102,493.988,411.369,336.558,215.576,345.692,311.322,460.102,464.478,418.374,527.644,47.5,309.676,302.069,312.42,87.436,123.313,77.965,1032.991,674.018,1138.469,513.246,357.055,300.906,428.46,509.864,263.007,485.335,92.95,73.869,68.963,1120.023,333.494,422.613,890.684,315.842,332.001,386.572,33,62,460,375,377,177,97.015,142.376
+68.388,288.446,255.774,384.595,148.093,56,43,706,564,170,127,102,185,611.498,299.894,513.217,484.273,404.05,331.912,217.424,346.966,310.924,455.842,463.34,409.657,527.681,46,315.743,305.491,305.081,87.677,123.738,75.5,1030.241,672.444,1133.638,507.209,357.292,294.291,423.336,509.608,265.724,481.752,91.443,74.747,67.498,1119.5,332.588,430.901,895.591,316.874,331.619,396.64,32,60,463,370,369,175,98.552,140.71
+68.5548,287.721,256.057,386.172,143.144,57,42,702,553,168,126,101,185,606.741,299.323,513.74,485.893,406.808,330.672,211.358,345.576,309.515,456.975,462.696,409.764,522.651,47,313.508,303.497,310.666,88.794,123.426,78.418,1035.093,685.972,1133.806,506.356,364.438,295.292,422.979,517.578,260.756,474.557,91.685,75.88,66.247,1132.088,333.649,435.795,898.774,321.71,332.172,397.163,32,62,458,363,368,173,97.571,142.121
+68.7216,287.409,250.778,388.331,144.77,56,42,697,558,166,127,100,180,608.788,302.495,522.764,485.519,401.866,331.813,210.421,345.194,308.079,459.098,455.948,403.406,516.407,46.5,318.274,306.325,313.254,88.356,121.911,77.058,1042.921,689.545,1136.609,508.889,359.791,298.489,422.54,517.847,261.195,473.509,93.163,74.393,68.01,1130.504,334.158,429.812,907.543,324.694,341.254,398.153,32,61,452,363,366,176,95.908,143.593
+68.8884,288.105,253.24,385.745,145.237,56,42,704,560,164,126,102,183,616.047,303.743,519.157,481.996,406.211,329.104,210.179,344.585,305.219,454.201,449.5,401.663,511.789,46,317.948,310.086,310.313,87.606,122.463,75.614,1042.65,691.866,1141.853,509.385,360.393,300.12,428.47,515.922,256.709,473.495,93.263,75.766,68.749,1144.633,339.024,437.803,911.333,327.055,339.553,397.489,31,61,448,357,367,172,93.563,142.192
+69.0552,284.724,256.906,382.549,143.568,56,42,694,552,170,125,99,181,618.804,308.053,522.149,478.475,395.741,330.39,208.872,336.178,299.828,456.649,445.991,390.082,506.536,45,318.613,311.161,310.793,88.356,120.395,76.038,1043.477,688.996,1145.66,504.947,357.423,301.154,425.852,512.172,258.704,474.571,90.334,73.812,68.38,1141.055,339.448,436.771,920.583,330.859,342.784,402.989,31,59,447,358,359,175,98.054,141.117
+69.222,285.625,255.01,386.591,143.399,56,45,697,554,162,124,99,177,616.207,307.108,522.505,477.782,400.358,324.939,207.877,335.762,302.815,450.549,439.769,393.463,503.981,46.5,313.339,306.82,313.735,88.808,120.594,76.152,1049.09,698.742,1147.055,507.711,363.928,302.99,427.636,518.984,254.911,470.946,92.253,73.982,67.398,1150.276,341.018,441.82,920.088,335.129,351.724,406.666,31,62,445,350,355,174,98.808,144.909
+69.3888,288.057,260.568,384.355,143.3,56,42,697,554,163,125,101,175,619.468,308.971,524.277,482.662,399.329,325.805,203.769,334.022,299.159,447.167,437.069,389.531,501.055,45,316.704,306.028,313.735,89.784,122.831,77.171,1052.97,700.401,1148.449,504.067,363.537,307.653,422.756,510.386,256.751,464.785,92.922,74.322,68.593,1154.534,341.159,442.23,916.241,336.812,352.192,405.789,31,59,442,344,353,171,98.665,143.423
+69.5556,289.028,257.348,384.936,143.568,56,43,690,549,165,124,98,178,622.808,315.786,527.648,474.974,392.558,327.03,202.49,328.419,296.03,446.02,437.237,388.435,496.174,45,322.12,308.587,317.397,87.479,123.469,77.072,1056.933,702.105,1163.551,510.066,366.103,308.22,419.374,508.152,252.76,465.691,92.197,74.605,69.176,1156.995,344.936,443.828,922.139,337.151,354.969,408.207,31,59,438,346,355,171,97.997,144.583
+69.7224,287,261.487,392.345,143.766,56,43,685,550,163,125,100,175,629.374,312.318,534.951,476.554,391.508,319.704,202.533,333.031,295.959,446.94,425.753,385.811,495.05,44.5,320.14,313.395,319.773,87.139,121.854,75.217,1059.153,709.471,1164.155,509.015,365.52,307.116,422.524,507.75,249.943,461.768,89.182,75.073,67.74,1158.862,341.923,446.247,932.195,342.157,357.25,414.514,29,60,431,338,352,167,96.207,144.23
+69.8892,291.751,263.683,383.915,142.663,55,41,693,552,163,122,97,173,631.025,311.254,530.951,476.324,394.736,326.255,203.656,329.292,294.01,451.285,425.71,380.291,489.102,44.5,324.368,313.933,314.838,88.95,121.514,78.035,1073.778,710.64,1163.745,505.588,370.703,310.726,424.45,505.5,243.433,455.353,91.557,76.191,67.996,1166.542,344.031,451.607,924.034,343.514,366.361,417.978,31,58,430,338,346,167,96.931,143.084
+70.056,291.596,259.563,385.676,143.356,55,43,693,543,165,125,97,172,629.041,314.775,535.277,476.242,391.427,324.165,199.193,327.501,293.739,444.591,425.966,380.436,493.591,45,323.774,314.088,319.985,88.497,119.517,76.293,1072.557,706.183,1176.657,506.357,369.177,317.736,426.362,511.091,249.476,455.424,89.651,72.75,66.958,1173.614,350.551,447.619,932.987,348.393,368.103,417.936,30,60,429,335,341,169,96.562,143.975
+70.2228,290.202,265.873,387.979,140.669,55,41,686,544,163,121,96,169,629.712,315.905,533.29,476.559,390.371,320.991,201.31,321.824,286.086,442.935,417.366,371.638,482.426,44.5,326.419,314.682,317.114,88.822,121.189,76.223,1076.772,713.789,1183.083,505.119,370.59,313.756,423.814,516.287,241.82,451.628,89.125,74.464,67.114,1176.697,345.7,457.505,938.871,351.207,368.358,423.408,30,59,427,332,342,166,97.059,143.607
+70.3896,292.807,264.868,385.092,141.532,54,42,690,543,162,123,97,173,636.047,317.246,536.031,474.478,392.288,320.042,196.151,323.608,290.126,442.439,410.004,373.874,476.356,44.5,328.229,315.05,319.136,88.398,119.971,76.166,1083.067,722.323,1188.842,507.865,373.777,319.532,424.507,507.242,242.244,452.166,90.988,74.86,67.157,1181.039,354.257,457.604,945.886,355.477,376.605,426.166,30,59,423,329,334,169,96.96,144.329
+70.5564,292.949,262.301,390.178,140.401,54,42,680,540,160,122,96,171,636.271,322.432,543.806,475.336,392.134,323.472,198.709,323.254,281.15,444.237,412.09,364.953,477.151,44,328.158,316.69,319.659,88.356,120.551,77.228,1090.225,729.468,1195.618,505.929,376.057,312.722,423.941,508.348,239.852,445.736,89.907,75.922,67.228,1196.88,354.143,460.702,947.117,360.978,378.05,426.576,30,58,425,325,331,162,100.2,145.291
+70.7232,292.313,263.4,388.738,139.114,53,41,681,540,165,120,95,171,635.93,322.146,540.218,475.843,389.233,325.533,196.605,323.781,281.392,440.656,409.749,362.743,468,44,327.621,314.145,323.704,88.384,121.486,75.784,1089.969,731.605,1199.239,508.02,381.901,321.628,424.808,508.035,235.62,442.961,91.727,73.827,66.289,1199.383,356.901,461.607,954.571,360.511,381.266,432.218,30,58,415,323,329,166,99.22,147.201
+70.89,293.859,264.436,390.121,138.888,53,41,678,538,164,121,95,170,637.136,319.794,541.257,475.718,392.792,321.305,195.013,315.88,280.908,441.661,408.54,363.396,463.983,43,327.621,321.554,324.142,89.077,121.019,76.449,1096.952,731.548,1212.801,508.42,377.415,326.262,426.976,512.183,239.838,446.062,88.187,73.303,68.237,1199.963,358.768,465.313,961.006,362.01,384.596,436.248,30,56,414,323,329,163,99.514,146.239
+71.0568,296.907,265.844,395.293,139.383,54,43,678,538,160,120,97,173,639.75,319.25,545.77,473.855,391.252,321.685,196.221,318.244,280.026,434.669,402.626,360.466,460.834,43,330.845,322.544,326.815,89.218,121.203,75.415,1110.618,729.053,1216.605,510.991,383.86,323.427,427.91,519.381,236.286,441.743,91.045,73.742,68.479,1200.359,358.203,462.781,963.226,365.856,385.106,443.106,30,56,411,319,326,164,99.476,147.431
+71.2236,299.598,268.593,390.604,136.781,55,40,678,530,157,119,95,171,642.064,322.93,544.397,472.224,393.736,321.814,193.822,321.388,277.964,441.293,401.567,356.753,456.869,43.5,333.263,321.059,325.754,88.935,121.358,77.724,1107.19,737.305,1228.578,506.44,382.287,329.954,428.246,518.13,234.658,444.915,89.794,75.158,65.834,1211.575,361.696,474.464,961.741,372.997,391.751,442.328,29,58,413,316,324,164,100.328,148.531
+71.3904,299.083,269.664,390.465,138.831,54,40,676,531,159,120,96,170,648.537,322.794,546.957,478.773,395.156,324.053,194.417,319.591,275.503,439.864,394.539,349.801,455.254,42.5,328.78,326.348,325.627,88.497,123.426,76.959,1122.948,744.307,1228.246,510.761,383.816,333.14,424.794,524.343,233.865,438.712,89.893,72.878,65.92,1220.754,362.007,473.092,974.301,378.28,391.921,448.354,29,56,404,315,320,161,98.125,146.975
+71.5572,299.91,270.235,388.274,138.223,53,41,675,526,157,118,96,168,646.319,328.635,555.363,474.939,393.328,322.282,191.504,312.826,273.283,436.297,391.073,351.74,455.554,42,333.376,322.191,328.596,88.893,120.679,77.483,1137.86,741.752,1229.594,513.082,387.019,331.663,423.503,521.668,232.832,439.094,91.756,73.402,68.166,1223.357,364.751,472.823,980.651,375.543,396.536,452.566,29,55,406,313,319,158,98.154,146.607
+71.724,296.842,270.65,398.403,132.892,54,42,662,534,158,115,94,172,651.672,322.852,556.505,477.881,395.134,320.734,190.693,313.689,271.349,434.485,386.325,349.419,445.949,42,335.384,325.895,329.925,85.994,119.277,76.69,1129.997,740.897,1239.945,515.158,392.462,343.363,419.639,519.347,228.049,441.558,90.547,72.878,68.408,1228.463,369.475,478,982.858,376.25,402.42,456.172,29,55,398,312,321,161,99.603,150.357
+71.8908,306.295,270.556,397.424,136.3,53,41,670,530,158,117,94,175,655.98,322.227,556.025,479.939,397.102,325.738,192.086,316.067,269.585,436.014,380.832,350.621,441.848,43,335.822,332.358,331.976,86.432,119.985,74.976,1142.765,747.056,1246.375,515.616,396.71,341.713,426.829,511.804,232.521,438.429,88.713,70.811,68.038,1235.817,366.378,481.677,979.124,384.225,401.853,458.759,29,57,401,310,314,162,102.034,149.21
+72.0576,303.491,275.011,398.02,135.027,53,40,666,527,158,116,95,171,654.067,325.81,556.047,474.506,394.85,327.448,189.313,318.529,271.093,434.316,381.977,348.288,448.668,43,338.085,327.338,329.317,88.271,118.229,76.676,1151.596,752.687,1245.778,524.059,401.663,342.584,417.879,517.253,227.398,434.137,88.357,73.501,64.327,1245.364,369.772,481.719,986.578,391.182,407.634,458.038,29,57,393,308,315,163,99.078,149.225
+72.2244,308.036,271.107,394.359,135.098,54,39,666,518,157,114,93,169,659.477,324.236,558.081,481.877,392.629,328.051,191.928,316.364,267.963,431.457,383.081,342.52,439.076,42.5,337.505,331.538,338.198,88.058,122.208,75.486,1154.205,758.187,1257.824,520.898,403.696,351.099,421.655,517.96,224.1,429.435,87.078,72.637,65.977,1252.408,373.251,482.497,988.6,388.651,410.525,470.043,29,56,398,309,312,161,99.49,148.913
+72.3912,303.099,276.503,400.633,133.345,53,42,671,527,157,114,95,171,661.72,325.694,556.961,484.882,399.841,329.576,188.843,315.798,267.679,434.33,376.368,340.905,438.202,41.5,345.848,332.301,338.268,86.404,122.336,75.883,1164.756,750.723,1253.392,527.087,397.485,348.438,425.275,514.722,223.095,432.707,89.381,73.147,67.299,1259.098,374.694,489.979,1002.404,395.353,415.299,471.514,29,54,394,308,314,161,100.385,150.908
+72.558,307.438,275.959,402.791,133.514,53,41,668,521,156,113,93,170,661.477,325.074,560.247,479.651,400.765,332.173,189.655,316.134,270.182,431.287,374.821,337.011,437.732,41,344.688,334.507,340.573,89.049,116.713,75.982,1170.476,755.231,1258.276,523.86,405.418,352.765,428.387,518.456,221.708,426.858,90.249,74.025,67.654,1264.572,375.91,488.211,1007.256,393.416,416.745,475.657,28,54,395,300,309,158,100.139,151.064
+72.7248,311.134,276.248,403.631,136.95,53,41,670,516,156,116,94,171,653.904,325.729,559.862,487.289,397.898,336.968,191.217,316.52,265.701,430.607,373.295,335.035,433.004,42.5,348.492,330.83,336.967,88.596,118.965,76.293,1172.125,765.257,1262.387,529.582,411.135,354.516,430.571,524.653,221.666,429.053,88.983,72,66.815,1267.443,377.396,489.725,1008.26,396.866,421.817,477.425,28,57,397,302,308,160,102.261,152.065
+72.8916,308.021,279.748,405.757,133.543,53,40,662,521,156,113,92,173,657.425,328.038,559.367,486.159,409.026,333.494,192.299,316.519,265.957,433.438,368.372,337.138,434.508,42,348.322,335.058,340.616,87.323,122.973,78.29,1178.05,757.4,1273.258,532.348,412.214,357.639,430.898,524.329,218.807,427.608,88.94,72.326,65.905,1266.339,380.663,500.827,1019.716,407.048,425.019,489.727,30,54,399,298,308,157,100.072,153.738
+73.0584,311.238,279.644,406.357,136.512,52,39,651,514,154,113,94,172,663.141,328.257,562.465,492.901,409.545,341.671,191.418,313.859,261.547,436.269,364.741,337.327,430.243,41.5,343.062,336.713,346.017,86.672,119.815,75.741,1187.477,763.729,1287.743,533.663,416.814,360.396,429.623,520.791,218.453,423.006,89.139,73.133,66.019,1280.596,383.053,502.907,1018.938,400.628,430.177,491.367,29,54,391,300,304,158,100.509,151.743
+73.2252,309.045,279.736,408.632,134.971,55,39,656,513,154,114,92,173,658.179,323.076,561.287,493.422,410.598,335.439,189.203,317.496,259.755,434.061,367.24,336.359,426.121,42,349.595,334.846,341.973,88.384,119.73,76.874,1193.433,766.633,1285.009,535.03,416.175,360.252,426.806,526.828,215.976,420.839,90.448,70.91,66.289,1281.77,384.977,508.55,1015.855,405.634,430.729,489.798,29,55,390,300,305,156,98.736,155.013
+73.392,314.799,280.811,408.049,137.106,51,41,654,518,151,114,94,174,665.822,325.891,561.436,498.223,418.994,339.681,191.161,315.684,263.141,426.998,366.228,337.963,425.824,41.5,348.492,338.763,340.432,89.727,118.71,78.418,1187.603,767.674,1290.505,540.453,420.456,365.692,430.966,527.272,213.825,420.088,88.741,71.363,65.109,1277.725,384.34,505.962,1027.75,413.93,437.303,496.544,29,54,393,299,301,156,99.461,153.314
+73.5588,315.807,282.467,411.274,137.219,52,40,657,515,151,111,93,177,666.371,323.93,565.673,502.445,419.972,349.682,189.882,323.025,259.94,434.075,356.986,332.861,425.328,41.5,352.225,339.159,340.432,88.228,121.245,76.506,1204.969,764.373,1286.651,541.171,420.517,368.903,433.515,525.219,213.471,421.618,88.812,73.444,64.91,1293.085,392.232,506.782,1023.521,410.577,436.531,499.724,29,54,388,301,302,159,102.83,154.163
+73.7256,318.862,284.185,416.724,136.625,52,40,654,510,152,112,94,176,662.726,323.804,565.364,508.094,419.321,351.159,190.095,320.99,256.853,429.178,358.538,332.815,425.357,42,350.853,338.353,348.548,88.073,120.565,76.421,1202.164,769.29,1293.993,548.601,426.447,370.083,431.149,530.272,210.117,417.723,91.301,72.481,64.427,1298.969,388.852,513.189,1033.874,417.653,440.08,503.91,29,55,390,297,301,159,103.029,155.634
+73.8924,317.924,283.494,419.855,135.225,53,39,658,510,155,112,93,177,663.912,326.115,563.904,508.26,421.553,350.547,188.886,319.29,260.395,430.749,357.891,334.433,421.368,41,354.106,342.412,346.413,88.61,119.532,76.534,1197.541,768.144,1304.606,551.487,431.684,379.766,436.453,532.516,209.367,418.644,86.424,72.467,63.574,1306.536,392.048,517.856,1038.174,421.414,446.286,510.542,28,54,389,294,297,157,102.574,155.988
+74.0592,316.378,288.932,420.664,135.381,52,39,653,510,153,113,95,179,670.149,326.544,559.24,508.929,426.129,357.83,193.324,320.989,259.399,432.051,356.045,330.297,422.34,41.5,354.799,342.468,345.268,87.931,121.316,77.186,1220.906,768.438,1305.08,557.615,439.646,383.081,443.133,536.586,212.225,419.777,90.234,72.566,66.332,1308.87,393.336,515.919,1040.635,418.841,446.584,513.257,29,54,392,297,295,155,100.74,154.573
+74.226,322.754,288.451,418.647,133.288,51,39,656,512,155,112,94,176,671.719,329.299,567.276,514.195,424.17,358.796,191.703,322.827,257.024,432.249,355.063,338.569,422.811,42,355.59,347.05,341.393,88.935,120.056,75.968,1219.092,776.632,1308.668,561.995,435.525,381.48,439.029,536.43,209.041,413.233,89.594,70.881,66.716,1313.466,397.084,514.462,1042.077,425.289,449.871,526.86,29,55,388,296,295,154,100.624,154.276
+74.3928,326.775,290.813,427.185,136.413,50,38,655,511,155,113,95,181,665.641,330.771,563.575,517.031,424.473,360.355,190.665,328.125,256.825,431.91,354.53,331.952,415.868,42,355.732,346.102,346.046,86.333,118.937,74.778,1216.297,778.279,1310.557,562.807,442.959,385.714,437.868,538.751,205.347,420.06,90.32,72.326,64.896,1321.938,398.498,518.507,1042.374,427.707,450.367,527.666,30,54,389,297,293,155,102.204,154.003
+74.5596,324.566,295.29,427.316,133.429,51,39,647,508,153,110,93,180,668.638,330.094,564.959,523.489,434.834,366.483,190.011,330.234,255.957,433.396,351.866,333.994,417.281,41.5,360.738,344.929,349.411,89.812,118.427,75.345,1219.642,775.348,1309.222,564.668,451.401,391.968,436.707,537.522,204.922,419.607,87.035,71.887,64.512,1318.006,404.24,523.061,1052.968,427.367,457.678,533.591,28,55,391,292,294,158,102.716,157.12
+74.7264,327.241,298.758,428.119,134.08,54,38,650,504,149,109,94,183,664.224,330.123,565.753,527.427,437.336,364.901,194.36,330.489,259.542,432.235,351.046,330.58,412.752,41,359.833,350.259,345.89,90.392,117.988,76.038,1227.165,781.868,1323.271,567.37,453.315,391.689,437.443,536.699,202.771,420.131,90.106,72.977,67.683,1320.282,404.799,521.868,1052.532,430.521,458.216,531.045,28,54,391,295,295,156,103.398,155.323
+74.8932,327.002,296.189,430.202,136.357,53,38,646,510,151,110,94,187,677.63,330.321,561.7,525.315,439.925,370.335,193.664,332.013,256.184,435.731,346.704,333.229,419.275,40.5,361.529,351.504,354.572,86.559,118.894,76.152,1226.745,782.175,1328.281,575.677,452.754,393.264,439.486,535.471,205.191,418.233,89.552,73.77,64.213,1321.698,404.707,529.2,1053.746,429.616,464.139,540.619,28,53,390,295,288,154,101.721,157.927
+75.06,330.401,294.293,432.682,136.965,51,38,652,509,154,111,93,185,672.706,330.409,568.65,536.821,444.332,375.363,194.545,337.222,256.284,433.792,349.077,337.496,419.253,41,361.091,350.33,355.251,90.718,117.634,77.823,1239.466,783.478,1329.278,579.357,457.859,397.395,445.072,538.572,205.064,419.621,88.016,70.188,64.626,1331.358,401.921,528.888,1051.412,438.439,461.518,536.32,28,54,390,292,293,155,101.906,156.979
+75.2268,327.656,291.914,432.805,135.706,51,39,646,500,150,111,95,186,672.492,329.763,570.525,540.505,449.786,376.316,192.967,337.081,253.695,432.929,344.992,334.589,415.895,40.5,359.027,351.362,354.205,88.143,118.271,76.336,1243.194,776.908,1338.748,581.121,463.519,401.973,441.534,543.575,200.875,420.754,89.139,74.096,65.195,1327.483,406.461,533.358,1059.785,436.276,461.461,539.883,28,53,394,294,289,155,101.831,159.144
+75.3936,330.501,297.258,432.625,136.866,52,39,644,503,148,110,95,187,669.014,331,566.56,540.087,450.432,379.923,197.69,336.048,251.632,434.811,349.686,333.437,415.528,41,367.087,353.625,358.489,90.746,118.625,76.817,1236.665,786.951,1337.563,588.372,466.286,401.084,440.716,543.735,202.134,418.261,89.424,71.83,63.972,1330.354,409.148,530.204,1063.038,431.765,463.983,544.776,28,54,396,300,291,154,103.228,157.161
+75.5604,334.868,300.433,436.348,133.019,52,39,647,503,150,109,94,190,673.608,331.206,573.122,544.443,457.129,389.066,202.348,339.299,254.378,432.745,351.994,338.186,416.644,41,371.06,354.021,357.174,88.158,120.452,77.412,1229.197,791.367,1336.119,591.414,469.035,409.444,440.099,550.927,201.837,417.95,89.225,71.335,64.341,1326.79,412.387,526.314,1063.972,435.753,462.226,549.4,28,54,394,296,290,153,100.996,158.238
+75.7272,331.91,300.985,443.235,135.197,53,39,642,506,148,111,94,194,668.513,330.636,567.431,552.394,463.69,386.835,198.155,342.379,252.173,435.335,350.621,338.656,419.139,39.5,366.747,355.067,356.326,88.299,121.599,77.285,1252.673,785.943,1333.491,597.366,473.181,411.534,437.882,556.631,200.294,421.816,89.466,70.23,65.578,1348.599,413.915,536.809,1067.875,438.92,458.053,551.252,28,51,391,296,293,155,102.998,157.644
+75.894,334.486,302.003,443.999,136.441,52,38,642,506,152,110,94,193,669.267,328.295,571.684,555.327,468.519,391.32,200.657,343.044,253.923,441.109,347.906,339.149,414.282,40.5,364.046,358.461,359.423,86.262,119.347,75.727,1248.271,792.601,1336.205,601.539,472.872,417.288,442.496,560.113,201.186,415.698,89.324,73.827,64.882,1352.531,415.697,537.177,1072.543,439.533,462.68,553.883,28,53,397,298,287,157,103.569,159.122
+76.0608,335.071,302.993,447.188,135.437,53,38,642,505,150,110,95,194,670.808,334.054,566.703,563.61,471.351,398.727,199.918,346.668,254.008,437.91,352.944,343.748,415.344,41,368.274,362.378,361.077,87.111,117.804,75.982,1240.185,787.153,1344.653,606.448,476.262,416.403,438.264,552.963,196.997,420.371,88.471,72.241,65.436,1345.304,414.593,533.542,1066.504,435.569,460.267,552.086,29,53,396,299,287,156,103.683,157.375
+76.2276,342.146,299.643,446.293,138.789,51,38,646,501,152,111,95,196,676.356,324.929,567.053,564.036,473.609,403.178,199.804,349.763,249.641,444.902,350.607,340.254,409.799,40,369.575,357.683,361.473,88.511,120.452,75.585,1258.443,786.709,1351.677,605.193,479.217,419.247,438.864,557.381,198.936,419.876,88.741,72.92,64.185,1345.176,417.054,536.059,1068.583,438.355,466.803,558.294,29,51,397,300,287,155,103.157,155.62
+76.3944,336.682,304.53,446.792,139.086,51,38,636,507,152,111,95,196,674.968,329.302,566.464,569.018,474.562,406.52,202.213,351.285,251.96,437.854,347.392,341.796,414.749,40.5,369.024,357.485,361.572,87.238,119.234,76.846,1256.151,788.178,1344.654,610.852,487.434,421.352,441.203,563.009,197.435,417.666,88.414,73.076,64.37,1358.57,421.708,536.554,1083.858,438.227,468.786,561.532,28,53,400,299,283,159,101.75,158.026
+76.5612,337.018,301.317,448.807,133.868,51,39,649,504,150,111,95,199,669.076,329.106,570.402,576.216,482.763,414.069,205.035,353.515,256.142,440.161,347.213,345.14,417.691,39.5,369.222,361.261,362.717,88.016,119.716,76.704,1259.106,788.372,1353.084,614.347,485.341,425.13,446.738,579.169,196.954,421.094,89.694,70.414,65.237,1355.529,424.791,540.232,1078.766,438.595,469.041,564.063,28,51,405,298,285,155,101.252,158.422
+76.728,336.046,305.73,451.143,138.336,51,37,637,502,149,113,97,201,668.503,326.334,567.568,577.019,488.639,415.533,205.456,353.354,254.805,441.746,351.811,344.37,417.595,40,371.329,358.857,362.915,89.699,119.277,77.044,1266.492,796.061,1357.178,627.574,489.399,425.968,438.482,567.015,195.879,428.515,90.789,70.726,63.744,1358.683,425.173,545.974,1083.759,443.219,474.255,566.467,28,52,402,307,281,160,102.6,160.261
+76.8948,335.185,306.924,454.945,140.189,51,38,640,508,148,109,97,204,668.981,327.713,569.122,593.009,491.283,420.287,208.897,362.801,254.748,439.948,351.583,351.726,418.992,38.5,372.205,363.311,362.109,93.419,119.546,74.792,1260.652,798.434,1357.963,626.324,496.354,429.132,442.34,568.232,195.496,420.952,88.812,72.127,64.882,1365.826,427.719,541.434,1080.803,437.577,471.195,571.275,27,50,403,302,282,155,102.233,160.285
+77.0616,339.859,306.508,454.462,138.888,52,39,640,509,149,110,98,206,668.57,331.559,563.69,591.738,495.009,418.403,207.052,361.838,259.271,438.561,351.938,350.084,422.297,40.5,375.882,361.331,364.782,90.378,119.291,75.217,1259.961,800.08,1360.57,629.294,493.577,423.607,440.005,572.28,193.062,427.311,88.357,72.906,64.27,1373.025,428.808,540.543,1079.176,444.817,466.448,571.586,28,53,408,301,284,156,101.508,160.785
+77.2284,341.748,308.921,457.317,138.478,51,37,646,499,150,109,96,206,669.262,329.402,569.867,596.283,502.602,433.063,209.369,363.932,256.227,445.879,350.961,349.7,419.798,40,371.074,361.02,363.382,89.247,120.452,78.659,1273.153,789.632,1368.012,637.129,495.188,431.235,449.53,566.859,193.161,430.044,89.694,72.623,65.834,1376.024,429.982,542.183,1085.117,441.154,467.072,571.247,28,52,409,303,283,158,102.83,157.007
+77.3952,340.569,310.463,463.121,138.676,50,38,639,508,151,111,99,210,668.208,330.509,566.466,606.07,504.181,429.195,208.857,368.192,256.142,445.85,352.802,357.792,419.253,38.5,373.308,362.717,362.717,91.057,121.882,76.095,1265.443,796.958,1363.867,642.636,496.383,433.684,454.356,582.036,194.081,431.149,89.196,71.136,64.441,1364.652,428.808,539.411,1076.984,437.478,465.244,576.408,27,50,412,307,283,156,102.347,159.625
+77.562,344.332,308.114,459.114,139.821,51,39,643,507,148,111,100,207,670.517,333.677,571.42,606.57,509.498,442.138,214.56,370.202,256.213,450.662,358.047,347.505,421.51,39.5,372.488,361.232,367.567,90.76,118.498,77.016,1271.438,797.929,1363.856,643.087,503.902,436.361,456.39,577.332,192.864,431.39,89.011,72.227,66.503,1371.738,429.741,538.916,1075.796,443.7,463.062,573.241,28,51,407,308,279,159,102.347,159.002
+77.7288,339.325,308.893,459.723,142.805,51,39,641,508,153,112,100,210,673.002,328.252,565.372,617.007,523.198,442.556,214.059,368.461,259.044,447.266,356.683,356.124,422.453,40,371.088,366.012,364.4,88.03,118.512,75.302,1268.81,800.524,1376.099,656.364,504.34,439.551,458.038,570.242,193.6,428.925,89.779,72.609,63.716,1376.321,432.429,543.57,1077.521,434.183,465.131,578.953,29,51,411,309,285,159,100.74,159.087
+77.8956,335.511,312.463,462.219,140.57,51,38,638,504,147,113,99,210,670.393,325.442,564.679,620.601,527.969,447.351,216.706,375.448,258.347,450.096,357.015,359.119,426.87,39.5,375.331,361.812,367.822,89.077,121.387,77.341,1265.976,802.871,1371.733,657.107,504.497,432.992,454.574,578.17,193.444,429.237,88.67,72.722,63.844,1376.391,431.849,537.12,1084.466,443.841,462.439,575.899,28,51,415,316,283,159,102.02,158.606
+78.0624,334.295,314.308,460.362,139.029,52,39,636,506,148,111,102,215,667.22,325.428,565.802,620.32,534.672,452.443,218.54,380.136,258.773,451.214,358.368,360.352,429.676,38.5,370.579,367.327,366.224,92.344,119.886,77.058,1273.534,805.965,1371.599,656.957,506.357,441.274,456.896,577.101,193.742,428.685,90.021,70.442,64.867,1380.026,435.979,543.216,1083.872,437.28,463.147,579.943,27,50,418,317,282,158,102.219,159.554
+78.2292,341.771,312.137,463.667,140.768,51,40,636,510,147,110,101,216,667.015,326.086,566.823,635.896,532.996,458.497,214.603,384.78,258.674,454.215,359.164,364.911,430.604,39.5,376.193,366.563,364.994,92.174,120.976,75.996,1267.038,806.836,1376.623,667.482,509.676,438.896,457.699,582.442,196.247,426.943,89.893,71.618,63.844,1382.049,433.39,548.633,1086.885,433.123,461.844,578.275,27,52,420,315,285,158,100.314,157.375
+78.396,339.305,314.113,468.682,143.851,52,39,643,510,149,112,102,219,671.256,324.202,565.902,637.437,538.434,457.6,218.946,390.418,260.936,455.885,362.263,369.503,432.579,40,376.759,366.521,364.442,88.695,121.132,75.203,1277.701,806.624,1379.94,668.51,516.407,444.758,456.35,583.291,192.609,430.795,90.448,72.694,63.147,1379.333,438.256,545.21,1078.766,438.241,460.469,578.501,28,52,424,317,284,160,102.915,155.988
+78.5628,342.459,312.005,462.957,143.017,50,39,641,512,152,109,101,222,667.048,330.447,569.263,644.875,546.708,459.949,220.285,389.952,261.803,456.649,367.113,369.585,433.376,39.5,374.171,366.323,368.529,89.925,119.404,75.684,1276.618,808.836,1371.776,672.066,515.299,444.399,460.738,581.409,189.51,439.717,87.575,73.529,65.735,1375.911,438.143,542.509,1085.272,434.523,456.658,580.678,28,51,422,320,283,159,102.872,155.182
+78.7296,342.501,309.303,471.012,144.728,50,39,641,513,153,111,101,221,670.254,327.613,564.074,657.48,556.165,465.621,225.231,393.168,262.557,456.791,362.418,375.67,437.919,38.5,376.547,370.113,368.119,87.804,121.684,76.449,1270.5,800.718,1379.585,682.075,518.305,443.977,458.87,586.102,194.874,436.729,87.149,72.085,64.54,1375.713,436.12,544.8,1081.185,438.524,458.415,580.466,27,50,426,319,286,160,100.556,157.969
+78.8964,342.672,310.151,470.003,142.536,50,38,640,512,151,113,103,223,666.619,325.161,565.894,659.15,561.37,470.619,226.942,399.173,266.114,460.117,369.687,375.023,437.789,40.5,374.397,370.367,362.929,90.986,120.126,76.888,1275.043,802.432,1370.121,679.857,521.978,451.285,454.598,586.321,191.463,440.015,88.144,70.485,65.706,1378.598,439.529,541.179,1084.056,436.969,453.413,579.505,28,53,428,322,285,161,98.964,159.993
+79.0632,341.363,310.491,465.813,145.633,51,38,645,516,151,112,103,226,663.127,324.67,567.963,672.152,565.138,478.197,223.618,399.836,262.7,458.984,365.364,376.264,439.448,39.5,375.104,365.616,367.624,91,122.35,75.628,1270.849,799.983,1378.405,682.33,523.11,441.587,463.32,590.502,194.577,435.624,88.955,72.467,65.322,1382.233,437.393,550.373,1076.461,431.709,449.956,585.529,28,51,434,327,284,160,100.442,155.465
+79.23,342.685,316.801,470.672,144.883,51,39,641,515,150,111,103,226,671.638,323.377,557.648,672.708,571.536,486.867,227.273,402.84,267.792,462.579,372.247,379.258,443.107,39,377.848,366.238,366.648,88.992,120.509,75.84,1279.375,809.043,1379.694,690.891,521.959,448.566,462.089,582.334,194.364,437.31,90.476,71.193,65.152,1390.578,437.577,542.99,1075.598,430.394,451.104,576.663,27,51,430,333,285,161,101.565,156.101
+79.3968,341.819,314.226,472.845,147.443,50,37,643,517,152,113,107,229,663.893,321.688,556.354,678.654,573.767,487.235,232.455,406.703,260.765,466.415,371.029,381.964,446.147,40,374.015,371.569,366.917,90.859,122.52,77.384,1268.488,802.389,1382.763,692.226,522.322,449.19,461.583,593.476,197.039,434.987,88.67,74.039,65.052,1385.373,436.587,543.188,1079.473,427,454.193,581.668,28,52,435,331,288,161,101.579,154.488
+79.5636,339.205,314.397,472.859,145.802,51,40,635,520,149,112,106,233,663.131,320.1,562.911,679.191,580.992,488.861,231.576,413.68,265.758,465.948,375.84,380.66,444.323,37,376.858,364.994,367.808,89.133,117.676,76.067,1270.331,797.003,1386.621,703.276,525.032,445.634,463.168,586.928,192.822,442.153,88.898,71.618,66.773,1375.019,440.264,544.376,1069.318,426.222,450.565,580.834,26,48,440,332,286,164,100.158,160.941
+79.7304,339.993,315.036,467.694,147.528,52,41,638,519,151,114,107,231,666.605,320.299,560.586,690.166,583.054,497.855,232.344,415.546,270.595,465.849,375.519,389.078,448.583,40,378.71,370,367.171,89.671,120.58,75.84,1270.907,803.873,1374.719,699.309,523.934,444.786,466.443,592.037,199.898,449.277,89.58,71.887,65.82,1382.318,441.509,538.916,1067.14,426.293,447.222,579.222,29,51,443,332,283,163,100.016,155.946
+79.8972,344.402,313.83,474.278,150.709,52,38,649,520,152,113,106,233,667.368,321.707,560.282,696.993,587.524,501.664,232.298,413.573,269.272,469.684,382.487,392.783,452.102,38.5,375.062,364.782,367.384,89.841,120.82,76.86,1267.517,799.315,1376.614,696.297,523.039,447.039,469.662,591.783,196.629,443.47,91.031,74.549,62.408,1388.343,435.003,541.024,1069.205,421.471,444.699,574.16,27,50,452,340,286,162,97.358,156.88
+80.064,339.339,311.552,472.014,150.737,52,39,641,524,150,114,107,235,661.238,315.925,558.814,705.402,593.064,502.386,233.758,422.37,271.007,466.302,380.249,393.746,453.696,38.5,375.09,372.686,363.82,90.279,122.279,77.54,1271.635,799.281,1382.731,710.94,528.998,448.595,462.056,591.238,196.898,448.229,89.936,72.963,63.829,1384.835,436.898,537.162,1073.038,421.287,437.048,575.941,27,50,447,346,286,165,101.238,156.045
+80.2308,340.74,316.376,469.989,152.972,52,40,647,521,153,115,110,238,664.351,319.77,563.189,701.15,602.331,505.379,234.675,423.984,272.344,465.537,383.52,398.136,458.439,38.5,373.464,368.812,364.584,90.548,123.639,76.265,1267.597,793.25,1370.107,712.187,526.386,446.242,462.593,595.356,198.879,454.135,87.405,72.283,66.872,1379.376,439.302,537.389,1062.388,422.659,448.341,573.849,27,50,453,348,288,165,100.3,156.752
+80.3976,338.566,311.207,471.324,152.745,52,39,643,520,153,114,108,241,663.661,316.359,559.337,710.961,605.733,513.965,238.599,426.477,276.128,476.18,386.211,399.035,462.476,39,373.238,365.531,367.652,90.746,121.259,77.157,1258.991,790.519,1370.721,713.969,522.177,444.035,459.197,596.077,197.648,449.9,89.964,73.812,65.394,1372.657,438.906,534.701,1071.058,410.653,441.568,574.386,27,51,450,352,289,160,99.94,155.224
+80.5644,339.546,312.656,474.791,152.774,51,39,645,524,157,115,110,240,662.354,322.556,557.435,723.208,613.537,517.314,238.977,428.244,273.312,473.137,389.333,403.107,464.153,39,372.333,366.266,367.454,90.52,119.999,75.982,1268.167,797.275,1371.839,712.268,522.954,448.711,469.133,591.604,196.176,448.158,90.433,71.547,68.053,1373.775,438.44,534.786,1070.959,412.195,438.239,572.873,28,50,461,350,283,164,96.349,152.391
+80.7312,336.719,309.161,471.822,154.075,53,40,646,522,154,115,109,242,660.083,317.096,558.359,726.372,612.8,518.089,243.688,433.698,274.72,474.836,392.684,406.744,468.184,39.5,374.85,363.679,359.988,90.123,120.056,77.426,1269.989,794.933,1372.746,721.732,524.409,446.117,462.193,591.726,199.544,452.053,91.742,71.674,65.067,1369.178,438.864,537.148,1062.713,409.635,436.411,570.186,29,50,456,354,286,165,100.115,154.064
+80.898,340.441,305.582,477.433,153.127,53,39,651,524,152,116,109,246,657.135,318.257,561.809,725.942,620.943,521.114,244.968,435.653,275.033,476.308,392.374,409.31,469.895,39.5,377.225,365.743,363.057,90.01,120.707,77.455,1274.751,792.231,1372.025,722.735,524.715,446.667,466.187,598.981,198.808,456.996,91.429,72.212,65.749,1375.288,444.224,531.958,1061.992,411.742,431.183,565.888,28,51,459,357,291,164,101.565,152.72
+81.0648,334.716,311.665,471.055,153.396,52,37,649,524,152,118,113,244,661.391,314.889,558.265,734.581,624.858,528.941,245.029,435.412,279.813,477.143,401.535,414.098,470.195,38.5,370.608,365.05,364.075,89.544,123.044,74.58,1266.448,793.296,1378.863,720.481,526.93,447.021,463.456,598.901,201.144,457.619,90.035,72.651,64.427,1367.354,438.991,532.339,1058.159,404.828,428.405,566.326,27,50,466,359,291,165,98.992,150.427
+81.2316,332.372,307.879,471.239,155.178,51,41,651,530,155,115,111,248,659.391,311.818,550.988,741.128,629.337,532.24,247.199,442.661,277.835,481.714,402.515,419.139,475.072,38.5,373.238,364.273,369.83,87.252,122.293,78.503,1259.929,788.518,1382.244,729.226,534.523,445.253,459.848,598.095,197.167,457.42,89.609,71.802,65.792,1361.583,434.395,530.034,1049.856,405.464,425.402,562.381,27,50,465,363,289,167,98.708,154.007
+81.3984,332.036,308.473,469.741,153.283,53,40,650,532,154,117,114,247,665.11,314.419,556.871,742.936,635.624,530.23,246.485,443.977,281.178,481.87,399.949,421.269,477.729,39,371.979,362.279,359.507,90.138,122.336,77.186,1250.848,787.297,1373.423,728.78,524.554,452.223,465.976,594.471,202.205,467.207,89.708,72.312,66.304,1361.13,436.134,529.893,1062.218,400.812,424.268,561.999,28,50,468,366,294,168,99.044,150.243
+81.5652,332.176,306.021,469.266,156.45,52,39,652,530,154,117,110,249,653.089,316.47,559.674,751.136,639.532,541.055,244.712,447.148,281.164,479.69,404.339,421.972,475.114,40,373.266,360.412,361.968,88.794,120.084,76.492,1260.437,782.291,1370.477,726.126,525.684,444.177,466.174,593.409,200.025,463.057,88.528,72.665,68.209,1347.609,441.085,523.839,1050.634,401.632,420.06,560.401,29,51,467,370,293,165,97.628,151.937
+81.732,335.801,304.974,475.041,157.002,53,41,654,537,154,120,115,250,649.334,313.024,550.492,757.509,643.332,541.937,248.01,452.361,281.591,479.506,407.214,427.577,485.406,38.5,370.099,361.586,363.636,90.59,122.109,76.973,1254.659,777.911,1365.712,729.805,524.602,442.414,465.927,600.518,200.945,465.564,91.599,72.779,66.616,1356.237,436.361,524.49,1054.142,400.557,419.989,554.985,27,50,472,376,291,168,98.935,149.847
+81.8988,332.418,302.417,472.865,155.941,52,39,658,533,153,120,114,254,649.702,312.742,556.424,764.478,646.471,544.534,248.042,452.205,285.46,487.729,409.94,430.597,487.646,39,372.347,364.032,361.02,90.972,123.766,76.732,1250.447,779.112,1362.459,732.468,526.987,441.443,466.965,598.356,205.121,468.85,93.149,73.034,66.46,1349.235,432.598,521.802,1050.578,399.27,419.564,553.628,28,50,480,380,294,169,99.386,151.276
+82.0656,330.345,300.838,471.744,155.531,53,41,656,535,157,120,112,254,648.582,313.143,558.58,764.882,653.105,550.827,247.782,454.363,288.22,483.71,413.092,427.478,484.811,38,368.784,360.893,361.473,88.978,120.098,76.846,1263.968,773.351,1360.917,731.505,522.644,448.991,465.339,604.611,202.516,473.948,89.836,73.303,65.408,1340.367,432.669,520.699,1045.415,392.78,414.308,551.04,27,49,480,380,294,169,100.115,151.271
+82.2324,331.08,300.171,470.684,154.725,52,40,653,541,158,120,113,254,644.13,311.649,554.08,776.431,656.545,552.125,252.189,457.451,283.696,488.989,415.711,431.05,489.654,38,367.412,362.675,360.257,88.822,120.792,77.936,1256.652,774.391,1370.23,735.351,524.044,439.307,463.879,594.741,203.578,474.5,89.865,71.32,66.275,1344.639,436.134,522.623,1046.745,393.6,412.437,549.47,28,48,481,384,300,171,100.001,152.196
+82.3992,335.119,301.489,472.71,154.64,53,41,658,539,158,121,114,251,648.504,311.378,549.786,769.944,662.006,554.802,252.388,453.673,287.964,490.121,419.168,436.219,491.764,38,369.703,361.176,361.317,86.078,121.543,74.721,1246.14,767.848,1366.552,739.845,520.581,441.528,458.703,604.618,207.838,472.504,90.945,72.68,65.777,1335.219,429.798,513.613,1042.29,384.96,409.419,549.513,27,49,485,385,292,168,97.821,149.38
+82.566,328.44,301.288,470.821,157.454,53,41,657,543,160,121,116,252,645.007,312.78,544.302,784.121,670.91,552.663,247.952,461.112,288.476,493.136,425.866,436.474,498.225,38.5,369.095,355.59,357.697,88.78,120.31,76.152,1248.719,765.915,1362.285,744.283,525.474,438.301,462.078,604.492,208.178,475.874,90.405,71.49,66.218,1334.399,431.311,516.88,1022.8,387.817,405.565,542.895,27,50,483,388,294,168,98.225,148.99
+82.7328,324.476,302.925,467.183,158.642,51,40,662,548,159,122,115,253,640.528,311.574,546.221,790.244,668.581,561.402,258.328,460.754,291.392,492.329,418.502,441.481,499.129,38,365.828,356.043,352.904,87.634,121.104,78.899,1249.431,773.559,1364.84,735.226,520.075,435.044,461.065,604.747,204.498,480.321,91.159,72.17,66.119,1328.515,428.2,515.664,1022.503,387.11,404.758,538.455,28,48,493,394,301,166,,
+82.8996,326.246,299.283,460.704,160.466,50,41,661,548,156,123,119,253,644.52,310.691,548.441,789.488,675.942,562.037,257.136,463.811,290.411,491.183,427.917,442.167,502.015,38.5,361.515,355.916,358.065,89.614,122.491,76.832,1254.201,762.445,1361.587,733.553,516.361,432.875,456.097,607.195,210.867,482.97,93.931,75.143,65.664,1323.551,429.572,512.354,1027.17,383.9,402.718,529.094,28,49,488,393,300,166,,
+83.0664,327.13,300.756,468.824,158.189,53,39,662,545,157,127,118,256,644.733,309.107,548.218,793.454,678.307,567.704,257.364,466.132,295.646,498.287,431.772,449.571,505.148,37.5,364.669,358.447,356.001,88.653,122.067,77.072,1246.547,765.17,1356.414,736.918,516.606,427.386,458.957,607.846,209.055,485.646,91.5,72.807,67.327,1325.432,429.741,509.37,1022.361,379.134,399.374,535.641,27,48,496,395,296,165,,
+83.2332,324.175,296.91,462.275,158.317,52,40,659,547,157,125,118,255,641.024,305.441,549.185,797.809,679.559,561.388,253.982,466.132,291.89,487.574,432.952,449.376,505.339,38,359.889,355.364,357.457,88.582,121.16,76.902,1255.345,755.725,1362.287,737.544,520.858,431.759,460.244,607.662,212.367,483.692,89.395,73.501,66.83,1321.641,423.009,510.841,1020.537,380.195,399.26,525.757,27,49,494,393,300,169,,
+83.4,318.467,299.428,462.276,159.787,52,42,670,546,165,124,114,253,638.848,309.995,547.401,803.129,687.664,566.697,255.817,470.749,293.839,495.301,432.296,451.07,506.848,38.5,361.162,356.198,360.653,89.303,121.344,76.591,1259.89,756.923,1348.022,740.9,514.538,429.961,459.41,603.648,210.937,484.782,91.301,74.407,68.252,1311.458,424.098,506.584,1025.105,373.11,387.699,520.963,28,49,500,400,297,167,,
+83.5668,321.578,295.92,465.824,156.521,52,40,667,551,158,120,116,259,635.474,308.885,547.814,805.236,689.756,571.591,259.481,468.821,295.589,499.391,435.767,451.076,513.302,39,362.038,359.041,350.387,88.44,122.931,75.741,1251.561,759.181,1351.991,733.354,510.358,429.189,456.769,606.234,213.018,491.849,89.822,72.991,68.181,1305.857,422.457,504.321,1018.486,371.866,394.443,524.753,28,50,501,404,295,172,,
+83.7336,323.706,292.072,469.194,163.124,52,40,671,560,159,124,118,256,636.732,310.106,542.95,810.336,688.104,576.485,257.437,466.089,293.512,498.783,440.737,457.364,515.742,39,360.031,353.455,351.956,89.119,123.582,76.123,1266.184,756.101,1356.614,737.686,511.465,428.703,459.54,601.817,211.022,492.317,91.144,73.189,66.588,1308.544,425.272,501.266,1015.332,369.335,393.522,518.828,28,50,502,405,302,168,,
+83.9004,317.995,293.014,464.889,162.573,52,41,673,553,161,124,118,259,635.562,303.927,546.65,819.453,690.849,577.682,255.133,472.162,299.088,501.557,440.604,455.905,518.804,38.5,354.219,348.506,351.504,89.727,120.707,77.37,1253.599,750.057,1340.604,739.776,512.084,425.444,459.86,602.921,216.556,489.343,91.343,71.83,67.086,1298.078,423.32,508.507,1014.172,366.054,386.608,514.925,27,50,508,404,299,165,,
+84.0672,316.335,293.014,461.86,158.232,53,40,670,556,159,126,117,255,634.97,305.241,541.456,819.697,693.153,576.258,261.189,466.593,299.088,497,440.1,459.627,520.146,38,357.118,351.108,346.866,84.537,121.656,77.398,1249.495,748.676,1333.467,734.782,511.785,420.371,459.223,606.927,215.297,495.447,90.234,71.802,67.541,1294.839,419.006,503.373,1014.497,365.107,385.63,506.611,28,48,512,413,300,167,,
+84.234,316.418,288.182,458.926,162.149,54,39,670,553,159,125,118,259,631.095,308.811,543.767,815.278,698.555,584.17,257.238,473.483,299.771,503.425,446.431,460.89,519.115,39.5,356.057,351.829,348.435,87.479,123.341,75.897,1257.743,753.478,1332.302,739.72,508.236,423.165,454.623,616.837,217.278,491.977,90.32,72.878,66.759,1287.131,423.221,492.921,1002.687,365.885,376.647,510.344,29,50,514,411,298,171,,
+84.4008,311.858,289.215,459.945,163.025,55,42,673,557,161,125,116,256,629.328,301.813,542.115,825.336,701.468,582.193,257.552,472.125,295.276,500.948,445.34,462.144,519.891,38.5,355.124,351.377,344.66,87.79,120.622,76.109,1250.29,749.398,1334.555,737.713,505.303,422.654,456.659,608.627,216.047,498.095,92.481,73.841,65.28,1284.854,417.069,496.768,1000.269,365.828,380.09,504.051,28,49,510,413,302,171,,
+84.5676,314.334,282.636,458.782,164.213,52,40,677,554,160,125,120,253,625.947,305.862,544.948,822.601,700.077,582.277,258.405,472.436,298.121,503.298,446.799,462.264,527.799,39,351.49,346.187,349.637,88.794,119.22,76.676,1253.313,747.751,1331.877,733.463,498.732,417.194,456.956,606.403,216.825,501.537,91.557,70.839,67.598,1279.521,415.202,495.623,997.412,360.13,378.815,499.243,27,51,521,410,304,170,,
+84.7344,314.884,286.47,454.888,160.282,52,41,678,559,165,126,119,258,629.788,300.873,535.995,830.528,703.073,581.532,255.831,468.113,298.761,503.34,448.427,460.801,524.508,37.5,356.382,349.171,346.484,88.285,123.511,78.149,1251.968,744.84,1325.704,729.33,503.207,418.539,456.198,602.666,220.647,495.291,91.4,73.501,67.185,1286.466,417.097,492.596,994.3,356.396,375.754,499.795,27,48,519,420,300,169,,
+84.9012,310.821,285.225,451.265,165.577,54,41,682,551,165,124,120,258,631.086,299.556,536.195,833.359,705.082,581.862,257.778,471.866,302.132,500.269,453.941,460.919,528.549,37.5,353.427,344.434,344.886,89.247,119.786,77.738,1260.852,749.631,1326,725.913,496.566,413.947,457.194,605.412,219.26,495.673,92.908,72.708,65.607,1279.62,413.745,489.187,992.433,353.851,373.006,490.547,27,48,521,414,303,166,,
+85.068,308.164,282.574,451.649,164.015,54,40,680,561,165,127,121,258,628.286,302.944,532.619,833.945,705.697,584.911,258.858,474.585,304.579,499.42,454.361,465.709,526.25,39,351.645,348.223,345.098,88.341,123.27,76.761,1251.138,744.507,1326.674,726.178,493.819,414.547,452.279,595.427,218.75,501.452,89.993,71.462,66.844,1271.191,411.27,487.391,989.76,353.95,373.119,491.466,28,50,524,426,303,169,,
+85.2348,306.444,284.055,454.65,160.989,54,41,684,564,162,129,120,255,627.235,302.928,536.422,836.961,708.954,584.104,258.999,474.243,300.824,500.665,462.54,467.419,525.551,38,351.32,345.692,351.094,88.271,122.222,75.458,1239.38,737.992,1321.116,724.315,490.466,408.149,455.076,593.976,220.661,502.896,89.808,71.83,66.688,1266.735,406.956,486.811,992.32,351.716,370.229,488.002,28,48,525,421,305,169,,
+85.4016,311.062,280.684,450.845,164.312,54,39,681,561,163,127,118,256,629.812,299.313,534.436,835.965,712.575,582.032,260.449,475.006,304.892,506.723,458.78,474.025,530.102,37.5,347.304,349.284,340.63,87.38,122.676,79.352,1235.362,744.02,1326.453,724.505,489.994,414.697,458.447,586.631,220.349,498.931,94.273,74.067,67.612,1267.584,414.537,485.722,982.547,350.019,368.004,482.232,28,47,518,425,307,169,,
+85.5684,301.679,278.342,445.047,161.852,51,40,687,560,162,128,123,256,617.953,305.788,531.868,835.443,716.36,577.842,256.042,478.02,306.329,508.11,456.614,473.707,533.867,37.5,345.027,341.549,343.302,87.818,122.123,78.63,1235.609,745.768,1315.559,723.459,482.945,402.527,454.201,592.882,219.076,499.78,91.244,73.147,66.602,1258.659,409.954,485.68,980.199,350.189,364.788,475.106,27,48,523,425,307,173,,
+85.7352,306.144,278.632,445.382,164.793,55,40,688,564,162,127,121,254,625.31,302.515,529.877,848.535,712.681,585.586,256.482,465.929,302.061,501.146,460.692,472.964,531.136,39,352.253,342.03,337.363,88.44,120.48,75.684,1218.249,740.092,1319.984,720.133,483.738,412.135,449.29,588.541,219.698,497.16,92.481,73.204,67.313,1257.118,405.216,481.422,977.398,348.124,363.994,475.021,29,49,527,424,306,170,,
+85.902,307.41,275.351,440.844,157.836,54,42,681,570,164,127,121,254,620.236,298.247,536.258,839.023,712.049,589.947,258.672,469.845,304.593,500.085,462.753,468.694,532.849,38,347.856,340.036,339.626,89.473,124.942,76.393,1227.265,738.227,1314.084,719.258,484.258,407.575,454.34,589.05,221.68,499.596,91.528,73.784,66.56,1259.989,407.069,483.501,976.819,344.448,364.816,475.205,27,49,526,427,310,168,,
+86.0688,301.502,273.964,445.341,161.951,53,42,693,565,162,128,123,253,619.404,297.522,529.933,848.87,716.46,584.944,256.312,466.932,306.571,508.124,468.51,470.574,535.881,38.5,345.381,341.761,340.46,87.79,122.024,75.316,1226.18,730.671,1311.262,721.98,483.433,401.543,450.77,582.787,224.468,502.797,90.903,74.025,67.782,1249.975,405.4,481.479,973.014,348.761,360.211,468.615,28,49,535,426,306,169,,
+86.2356,301.942,271.899,437.783,162.446,53,41,692,562,161,131,122,249,619.876,298.735,528.932,842.485,710.775,581.47,253.184,466.04,305.219,508.832,468.636,471.767,532.806,37.5,349.114,341.521,336.614,89.43,121.344,75.16,1217.21,732.811,1309.541,715.966,479.122,402.816,455.418,588.594,223.152,500.616,90.775,73.784,67.214,1248.872,404.184,479.527,970.129,340.262,360.452,463.313,27,48,534,427,309,167,,
+86.4024,297.861,271.319,437.911,163.709,54,41,698,569,162,132,121,253,617.3,297.943,529.477,847.945,717.339,583.639,249.943,466.528,307.012,503.496,468.496,474.633,535.031,38,350.415,341.605,337.901,84.791,120.636,75.288,1211.968,733.974,1309.446,714.722,472.51,405.254,449.827,587.18,221.609,499.256,91.585,73.812,66.688,1245.435,399.799,485.255,958.163,340.955,359.772,459.99,27,49,534,429,303,168,,
+86.5692,298.174,269.579,436.078,161.894,53,41,690,569,165,132,120,252,612.807,295.902,531.724,845.997,710.087,578.651,255.092,465.691,305.674,508.449,464.69,468.892,529.44,37,345.749,337.957,339.711,84.947,122.817,76.69,1212.358,730.853,1322.723,712.135,474.795,395.02,451.161,586.642,223.095,495.673,89.779,75.044,67.455,1237.034,398.357,472.342,962.067,343.599,360.962,458.123,27,47,533,426,307,170,,
+86.736,297.296,271.383,433.034,162.092,55,41,700,565,164,130,121,248,614.079,302.241,524.062,850.973,717.559,582.326,254.052,462.437,307.495,502.831,474.076,465.511,537.24,37,341.125,337.024,337.01,85.23,121.783,74.098,1216.714,729.873,1304.235,706.793,471.199,401.578,445.893,591.781,227.482,496.481,91.315,76.304,66.972,1239.947,394.495,480.135,958.701,338.537,358.554,455.351,28,46,535,432,307,169,,
+86.9028,294.853,267.261,430.978,163.733,55,41,700,566,164,130,122,247,614.89,296.072,526.593,850.52,717.282,583.32,249.929,459.167,306.542,508.35,472.837,471.47,535.663,37.5,342.001,340.729,333.574,87.521,122.562,75.005,1202.707,727.758,1308.702,701.101,468.496,396.276,447.167,584.671,225.133,495.744,89.566,74.662,67.64,1235.676,395.132,476.26,963.41,337.547,353.892,454.63,28,47,532,433,308,169,,
+87.0696,301.416,267.301,431.689,163.365,53,40,696,567,164,132,123,243,612.41,301.942,524.282,846.046,714.623,580.772,254.45,461.716,306.884,510.997,470.535,472.88,530.655,37,341.224,338.65,331.297,85.428,119.985,75.628,1211.318,720.355,1303.101,700.574,462.236,390.619,450.821,580.573,222.147,498.279,91.386,74.619,66.09,1229.509,395.16,468.212,956.013,337.604,355.791,447.362,26,48,534,433,307,169,,
+87.2364,294.384,263.949,429.686,161.64,55,41,700,571,167,132,119,245,614.767,296.917,522.773,854.509,720.026,581.116,248.308,454.659,305.347,506.723,471.677,470.407,534.687,37,341.351,333.644,336.741,86.446,120.778,75.387,1205.144,728.136,1300.11,704.442,465.82,388.408,449.884,582.711,226.945,500.701,93.121,74.747,66.531,1224.616,395.004,473.389,955.886,335.921,350.945,448.932,27,47,530,433,311,169,,
+87.4032,291.998,263.171,428.961,164.595,53,40,697,572,166,131,120,242,612.528,297.665,520.932,845.458,712.073,576.782,253.611,456.665,309.914,503.85,470.677,467.519,528.587,37,337.788,338.735,334.988,86.064,120.636,75.84,1201.892,727.014,1289.915,697.18,463.165,388.493,451.579,578.758,227.298,498.817,90.22,76.262,67.74,1230.075,390.436,471.79,953.425,335.157,351.03,445.524,27,47,534,432,310,166,,
+87.57,291.093,264.187,422.391,161.272,52,41,707,573,165,133,123,244,610.745,301.149,519.844,855.25,716.337,573.225,251.237,458.513,306.67,506.072,473.247,472.688,531.448,38.5,340.347,333.206,334.663,85.654,121.557,73.574,1202.416,724.59,1301.322,694.601,457.26,384.314,446.006,578.673,226.053,492.997,90.021,72.411,67.327,1222.508,391.737,467.378,953.694,335.723,356.938,434.721,28,49,526,431,310,164,,
+87.7368,288.776,261.771,422.789,161.131,55,42,700,570,168,134,121,237,617.396,296.14,521.554,850.809,713.656,574.836,249.076,449.886,311.905,507.784,471.045,465.878,531.292,38,340.404,331.226,335.37,88.186,121.882,74.339,1193.54,726.588,1289.787,697.304,457.326,389.105,449.808,573.554,226.662,498.336,89.95,74.35,66.787,1222.551,387.282,467.307,955.278,331.142,352.504,433.49,28,48,532,426,311,170,,
+87.9036,289.89,263.765,424.568,161.583,53,42,705,570,166,132,121,239,611.822,298.371,515.128,847.707,712.959,571.238,249.204,445.242,305.817,507.43,467.859,467.122,528.153,36.5,337.42,331.226,334.139,86.036,119.234,77.341,1190.223,722.233,1287.597,687.777,457.171,384.155,444.492,569.775,227.681,492.274,91.301,72.793,66.943,1218.506,389.248,464.973,948.446,338.198,350.336,429.474,27,46,531,433,307,166,,
+88.0704,288.412,260.31,416.44,160.593,55,42,710,570,165,132,119,236,607.714,293.901,523.303,838.352,703.745,568.055,246.132,449.787,309.188,506.977,466.145,467.66,528.601,37,340.799,335.073,333.517,86.757,120.339,74.183,1193.519,722.482,1291.554,690.294,454.673,384.409,450.756,570.567,230.228,497.727,92.012,74.846,65.223,1221.801,380.691,470.956,947.315,333.517,350.251,433.731,26,48,529,436,308,165,,
+88.2372,289.586,261.163,420.401,162.916,55,42,715,573,166,134,118,238,608.029,297.833,518.592,842.478,713.187,568.085,243.617,447.082,307.154,507.345,471.055,463.581,526.838,36,337.491,330.237,332.471,85.286,118.257,74.226,1187.303,723.944,1286.064,687.493,447.861,383.885,454.385,577.349,228.388,492.543,91.386,73.487,65.735,1214.998,383.053,467.264,949.776,334.45,351.639,432.26,27,45,528,430,311,167,,
+88.404,283.524,259.836,416.455,164.92,54,43,709,571,166,134,122,234,609.231,299.125,513.01,844.595,707.521,568.115,241.302,445.978,308.491,500.991,466.527,467.137,532.595,36,337.264,332.541,334.069,86.969,120.523,73.914,1184.056,721.221,1279.236,680.981,451.214,383.365,448.597,572.336,223.888,494.569,91.144,71.108,66.801,1216.483,383.732,462.427,951.982,330.138,352.362,429.474,26,46,529,430,309,167,,
+88.5708,287.076,255.036,416.185,158.798,54,41,717,574,166,131,118,232,602.994,298.549,517.182,844.255,700.657,562.973,238.722,441.927,309.928,509.199,471.112,459.927,527.007,35.5,337.137,330.364,336.755,87.436,119.489,75.953,1183.097,722.19,1283.875,682.361,451.763,377.5,448.918,573.115,227.95,488.705,92.253,73.402,65.621,1217.431,380.422,469.952,946.452,336.487,353.793,425.656,26,45,522,424,309,168,,
+88.7376,288.682,258.221,415.957,162.531,54,41,705,573,166,134,118,231,609.541,296.818,512.745,845.012,696.432,561.798,238.656,441.728,306.315,503.213,462.476,457.123,519.481,36,337.872,331.594,332.683,86.757,120.41,72.54,1179.035,722.039,1278.151,677.513,449.67,382.371,449.668,571.077,230.115,488.748,91.372,72.92,66.119,1197.799,380.139,464.45,936.509,333.772,349.188,424.03,27,45,524,424,305,162,,
+88.9044,286.812,253.341,415.394,157.539,54,41,717,576,168,134,118,233,612.072,300.778,511.206,842.669,700.403,560.099,238.651,436.361,304.238,505.944,462.328,456.217,522.849,37,334.111,325.994,329.756,84.692,118.229,74.877,1169.157,723.939,1270.036,675.062,451.763,376.736,454.948,571.825,226.11,490.023,90.846,72.439,66.048,1196.739,375.571,463.219,949.691,331.311,352.589,421.315,27,47,528,419,307,163,,
+89.0712,283.949,252.476,412.917,159.151,54,41,710,573,169,135,116,230,606.195,299.064,511.5,842.081,693.195,555.54,235.01,434.663,305.703,502.533,461.91,451.989,516.974,37,333.164,332.146,332.442,86.616,117.025,73.489,1172.844,714.359,1273.853,671.639,448.851,379.14,445.566,572.798,228.289,491.552,92.268,74.124,65.095,1206.37,378.046,464.464,944.316,334.267,353.708,417.752,27,47,522,426,310,161,,
+89.238,287.65,251.684,408.916,159.377,55,42,716,573,170,133,118,227,604.795,295.9,507.156,845.02,691.267,553.046,234.874,431.301,303.683,501.415,458.552,454.177,518.45,37.5,333.574,329.035,332.329,86.602,119.149,71.747,1167.44,719.107,1271.874,665.477,445.818,378.916,455.377,572.999,229.648,487.912,93.092,72.807,66.503,1206.13,378.159,464.549,947.188,334.677,355.309,414.146,27,48,525,421,309,162,,
+89.4048,278.644,253.24,403.915,158.486,55,41,715,578,171,135,117,229,604.697,297.963,512.53,845.26,689.015,554.862,235.241,432.99,304.963,503.623,461.018,448.864,514.226,37,334.705,328.017,325.556,85.711,117.464,73.05,1167.831,725.243,1263.074,666.074,444.953,374.825,457.52,571.728,227.582,487.516,91.699,73.926,67.811,1209.213,377.325,464.351,941.954,331.17,348.905,416.508,27,47,521,423,313,160,,
+89.5716,282.829,253.735,412.777,154.98,54,41,718,580,170,135,116,222,599.897,300.806,508.308,841.126,687.317,547.218,231.278,421.564,303.839,500.425,459.075,450.056,508.564,37,336.374,331.566,329.883,86.135,120.339,72.427,1160.687,718.076,1264.219,667.464,444.828,376.265,454.198,575.659,226.124,484.202,89.993,72.637,65.777,1201.972,376.731,462.102,936.693,331.877,348.466,415.885,27,47,523,420,308,162,,
+89.7384,280.588,249.299,404.832,156.62,54,41,713,576,167,137,117,223,600.595,296.465,513.747,837.285,683.186,545.722,233.716,423.79,301.322,502.264,456.826,444.111,512.682,38,336.43,334.323,330.293,86.885,119.971,71.96,1167.129,716.294,1276.084,652.993,441.36,372.992,452.704,575.025,227.44,481.723,89.296,74.308,66.048,1197.375,371.356,468.396,934.84,335.186,352.22,409.451,27,49,521,413,309,162,,
+89.9052,279.169,251.502,399.824,157.935,55,42,713,570,169,137,116,220,607.743,300.869,513.433,835.103,679.49,543.453,233.033,424.341,306.77,497.552,450.999,446.416,508.324,36,329.827,325.839,328.653,86.687,118.554,72.54,1158.609,717.369,1270.13,658.323,439.321,366.833,446.214,563.072,227.624,481.865,91.997,75.172,65.379,1199.228,374.807,459.344,943.171,331.962,357.363,411.106,26,46,517,415,309,163,,
+90.072,277.805,249.582,404.839,156.111,54,40,714,575,168,136,114,220,602.336,301.513,514.169,839.243,682.219,544.572,227.97,420.11,303.583,500.609,453.2,444.111,506.734,37,331.424,324.481,324.595,86.602,118.441,74.934,1157.59,721.983,1255.453,657.916,438.947,377.298,445.352,566.803,223.038,478.65,91.215,73.345,64.711,1197.304,372.827,463.389,943.836,337.663,359.744,404.539,25,49,518,412,312,159,,
+90.2388,275.93,246.018,402.921,157.482,56,41,712,574,168,136,115,221,608.802,298.068,515.414,822.435,683.442,535.485,227.856,420.322,302.289,495.768,451.551,437.126,503.727,37.5,334.309,326.461,324.227,84.834,117.067,71.606,1154.256,721.683,1263.865,654.814,438.471,370.774,436.651,565.07,224.468,481.893,89.324,72.453,65.123,1206.384,370.946,466.656,951.134,334.499,353.439,403.101,28,47,515,414,302,162,,
+90.4056,274.706,248.071,397.2,156.365,54,40,716,573,167,135,115,216,598.108,303.245,513.282,828.592,682.744,534.364,226.083,419.95,301.08,501.458,451.911,436.94,494.682,36,332.344,326.673,331.241,84.127,116.685,72.356,1149.903,728.704,1245.828,649.713,432.506,368.941,437.458,563.88,223.279,475.223,93.064,72.312,66.289,1196.215,370.055,466.727,942.831,339.937,356.957,410.498,26,46,519,407,306,160,,
+90.5724,273.785,243.988,401.316,158.062,54,41,718,578,167,137,113,213,609.017,300.409,508.588,824.971,674.778,535.027,224.386,413.007,304.081,494.325,451.452,436.148,494.067,36,334.945,325.91,326.659,86.276,115.722,73.928,1146.456,718.748,1251.249,641.427,431.177,373.891,439.269,565.769,224.241,472.489,91.116,74.053,64.37,1196.597,366.774,470.546,946.919,339.554,357.59,406.372,26,46,510,411,305,157,,
+90.7392,274.083,249.052,399.937,154.485,54,39,722,576,168,138,115,215,600.352,298.343,511.657,822.1,669.617,531.844,222.21,414.33,300.632,496.221,447.209,430.491,493.436,37,333.758,324.863,328.328,84.975,115.552,74.325,1163.322,723.558,1248.018,645.551,432.406,372.801,442.167,562.203,223.222,473.765,92.595,72.609,66.958,1192.255,364.808,466.274,950.441,338.608,360.126,406.143,27,47,508,407,305,159,,
+90.906,276.703,245.289,398.508,152.279,54,42,716,573,169,134,111,213,604.858,299.538,507.929,823.261,670.843,530.924,219.99,412.251,302.239,493.702,442.004,425.456,494.972,36,332.329,322.997,324.764,85.612,118.738,75.104,1150.437,728.825,1256.598,650.938,428.351,371.229,435.603,565.754,224.1,472.953,91.699,73.954,63.872,1195.734,371.286,468.792,935.208,341.181,358.256,400.416,26,46,505,404,302,157,,
+91.0728,272.137,246.237,395.306,155.333,54,39,717,571,169,138,111,208,601.033,300.067,512.587,820.185,667.463,525.518,221.128,406.25,298.128,495.91,441.87,427.252,488.578,36,327.804,326.489,324.807,84.551,118.866,74.381,1139.993,727.982,1248.608,649.935,431.821,368.724,432.377,564.085,222.557,471.029,90.263,73.034,65.834,1159.696,369.512,452.569,939.166,340.008,361.713,398.577,26,46,511,399,303,157,,
+91.2396,272.989,248.175,393.601,153.763,54,39,723,574,169,137,110,210,601.102,299.03,511.951,816.018,663.539,522.282,217.25,407.316,291.99,491.494,438.129,418.389,485.227,35.5,337.717,328.752,326.235,86.121,117.308,73.234,1145.427,725.86,1255.378,634.965,431.269,372,437.834,563.964,227.143,468.042,92.381,73.671,65.337,1154.35,348.854,449.938,912.041,346.314,361.657,397.828,27,44,505,394,305,153,,
+91.4064,274.142,245.94,395.612,156.351,55,39,723,571,169,137,112,209,603.504,299.409,511.258,807.463,662.741,518.084,218.91,406.836,298.206,490.829,436.63,414.127,479.726,37,334.436,325.669,327.79,84.975,116.713,73.957,1150.897,730.105,1243.896,630.819,431.556,371.539,439.241,559.43,220.208,462.59,91.571,70.556,64.626,1155.708,350.933,452.456,912.323,344.646,365.61,401.519,26,48,502,399,304,151,,
+91.5732,270.328,247.213,391.89,152.01,53,40,722,572,167,137,110,207,605.877,297.475,513.217,806.032,662.788,519.563,219.237,397.729,295.66,483.724,434.112,418.02,480.418,35,331.806,327.889,326.928,88.101,114.745,71.946,1139.69,722.08,1246.565,629.003,429.198,371.497,432.391,558.512,218.524,467.816,91.912,73.232,64.882,1172.157,355.303,454.252,917.726,347.007,365.709,393.6,25,45,504,394,302,153,,
+91.74,270.072,247.637,397.092,152.915,54,41,720,575,165,135,110,209,607.291,301.288,509.553,807.134,661.037,518.623,217.861,399.087,295.774,486.625,430.313,410.775,480.562,36,335.511,326.716,327.691,83.943,116.94,74.197,1148.735,729.755,1241.076,625.455,430.178,370.117,432.532,579.342,218.283,462.037,88.201,72.17,63.801,1172.807,353.974,460.292,921.913,345.07,364.094,402.509,26,46,496,394,303,154,,
+91.9068,269.793,246.052,393.459,153.283,54,40,720,570,166,134,111,207,601.451,300.634,513.633,810.688,658.826,511.45,217.132,394.95,294.764,490.022,427.521,412.412,470.079,35.5,332.584,326.306,327.352,86.757,121.528,71.436,1140.721,731.279,1251.531,621.636,430.133,373.622,436.87,581.017,218.255,460.819,90.675,72.651,63.758,1178.437,362.191,462.654,920.06,349.284,371.036,394.576,25,46,498,391,298,152,,
+92.0736,277.193,244.162,393.681,149.931,54,41,715,573,167,136,110,205,606.073,299.953,508.745,813.267,656.739,515.133,212.854,398.896,294.18,487.871,426.702,407.691,465.125,36,336.26,324.481,328.738,87.125,117.747,74.268,1147.975,729.158,1238.228,627.297,428.735,375.594,434.945,583.061,219.047,461.74,89.182,71.349,63.758,1191.618,362.672,465.185,936.127,349.807,371.022,400.246,26,46,494,389,300,151,,
+92.2404,274.969,249.285,390.186,149.338,52,40,722,574,170,135,109,203,599.075,300.153,514.323,804.529,650.102,513.065,210.864,393.398,296.798,479.252,420.378,406.478,467.576,34,333.178,329.515,331.467,83.617,115.198,73.234,1140.189,729.74,1232.974,616.239,434.492,374.202,434.301,584.897,215.919,459.828,92.467,72.042,64.64,1191.321,357.354,463.304,944.854,354.403,374.168,397.969,24,44,493,386,297,151,,
+92.4072,271.56,245.374,389.485,151.741,52,40,715,561,167,139,108,200,604.248,296.337,513.032,798.754,649.997,511.193,212.612,395.436,288.633,480.95,421.901,398.809,462.236,34.5,331.976,325.598,332.061,84.042,115.736,73.362,1153.714,735.656,1243.892,619.128,427.97,373.338,432.603,578.524,214.773,454.73,91.002,71.972,67.128,1201.236,360.367,466.911,941.375,359.295,375.981,401.165,24,45,493,381,298,151,,
+92.574,274.027,245.039,385.021,146.679,52,40,721,565,168,136,107,202,608.908,299.407,513.776,803.363,646.158,505.281,209.665,387.933,292.032,482.875,416.63,400.742,457.222,34.5,335.129,325.556,332.131,83.434,115.948,72.073,1144.592,739.448,1231.694,615.446,431.036,371.448,437.919,570.931,213.966,453.058,89.865,70.825,63.901,1209.637,363.224,471.225,950.285,354.346,375.91,398.832,25,44,487,380,299,152,,
+92.7408,272.677,243.186,386.314,150.129,52,40,716,571,168,138,107,200,605.496,297.989,510.019,799.85,650.397,504.288,207.518,391.729,287.736,482.634,413.46,394.227,453.214,35.5,336.543,328.964,329.812,83.179,118.03,74.112,1139.786,736.474,1246.944,620.027,431.039,376.567,437.565,562.827,211.093,449.957,91.329,70.811,65.067,1209.34,365.515,474.365,954.67,357.089,378.092,397.786,26,45,485,375,295,152,,
+92.9076,274.206,250.877,387.103,149.408,53,41,721,567,169,137,107,198,608.301,299.27,507.326,797.043,644.992,500.347,208.06,387.596,289.145,484.035,413.943,394.737,449.033,35.5,335.624,329.657,331.368,84.537,115.325,73.801,1144.006,741.502,1238.236,615.361,427.202,374.145,436.566,559.132,210.881,458.171,87.803,70.683,63.374,1220.245,364.567,475.468,949.154,363.212,383.788,398.648,26,45,485,376,293,149,,
+93.0744,273.421,247.454,391.943,148.687,53,40,710,570,167,136,110,198,604.148,301.568,512.511,802.557,640.581,499.539,205.769,385.71,286.982,478.077,402.456,389.503,449.263,35.5,334.974,328.879,332.216,86.955,114.589,74.084,1146.131,736.378,1234.482,612.405,429.722,375.976,438.293,551.846,212.424,448.342,88.713,72.439,65.465,1221.801,359.815,477.222,957.314,359.719,383.576,392.299,25,46,479,377,291,149,,
+93.2412,274.538,244.752,386.626,149.267,53,39,713,566,169,136,108,197,611.072,301.024,512.752,781.578,638.11,497.697,208.204,390.183,288.305,482.79,400.605,379.895,444.96,35.5,336.699,329.827,334.762,85.81,112.025,71.521,1143.313,740.801,1240.772,614.011,428.663,360.242,436.87,548.82,212.424,441.502,89.552,71.179,65.55,1235.124,362.955,480.432,959.294,362.548,386.069,405.266,25,46,478,371,289,150,,
+93.408,272.857,242.785,389.647,148.418,55,39,714,571,170,137,110,196,608.568,300.381,511.743,761.583,615.504,486.715,200.683,379.954,286.47,475.812,398.887,381.625,442.082,35,339.315,329.812,332.824,87.606,114.532,72.611,1146.925,741.595,1233.573,536.037,413.214,357.597,440.334,553.102,209.65,447.266,89.367,71.519,63.787,1226.582,362.63,481.578,965.588,363.891,388.492,400.189,25,45,478,374,291,151,,
+93.5748,266.724,246.114,382.762,146.128,51,40,715,563,163,135,106,195,611.269,298.896,511.3,775.214,622.824,478.929,206.577,377.109,283.312,481.813,395.344,382.43,434.296,34.5,341.945,331.976,335.002,85.739,112.408,71.563,1146.783,740.271,1250.014,522.992,401.183,363.843,434.896,543.507,204.71,446.487,89.395,70.074,63.247,1235.747,362.064,482.243,960.384,362.746,388.421,404.234,25,44,471,374,292,149,,
+93.7416,269.589,249.307,389.394,147.74,52,40,713,559,167,133,107,196,613.01,305.553,508.178,783.424,622.427,486.614,203.513,376.076,284.18,478.997,396.904,374.355,431.305,34.5,339.88,330.604,331.17,87.365,113.767,73.461,1150.035,742.022,1243.749,530.123,402.754,372.348,437.967,542.672,207.357,444.872,88.77,71.915,61.91,1233.936,365.43,485.849,969.619,368.331,397.872,404.912,25,44,472,368,287,148,,
+93.9084,270.787,249.024,388.885,147.033,54,39,711,562,163,135,109,196,606.537,300.457,512.638,782.219,614.464,481.344,202.861,377.533,284.137,478.544,390.988,368.905,426.785,35,335.836,332.089,332.81,86.418,113.725,71.861,1145.143,745.177,1245.621,545.103,400.53,376.014,441.612,549.782,206.239,436.587,89.808,72.906,60.929,1246.369,367.877,482.794,971.147,368.076,398.269,398.648,26,44,467,365,287,147,,
+94.0752,272.136,249.392,390.575,147.004,50,39,712,564,168,134,104,196,609.39,304.245,510.662,781.09,618.958,483.961,202.874,373.372,283.27,478.19,384.554,369.914,421.887,35,338.523,333.503,331.976,85.088,111.36,72.413,1162.974,745.942,1242.146,551.856,401.998,375.698,444.831,539.487,204.427,432.99,88.741,71.476,63.431,1244.261,364.695,486.047,980.906,371.838,401.457,405.931,26,44,468,365,285,148,,
+94.242,274.296,249.692,386.711,146.594,51,40,713,562,167,137,106,194,613.548,301.541,511.329,786.851,613.013,481.934,200.813,373.769,280.794,481.091,382.388,370.718,419.926,33.5,336.656,332.442,331.735,84.551,115.509,73.744,1154.826,742.142,1237.842,554.53,406.648,379.577,443.445,546.917,205.687,437.14,89.751,72.665,62.649,1252.026,366.448,490.927,981.599,373.195,400.819,406.524,24,43,459,362,285,144,,
+94.4088,273.543,248.307,391.115,147.612,54,39,710,562,163,133,105,193,612.188,300.963,515.211,788.14,611.779,478.745,200.57,371.816,278.817,473.746,380.702,368.924,416.647,35,340.22,329.105,334.974,85.923,114.249,72.795,1153.487,740.697,1244.297,558.413,412.023,380.133,448.142,546.399,201.95,438.117,91.116,70.924,64.014,1249.07,367.919,496.019,984.979,373.012,401.06,405.506,25,45,466,358,286,145,,
+94.5756,274.97,247.556,388.504,141.885,51,38,712,559,165,133,107,193,609.538,303.83,518.549,782.471,597.557,479.496,199.429,372.934,276.783,475.232,378.697,364.16,416.248,34.5,339.682,335.03,336.444,83.844,114.192,75.09,1159.594,748.117,1247.982,560.26,410.357,380.243,447.748,543.039,202.828,434.421,88.94,70.06,62.763,1253.624,369.278,496.754,979.638,372.969,410,405.888,24,45,462,360,286,144,,
+94.7424,273.577,250.145,388.504,141.079,51,39,710,565,165,134,105,190,607.159,300.371,514.084,783.638,600.606,481.066,198.899,372.941,274.976,477.596,372.644,357.92,410.146,35.5,337.208,336.812,342.864,86.135,112.224,73.546,1149.721,747.356,1246.604,559.891,421.506,383.899,448.792,539.048,201.384,427.722,88.485,71.306,63.517,1257.542,371.526,492.723,985.969,379.587,405.225,410.837,25,46,457,355,287,143,,
+94.9092,273.322,250.594,387.851,141.744,52,38,709,562,164,135,103,192,610.385,303.73,515.901,784.13,605.307,476.548,200.361,378.107,276.029,473.803,371.37,351.867,408.384,34,343.684,331.99,333.178,84.777,110.737,71.733,1160.357,746.283,1248.99,561.512,419.487,385.062,446.841,540.435,200.153,431.262,86.623,72.524,63.488,1255.138,368.825,491.691,986.196,377.466,412.834,413.793,24,44,454,355,277,143,,
+95.076,276.498,249.01,392.89,142.126,50,40,706,560,164,130,106,192,613.271,307.232,509.568,785.139,592.673,471.1,195.127,372.141,272.672,477.567,367.63,350.112,399.595,34.5,344.32,336.331,342.609,84.551,113.031,71.676,1166.18,753.349,1246.888,569.97,424.965,386.603,451.975,542.757,196.332,432.126,88.997,69.72,62.351,1262.69,378.089,496.655,988.459,387.831,414.775,420.014,25,44,458,350,281,143,,
+95.2428,283.048,249.568,388.686,143.356,52,37,715,559,165,135,104,193,612.884,301.384,513.669,789.034,592.524,469.418,195.959,366.981,275.759,471.142,369.461,348.454,404.962,34.5,341.577,338.07,335.186,83.886,112.79,74.027,1163.978,749.306,1245.599,565.863,423.04,385.927,447.378,536.729,198.681,428.359,89.808,68.12,62.251,1261.686,371.172,495.057,991.882,384.564,417.736,414.641,25,44,453,349,280,142,,
+95.4096,275.595,252.136,388.391,139.453,51,38,698,556,163,134,102,190,612.821,305.348,517.604,786.625,593.881,473.479,194.073,372.368,271.775,469.882,358.51,343.182,395.148,34.5,344.49,335.963,339.739,81.666,115.07,73.348,1163.549,756.43,1258.733,572.217,426.524,390.255,446.094,540.49,193.812,429.294,87.433,67.861,61.213,1260.668,372.134,501.549,994.102,378.852,417.765,416.027,25,44,451,352,279,145,,
+95.5764,279.571,251.683,390.628,140.542,52,38,707,559,164,131,105,192,617.57,302.674,520.566,786.752,591.742,473.514,196.28,368.938,273.397,474.977,356.081,345.14,393.717,35,346.484,337.901,342.609,85.032,113.668,73.447,1170.779,760.259,1258.812,574.295,427.386,390.676,447.833,541.384,191.944,427.481,86.13,65.358,62.749,1265.901,371.667,502.567,994.003,389.047,423.234,419.039,25,45,448,347,275,144,,
+95.7432,280.206,249.533,389.894,142.098,52,38,700,558,164,133,105,191,615.604,300.659,519.515,783.681,590.342,471.582,196.607,371.475,270.453,471.807,357.603,342.107,391.367,34.5,342.949,338.466,338.198,86.616,113.994,72.767,1168.849,758.716,1253.789,572.714,433.016,390.34,451.845,538.298,193.218,428.515,90.454,68.017,61.924,1267.726,376.589,500.092,996.563,389.202,431.027,420.905,25,44,448,346,275,140,,
+95.91,276.399,254.796,396.262,141.716,50,39,703,553,167,133,104,192,614.039,303.525,513.253,779.955,593.59,474.373,196.101,370.798,270.709,468.906,356.18,339.489,388.852,33.5,343.232,334.663,339.541,84.565,110.524,73.815,1171.487,760.008,1262.26,573.115,427.797,391.856,445.44,537.159,189.849,423.119,88.648,66.574,61.952,1277.711,376.547,501.393,1002.758,395.198,429.383,427.254,24,43,448,341,275,144,,
+96.0768,279.862,251.896,391.343,140.061,51,38,701,554,162,133,100,191,616.098,300.654,516.567,786.639,584.532,472.261,195.15,376.009,268.575,469.047,351.103,335.742,383.889,33.5,347.757,332.655,345.098,82.854,110.963,70.331,1177.234,754.68,1254.812,572.347,438.928,396.554,445.142,532.552,192.935,425.852,87.538,68.271,60.345,1276.07,378.103,505.198,999.972,388.58,433.506,423.96,24,43,443,343,271,141,,
+96.2436,280.959,256.311,390.334,140.005,52,37,705,550,158,132,103,191,614.709,300.686,519.065,781.401,589.822,472.7,194.318,368.416,270.837,470.123,347.948,337.535,384.411,34.5,345.225,335.355,338.48,86.474,111.813,72.186,1179.765,762.484,1267.691,574.38,440.311,397.088,442.229,529.948,188.802,425.526,89.202,66.956,59.833,1276.367,381.257,506.527,1011.315,397.856,434.626,428.23,25,44,447,342,276,141,,
+96.4104,282.493,252.663,396.244,138.209,52,38,697,559,159,135,103,193,617.892,304.203,518.262,787.531,589.111,471.398,195.661,366.316,266.953,468.807,345.848,331.315,377.714,34.5,348.223,340.488,342.836,84.127,110.255,72.271,1174.709,753.975,1272.682,574.167,443.975,400.447,442.326,534.395,189.651,423.374,90.71,67.861,61.952,1294.287,374.708,504.476,1012.149,392.483,439.004,428.357,25,44,438,341,272,138,,
+96.5772,280.819,250.007,393.166,140.104,52,36,701,552,163,131,103,188,614.255,301.828,521.641,786.647,589.68,471.58,193.678,370.584,266.199,470.321,340.254,330.454,373.11,35,352.14,338.283,343.203,84.89,110.34,70.133,1175.253,768.567,1282.003,576.982,444.119,399.314,443.119,538.752,188.618,425.442,87.282,66.999,59.961,1284.627,379.065,510.94,1011.301,398.719,435.844,432.331,25,45,437,335,271,140,,
diff --git a/data/cytokine_example.csv b/data/cytokine_example.csv
new file mode 100644
index 0000000..53999fb
--- /dev/null
+++ b/data/cytokine_example.csv
@@ -0,0 +1,13 @@
+Participant ID,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+Replicate,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
+Group,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 1,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2,Group 2
+12,7.303412021103958,3.0183106049957953,7.472288517724754,4.2833683797257365,5.307224114720199,5.797461270079848,2.0148504317254647,8.351353410655152,5.949010676727963,8.396508850694618,6.581509124178313,4.82651183775716,4.70854991200212,6.237100849617728,2.1257509092740365
+16,7.470909332838964,3.159377499143629,7.194721366606613,4.206290504442118,5.782422181359651,6.865096419806498,1.7096204158938526,7.666736181836135,6.396742727621743,9.334161028118507,6.756186455901731,5.307861759016582,5.174685699195872,7.299988101063307,3.303965276727033
+20,7.261947587924801,2.760872800583458,7.064868484330388,3.834592707519103,5.336515254122448,6.118002069099847,1.5687725842145999,8.236915858211695,6.662303816752572,9.557423047799322,6.645150296757134,4.593766951122319,4.531075393451904,7.808251556954222,3.377807692287375
+24,7.178267889126078,2.253390838807173,5.583008205065701,3.834592707519103,5.355695459968111,5.598599908645074,0.13906572752021826,7.903972447572472,6.274664620561641,9.661972945972074,5.637980363670573,4.175954613346791,4.258372798513361,8.112823672314509,3.876665068050742
+28,7.057189246086794,1.7144336895534475,4.737346322809824,3.3386151307055925,5.051423706608176,4.9471899877601295,0.13975752722479498,8.682448933222412,6.052569180508415,9.313859321426646,4.9601026824463395,3.7842123981852134,3.981118534241465,7.650683562817428,3.1868241900676892
+32,6.7784682796075115,1.7168442988907406,5.42472806938663,2.926499618854903,4.9899976954659016,4.823701912968817,0.9578522362216607,9.008251509900196,6.706374315133839,9.019332091488385,5.428224999195163,4.0056198119714335,4.198479292444571,7.149583086426804,2.4935222331322247
+36,7.19883327539918,1.921475127949834,5.611103908849838,3.71371000907927,4.73052468719874,5.855645334090556,0.9410981700386614,9.666899975933593,7.293662830814861,9.064955677374822,4.876509086310544,4.477925024922587,4.531104896719646,7.245166684583364,3.2751078579764026
+40,7.1351573120917156,1.8324801326640756,5.451416082512381,3.74555019743639,5.345293141399031,6.271420915498466,1.1608132313399537,9.580334788901121,8.279589266012023,9.017082271347466,4.899086286289969,4.608509835174005,4.699573683819483,7.956012733240144,3.7325196891350143
+44,6.805078044707797,1.5702068426700866,5.559556922018524,3.173376027477184,4.958510886115044,5.602514752976599,1.2310302731366591,9.844202487595897,8.821657979727318,9.162358987530174,4.92587479651267,4.29068900965397,4.3166190774113735,7.971137603593861,3.5431248234944768
+48,6.495573648941756,1.301119260491838,4.006067500381569,3.0227276920576904,4.883857750929148,4.9685787076810914,-0.018741032093890084,9.968871626671714,9.878880865099761,9.217047452402374,4.3873760272622615,3.600469170422337,4.254204052980737,7.696191488688788,3.289785181179364
diff --git a/images/live_cell_fitting-01.png b/images/live_cell_fitting-01.png
new file mode 100644
index 0000000..d42d750
Binary files /dev/null and b/images/live_cell_fitting-01.png differ
diff --git a/notebooks/live_cell_tutorial.ipynb b/notebooks/live_cell_tutorial.ipynb
new file mode 100644
index 0000000..4868a6a
--- /dev/null
+++ b/notebooks/live_cell_tutorial.ipynb
@@ -0,0 +1,236 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "dfaa8027",
+   "metadata": {},
+   "source": [
+    "# Extracting circadian parameters from live-cell data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9f4c310b",
+   "metadata": {},
+   "source": [
+    "The aim of this tutorial is to use the cosinor_lite Python package to extract circadian parameters from live-cell data. Here we will use bioluminescence data, but in theory any data (e.g. qPCR, cytokine) could be used."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3ba2467a",
+   "metadata": {},
+   "source": [
+    "## Core methodology - three types of cosinor models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e11c9c2",
+   "metadata": {},
+   "source": [
+    "The core of the methodology is the possibility to choose between three different cosinor models:\n",
+    "\n",
+    "- a) Fixed 24-h period\n",
+    "\n",
+    "- b) Free period\n",
+    "\n",
+    "- c) Free period with damped amplitude\n",
+    "\n",
+    "<div style=\"text-align: center;\">\n",
+    "  <img src=\"../images/live_cell_fitting-01.png\" alt=\"Model selection\" style=\"width:100%;\"/>\n",
+    "</div>\n",
+    "\n",
+    "Once a model is chosen, it is fitted independently to each sample. The fitted parameters can be exported for downstream statistical analysis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1cd9375a",
+   "metadata": {},
+   "source": [
+    "## Loading data and creating a LiveCellDataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8386b47",
+   "metadata": {},
+   "source": [
+    "We first load the data, where we assume it's in a standardised format (see data folder for examples). The data is assumed to have the following format:\n",
+    "- participant_id (row 1)\n",
+    "- replicate (row 2)\n",
+    "- group (row 3)\n",
+    "- time (col 1)\n",
+    "- time series (all the rest of the data from row 4, col 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "08f0717b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "import pandas as pd\n",
+    "\n",
+    "from cosinor_lite.livecell_cosinor_analysis import CosinorAnalysis\n",
+    "from cosinor_lite.livecell_dataset import LiveCellDataset\n",
+    "\n",
+    "file: Path = Path.cwd().parent / \"data\" / \"bioluminescence_example.csv\"\n",
+    "\n",
+    "df_data = pd.read_csv(file, header=None)\n",
+    "\n",
+    "participant_id = df_data.iloc[0, 1:].astype(str)\n",
+    "replicate = df_data.iloc[1, 1:].astype(int)\n",
+    "group = df_data.iloc[2, 1:].astype(str)\n",
+    "time = df_data.iloc[3:, 0].to_numpy(dtype=float)\n",
+    "\n",
+    "time_rows = df_data.iloc[3:, 1:].apply(pd.to_numeric)\n",
+    "time_series = time_rows.to_numpy(dtype=float)\n",
+    "\n",
+    "dataset = LiveCellDataset(\n",
+    "    ids=participant_id.tolist(),\n",
+    "    group=group.tolist(),\n",
+    "    replicate=replicate.tolist(),\n",
+    "    time_series=time_series,\n",
+    "    time=time,\n",
+    "    group1_label=\"Group 1\",\n",
+    "    group2_label=\"Group 2\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e26f44d7",
+   "metadata": {},
+   "source": [
+    "We can now plot the data and perform detrending using either:\n",
+    "- none\n",
+    "- linear\n",
+    "- poly2 (linear + quadratic terms)\n",
+    "- moving_average (need to provide number of window steps)\n",
+    "\n",
+    "As measurements are every 10 mins, we'll use a moving_average window of 240 (24 hour moving average window)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b2e334b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 984.252x590.551 with 13 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, tmp_path = dataset.plot_group_data(\"group1\", method = \"moving_average\", window=240, plot_style = \"line\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f097472b",
+   "metadata": {},
+   "source": [
+    "## Fitting cosinor parameters"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "438423e7",
+   "metadata": {},
+   "source": [
+    "We then create a CosinorAnalysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6b09bd68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cosinor_analysis = CosinorAnalysis(\n",
+    "    ids=participant_id.tolist(),\n",
+    "    group=group.tolist(),\n",
+    "    replicate=replicate.tolist(),\n",
+    "    time_series=time_rows.to_numpy(dtype=float),\n",
+    "    time=time,\n",
+    "    group1_label=\"Group 1\",\n",
+    "    group2_label=\"Group 2\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66a17998",
+   "metadata": {},
+   "source": [
+    "We can then fit our chosen cosinor model from , plot the results and export the parameters as a pandas dataframe df_export, which can then be saved as a .csv file for downstream analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c4330b81",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 984.252x590.551 with 13 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df_export, tmp1_path, fig, tmp2_path = cosinor_analysis.fit_cosinor(\n",
+    "    \"group1\",\n",
+    "    method=\"poly2\",\n",
+    "    cosinor_model = \"cosinor_damped\",\n",
+    "    plot_style=\"line\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df494a87",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cosinor-lite",
+   "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.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/omics_demo.ipynb b/notebooks/omics_tutorial.ipynb
similarity index 99%
rename from notebooks/omics_demo.ipynb
rename to notebooks/omics_tutorial.ipynb
index 5b57a84..1030312 100644
--- a/notebooks/omics_demo.ipynb
+++ b/notebooks/omics_tutorial.ipynb
@@ -67,12 +67,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from cosinor_lite.datasets import OmicsDataset\n",
-    "from cosinor_lite.differential_rhytmicity_omics import DifferentialRhythmicity, OmicsHeatmap, TimeSeriesExample\n",
     "from pathlib import Path\n",
+    "\n",
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
     "import pandas as pd\n",
+    "\n",
+    "from cosinor_lite.datasets import OmicsDataset\n",
+    "from cosinor_lite.differential_rhytmicity_omics import DifferentialRhythmicity, OmicsHeatmap, TimeSeriesExample\n",
+    "\n",
     "plt.rcParams.update(\n",
     "    {\n",
     "        \"font.size\": 8,\n",
diff --git a/notebooks/setup_notebook.py b/notebooks/setup_notebook.py
deleted file mode 100644
index 48d42c3..0000000
--- a/notebooks/setup_notebook.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import matplotlib.pyplot as plt
-
-plt.rcParams.update(
-    {
-        "font.size": 8,
-        "axes.titlesize": 8,
-        "axes.labelsize": 8,
-        "xtick.labelsize": 8,
-        "ytick.labelsize": 8,
-        "legend.fontsize": 8,
-        "figure.titlesize": 8,
-        "pdf.fonttype": 42,
-    },
-)
-plt.style.use("seaborn-v0_8-ticks")
diff --git a/pyproject.toml b/pyproject.toml
index 65d034f..0727e15 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,6 +20,8 @@ dependencies = [
     "pingouin",
     "pydantic>=2.11.9",
     "tqdm>=4.67.1",
+    "openpyxl>=3.1.5",
+    "gradio>=5.50.0",
 ]
 name = "cosinor-lite"
 version = "0.0.0"
@@ -114,8 +116,6 @@ lint.ignore = [
     "FA102",   # Flake8-future-annotations - Missing `from __future__ import annotations`, but uses PEP 604 union
 ]
 
-# Avoid trying to fix flake8-bugbear (`B`) violations.
-#unfixable = ["B"]
 line-length = 119
 
 # Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
@@ -126,8 +126,5 @@ line-length = 119
 [tool.ty.environment]
 root = "./src/cosinor_lite"
 
-# [tool.ty.rules]
-# invalid-type-form = "ignore"
-
-# [tool.uv.sources]
-# cosinor-lite = { workspace = true }
+[tool.interrogate]
+exclude = ["tests", "app.py"]
diff --git a/run.sh b/run.sh
index 6610aea..9d38ce5 100755
--- a/run.sh
+++ b/run.sh
@@ -4,22 +4,19 @@ set -e
 
 THIS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 
-# install core and development Python dependencies into the currently activated venv
+# install core and development Python dependencies using uv
 function install {
-    python -m pip install --upgrade pip
-    python -m pip install --editable "$THIS_DIR/[dev]"
+    uv sync --extra dev
 }
 
 # run linting, formatting, and other static code quality tools
 function lint {
-    pre-commit run --all-files
+    uv run pre-commit run --all-files
 }
 
 # same as `lint` but with any special considerations for CI
 function lint:ci {
-    # We skip no-commit-to-branch since that blocks commits to `main`.
-    # All merged PRs are commits to `main` so this must be disabled.
-    SKIP=no-commit-to-branch pre-commit run --all-files
+    SKIP=no-commit-to-branch uv run pre-commit run --all-files
 }
 
 # execute tests that are not marked as `slow`
@@ -34,10 +31,9 @@ function test:ci {
     COVERAGE_DIR="$INSTALLED_PKG_DIR" run-tests
 }
 
-# (example) ./run.sh test tests/test_states_info.py::test__slow_add
 function run-tests {
     PYTEST_EXIT_STATUS=0
-    python -m pytest ${@:-"$THIS_DIR/tests/"} \
+    uv run python -m pytest ${@:-"$THIS_DIR/tests/"} \
         --cov "${COVERAGE_DIR:-$THIS_DIR/src}" \
         --cov-report html \
         --cov-report term \
@@ -50,56 +46,12 @@ function run-tests {
     return $PYTEST_EXIT_STATUS
 }
 
-function test:wheel-locally {
-    deactivate || true
-    rm -rf test-env || true
-    python -m venv test-env
-    source test-env/bin/activate
-    clean || true
-    pip install build
-    build
-    pip install ./dist/*.whl pytest pytest-cov
-    test:ci
-    deactivate || true
-}
-
-# serve the html test coverage report on localhost:8000
 function serve-coverage-report {
-    python -m http.server --directory "$THIS_DIR/test-reports/htmlcov/" 8000
-}
-
-# build a wheel and sdist from the Python source code
-function build {
-    python -m build --sdist --wheel "$THIS_DIR/"
+    python -m http.server 8000 \
+        --bind 127.0.0.1 \
+        --directory "$THIS_DIR/test-reports/htmlcov/"
 }
 
-function release:test {
-    lint
-    clean
-    build
-    publish:test
-}
-
-function release:prod {
-    release:test
-    publish:prod
-}
-
-function publish:test {
-    try-load-dotenv || true
-    twine upload dist/* \
-        --repository testpypi \
-        --username=__token__ \
-        --password="$TEST_PYPI_TOKEN"
-}
-
-function publish:prod {
-    try-load-dotenv || true
-    twine upload dist/* \
-        --repository pypi \
-        --username=__token__ \
-        --password="$PROD_PYPI_TOKEN"
-}
 
 # remove all files generated by tests, builds, or operating this codebase
 function clean {
@@ -122,17 +74,6 @@ function clean {
       -exec rm {} +
 }
 
-# export the contents of .env as environment variables
-function try-load-dotenv {
-    if [ ! -f "$THIS_DIR/.env" ]; then
-        echo "no .env file found"
-        return 1
-    fi
-
-    while read -r line; do
-        export "$line"
-    done < <(grep -v '^#' "$THIS_DIR/.env" | grep -v '^$')
-}
 
 # print all functions in this file
 function help {
diff --git a/src/cosinor_lite/base_models.py b/src/cosinor_lite/base_models.py
deleted file mode 100644
index a2e56df..0000000
--- a/src/cosinor_lite/base_models.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-
-import pandas as pd
-import statsmodels.formula.api as smf
-from pydantic.dataclasses import dataclass
-
-
-@dataclass
-class ModelResult:
-    name: int
-    llf: float
-    bic: float
-    alpha_phase: float
-    alpha_amp: float
-    beta_phase: float
-    beta_amp: float
-
-
-@dataclass
-class ModelResultOneCondition:
-    name: int
-    llf: float
-    bic: float
-    phase: float
-    amp: float
-
-
-class BaseModel(ABC):
-    name: str
-    k: int
-    formula: str
-
-    def fit(self, df: pd.DataFrame) -> ModelResult:
-        # df must already contain: y, constant, cos_wt, sin_wt, is_alpha, is_beta
-        model = smf.ols(self.formula, data=df).fit()
-        n = len(df)
-        alpha_phase, alpha_amp, beta_phase, beta_amp = self.extract(model.params)
-        return ModelResult(
-            name=self.name,
-            llf=model.llf,
-            bic=bic(model.llf, self.k, n),
-            alpha_phase=alpha_phase,
-            alpha_amp=alpha_amp,
-            beta_phase=beta_phase,
-            beta_amp=beta_amp,
-        )
-
-    @abstractmethod
-    def extract(self, params: pd.Series) -> tuple[float, float, float, float]: ...
-
-
-class BaseModelOneCondition(ABC):
-    name: str
-    k: int
-    formula: str
-
-    def fit(self, df: pd.DataFrame) -> ModelResultOneCondition:
-        # df must already contain: y, constant, cos_wt, sin_wt, is_alpha, is_beta
-        model = smf.ols(self.formula, data=df).fit()
-        n = len(df)
-        phase, amp = self.extract(model.params)
-        return ModelResultOneCondition(
-            name=self.name,
-            llf=model.llf,
-            bic=bic(model.llf, self.k, n),
-            phase=phase,
-            amp=amp,
-        )
-
-    @abstractmethod
-    def extract(self, params: pd.Series) -> tuple[float, float]: ...
diff --git a/src/cosinor_lite/cities.json b/src/cosinor_lite/cities.json
deleted file mode 100644
index c37c112..0000000
--- a/src/cosinor_lite/cities.json
+++ /dev/null
@@ -1,233 +0,0 @@
-[
-    {
-        "city": "Montgomery",
-        "state": "Alabama",
-        "lat": 32.3792233,
-        "lng": -86.3077368,
-        "capital": true
-    },
-    {
-        "city": "Juneau",
-        "state": "Alaska",
-        "lat": 58.3019444,
-        "lng": -134.4197222,
-        "capital": true
-    },
-    {
-        "city": "Phoenix",
-        "state": "Arizona",
-        "lat": 33.4483771,
-        "lng": -112.0740373,
-        "capital": true
-    },
-    {
-        "city": "Little Rock",
-        "state": "Arkansas",
-        "lat": 34.7464809,
-        "lng": -92.2895948,
-        "capital": true
-    },
-    {
-        "city": "Sacramento",
-        "state": "California",
-        "lat": 38.5757647,
-        "lng": -121.4788515,
-        "capital": true
-    },
-    {
-        "city": "Denver",
-        "state": "Colorado",
-        "lat": 39.7392364,
-        "lng": -104.9848623,
-        "capital": true
-    },
-    {
-        "city": "Hartford",
-        "state": "Connecticut",
-        "lat": 41.7658043,
-        "lng": -72.6733723,
-        "capital": true
-    },
-    {
-        "city": "Dover",
-        "state": "Delaware",
-        "lat": 39.158168,
-        "lng": -75.5243682,
-        "capital": true
-    },
-    {
-        "city": "Tallahassee",
-        "state": "Florida",
-        "lat": 30.4382559,
-        "lng": -84.2807329,
-        "capital": true
-    },
-    {
-        "city": "Atlanta",
-        "state": "Georgia",
-        "lat": 33.7489954,
-        "lng": -84.3879824,
-        "capital": true
-    },
-    {
-        "city": "Honolulu",
-        "state": "Hawaii",
-        "lat": 21.3069444,
-        "lng": -157.8583333,
-        "capital": true
-    },
-    {
-        "city": "Boise",
-        "state": "Idaho",
-        "lat": 43.6150186,
-        "lng": -116.2023137,
-        "capital": true
-    },
-    {
-        "city": "Springfield",
-        "state": "Illinois",
-        "lat": 39.7983633,
-        "lng": -89.6549613,
-        "capital": true
-    },
-    {
-        "city": "Indianapolis",
-        "state": "Indiana",
-        "lat": 39.7683331,
-        "lng": -86.1583502,
-        "capital": true
-    },
-    {
-        "city": "Des Moines",
-        "state": "Iowa",
-        "lat": 41.6005448,
-        "lng": -93.6091064,
-        "capital": true
-    },
-    {
-        "city": "Topeka",
-        "state": "Kansas",
-        "lat": 39.0558243,
-        "lng": -95.6890185,
-        "capital": true
-    },
-    {
-        "city": "Frankfort",
-        "state": "Kentucky",
-        "lat": 38.2009055,
-        "lng": -84.8732835,
-        "capital": true
-    },
-    {
-        "city": "Baton Rouge",
-        "state": "Louisiana",
-        "lat": 30.4582829,
-        "lng": -91.1403196,
-        "capital": true
-    },
-    {
-        "city": "Augusta",
-        "state": "Maine",
-        "lat": 44.3106241,
-        "lng": -69.7794897,
-        "capital": true
-    },
-    {
-        "city": "Annapolis",
-        "state": "Maryland",
-        "lat": 38.9784453,
-        "lng": -76.4921829,
-        "capital": true
-    },
-    {
-        "city": "Boston",
-        "state": "Massachusetts",
-        "lat": 42.3600825,
-        "lng": -71.0588801,
-        "capital": true
-    },
-    {
-        "city": "Lansing",
-        "state": "Michigan",
-        "lat": 42.732535,
-        "lng": -84.5555347,
-        "capital": true
-    },
-    {
-        "city": "Oklahoma City",
-        "state": "Oklahoma",
-        "lat": 42.732535,
-        "lng": -84.5555347,
-        "capital": true
-    },
-    {
-        "city": "Salem",
-        "state": "Oregon",
-        "lat": 42.732535,
-        "lng": -84.5555347,
-        "capital": true
-    },
-    {
-        "city": "St. Paul",
-        "state": "Minnesota",
-        "lat": 44.9537029,
-        "lng": -93.0899578,
-        "capital": true
-    },
-    {
-        "city": "Jackson",
-        "state": "Mississippi",
-        "lat": 32.2987573,
-        "lng": -90.1848103,
-        "capital": true
-    },
-    {
-        "city": "Jefferson City",
-        "state": "Missouri",
-        "lat": 38.5767017,
-        "lng": -92.1735164,
-        "capital": true
-    },
-    {
-        "city": "Helena",
-        "state": "Montana",
-        "lat": 46.5958056,
-        "lng": -112.0270318,
-        "capital": true
-    },
-    {
-        "city": "Lincoln",
-        "state": "Nebraska",
-        "lat": 40.813616,
-        "lng": -96.7025955,
-        "capital": true
-    },
-    {
-        "city": "Carson City",
-        "state": "Nevada",
-        "lat": 39.1637984,
-        "lng": -119.7674034,
-        "capital": true
-    },
-    {
-        "city": "Concord",
-        "state": "New Hampshire",
-        "lat": 43.2081366,
-        "lng": -71.5375718,
-        "capital": true
-    },
-    {
-        "city": "Trenton",
-        "state": "New Jersey",
-        "lat": 40.2205824,
-        "lng": -74.759717,
-        "capital": true
-    },
-    {
-        "city": "Santa Fe",
-        "state": "New Mexico",
-        "lat": 35.6869752,
-        "lng": -105.937799,
-        "capital": true
-    }
-]
diff --git a/src/cosinor_lite/live_cell_dataset.py b/src/cosinor_lite/live_cell_dataset.py
deleted file mode 100644
index e69de29..0000000
diff --git a/src/cosinor_lite/livecell_cosinor_analysis.py b/src/cosinor_lite/livecell_cosinor_analysis.py
new file mode 100644
index 0000000..c80b55b
--- /dev/null
+++ b/src/cosinor_lite/livecell_cosinor_analysis.py
@@ -0,0 +1,727 @@
+from __future__ import annotations
+
+import os
+import tempfile
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from numpy.typing import NDArray
+from scipy.optimize import curve_fit
+from scipy.stats import f as f_dist
+
+from cosinor_lite.livecell_dataset import LiveCellDataset
+
+plt.rcParams.update(
+    {
+        "font.size": 8,
+        "axes.titlesize": 8,
+        "axes.labelsize": 8,
+        "xtick.labelsize": 8,
+        "ytick.labelsize": 8,
+        "legend.fontsize": 8,
+        "figure.titlesize": 8,
+        "pdf.fonttype": 42,
+    },
+)
+plt.style.use("seaborn-v0_8-ticks")
+
+
+def constant_model(x: NDArray[np.float64], mesor: float) -> NDArray[np.float64]:
+    """
+    Evaluate a constant model at the supplied mesor.
+
+    Parameters
+    ----------
+    x : NDArray[np.float64]
+        Time values at which the constant model is evaluated.
+    mesor : float
+        The mesor (mean level) used as the constant prediction.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        The mesor value supplied by the caller broadcast over ``x``.
+
+    """
+    return np.full_like(x, mesor)
+
+
+def cosine_model_24(x: NDArray[np.float64], amplitude: float, acrophase: float, mesor: float) -> NDArray[np.float64]:
+    """
+    Evaluate a 24 h cosine model for the provided time points.
+
+    Parameters
+    ----------
+    x : NDArray[np.float64]
+        Time values at which to evaluate the curve.
+    amplitude : float
+        Cosine amplitude.
+    acrophase : float
+        Phase shift (in hours) applied to the cosine.
+    mesor : float
+        Baseline offset of the curve.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        The cosine values with a fixed 24 h period.
+
+    """
+    period = 24.0
+    return amplitude * np.cos(2 * np.pi * (x - acrophase) / period) + mesor
+
+
+def cosine_model_free_period(
+    x: NDArray[np.float64],
+    amplitude: float,
+    acrophase: float,
+    period: float,
+    mesor: float,
+) -> NDArray[np.float64]:
+    """
+    Evaluate a cosine model allowing the period to vary.
+
+    Parameters
+    ----------
+    x : NDArray[np.float64]
+        Time values at which to evaluate the cosine.
+    amplitude : float
+        Cosine amplitude.
+    acrophase : float
+        Phase shift (in hours) applied to the cosine.
+    period : float
+        Oscillation period in hours.
+    mesor : float
+        Baseline offset for the model.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        The cosine values with the requested period.
+
+    """
+    return amplitude * np.cos(2 * np.pi * (x - acrophase) / period) + mesor
+
+
+def cosine_model_damped(  # noqa: PLR0913
+    x: NDArray[np.float64],
+    amplitude: float,
+    damp: float,
+    acrophase: float,
+    period: float,
+    mesor: float,
+) -> NDArray[np.float64]:
+    """
+    Evaluate a damped cosine model that decays exponentially over time.
+
+    Parameters
+    ----------
+    x : NDArray[np.float64]
+        Time values at which to evaluate the cosine.
+    amplitude : float
+        Initial amplitude of the oscillation.
+    damp : float
+        Exponential damping coefficient (positive values decay).
+    acrophase : float
+        Phase shift (in hours) applied to the cosine.
+    period : float
+        Oscillation period in hours.
+    mesor : float
+        Baseline offset for the model.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        The damped cosine evaluated at ``x``.
+
+    """
+    return amplitude * np.exp(-damp * x) * np.cos(2 * np.pi * (x - acrophase) / period) + mesor
+
+
+def _metrics(y_true: NDArray[np.float64], y_pred: NDArray[np.float64], p: int) -> tuple[float, float, float]:
+    """
+    Compute residual sum of squares and R-squared metrics.
+
+    Parameters
+    ----------
+    y_true : NDArray[np.float64]
+        Observed values.
+    y_pred : NDArray[np.float64]
+        Predicted values from a model.
+    p : int
+        Number of model parameters used in the fit.
+
+    Returns
+    -------
+    tuple[float, float, float]
+        Residual sum of squares, R-squared, and adjusted R-squared.
+
+    """
+    y_true = np.asarray(y_true, float)
+    y_pred = np.asarray(y_pred, float)
+    n: int = y_true.size
+    rss: float = np.sum((y_true - y_pred) ** 2)
+    sst: float = np.sum((y_true - np.mean(y_true)) ** 2)
+    r2 = np.nan
+    r2_adj = np.nan
+    if sst > 0:
+        r2 = 1.0 - (rss / sst)
+        if n > p and n > 1:
+            r2_adj = 1.0 - (rss / (n - p)) / (sst / (n - 1))
+    return rss, r2, r2_adj
+
+
+def _sanitize_xy(
+    x: NDArray[np.float64],
+    y: NDArray[np.float64],
+    min_points: int = 4,
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """
+    Remove non-finite values, sort by time, and validate point count.
+
+    Parameters
+    ----------
+    x : NDArray[np.float64]
+        Candidate time points.
+    y : NDArray[np.float64]
+        Candidate measurements aligned with ``x``.
+    min_points : int, optional
+        Minimum required number of finite points after cleaning, by default 4.
+
+    Returns
+    -------
+    tuple[NDArray[np.float64], NDArray[np.float64]]
+        Cleaned and sorted ``x`` and ``y`` arrays.
+
+    Raises
+    ------
+    ValueError
+        If fewer than ``min_points`` observations remain after cleaning.
+
+    """
+    x = np.asarray(x, float)
+    y = np.asarray(y, float)
+    ok = np.isfinite(x) & np.isfinite(y)
+    x, y = x[ok], y[ok]
+    order: NDArray[np.float64] = np.argsort(x)
+    x, y = x[order], y[order]
+    if y.size < min_points:
+        msg = f"Not enough valid points after cleaning (need ≥{min_points}, got {y.size})."
+        raise ValueError(
+            msg,
+        )
+    return x, y
+
+
+class CosinorAnalysis(LiveCellDataset):
+    """
+    Extend ``LiveCellDataset`` with cosinor model fitting utilities.
+
+    Parameters
+    ----------
+    *args
+        Positional arguments forwarded to ``LiveCellDataset``.
+    period : float, optional
+        Default oscillation period for fits, by default 24.0.
+    method : str, optional
+        Default detrending method, by default ``"ols"``.
+    t_lower : float, optional
+        Lower bound on time window (hours) used when fitting, by default 0.0.
+    t_upper : float, optional
+        Upper bound on time window (hours) used when fitting, by default 720.0.
+    **kwargs
+        Keyword arguments forwarded to ``LiveCellDataset``.
+
+    """
+
+    def __init__(
+        self,
+        *args,  # noqa: ANN002
+        period: float = 24.0,
+        method: str = "ols",
+        t_lower: float = 0.0,
+        t_upper: float = 720.0,
+        **kwargs,  # noqa: ANN003
+    ) -> None:
+        """
+        Initialize the cosinor analysis object with dataset metadata.
+
+        Parameters
+        ----------
+        *args
+            Positional arguments passed to ``LiveCellDataset``.
+        period : float, optional
+            Default oscillation period (hours), by default 24.0.
+        method : str, optional
+            Default detrending method, by default ``"ols"``.
+        t_lower : float, optional
+            Lower time bound (hours), by default 0.0.
+        t_upper : float, optional
+            Upper time bound (hours), by default 720.0.
+        **kwargs
+            Keyword arguments forwarded to ``LiveCellDataset``.
+
+        """
+        super().__init__(*args, **kwargs)
+
+        self.t_lower = t_lower
+        self.t_upper = t_upper
+        self.period = period
+        self.method = method
+
+    def fit_cosinor_24(
+        self,
+        x: NDArray[np.float64],
+        y: NDArray[np.float64],
+    ) -> tuple[dict, NDArray[np.float64], NDArray[np.float64]]:
+        """
+        Fit a fixed 24 h cosinor model to the supplied data.
+
+        Parameters
+        ----------
+        x : NDArray[np.float64]
+            Time values (hours).
+        y : NDArray[np.float64]
+            Measurements aligned with ``x``.
+
+        Returns
+        -------
+        tuple[dict, NDArray[np.float64], NDArray[np.float64]]
+            Fit summary metrics, high-resolution prediction times, and predictions.
+
+        """
+        x, y = _sanitize_xy(x, y)
+
+        p0_const: list[float] = [float(np.mean(y))]
+        params_const, _ = curve_fit(constant_model, x, y, p0=p0_const)
+        yhat_const: float = constant_model(x, *params_const)
+
+        p0_cos: list[float] = [
+            float(np.std(y)),
+            0.0,
+            float(np.mean(y)),
+        ]
+        params_cos, _ = curve_fit(cosine_model_24, x, y, p0=p0_cos)
+        amp_fit, acro_fit, mesor_fit = params_cos
+        yhat_cos: NDArray[np.float64] = cosine_model_24(x, amp_fit, acro_fit, mesor_fit)
+
+        rss_cos, r2, r2_adj = _metrics(y, yhat_cos, p=3)
+        rss_const, _, _ = _metrics(y, np.full_like(x, yhat_const), p=1)
+
+        n = len(y)
+        p1, p2 = 1, 3
+        num = max(rss_const - rss_cos, 0.0)
+        den = max(rss_cos, 1e-12)
+        f_stat = (num / (p2 - p1)) / (den / max(n - p2, 1))
+        p_val = np.nan
+        if n > p2:
+            p_val = f_dist.sf(f_stat, p2 - p1, n - p2)
+
+        t_test_acro = np.linspace(0.0, 24.0, 1440)
+        y_test_acro = cosine_model_24(t_test_acro, amp_fit, acro_fit, mesor_fit)
+        amplitude = abs(amp_fit)
+        acrophase = t_test_acro[int(np.argmax(y_test_acro))]
+        mesor = mesor_fit
+
+        t_test: NDArray[np.float64] = np.linspace(float(x[0]), float(x[-1]), 1440)
+        y_test = cosine_model_24(t_test, amp_fit, acro_fit, mesor_fit)
+
+        results = {
+            "mesor": mesor,
+            "amplitude": amplitude,
+            "acrophase": acrophase,
+            "p-val osc": p_val,
+            "r2": r2,
+            "r2_adj": r2_adj,
+        }
+        return results, t_test, y_test
+
+    def fit_cosinor_free_period(
+        self,
+        x: NDArray[np.float64],
+        y: NDArray[np.float64],
+    ) -> tuple[dict, NDArray[np.float64], NDArray[np.float64]]:
+        """
+        Fit a cosinor model with a free (bounded) period parameter.
+
+        Parameters
+        ----------
+        x : NDArray[np.float64]
+            Time values (hours).
+        y : NDArray[np.float64]
+            Measurements aligned with ``x``.
+
+        Returns
+        -------
+        tuple[dict, NDArray[np.float64], NDArray[np.float64]]
+            Fit summary metrics, high-resolution prediction times, and predictions.
+
+        """
+        x, y = _sanitize_xy(x, y)
+
+        p0_const = [float(np.mean(y))]
+        params_const, _ = curve_fit(constant_model, x, y, p0=p0_const)
+        yhat_const = constant_model(x, *params_const)
+
+        p0_24 = [float(np.std(y)), 0.0, float(np.mean(y))]
+        params_24, _ = curve_fit(cosine_model_24, x, y, p0=p0_24)
+        amp0, acro0, mesor0 = params_24
+        p0_free = [amp0, acro0, 24.0, mesor0]  # [A, phase, period, mesor]
+
+        bounds = ([-np.inf, -np.inf, 20.0, -np.inf], [np.inf, np.inf, 28.0, np.inf])
+        params_free, _ = curve_fit(
+            cosine_model_free_period,
+            x,
+            y,
+            p0=p0_free,
+            bounds=bounds,
+        )
+        amp_fit, acro_fit, period_fit, mesor_fit = params_free
+        yhat_free = cosine_model_free_period(
+            x,
+            amp_fit,
+            acro_fit,
+            period_fit,
+            mesor_fit,
+        )
+
+        rss_free, r2, r2_adj = _metrics(y, yhat_free, p=4)
+        rss_const, _, _ = _metrics(y, yhat_const, p=1)
+
+        n = len(y)
+        p1, p2 = 1, 4
+        num = max(rss_const - rss_free, 0.0)
+        den = max(rss_free, 1e-12)
+        f_stat = (num / (p2 - p1)) / (den / max(n - p2, 1))
+        p_val = np.nan
+        if n > p2:
+            p_val = f_dist.sf(f_stat, p2 - p1, n - p2)
+
+        t_test_acro = np.linspace(0.0, float(period_fit), 2000)
+        y_test_acro = cosine_model_free_period(
+            t_test_acro,
+            amp_fit,
+            acro_fit,
+            period_fit,
+            mesor_fit,
+        )
+        amplitude = abs(amp_fit)
+        acrophase = t_test_acro[int(np.argmax(y_test_acro))]
+        mesor = mesor_fit
+        period = float(period_fit)
+
+        t_test = np.linspace(float(x[0]), float(x[-1]), 1440)
+        y_test = cosine_model_free_period(
+            t_test,
+            amp_fit,
+            acro_fit,
+            period_fit,
+            mesor_fit,
+        )
+
+        results = {
+            "mesor": mesor,
+            "amplitude": amplitude,
+            "acrophase": acrophase,
+            "period": period,
+            "p-val osc": p_val,
+            "r2": r2,
+            "r2_adj": r2_adj,
+        }
+        return results, t_test, y_test
+
+    def fit_cosinor_damped(
+        self,
+        x: NDArray[np.float64],
+        y: NDArray[np.float64],
+    ) -> tuple[dict, NDArray[np.float64], NDArray[np.float64]]:
+        """
+        Fit a damped cosinor model with exponential decay.
+
+        Parameters
+        ----------
+        x : NDArray[np.float64]
+            Time values (hours).
+        y : NDArray[np.float64]
+            Measurements aligned with ``x``.
+
+        Returns
+        -------
+        tuple[dict, NDArray[np.float64], NDArray[np.float64]]
+            Fit summary metrics, high-resolution prediction times, and predictions.
+
+        """
+        x, y = _sanitize_xy(x, y)
+
+        p0_const = [float(np.mean(y))]
+        params_const, _ = curve_fit(constant_model, x, y, p0=p0_const)
+        yhat_const = constant_model(x, *params_const)
+
+        p0_24 = [float(np.std(y)), 0.0, float(np.mean(y))]
+        params_24, _ = curve_fit(cosine_model_24, x, y, p0=p0_24)
+        amp0, acro0, mesor0 = params_24
+
+        p0_damped = [amp0, 0.01, acro0, 24.0, mesor0]
+        bounds = (
+            [-np.inf, 0.0, -np.inf, 20.0, -np.inf],
+            [np.inf, np.inf, np.inf, 28.0, np.inf],
+        )
+        params_damped, _ = curve_fit(
+            cosine_model_damped,
+            x,
+            y,
+            p0=p0_damped,
+            bounds=bounds,
+        )
+        amp_fit, damp_fit, acro_fit, period_fit, mesor_fit = params_damped
+        yhat_damped = cosine_model_damped(
+            x,
+            amp_fit,
+            damp_fit,
+            acro_fit,
+            period_fit,
+            mesor_fit,
+        )
+
+        rss_damped, r2, r2_adj = _metrics(y, yhat_damped, p=5)
+        rss_const, _, _ = _metrics(y, yhat_const, p=1)
+
+        n = len(y)
+        p1, p2 = 1, 5
+        num = max(rss_const - rss_damped, 0.0)
+        den = max(rss_damped, 1e-12)
+        f_stat = (num / (p2 - p1)) / (den / max(n - p2, 1))
+        p_val = np.nan
+        if n > p2:
+            p_val = f_dist.sf(f_stat, p2 - p1, n - p2)
+
+        t_test_acro = np.linspace(0.0, float(period_fit), 1440)
+        y_test_acro = cosine_model_damped(
+            t_test_acro,
+            amp_fit,
+            damp_fit,
+            acro_fit,
+            period_fit,
+            mesor_fit,
+        )
+        amplitude = abs(amp_fit)
+        acrophase = t_test_acro[int(np.argmax(y_test_acro))]
+        mesor = mesor_fit
+        period = float(period_fit)
+        damp = float(damp_fit)
+
+        t_test = np.linspace(float(x[0]), float(x[-1]), 1440)
+        y_test = cosine_model_damped(
+            t_test,
+            amp_fit,
+            damp_fit,
+            acro_fit,
+            period_fit,
+            mesor_fit,
+        )
+
+        results = {
+            "mesor": mesor,
+            "amplitude": amplitude,
+            "acrophase": acrophase,
+            "period": period,
+            "damp": damp,
+            "p-val osc": p_val,
+            "r2": r2,
+            "r2_adj": r2_adj,
+        }
+        return results, t_test, y_test
+
+    def get_cosinor_fits(
+        self,
+        x: NDArray[np.float64],
+        y: NDArray[np.float64],
+        method: str = "cosinor_24",
+    ) -> tuple[dict, NDArray[np.float64], NDArray[np.float64]]:
+        """
+        Dispatch to the requested cosinor model and return its fit.
+
+        Parameters
+        ----------
+        x : NDArray[np.float64]
+            Time values (hours).
+        y : NDArray[np.float64]
+            Measurements aligned with ``x``.
+        method : str, optional
+            Cosinor model name (``"cosinor_24"``, ``"cosinor_free_period"``, ``"cosinor_damped"``).
+
+        Returns
+        -------
+        tuple[dict, NDArray[np.float64], NDArray[np.float64]]
+            Fit summary metrics, prediction times, and predictions.
+
+        Raises
+        ------
+        ValueError
+            If an unknown model name is supplied.
+
+        """
+        if method == "cosinor_24":
+            results, t_test, model_predictions_cosine = self.fit_cosinor_24(x, y)
+        elif method == "cosinor_free_period":
+            results, t_test, model_predictions_cosine = self.fit_cosinor_free_period(
+                x,
+                y,
+            )
+        elif method == "cosinor_damped":
+            results, t_test, model_predictions_cosine = self.fit_cosinor_damped(x, y)
+        else:
+            msg = f"Unknown cosine model: {method}"
+            raise ValueError(msg)
+
+        return results, t_test, model_predictions_cosine
+
+    def group_selector(
+        self,
+        group: str,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray, str, int, str]:
+        """
+        Retrieve group-specific data and plotting metadata.
+
+        Parameters
+        ----------
+        group : str
+            Group name (``"group1"`` or ``"group2"``).
+
+        Returns
+        -------
+        tuple[np.ndarray, np.ndarray, np.ndarray, str, int, str]
+            Tuple containing IDs, replicates, data matrix, color, number of unique IDs,
+            and group label.
+
+        Raises
+        ------
+        ValueError
+            If ``group`` is not ``"group1"`` or ``"group2"``.
+
+        """
+        if group == "group1":
+            ids, replicates, data = self.get_group1_ids_replicates_data()
+            color = self.color_group1
+            group_label = self.group1_label
+        elif group == "group2":
+            ids, replicates, data = self.get_group2_ids_replicates_data()
+            color = self.color_group2
+            group_label = self.group2_label
+        else:
+            msg = "group must be 'group1' or 'group2'"
+            raise ValueError(msg)
+
+        ids = np.asarray(ids)
+        replicates = np.asarray(replicates)
+        data = np.asarray(data)
+
+        n_group = len(np.unique(ids))
+        return ids, replicates, data, color, n_group, group_label
+
+    def fit_cosinor(  # noqa: PLR0913
+        self,
+        group: str,
+        method: str = "linear",
+        window: int = 5,
+        cosinor_model: str = "cosinor_24",
+        m: int = 5,
+        plot_style: str = "scatter",
+    ) -> tuple[pd.DataFrame, str, plt.Figure, str]:
+        """
+        Detrend each replicate in a group and fit the selected cosinor model.
+
+        Parameters
+        ----------
+        group : str
+            Group name (``"group1"`` or ``"group2"``).
+        method : str, optional
+            Detrending method provided to ``get_trend``, by default ``"linear"``.
+        window : int, optional
+            Window size for moving-average detrending, by default 5.
+        cosinor_model : str, optional
+            Name of cosinor model to fit, by default ``"cosinor_24"``.
+        m : int, optional
+            Number of subplot columns, by default 5.
+        plot_style : str, optional
+            Plot style for data (``"scatter"`` or ``"line"``), by default ``"scatter"``.
+
+        Returns
+        -------
+        tuple[pd.DataFrame, str, plt.Figure, str]
+            DataFrame of fit metrics, CSV path, generated figure, and PDF path.
+
+        Raises
+        ------
+        ValueError
+            If ``group`` is not ``"group1"`` or ``"group2"``.
+
+        """
+        ids, _replicates, data, color, n_group, group_label = self.group_selector(group)
+        n = np.ceil(n_group / m).astype(int)
+
+        study_list = np.unique(ids).tolist()
+
+        fig = plt.figure(figsize=(5 * m / 2.54, 5 * n / 2.54))
+
+        to_export_list = []
+
+        for i, id_curr in enumerate(study_list):
+            mask = np.array(ids) == id_curr
+            n_reps = np.sum(mask)
+
+            ax = fig.add_subplot(n, m, i + 1)
+
+            for j in range(n_reps):
+                exp_info = {"id": id_curr, "replicate": j + 1, "group": group_label}
+
+                x = self.time
+                y = data[:, mask][:, j]
+
+                valid_mask = ~np.isnan(y)
+                x_valid = x[valid_mask]
+                y_valid = y[valid_mask]
+
+                range_mask = (x_valid >= self.t_lower) & (x_valid <= self.t_upper)
+                x_fit = x_valid[range_mask]
+                y_fit = y_valid[range_mask]
+
+                x_processed, y_processed = self.get_trend(
+                    x_fit,
+                    y_fit,
+                    method=method,
+                    window=window,
+                )
+                y_detrended = y_fit - y_processed + np.mean(y_fit)
+
+                if plot_style == "scatter":
+                    ax.scatter(x_processed, y_detrended, s=4, alpha=0.8, color=color)
+                else:
+                    ax.plot(x_processed, y_detrended, color=color)
+
+                results, t_test, model_predictions_cosine = self.get_cosinor_fits(
+                    x_processed,
+                    y_detrended,
+                    method=cosinor_model,
+                )
+                to_export_list.append({**exp_info, **results})
+                ax.plot(t_test, model_predictions_cosine, color="k", linestyle="--")
+
+            ax.set_title(f"ID: {id_curr} (n={n_reps}) - {group_label}")
+            ax.set_xlabel("Time (h)")
+            if i % m == 0:
+                ax.set_ylabel("Expression")
+
+        plt.tight_layout()
+
+        df_export = pd.DataFrame(to_export_list)
+        fd, tmp1_path = tempfile.mkstemp(suffix=".csv")
+        os.close(fd)
+        df_export.to_csv(tmp1_path, index=False)
+
+        fd, tmp2_path = tempfile.mkstemp(suffix=".pdf")
+        os.close(fd)
+        fig.savefig(tmp2_path)
+
+        return df_export, tmp1_path, fig, tmp2_path
diff --git a/src/cosinor_lite/livecell_dataset.py b/src/cosinor_lite/livecell_dataset.py
new file mode 100644
index 0000000..2f45d8b
--- /dev/null
+++ b/src/cosinor_lite/livecell_dataset.py
@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+import os
+import tempfile
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+from pydantic import ConfigDict, field_validator, model_validator
+from pydantic.dataclasses import dataclass
+
+plt.rcParams.update(
+    {
+        "font.size": 8,
+        "axes.titlesize": 8,
+        "axes.labelsize": 8,
+        "xtick.labelsize": 8,
+        "ytick.labelsize": 8,
+        "legend.fontsize": 8,
+        "figure.titlesize": 8,
+        "pdf.fonttype": 42,
+    },
+)
+plt.style.use("seaborn-v0_8-ticks")
+
+
+@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
+class LiveCellDataset:
+    """
+    Handles live cell dataset operations: validation, trend analysis, and plotting.
+
+    Attributes:
+        ids (list[str]): Unique identifiers for each sample.
+        group (list[str]): Group labels for each sample.
+        replicate (list[int]): Replicate numbers for each sample.
+        time_series (np.ndarray): 2D array of time series data (shape: [timepoints, samples]).
+        time (np.ndarray): 1D array of timepoints.
+        group1_label (str): Label for group 1 (default: "group1").
+        group2_label (str): Label for group 2 (default: "group2").
+        color_group1 (str): Color for plotting group 1 (default: "tab:blue").
+        color_group2 (str): Color for plotting group 2 (default: "tab:orange").
+
+    Methods:
+        _to_2d_f64(v): Converts input to a 2D numpy array of float64 type.
+        _check_columns(): Validates that ids, group, and replicate lengths match time_series columns.
+        get_group1_ids_replicates_data(): Returns ids, replicates, and data for group 1.
+        get_group2_ids_replicates_data(): Returns ids, replicates, and data for group 2.
+        linear_trend(x, y): Fits a linear trend to the data.
+        poly2_trend(x, y): Fits a second-order polynomial trend to the data.
+        moving_average_trend(x, y, window): Computes a moving average trend.
+        get_trend(x, y, method, window): Applies the specified detrending method.
+        plot_group_data(group, method, window, m, plot_style): Plots time series data for the specified group.
+
+    """
+
+    ids: list[str]
+    group: list[str]
+    replicate: list[int]
+    time_series: np.ndarray
+    time: np.ndarray
+
+    group1_label: str = "group1"
+    group2_label: str = "group2"
+
+    color_group1: str = "tab:blue"
+    color_group2: str = "tab:orange"
+
+    @field_validator("time_series", mode="before")
+    @classmethod
+    def _to_2d_f64(cls, v: object) -> np.ndarray:
+        """
+        Converts the input object to a 2D NumPy array of type float64.
+
+        Parameters
+        ----------
+        v : object
+            The input object to be converted. Should be convertible to a NumPy array.
+
+        Returns
+        -------
+        np.ndarray
+            A 2D NumPy array of dtype float64.
+
+        Raises
+        ------
+        ValueError
+            If the input cannot be converted to a 2D array.
+
+        """
+        a = np.asarray(v, dtype=np.float64)
+        two_d_array_dims = 2
+        if a.ndim != two_d_array_dims:
+            msg = "expected 2D array"
+            raise ValueError(msg)
+        return a
+
+    @model_validator(mode="after")
+    def _check_columns(self) -> LiveCellDataset:
+        """
+        Validates that the lengths of `ids`, `group`, and `replicate` match the number of columns in `time_series`.
+
+        Parameters
+        ----------
+        self : LiveCellDataset
+            The instance of the LiveCellDataset being validated.
+
+        Returns
+        -------
+        LiveCellDataset
+            The validated instance.
+
+        Raises
+        ------
+        ValueError
+            If the length of `ids`, `group`, or `replicate` does not match the number of columns in `time_series`.
+
+        """
+        if len(self.ids) != self.time_series.shape[1]:
+            msg = "Length of ids must match number of columns in time_series"
+            raise ValueError(
+                msg,
+            )
+        if len(self.group) != self.time_series.shape[1]:
+            msg = "Length of group must match number of columns in time_series"
+            raise ValueError(
+                msg,
+            )
+        if len(self.replicate) != self.time_series.shape[1]:
+            msg = "Length of replicate must match number of columns in time_series"
+            raise ValueError(
+                msg,
+            )
+        return self
+
+    def get_group1_ids_replicates_data(self) -> tuple[list[str], list[int], np.ndarray]:
+        """
+        Retrieves the IDs, replicate numbers, and time series data for samples belonging to group1.
+
+        Returns:
+            tuple[list[str], list[int], np.ndarray]:
+                - ids: List of sample IDs in group1.
+                - replicates: List of replicate numbers corresponding to group1 samples.
+                - data: 2D NumPy array of time series data for group1 samples (columns correspond to samples).
+
+        """
+        mask = np.array(self.group) == self.group1_label
+        ids = list(np.array(self.ids)[mask])
+        replicates = list(np.array(self.replicate)[mask])
+        data = self.time_series[:, mask]
+        return ids, replicates, data
+
+    def get_group2_ids_replicates_data(self) -> tuple[list[str], list[int], np.ndarray]:
+        """
+        Retrieves the IDs, replicate numbers, and time series data for samples belonging to group2.
+
+        Returns:
+            tuple[list[str], list[int], np.ndarray]:
+                - ids: List of sample IDs in group2.
+                - replicates: List of replicate numbers corresponding to group2 samples.
+                - data: 2D NumPy array of time series data for group2 samples (columns correspond to samples).
+
+        """
+        mask = np.array(self.group) == self.group2_label
+        ids = list(np.array(self.ids)[mask])
+        replicates = list(np.array(self.replicate)[mask])
+        data = self.time_series[:, mask]
+        return ids, replicates, data
+
+    def linear_trend(self, x: np.ndarray, y: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Fits a linear regression model to the provided data and returns the input x values along with the predicted linear trend.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            The independent variable values.
+        y : np.ndarray
+            The dependent variable values.
+
+        Returns
+        -------
+        tuple[np.ndarray, np.ndarray]
+            A tuple containing the original x values and the predicted linear fit values.
+
+        """
+        model = sm.OLS(y, sm.add_constant(x)).fit()
+        linear_fit = model.predict(sm.add_constant(x))
+        return x, linear_fit
+
+    def poly2_trend(self, x: np.ndarray, y: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Fits a second-degree polynomial (quadratic) trend to the given data.
+
+        Args:
+            x (np.ndarray): 1D array of independent variable values.
+            y (np.ndarray): 1D array of dependent variable values.
+
+        Returns:
+            tuple[np.ndarray, np.ndarray]:
+                - x: The input array of independent variable values.
+                - poly_fit: The fitted quadratic values corresponding to x.
+
+        """
+        coeffs = np.polyfit(x, y, 2)
+        poly_fit = np.polyval(coeffs, x)
+        return x, poly_fit
+
+    def moving_average_trend(self, x: np.ndarray, y: np.ndarray, window: int = 5) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Computes the moving average trend of the input data using a specified window size.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            The array of x-values (e.g., time points).
+        y : np.ndarray
+            The array of y-values (e.g., measurements corresponding to x).
+        window : int, optional
+            The size of the moving average window. Must be at least 1. Default is 5.
+
+        Returns
+        -------
+        tuple[np.ndarray, np.ndarray]
+            A tuple containing:
+                - x values corresponding to valid (finite) moving average points.
+                - The moving average values (trend) for the valid points.
+
+        Raises
+        ------
+        ValueError
+            If the window size is less than 1.
+
+        """
+        if window < 1:
+            msg = "Window size must be at least 1."
+            raise ValueError(msg)
+        y_series = pd.Series(y)
+        ma_fit = y_series.rolling(window=window, center=True).mean().to_numpy()
+        good = np.isfinite(x) & np.isfinite(ma_fit)
+        return x[good], ma_fit[good]
+
+    def get_trend(
+        self,
+        x: np.ndarray,
+        y: np.ndarray,
+        method: str = "linear",
+        window: int = 5,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Computes the trend of the given data using the specified method.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            The independent variable data (e.g., time points).
+        y : np.ndarray
+            The dependent variable data (e.g., measurements).
+        method : str, optional
+            The detrending method to use. Options are:
+                - "none": No detrending, returns x and zeros for y.
+                - "linear": Applies a linear trend.
+                - "poly2": Applies a quadratic (2nd degree polynomial) trend.
+                - "moving_average": Applies a moving average trend.
+            Default is "linear".
+        window : int, optional
+            The window size for the moving average method. Default is 5.
+
+        Returns
+        -------
+        tuple[np.ndarray, np.ndarray]
+            A tuple containing:
+                - The x values (possibly unchanged).
+                - The trend values corresponding to y.
+
+        Raises
+        ------
+        ValueError
+            If an unknown detrending method is specified.
+
+        """
+        if method == "none":
+            return np.asarray(x, float), np.zeros_like(np.asarray(y, float))
+        if method == "linear":
+            return self.linear_trend(x, y)
+        if method == "poly2":
+            return self.poly2_trend(x, y)
+        if method == "moving_average":
+            return self.moving_average_trend(x, y, window=window)
+        msg = f"Unknown detrending method: {method}"
+        raise ValueError(msg)
+
+    def plot_group_data(
+        self,
+        group: str,
+        method: str = "linear",
+        window: int = 5,
+        m: int = 5,
+        plot_style: str = "scatter",
+    ) -> tuple[plt.Figure, str]:
+        """
+        Plots data for a specified group, with options for trend fitting and plot style.
+
+        Parameters
+        ----------
+        group : str
+            The group to plot, must be either 'group1' or 'group2'.
+        method : str, optional
+            The method used for trend fitting. Default is "linear".
+            Use "none" to skip trend fitting.
+        window : int, optional
+            The window size for trend fitting (if applicable). Default is 5.
+        m : int, optional
+            Number of columns in the subplot grid. Default is 5.
+        plot_style : str, optional
+            The style of the plot, either "scatter" or "line". Default is "scatter".
+
+        Returns
+        -------
+        fig : matplotlib.figure.Figure
+            The matplotlib Figure object containing the plots.
+        tmp_path : str
+            The path to the saved temporary PDF file of the figure.
+
+        Raises
+        ------
+        ValueError
+            If the group argument is not 'group1' or 'group2'.
+
+        """
+        if group == "group1":
+            ids, _replicates, data = self.get_group1_ids_replicates_data()
+            color = self.color_group1
+            group_label = self.group1_label
+        elif group == "group2":
+            ids, _replicates, data = self.get_group2_ids_replicates_data()
+            color = self.color_group2
+            group_label = self.group2_label
+        else:
+            msg = "group must be 'group1' or 'group2'"
+            raise ValueError(msg)
+
+        n_group = len(np.unique(ids))
+        n_cols = m
+        n_rows = int(np.ceil(n_group / n_cols))
+
+        study_list = np.unique(ids).tolist()
+        fig = plt.figure(figsize=(5 * n_cols / 2.54, 5 * n_rows / 2.54))
+
+        for i, id_curr in enumerate(study_list):
+            mask = np.array(ids) == id_curr
+            n_reps = int(np.sum(mask))
+            ax = fig.add_subplot(n_rows, n_cols, i + 1)
+
+            for j in range(n_reps):
+                x = self.time
+                y = data[:, mask][:, j]
+
+                if plot_style == "scatter":
+                    ax.scatter(x, y, s=4, alpha=0.8, color=color)
+                else:
+                    ax.plot(x, y, color=color)
+
+                valid_mask = ~np.isnan(y)
+                x_fit = x[valid_mask]
+                y_fit = y[valid_mask]
+
+                x_processed, y_processed = self.get_trend(
+                    x_fit,
+                    y_fit,
+                    method=method,
+                    window=window,
+                )
+                if method != "none":
+                    ax.plot(
+                        x_processed,
+                        y_processed,
+                        color="black",
+                        linestyle="--",
+                        linewidth=0.8,
+                    )
+
+            ax.set_title(f"ID: {id_curr} (n={n_reps}) - {group_label}")
+            ax.set_xlabel("Time (h)")
+            if i % n_cols == 0:
+                ax.set_ylabel("Expression")
+
+        plt.tight_layout()
+
+        fd, tmp_path = tempfile.mkstemp(suffix=".pdf")
+        os.close(fd)
+
+        fig.savefig(tmp_path)
+
+        return fig, tmp_path
diff --git a/src/cosinor_lite/models.py b/src/cosinor_lite/models.py
deleted file mode 100644
index db8d7dc..0000000
--- a/src/cosinor_lite/models.py
+++ /dev/null
@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-import pandas as pd
-from pydantic.dataclasses import dataclass
-
-from cosinor_lite.base_models import BaseModel, BaseModelOneCondition
-from cosinor_lite.utils import amp_from_ab, phase_from_ab
-
-
-@dataclass
-class M0:
-    name: int = 0
-    alpha_phase: float = np.nan
-    alpha_amp: float = np.nan
-    beta_phase: float = np.nan
-    beta_amp: float = np.nan
-    amp: float = np.nan
-    phase: float = np.nan
-    bic: float = np.nan
-
-
-class M1(BaseModel):
-    name: int = 1
-    k: int = 3
-    formula: str = "y ~ is_alpha:constant + is_beta:constant -1"
-
-    def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # No rhythmic terms → phases/amps are NaN
-        return (np.nan, np.nan, np.nan, np.nan)
-
-
-class M1OneCondition(BaseModelOneCondition):
-    name: int = 1
-    k: int = 1
-    formula: str = "y ~ 1"
-
-    def extract(self, params: pd.Series) -> tuple[float, float]:
-        # No rhythmic terms → phases/amps are NaN
-        return (np.nan, np.nan)
-
-
-class M2(BaseModel):
-    name: int = 2
-    k: int = 5
-    formula: str = "y ~ is_alpha:constant + is_beta:constant + is_beta:cos_wt + is_beta:sin_wt -1"
-
-    def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # beta has rhythmic terms, alpha does not
-        a: float = params["is_beta:cos_wt"]
-        b: float = params["is_beta:sin_wt"]
-        beta_phase: float = phase_from_ab(a, b)
-        beta_amp: float = amp_from_ab(a, b)
-        return (np.nan, np.nan, beta_phase, beta_amp)
-
-
-class M3(BaseModel):
-    name: int = 3
-    k: int = 5
-    formula: str = "y ~ is_alpha:constant + is_beta:constant + is_alpha:cos_wt + is_alpha:sin_wt -1"
-
-    def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # alpha has rhythmic terms, beta does not
-        a: float = params["is_alpha:cos_wt"]
-        b: float = params["is_alpha:sin_wt"]
-        alpha_phase: float = phase_from_ab(a, b)
-        alpha_amp: float = amp_from_ab(a, b)
-        return (alpha_phase, alpha_amp, np.nan, np.nan)
-
-
-class MOscOneCondition(BaseModelOneCondition):
-    name: int = 3
-    k: int = 3
-    formula: str = "y ~ 1 + cos_wt + sin_wt"
-
-    def extract(self, params: pd.Series) -> tuple[float, float]:
-        # alpha has rhythmic terms, beta does not
-        a: float = params["cos_wt"]
-        b: float = params["sin_wt"]
-        phase: float = phase_from_ab(a, b)
-        amp: float = amp_from_ab(a, b)
-        return (phase, amp)
-
-
-class M4(BaseModel):
-    name: int = 4
-    k: int = 5
-    formula: str = "y ~ is_alpha:constant + is_beta:constant + cos_wt + sin_wt -1"
-
-    def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # shared rhythmic terms for both alpha and beta
-        a: float = params["cos_wt"]
-        b: float = params["sin_wt"]
-        ph: float = phase_from_ab(a, b)
-        am: float = amp_from_ab(a, b)
-        return (ph, am, ph, am)
-
-
-class M5(BaseModel):
-    name: int = 5
-    k: int = 7
-    formula: str = (
-        "y ~ is_alpha:constant + is_beta:constant + "
-        "is_alpha:cos_wt + is_alpha:sin_wt + is_beta:cos_wt + is_beta:sin_wt -1"
-    )
-
-    def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        a_cond1: float = params["is_alpha:cos_wt"]
-        b_cond1: float = params["is_alpha:sin_wt"]
-        a_cond2: float = params["is_beta:cos_wt"]
-        b_cond2: float = params["is_beta:sin_wt"]
-
-        alpha_phase: float = phase_from_ab(a_cond1, b_cond1)
-        alpha_amp: float = amp_from_ab(a_cond1, b_cond1)
-        beta_phase: float = phase_from_ab(a_cond2, b_cond2)
-        beta_amp: float = amp_from_ab(a_cond2, b_cond2)
-        return (alpha_phase, alpha_amp, beta_phase, beta_amp)
diff --git a/src/cosinor_lite/datasets.py b/src/cosinor_lite/omics_dataset.py
similarity index 50%
rename from src/cosinor_lite/datasets.py
rename to src/cosinor_lite/omics_dataset.py
index d2fbfca..57d6aa7 100644
--- a/src/cosinor_lite/datasets.py
+++ b/src/cosinor_lite/omics_dataset.py
@@ -9,9 +9,47 @@
 from pydantic.dataclasses import dataclass
 from scipy.stats import spearmanr
 
+plt.rcParams.update(
+    {
+        "font.size": 8,
+        "axes.titlesize": 8,
+        "axes.labelsize": 8,
+        "xtick.labelsize": 8,
+        "ytick.labelsize": 8,
+        "legend.fontsize": 8,
+        "figure.titlesize": 8,
+        "pdf.fonttype": 42,
+    },
+)
+plt.style.use("seaborn-v0_8-ticks")
+
 
 @dataclass(config=ConfigDict(arbitrary_types_allowed=True))
 class OmicsDataset:
+    """
+    Represent an omics expression table and derived metrics.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Input table containing gene expression measurements.
+    columns_cond1 : list[str]
+        Column names for condition 1 samples.
+    columns_cond2 : list[str]
+        Column names for condition 2 samples.
+    t_cond1 : numpy.ndarray
+        Time points associated with ``columns_cond1``.
+    t_cond2 : numpy.ndarray
+        Time points associated with ``columns_cond2``.
+    cond1_label : str, optional
+        Display label for condition 1, by default ``"cond1"``.
+    cond2_label : str, optional
+        Display label for condition 2, by default ``"cond2"``.
+    deduplicate_on_init : bool, optional
+        Whether to deduplicate genes immediately after initialization, by default ``False``.
+
+    """
+
     df: pd.DataFrame
 
     columns_cond1: list[str]
@@ -23,10 +61,29 @@ class OmicsDataset:
 
     deduplicate_on_init: bool = False
 
-    # --- validators ---
     @field_validator("t_cond1", "t_cond2", mode="before")
     @classmethod
     def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
+        """
+        Coerce incoming arrays to one-dimensional ``float64`` np.ndarrays.
+
+        Parameters
+        ----------
+        v : object
+            Sequence-like data to convert.
+
+        Returns
+        -------
+        numpy.ndarray
+            Converted one-dimensional array.
+
+        Raises
+        ------
+        ValueError
+            If the incoming value cannot be reshaped to one dimension.
+
+
+        """
         a = np.asarray(v, dtype=np.float64)
         if a.ndim != 1:
             text: str = "expected 1D array"
@@ -35,6 +92,21 @@ def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
 
     @model_validator(mode="after")
     def _check_columns(self) -> Self:
+        """
+        Ensure all requested columns are present in the DataFrame.
+
+        Returns
+        -------
+        Self
+            The validated dataset instance.
+
+        Raises
+        ------
+        ValueError
+            If any required columns are missing.
+
+
+        """
         missing = [c for c in (self.columns_cond1 + self.columns_cond2) if c not in self.df.columns]
         if missing:
             text = f"Missing columns: {missing}"  # satisfies EM101 (no string literal in raise)
@@ -42,6 +114,7 @@ def _check_columns(self) -> Self:
         return self
 
     def __post_init__(self) -> None:
+        """Populate derived columns and optionally deduplicate entries."""
         self.add_detected_timepoint_counts()
         self.add_mean_expression()
         self.add_number_detected()
@@ -50,13 +123,23 @@ def __post_init__(self) -> None:
 
     def detected_timepoint_counts(self, cond: str) -> list[int]:
         """
-        Count number of timepoints with detected values for each gene.
+        Count detected time points per gene for the requested condition.
+
+        Parameters
+        ----------
+        cond : str
+            Either ``"cond1"`` or ``"cond2"`` specifying which condition to evaluate.
+
+        Returns
+        -------
+        list[int]
+            Number of distinct time points detected for each gene.
 
-        Args:
-            cond (str): "cond1" or "cond2"
+        Raises
+        ------
+        ValueError
+            If ``cond`` is not a recognized condition label.
 
-        Returns:
-            list[int]: List of counts for each gene.
 
         """
         if cond == "cond1":
@@ -69,37 +152,29 @@ def detected_timepoint_counts(self, cond: str) -> list[int]:
             text = f"Invalid condition: {cond}"  # satisfies EM101 (no string literal in raise)
             raise ValueError(text)
 
-        # y-like frame, boolean mask of non-NaN
-        mask = y.notna()  # shape: (n_rows, n_cols)
+        mask = y.notna()
 
-        # t_beta must be length n_cols and aligned to those columns
-        # Group columns by time, check if ANY non-NaN per group, then count groups per row
-        detected_timepoints = (
-            mask.T.groupby(t)
-            .any()  # (n_rows, n_unique_times) booleans
-            .T.sum(axis=1)  # per-row counts
-            .to_numpy()
-        )
+        detected_timepoints = mask.T.groupby(t).any().T.sum(axis=1).to_numpy()
 
         return detected_timepoints
 
     def add_detected_timepoint_counts(self) -> None:
-        """Add two columns to self.df with counts for cond1 and cond2."""
-        self.df["detected_cond1"] = self.detected_timepoint_counts("cond1")
-        self.df["detected_cond2"] = self.detected_timepoint_counts("cond2")
+        """Augment the DataFrame with detected time-point counts for each condition."""
+        self.df["detected_timepoints_cond1"] = self.detected_timepoint_counts("cond1")
+        self.df["detected_timepoints_cond2"] = self.detected_timepoint_counts("cond2")
 
     def add_mean_expression(self) -> None:
-        """Add two columns to self.df with mean expression for cond1 and cond2."""
+        """Compute mean expression for both conditions and store in the DataFrame."""
         self.df["mean_cond1"] = self.df[self.columns_cond1].mean(axis=1)
         self.df["mean_cond2"] = self.df[self.columns_cond2].mean(axis=1)
 
     def add_number_detected(self) -> None:
-        """Add two columns to self.df with number of detected values for cond1 and cond2."""
+        """Store the count of non-null measurements for each condition."""
         self.df["num_detected_cond1"] = self.df[self.columns_cond1].count(axis=1)
         self.df["num_detected_cond2"] = self.df[self.columns_cond2].count(axis=1)
 
     def deduplicate_genes(self) -> None:
-        """Deduplicate self.df by 'Genes', keeping entry with highest total mean expression."""
+        """Remove duplicate gene entries, keeping the highest combined mean expression."""
         if not {"mean_cond1", "mean_cond2"}.issubset(self.df):
             self.add_mean_expression()
 
@@ -117,9 +192,21 @@ def add_is_expressed(
         mean_min: float | None = None,
         num_detected_min: int | None = None,
     ) -> None:
-        """Add is_expressed_cond1/cond2 based on thresholds."""
-        # Ensure prerequisite columns exist
-        if not {"detected_cond1", "detected_cond2"}.issubset(self.df):
+        """
+        Flag genes as expressed based on configurable thresholds.
+
+        Parameters
+        ----------
+        detected_min : int | None, optional
+            Minimum detected time points required, by default ``None``.
+        mean_min : float | None, optional
+            Minimum mean expression required, by default ``None``.
+        num_detected_min : int | None, optional
+            Minimum number of detected samples required, by default ``None``.
+
+
+        """
+        if not {"detected_timepoints_cond1", "detected_timepoints_cond2"}.issubset(self.df):
             self.add_detected_timepoint_counts()
         if not {"mean_cond1", "mean_cond2"}.issubset(self.df):
             self.add_mean_expression()
@@ -127,7 +214,6 @@ def add_is_expressed(
             self.add_number_detected()
 
         def _mask(which: Literal["cond1", "cond2"]) -> pd.Series:
-            # start with all-True masks
             m_detected = pd.Series(True, index=self.df.index)
             m_mean = pd.Series(True, index=self.df.index)
             m_num = pd.Series(True, index=self.df.index)
@@ -144,10 +230,24 @@ def _mask(which: Literal["cond1", "cond2"]) -> pd.Series:
         self.df["is_expressed_cond1"] = _mask("cond1")
         self.df["is_expressed_cond2"] = _mask("cond2")
 
-    def expression_histogram(self, bins: int = 20) -> None:
-        """Plot histogram of mean expression for cond1 and cond2."""
+    def expression_histogram(self, bins: int = 20) -> plt.Figure:
+        """
+        Plot histograms of mean expression for both conditions.
+
+        Parameters
+        ----------
+        bins : int, optional
+            Number of histogram bins, by default 20.
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            Figure containing the histogram panels.
+
+
+        """
         print(plt.rcParams["font.size"])
-        plt.figure(figsize=(6 / 2.54, 12 / 2.54))
+        fig = plt.figure(figsize=(6 / 2.54, 12 / 2.54))
         plt.subplot(2, 1, 1)
         plt.hist(self.df["mean_cond1"].to_numpy().flatten(), bins=bins)
         plt.xlabel("Mean Expression")
@@ -161,24 +261,54 @@ def expression_histogram(self, bins: int = 20) -> None:
         plt.title(f"Mean expression ({self.cond2_label})")
         plt.gca().xaxis.set_major_locator(plt.MaxNLocator(nbins=10))
         plt.tight_layout()
-        plt.show()
 
-    def replicate_scatterplot(self, sample1: str, sample2: str) -> None:
-        """Scatterplot of two replicates."""
+        return fig
+
+    def replicate_scatterplot(self, sample1: str, sample2: str) -> plt.Figure:
+        """
+        Create a scatterplot comparing two samples with correlation annotations.
+
+        Parameters
+        ----------
+        sample1 : str
+            Column name of the first sample.
+        sample2 : str
+            Column name of the second sample.
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            Figure containing the scatter plot.
+
+        Raises
+        ------
+        ValueError
+            If either sample column is missing from the DataFrame.
+
+
+        """
         if sample1 not in self.df.columns or sample2 not in self.df.columns:
             text = f"Samples {sample1} and/or {sample2} not in DataFrame columns."
             raise ValueError(text)
 
-        plt.figure(figsize=(8 / 2.54, 8 / 2.54))
-        x: np.ndarray = self.df[sample1].to_numpy().flatten()
-        y: np.ndarray = self.df[sample2].to_numpy().flatten()
+        fig = plt.figure(figsize=(8 / 2.54, 8 / 2.54))
+        xy = self.df[[sample1, sample2]].dropna()
+        x: np.ndarray = xy[sample1].to_numpy().flatten()
+        y: np.ndarray = xy[sample2].to_numpy().flatten()
         r_pearson: float = np.corrcoef(x, y)[0, 1]
         r_spearman: float = spearmanr(x, y).statistic
         plt.scatter(x, y, alpha=0.1, s=4)
         plt.xlabel(sample1)
         plt.ylabel(sample2)
-        plt.title(f"{sample1} vs {sample2} (Pearson R = {r_pearson:.2f}, Spearman R = {r_spearman:.2f})")
+        plt.title(f"Pearson R = {r_pearson:.2f}, Spearman R = {r_spearman:.2f}")
         plt.axis("equal")
-        plt.plot([x.min(), x.max()], [x.min(), x.max()], color="grey", linestyle="--", alpha=0.8)
+        plt.plot(
+            [x.min(), x.max()],
+            [x.min(), x.max()],
+            color="grey",
+            linestyle="--",
+            alpha=0.8,
+        )
         plt.tight_layout()
-        plt.show()
+
+        return fig
diff --git a/src/cosinor_lite/differential_rhytmicity_omics.py b/src/cosinor_lite/omics_differential_rhytmicity.py
similarity index 50%
rename from src/cosinor_lite/differential_rhytmicity_omics.py
rename to src/cosinor_lite/omics_differential_rhytmicity.py
index 8574dbb..1cba7b8 100644
--- a/src/cosinor_lite/differential_rhytmicity_omics.py
+++ b/src/cosinor_lite/omics_differential_rhytmicity.py
@@ -1,15 +1,21 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from dataclasses import dataclass as std_dataclass
+from typing import Self, cast
 
+import gradio as gr
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import statsmodels.formula.api as smf
 from pydantic import ConfigDict, field_validator, model_validator
-from pydantic.dataclasses import dataclass
+from pydantic.dataclasses import dataclass as pydantic_dataclass
 from tqdm import tqdm
 
+from cosinor_lite.omics_dataset import OmicsDataset
+
 plt.rcParams.update(
     {
         "font.size": 8,
@@ -22,25 +28,79 @@
         "pdf.fonttype": 42,
     },
 )
+plt.style.use("seaborn-v0_8-ticks")
+
 
 W: float = 2 * np.pi / 24.0
 RAD2H: float = 24.0 / (2.0 * np.pi)
 
 
 def phase_from_ab(a: float, b: float) -> float:
+    """
+    Convert cosine and sine coefficients to a phase value in hours.
+
+    Parameters
+    ----------
+    a : float
+        Cosine-term regression coefficient.
+    b : float
+        Sine-term regression coefficient.
+
+    Returns
+    -------
+    float
+        Phase value constrained to the ``[0, 24)`` hour interval.
+
+    """
     return (np.arctan2(b, a) * RAD2H) % 24.0
 
 
 def amp_from_ab(a: float, b: float) -> float:
+    """
+    Compute the amplitude implied by cosine and sine coefficients.
+
+    Parameters
+    ----------
+    a : float
+        Cosine-term regression coefficient.
+    b : float
+        Sine-term regression coefficient.
+
+    Returns
+    -------
+    float
+        Non-negative amplitude derived from the Euclidean norm.
+
+    """
     return float(np.hypot(a, b))
 
 
 def bic(llf: float, k: int, n: int) -> float:
+    """
+    Evaluate the Bayesian Information Criterion for a fitted model.
+
+    Parameters
+    ----------
+    llf : float
+        Log-likelihood of the fitted model.
+    k : int
+        Number of estimated parameters.
+    n : int
+        Number of observations used during fitting.
+
+    Returns
+    -------
+    float
+        BIC score, where lower values indicate preferred models.
+
+    """
     return k * np.log(n) - 2.0 * llf
 
 
-@dataclass
+@std_dataclass
 class ModelResult:
+    """Store parameter estimates and metrics for dual-condition models."""
+
     name: int
     llf: float
     bic: float
@@ -50,8 +110,10 @@ class ModelResult:
     beta_amp: float
 
 
-@dataclass
+@std_dataclass
 class ModelResultOneCondition:
+    """Store parameter estimates and metrics for single-condition models."""
+
     name: int
     llf: float
     bic: float
@@ -60,14 +122,29 @@ class ModelResultOneCondition:
 
 
 class BaseModel(ABC):
-    name: str
+    """Template for two-condition cosinor models sharable across datasets."""
+
+    name: int
     k: int
     formula: str
 
     def fit(self, df: pd.DataFrame) -> ModelResult:
-        # df must already contain: y, constant, cos_wt, sin_wt, is_alpha, is_beta
+        """
+        Fit the configured statsmodels OLS formula to the supplied design matrix.
+
+        Parameters
+        ----------
+        df : pandas.DataFrame
+            Design matrix containing predictors and response values.
+
+        Returns
+        -------
+        ModelResult
+            Bundle of model metadata, BIC, and derived phase/amplitude values.
+
+        """
         model = smf.ols(self.formula, data=df).fit()
-        n = len(df)
+        n: int = len(df)
         alpha_phase, alpha_amp, beta_phase, beta_amp = self.extract(model.params)
         return ModelResult(
             name=self.name,
@@ -84,12 +161,27 @@ def extract(self, params: pd.Series) -> tuple[float, float, float, float]: ...
 
 
 class BaseModelOneCondition(ABC):
-    name: str
+    """Template for single-condition cosinor models."""
+
+    name: int
     k: int
     formula: str
 
     def fit(self, df: pd.DataFrame) -> ModelResultOneCondition:
-        # df must already contain: y, constant, cos_wt, sin_wt, is_alpha, is_beta
+        """
+        Fit a single-condition OLS cosinor model on the provided design matrix.
+
+        Parameters
+        ----------
+        df : pandas.DataFrame
+            Design matrix containing predictors and response values.
+
+        Returns
+        -------
+        ModelResultOneCondition
+            Bundle of model metadata plus the fitted phase and amplitude.
+
+        """
         model = smf.ols(self.formula, data=df).fit()
         n = len(df)
         phase, amp = self.extract(model.params)
@@ -105,11 +197,10 @@ def fit(self, df: pd.DataFrame) -> ModelResultOneCondition:
     def extract(self, params: pd.Series) -> tuple[float, float]: ...
 
 
-# ----- Five concrete models -----
-
-
-@dataclass
+@std_dataclass
 class M0:
+    """Fallback result used when all cosinor models fall below the weight cutoff."""
+
     name: int = 0
     alpha_phase: float = np.nan
     alpha_amp: float = np.nan
@@ -125,8 +216,7 @@ class M1(BaseModel):
     k: int = 3
     formula: str = "y ~ is_alpha:constant + is_beta:constant -1"
 
-    def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # No rhythmic terms → phases/amps are NaN
+    def extract(self, params: pd.Series) -> tuple[float, float, float, float]:  # noqa: ARG002
         return (np.nan, np.nan, np.nan, np.nan)
 
 
@@ -135,8 +225,7 @@ class M1OneCondition(BaseModelOneCondition):
     k: int = 1
     formula: str = "y ~ 1"
 
-    def extract(self, params: pd.Series) -> tuple[float, float]:
-        # No rhythmic terms → phases/amps are NaN
+    def extract(self, params: pd.Series) -> tuple[float, float]:  # noqa: ARG002
         return (np.nan, np.nan)
 
 
@@ -146,9 +235,8 @@ class M2(BaseModel):
     formula: str = "y ~ is_alpha:constant + is_beta:constant + is_beta:cos_wt + is_beta:sin_wt -1"
 
     def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # beta has rhythmic terms, alpha does not
-        a: float = params["is_beta:cos_wt"]
-        b: float = params["is_beta:sin_wt"]
+        a: float = cast(float, params["is_beta:cos_wt"])
+        b: float = cast(float, params["is_beta:sin_wt"])
         beta_phase: float = phase_from_ab(a, b)
         beta_amp: float = amp_from_ab(a, b)
         return (np.nan, np.nan, beta_phase, beta_amp)
@@ -160,9 +248,8 @@ class M3(BaseModel):
     formula: str = "y ~ is_alpha:constant + is_beta:constant + is_alpha:cos_wt + is_alpha:sin_wt -1"
 
     def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # alpha has rhythmic terms, beta does not
-        a: float = params["is_alpha:cos_wt"]
-        b: float = params["is_alpha:sin_wt"]
+        a: float = cast(float, params["is_alpha:cos_wt"])
+        b: float = cast(float, params["is_alpha:sin_wt"])
         alpha_phase: float = phase_from_ab(a, b)
         alpha_amp: float = amp_from_ab(a, b)
         return (alpha_phase, alpha_amp, np.nan, np.nan)
@@ -174,9 +261,8 @@ class MOscOneCondition(BaseModelOneCondition):
     formula: str = "y ~ 1 + cos_wt + sin_wt"
 
     def extract(self, params: pd.Series) -> tuple[float, float]:
-        # alpha has rhythmic terms, beta does not
-        a: float = params["cos_wt"]
-        b: float = params["sin_wt"]
+        a: float = cast(float, params["cos_wt"])
+        b: float = cast(float, params["sin_wt"])
         phase: float = phase_from_ab(a, b)
         amp: float = amp_from_ab(a, b)
         return (phase, amp)
@@ -188,9 +274,8 @@ class M4(BaseModel):
     formula: str = "y ~ is_alpha:constant + is_beta:constant + cos_wt + sin_wt -1"
 
     def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        # shared rhythmic terms for both alpha and beta
-        a: float = params["cos_wt"]
-        b: float = params["sin_wt"]
+        a: float = cast(float, params["cos_wt"])
+        b: float = cast(float, params["sin_wt"])
         ph: float = phase_from_ab(a, b)
         am: float = amp_from_ab(a, b)
         return (ph, am, ph, am)
@@ -205,10 +290,10 @@ class M5(BaseModel):
     )
 
     def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
-        a_cond1: float = params["is_alpha:cos_wt"]
-        b_cond1: float = params["is_alpha:sin_wt"]
-        a_cond2: float = params["is_beta:cos_wt"]
-        b_cond2: float = params["is_beta:sin_wt"]
+        a_cond1: float = cast(float, params["is_alpha:cos_wt"])
+        b_cond1: float = cast(float, params["is_alpha:sin_wt"])
+        a_cond2: float = cast(float, params["is_beta:cos_wt"])
+        b_cond2: float = cast(float, params["is_beta:sin_wt"])
 
         alpha_phase: float = phase_from_ab(a_cond1, b_cond1)
         alpha_amp: float = amp_from_ab(a_cond1, b_cond1)
@@ -217,26 +302,89 @@ def extract(self, params: pd.Series) -> tuple[float, float, float, float]:
         return (alpha_phase, alpha_amp, beta_phase, beta_amp)
 
 
-# ----- Runner utilities -----
-
 MODELS: tuple[BaseModel, ...] = (M1(), M2(), M3(), M4(), M5())
-MODELS_ONE_CONDITION: tuple[BaseModelOneCondition, ...] = (M1OneCondition(), MOscOneCondition())
+MODELS_ONE_CONDITION: tuple[BaseModelOneCondition, ...] = (
+    M1OneCondition(),
+    MOscOneCondition(),
+)
 
 
 def akaike_weights_from_bics(bics: np.ndarray) -> np.ndarray:
+    """
+    Convert BIC scores into normalized Akaike weights.
+
+    Parameters
+    ----------
+    bics : numpy.ndarray
+        Array of BIC values where lower entries indicate better fits.
+
+    Returns
+    -------
+    numpy.ndarray
+        Non-negative weights that sum to one after exponentiation and scaling.
+
+    """
     d: np.ndarray = bics - np.nanmin(bics)
     w: np.ndarray = np.exp(-0.5 * d)
     return w / np.nansum(w)
 
 
+def _weight_mapping(model_ids: Sequence[int], weights: np.ndarray) -> dict[str, float]:
+    """
+    Align Akaike weights with ``w_model{n}`` keys expected in result tables.
+
+    Parameters
+    ----------
+    model_ids : collections.abc.Sequence[int]
+        Sequence of model identifiers that produced ``weights``.
+    weights : numpy.ndarray
+        Akaike weights in positional order matching ``model_ids``.
+
+    Returns
+    -------
+    dict[str, float]
+        Mapping of weight column names to values (or ``nan`` when absent).
+
+    """
+    mapping: dict[str, float] = {f"w_model{i}": np.nan for i in range(1, len(MODELS) + 1)}
+    for idx, model_id in enumerate(model_ids):
+        if idx < len(weights):
+            mapping[f"w_model{model_id}"] = float(weights[idx])
+    return mapping
+
+
 def build_design(
     alpha_vals: np.ndarray,
     beta_vals: np.ndarray,
     t_cond1: np.ndarray,
     t_cond2: np.ndarray,
 ) -> pd.DataFrame:
-    df_cond1: pd.DataFrame = pd.DataFrame({"y": alpha_vals, "time": t_cond1, "dataset": "alpha"}).dropna()
-    df_cond2: pd.DataFrame = pd.DataFrame({"y": beta_vals, "time": t_cond2, "dataset": "beta"}).dropna()
+    """
+    Construct the full design matrix for simultaneously fitting both conditions.
+
+    Parameters
+    ----------
+    alpha_vals : numpy.ndarray
+        Expression values for condition 1 samples.
+    beta_vals : numpy.ndarray
+        Expression values for condition 2 samples.
+    t_cond1 : numpy.ndarray
+        Zeitgeber time points corresponding to ``alpha_vals``.
+    t_cond2 : numpy.ndarray
+        Zeitgeber time points corresponding to ``beta_vals``.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Design matrix including indicator, cosine, and sine predictors.
+
+    """
+    df_cond1: pd.DataFrame = pd.DataFrame(
+        {"y": alpha_vals, "time": t_cond1, "dataset": "alpha"},
+    ).dropna()
+    df_cond2: pd.DataFrame = pd.DataFrame(
+        {"y": beta_vals, "time": t_cond2, "dataset": "beta"},
+    ).dropna()
     df: pd.DataFrame = pd.concat([df_cond1, df_cond2], ignore_index=True)
     df["constant"] = 1.0
     df["cos_wt"] = np.cos(W * df["time"].to_numpy().astype(float))
@@ -250,7 +398,25 @@ def build_design_cond1(
     alpha_vals: np.ndarray,
     t_cond1: np.ndarray,
 ) -> pd.DataFrame:
-    df_cond1: pd.DataFrame = pd.DataFrame({"y": alpha_vals, "time": t_cond1, "dataset": "alpha"}).dropna()
+    """
+    Construct the design matrix for condition 1 only.
+
+    Parameters
+    ----------
+    alpha_vals : numpy.ndarray
+        Expression values for condition 1 samples.
+    t_cond1 : numpy.ndarray
+        Zeitgeber time points associated with ``alpha_vals``.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Single-condition design matrix with cosine and sine predictors.
+
+    """
+    df_cond1: pd.DataFrame = pd.DataFrame(
+        {"y": alpha_vals, "time": t_cond1, "dataset": "alpha"},
+    ).dropna()
     df: pd.DataFrame = pd.concat([df_cond1], ignore_index=True)
     df["constant"] = 1.0
     df["cos_wt"] = np.cos(W * df["time"].to_numpy().astype(float))
@@ -262,7 +428,25 @@ def build_design_cond2(
     beta_vals: np.ndarray,
     t_cond2: np.ndarray,
 ) -> pd.DataFrame:
-    df_cond2: pd.DataFrame = pd.DataFrame({"y": beta_vals, "time": t_cond2, "dataset": "beta"}).dropna()
+    """
+    Construct the design matrix for condition 2 only.
+
+    Parameters
+    ----------
+    beta_vals : numpy.ndarray
+        Expression values for condition 2 samples.
+    t_cond2 : numpy.ndarray
+        Zeitgeber time points associated with ``beta_vals``.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Single-condition design matrix with cosine and sine predictors.
+
+    """
+    df_cond2: pd.DataFrame = pd.DataFrame(
+        {"y": beta_vals, "time": t_cond2, "dataset": "beta"},
+    ).dropna()
     df: pd.DataFrame = pd.concat([df_cond2], ignore_index=True)
     df["constant"] = 1.0
     df["cos_wt"] = np.cos(W * df["time"].to_numpy().astype(float))
@@ -270,76 +454,118 @@ def build_design_cond2(
     return df
 
 
-@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
+@pydantic_dataclass(config=ConfigDict(arbitrary_types_allowed=True))
 class DifferentialRhythmicity:
+    """
+    Coordinate cosinor model selection across an :class:`OmicsDataset`.
+
+    Parameters
+    ----------
+    dataset : OmicsDataset
+        Dataset containing expression values and metadata required for fitting.
+    BIC_cutoff : float, optional
+        Minimum Akaike weight threshold for accepting a rhythmic model, by default ``0.5``.
+
+    """
+
     dataset: OmicsDataset
     BIC_cutoff: float = 0.5
 
     @property
     def df(self) -> pd.DataFrame:
+        """pandas.DataFrame: Alias to the underlying dataset table."""
         return self.dataset.df
 
     @property
     def columns_cond1(self) -> list[str]:
+        """list[str]: Column names belonging to condition 1."""
         return self.dataset.columns_cond1
 
     @property
     def columns_cond2(self) -> list[str]:
+        """list[str]: Column names belonging to condition 2."""
         return self.dataset.columns_cond2
 
     @property
     def t_cond1(self) -> np.ndarray:
+        """numpy.ndarray: Zeitgeber time points for condition 1."""
         return self.dataset.t_cond1
 
     @property
     def t_cond2(self) -> np.ndarray:
+        """numpy.ndarray: Zeitgeber time points for condition 2."""
         return self.dataset.t_cond2
 
     @property
     def cond1_label(self) -> str:
+        """str: Human-readable label for condition 1."""
         return self.dataset.cond1_label
 
     @property
     def cond2_label(self) -> str:
+        """str: Human-readable label for condition 2."""
         return self.dataset.cond2_label
 
-    def rhythmic_genes_expressed_both(self) -> pd.DataFrame:
+    def rhythmic_genes_expressed_both(self, progress: gr.Progress | None = None) -> pd.DataFrame:
+        """
+        Evaluate rhythmicity for genes expressed in both conditions.
+
+        Parameters
+        ----------
+        progress : gradio.Progress | None, optional
+            Progress reporter used when running inside a Gradio app, by default ``None``.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Per-gene summaries containing model identity, weights, and fitted parameters.
+
+        """
         df: pd.DataFrame = self.df
         mask: pd.Series = (df["is_expressed_cond1"]) & (df["is_expressed_cond2"])
         df_to_analyse: pd.DataFrame = df[mask].reset_index(drop=True)
 
+        progress_manager = progress or gr.Progress()
+        model_ids: list[int] = [model.name for model in MODELS]
         rows: list[dict] = []
-        for gene, row in tqdm(
+        for gene, row in progress_manager.tqdm(
             df_to_analyse.set_index("Genes").iterrows(),
             total=len(df_to_analyse),
             desc="Fitting models to genes expressed in both conditions",
         ):
             alpha_vec: np.ndarray = row[self.columns_cond1].to_numpy(float)
             beta_vec: np.ndarray = row[self.columns_cond2].to_numpy(float)
-            design: pd.DataFrame = build_design(alpha_vec, beta_vec, self.t_cond1, self.t_cond2)
-            results: list[BaseModel] = [m.fit(design) for m in MODELS]
-            bics: np.ndarray = np.array([r.bic for r in results])
+            design: pd.DataFrame = build_design(
+                alpha_vec,
+                beta_vec,
+                self.t_cond1,
+                self.t_cond2,
+            )
+            results: list[ModelResult] = [model.fit(design) for model in MODELS]
+            bics: np.ndarray = np.array([result.bic for result in results], dtype=float)
             weights: np.ndarray = akaike_weights_from_bics(bics)
-            if np.max(weights) < self.BIC_cutoff:
-                best: M0 = M0()
+            best_result: ModelResult | M0
+            if float(np.nanmax(weights)) < self.BIC_cutoff:
+                best_result = M0()
                 chosen_model_biw: float = np.nan
                 model: int = 0
             else:
-                pick: int = int(np.argmax(weights))
-                best: BaseModel = results[pick]
-                chosen_model_biw: np.ndarray = weights[pick]
-                model: int = best.name
+                pick: int = int(np.nanargmax(weights))
+                best_result = results[pick]
+                chosen_model_biw = float(weights[pick])
+                model = int(best_result.name)
+            weight_columns = _weight_mapping(model_ids, weights)
             rows.append(
                 {
                     "gene": gene,
                     "model": model,
                     "chosen_model_bicw": chosen_model_biw,
                     # "weight": weights[pick],
-                    **{f"w_model{i}": weights[i - 1] for i in range(1, 6)},
-                    "alpha_phase": best.alpha_phase,
-                    "alpha_amp": best.alpha_amp,
-                    "beta_phase": best.beta_phase,
-                    "beta_amp": best.beta_amp,
+                    **weight_columns,
+                    "alpha_phase": best_result.alpha_phase,
+                    "alpha_amp": best_result.alpha_amp,
+                    "beta_phase": best_result.beta_phase,
+                    "beta_amp": best_result.beta_amp,
                 },
             )
 
@@ -349,10 +575,20 @@ def rhythmic_genes_expressed_both(self) -> pd.DataFrame:
         return df_results
 
     def rhythmic_genes_expressed_cond1(self) -> pd.DataFrame:
+        """
+        Evaluate rhythmicity for genes uniquely expressed in condition 1.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Per-gene summaries containing model identity, weights, and fitted parameters.
+
+        """
         df: pd.DataFrame = self.df
         mask: pd.Series = (df["is_expressed_cond1"]) & ~(df["is_expressed_cond2"])
         df_to_analyse: pd.DataFrame = df[mask].reset_index(drop=True)
 
+        model_ids: list[int] = [model.name for model in MODELS_ONE_CONDITION]
         rows: list[dict] = []
         for gene, row in tqdm(
             df_to_analyse.set_index("Genes").iterrows(),
@@ -361,27 +597,29 @@ def rhythmic_genes_expressed_cond1(self) -> pd.DataFrame:
         ):
             alpha_vec: np.ndarray = row[self.columns_cond1].to_numpy(float)
             design: pd.DataFrame = build_design_cond1(alpha_vec, self.t_cond1)
-            results: list[BaseModelOneCondition] = [m.fit(design) for m in MODELS_ONE_CONDITION]
-            bics: np.ndarray = np.array([r.bic for r in results])
+            results: list[ModelResultOneCondition] = [model.fit(design) for model in MODELS_ONE_CONDITION]
+            bics: np.ndarray = np.array([result.bic for result in results], dtype=float)
             weights: np.ndarray = akaike_weights_from_bics(bics)
-            if np.max(weights) < self.BIC_cutoff:
-                best: M0 = M0()
+            best_result: ModelResultOneCondition | M0
+            if float(np.nanmax(weights)) < self.BIC_cutoff:
+                best_result = M0()
                 chosen_model_biw: float = np.nan
                 model: int = 0
             else:
-                pick: int = int(np.argmax(weights))
-                best: BaseModel = results[pick]
-                chosen_model_biw: np.ndarray = weights[pick]
-                model: int = [1, 3][pick]
+                pick: int = int(np.nanargmax(weights))
+                best_result = results[pick]
+                chosen_model_biw = float(weights[pick])
+                model = int(best_result.name)
+            weight_columns = _weight_mapping(model_ids, weights)
             rows.append(
                 {
                     "gene": gene,
                     "model": model,
                     "chosen_model_bicw": chosen_model_biw,
                     # "weight": weights[pick],
-                    **{f"w_model{model}": weights[i - 1] for i, model in enumerate([1, 3])},
-                    "alpha_phase": best.phase,
-                    "alpha_amp": best.amp,
+                    **weight_columns,
+                    "alpha_phase": getattr(best_result, "phase", np.nan),
+                    "alpha_amp": getattr(best_result, "amp", np.nan),
                     "beta_phase": np.nan,
                     "beta_amp": np.nan,
                 },
@@ -393,10 +631,20 @@ def rhythmic_genes_expressed_cond1(self) -> pd.DataFrame:
         return df_results
 
     def rhythmic_genes_expressed_cond2(self) -> pd.DataFrame:
+        """
+        Evaluate rhythmicity for genes uniquely expressed in condition 2.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Per-gene summaries containing model identity, weights, and fitted parameters.
+
+        """
         df: pd.DataFrame = self.df
         mask: pd.Series = ~(df["is_expressed_cond1"]) & (df["is_expressed_cond2"])
         df_to_analyse: pd.DataFrame = df[mask].reset_index(drop=True)
 
+        model_ids: list[int] = [model.name for model in MODELS_ONE_CONDITION]
         rows: list[dict] = []
         for gene, row in tqdm(
             df_to_analyse.set_index("Genes").iterrows(),
@@ -405,29 +653,31 @@ def rhythmic_genes_expressed_cond2(self) -> pd.DataFrame:
         ):
             beta_vec: np.ndarray = row[self.columns_cond2].to_numpy(float)
             design: pd.DataFrame = build_design_cond2(beta_vec, self.t_cond2)
-            results: list[BaseModelOneCondition] = [m.fit(design) for m in MODELS_ONE_CONDITION]
-            bics: np.ndarray = np.array([r.bic for r in results])
+            results: list[ModelResultOneCondition] = [model.fit(design) for model in MODELS_ONE_CONDITION]
+            bics: np.ndarray = np.array([result.bic for result in results], dtype=float)
             weights: np.ndarray = akaike_weights_from_bics(bics)
-            if np.max(weights) < self.BIC_cutoff:
-                best: M0 = M0()
+            best_result: ModelResultOneCondition | M0
+            if float(np.nanmax(weights)) < self.BIC_cutoff:
+                best_result = M0()
                 chosen_model_biw: float = np.nan
                 model: int = 0
             else:
-                pick: int = int(np.argmax(weights))
-                best: BaseModel = results[pick]
-                chosen_model_biw: np.ndarray = weights[pick]
-                model: int = [1, 2][pick]
+                pick: int = int(np.nanargmax(weights))
+                best_result = results[pick]
+                chosen_model_biw = float(weights[pick])
+                model = int(best_result.name)
+            weight_columns = _weight_mapping(model_ids, weights)
             rows.append(
                 {
                     "gene": gene,
                     "model": model,
                     "chosen_model_bicw": chosen_model_biw,
                     # "weight": weights[pick],
-                    **{f"w_model{model}": weights[i - 1] for i, model in enumerate([1, 2])},
+                    **weight_columns,
                     "alpha_phase": np.nan,
                     "alpha_amp": np.nan,
-                    "beta_phase": best.phase,
-                    "beta_amp": best.amp,
+                    "beta_phase": getattr(best_result, "phase", np.nan),
+                    "beta_amp": getattr(best_result, "amp", np.nan),
                 },
             )
 
@@ -437,14 +687,34 @@ def rhythmic_genes_expressed_cond2(self) -> pd.DataFrame:
         return df_results
 
     def extract_all_circadian_params(self) -> pd.DataFrame:
+        """
+        Combine rhythmicity results from all subsets into a single table.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Dataset joined with cosinor parameters and model weights.
+
+        """
         rhythmic_analysis_expressed_both = self.rhythmic_genes_expressed_both()
         rhythmic_analysis_cond1 = self.rhythmic_genes_expressed_cond1()
 
         rhythmic_analysis_cond2 = self.rhythmic_genes_expressed_cond2()
 
-        results_total = pd.concat([rhythmic_analysis_expressed_both, rhythmic_analysis_cond1, rhythmic_analysis_cond2])
+        results_total = pd.concat(
+            [
+                rhythmic_analysis_expressed_both,
+                rhythmic_analysis_cond1,
+                rhythmic_analysis_cond2,
+            ],
+        )
 
-        df_pre_export = self.df.merge(results_total, left_on="Genes", right_on="gene", how="right")
+        df_pre_export = self.df.merge(
+            results_total,
+            left_on="Genes",
+            right_on="gene",
+            how="right",
+        )
         column_list: list = [
             "Genes",
             *self.columns_cond1,
@@ -470,8 +740,32 @@ def extract_all_circadian_params(self) -> pd.DataFrame:
         return df_export
 
 
-@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
+@pydantic_dataclass(config=ConfigDict(arbitrary_types_allowed=True))
 class OmicsHeatmap:
+    """
+    Generate clustered heatmaps highlighting rhythmic expression patterns.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Source table with model classifications and expression data.
+    columns_cond1 : list[str]
+        Column names for condition 1 replicates.
+    columns_cond2 : list[str]
+        Column names for condition 2 replicates.
+    t_cond1 : numpy.ndarray
+        Zeitgeber time points for condition 1 samples.
+    t_cond2 : numpy.ndarray
+        Zeitgeber time points for condition 2 samples.
+    cond1_label : str, optional
+        Human-readable label for condition 1, by default ``"cond1"``.
+    cond2_label : str, optional
+        Human-readable label for condition 2, by default ``"cond2"``.
+    show_unexpressed : bool, optional
+        Whether to include non-expressed entries when plotting, by default ``True``.
+
+    """
+
     df: pd.DataFrame
 
     columns_cond1: list[str]
@@ -483,10 +777,28 @@ class OmicsHeatmap:
 
     show_unexpressed: bool = True
 
-    # --- validators ---
     @field_validator("t_cond1", "t_cond2", mode="before")
     @classmethod
-    def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
+    def _to_1d_f64(cls, v: object) -> np.ndarray:
+        """
+        Coerce input to a one-dimensional ``float64`` NumPy array.
+
+        Parameters
+        ----------
+        v : object
+            Sequence-like structure representing time points.
+
+        Returns
+        -------
+        numpy.ndarray
+            Flattened array in ``float64`` precision.
+
+        Raises
+        ------
+        ValueError
+            If ``v`` cannot be interpreted as a one-dimensional array.
+
+        """
         a = np.asarray(v, dtype=np.float64)
         if a.ndim != 1:
             text: str = "expected 1D array"
@@ -495,23 +807,53 @@ def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
 
     @model_validator(mode="after")
     def _check_columns(self) -> Self:
+        """
+        Confirm that required expression columns exist in the DataFrame.
+
+        Returns
+        -------
+        Self
+            The validated :class:`OmicsHeatmap` instance.
+
+        Raises
+        ------
+        ValueError
+            If any specified column names are absent.
+
+        """
         missing = [c for c in (self.columns_cond1 + self.columns_cond2) if c not in self.df.columns]
         if missing:
-            text = f"Missing columns: {missing}"  # satisfies EM101 (no string literal in raise)
+            text = f"Missing columns: {missing}"
             raise ValueError(text)
         return self
 
-    def timepoint_means(self, df: pd.DataFrame, columns: list[str], times: np.ndarray) -> np.ndarray:
+    def timepoint_means(
+        self,
+        df: pd.DataFrame,
+        columns: list[str],
+        times: np.ndarray,
+    ) -> np.ndarray:
         """
-        Compute mean expression across columns at each unique timepoint.
-
-        Args:
-            df: DataFrame with expression values.
-            columns: Subset of column names to use.
-            times: 1D array of timepoints, length must equal len(columns).
-
-        Returns:
-            np.ndarray of shape (n_genes, n_unique_times).
+        Average replicates at identical time points for a collection of genes.
+
+        Parameters
+        ----------
+        df : pandas.DataFrame
+            Table containing the expression measurements.
+        columns : list[str]
+            Subset of column names whose values should be aggregated.
+        times : numpy.ndarray
+            Zeitgeber time labels corresponding to ``columns``.
+
+        Returns
+        -------
+        numpy.ndarray
+            Array where each column represents the mean expression at a unique time.
+
+        Raises
+        ------
+        ValueError
+            If the number of columns differs from the number of time labels provided.
 
         """
         if len(columns) != len(times):
@@ -528,41 +870,76 @@ def timepoint_means(self, df: pd.DataFrame, columns: list[str], times: np.ndarra
         return result
 
     def get_z_score(self, arr: np.ndarray) -> np.ndarray:
-        """Compute z-score normalization for each row in a 2D array."""
-        arr: np.ndarray = (arr - np.mean(arr, axis=1).reshape(-1, 1)) / np.where(
-            np.std(arr, axis=1).reshape(-1, 1) == 0,
-            1,
-            np.std(arr, axis=1).reshape(-1, 1),
-        )
-        return arr
+        """
+        Z-score normalize each gene profile independently.
+
+        Parameters
+        ----------
+        arr : numpy.ndarray
+            Matrix of expression values where rows correspond to genes.
 
-    def plot_heatmap(self, cmap: str = "bwr") -> None:
+        Returns
+        -------
+        numpy.ndarray
+            Z-score normalized matrix preserving the original shape.
+
+        """
+        means: np.ndarray = np.mean(arr, axis=1, keepdims=True)
+        stds: np.ndarray = np.std(arr, axis=1, keepdims=True)
+        safe_stds: np.ndarray = np.where(stds == 0, 1, stds)
+        return (arr - means) / safe_stds
+
+    def plot_heatmap(self, cmap: str = "bwr") -> plt.Figure:  # noqa: PLR0915
+        """
+        Render the full alpha/beta heatmap split by rhythmic subclasses.
+
+        Parameters
+        ----------
+        cmap : str, optional
+            Matplotlib colormap name used for heat intensity, by default ``"bwr"``.
+
+        Returns
+        -------
+        matplotlib.figure.Figure
+            Figure containing the subplot grid of heatmaps.
+
+        """
         df: pd.DataFrame = self.df
-        df: pd.DataFrame = df.sort_values(by=["alpha_phase", "beta_phase"]).reset_index(drop=True)
+        df_sorted: pd.DataFrame = df.sort_values(by=["alpha_phase", "beta_phase"]).reset_index(
+            drop=True,
+        )
 
         t_unique: np.ndarray = np.unique(self.t_cond1).astype(int)
 
-        mean_cond1: np.ndarray = self.timepoint_means(df, self.columns_cond1, self.t_cond1)
-        mean_cond2: np.ndarray = self.timepoint_means(df, self.columns_cond2, self.t_cond2)
+        mean_cond1: np.ndarray = self.timepoint_means(
+            df_sorted,
+            self.columns_cond1,
+            self.t_cond1,
+        )
+        mean_cond2: np.ndarray = self.timepoint_means(
+            df_sorted,
+            self.columns_cond2,
+            self.t_cond2,
+        )
 
         z_cond1: np.ndarray = self.get_z_score(mean_cond1)
         z_cond2: np.ndarray = self.get_z_score(mean_cond2)
 
-        total_rows: int = (df["model"].isin([2, 3, 4, 5])).sum()
+        total_rows: int = (df_sorted["model"].isin([2, 3, 4, 5])).sum()
 
         m2: int = 2
         m3: int = 3
         m4: int = 4
         m5: int = 5
 
-        n_m2a: int = ((df["model"] == m2) & (df["subclass"] == "b")).sum()
-        n_m2b: int = ((df["model"] == m2) & (df["subclass"] == "c")).sum()
-        n_m3a: int = ((df["model"] == m3) & (df["subclass"] == "a")).sum()
-        n_m3b: int = ((df["model"] == m3) & (df["subclass"] == "c")).sum()
-        n_m4: int = (df["model"] == m4).sum()
-        n_m5: int = (df["model"] == m5).sum()
+        n_m2a: int = ((df_sorted["model"] == m2) & (df_sorted["subclass"] == "b")).sum()
+        n_m2b: int = ((df_sorted["model"] == m2) & (df_sorted["subclass"] == "c")).sum()
+        n_m3a: int = ((df_sorted["model"] == m3) & (df_sorted["subclass"] == "a")).sum()
+        n_m3b: int = ((df_sorted["model"] == m3) & (df_sorted["subclass"] == "c")).sum()
+        n_m4: int = (df_sorted["model"] == m4).sum()
+        n_m5: int = (df_sorted["model"] == m5).sum()
 
-        _fig, axes = plt.subplots(
+        fig, axes = plt.subplots(
             nrows=6,
             ncols=2,
             gridspec_kw={
@@ -574,19 +951,19 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
                     n_m4 / total_rows,
                     n_m5 / total_rows,
                 ],
-                "width_ratios": [1, 1],  # Equal column widths
+                "width_ratios": [1, 1],
             },
-            figsize=(12 / 2.54, 18 / 2.54),  # Adjust figure size as needed
+            figsize=(12 / 2.54, 18 / 2.54),
         )
 
         vmin_global = -2.5
         vmax_global = 2.5
 
-        mask = (df["model"] == m2) & (df["subclass"] == "b")
+        mask = (df_sorted["model"] == m2) & (df_sorted["subclass"] == "b")
         z_cond1_filtered = z_cond1[mask.to_numpy()].copy()
         if not self.show_unexpressed:
             z_cond1_filtered[:] = 0
-        im1 = axes[0, 0].imshow(
+        axes[0, 0].imshow(
             z_cond1_filtered,
             aspect="auto",
             cmap=cmap,
@@ -600,21 +977,20 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[0, 0].set_xticks([])
         axes[0, 0].set_yticks([])
 
-        # Add text to the left of the y-axis
         axes[0, 0].text(
             -0.2,
             0.5,
-            "M2a",  # Coordinates: (x, y)
-            transform=axes[0, 0].transAxes,  # Use axis-relative coordinates
+            "M2a",
+            transform=axes[0, 0].transAxes,
             ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
+            va="center",
+            rotation=0,
+            fontsize=8,
         )
 
-        mask = (df["model"] == m2) & (df["subclass"] == "c")
+        mask = (df_sorted["model"] == m2) & (df_sorted["subclass"] == "c")
         z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im2 = axes[1, 0].imshow(
+        axes[1, 0].imshow(
             z_cond1_filtered,
             aspect="auto",
             cmap=cmap,
@@ -626,20 +1002,19 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[1, 0].set_xticks([])
         axes[1, 0].set_yticks([])
 
-        # Add text to the left of the y-axis
         axes[1, 0].text(
             -0.2,
             0.5,
-            "M2b",  # Coordinates: (x, y)
-            transform=axes[1, 0].transAxes,  # Use axis-relative coordinates
+            "M2b",
+            transform=axes[1, 0].transAxes,
             ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
+            va="center",
+            rotation=0,
+            fontsize=8,
         )
-        mask = (df["model"] == m3) & (df["subclass"] == "a")
+        mask = (df_sorted["model"] == m3) & (df_sorted["subclass"] == "a")
         z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im2 = axes[2, 0].imshow(
+        axes[2, 0].imshow(
             z_cond1_filtered,
             aspect="auto",
             cmap=cmap,
@@ -651,20 +1026,19 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[2, 0].set_xticks([])
         axes[2, 0].set_yticks([])
 
-        # Add text to the left of the y-axis
         axes[2, 0].text(
             -0.2,
             0.5,
-            "M3a",  # Coordinates: (x, y)
-            transform=axes[2, 0].transAxes,  # Use axis-relative coordinates
+            "M3a",
+            transform=axes[2, 0].transAxes,
             ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
+            va="center",
+            rotation=0,
+            fontsize=8,
         )
-        mask = (df["model"] == m3) & (df["subclass"] == "c")
+        mask = (df_sorted["model"] == m3) & (df_sorted["subclass"] == "c")
         z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im3 = axes[3, 0].imshow(
+        axes[3, 0].imshow(
             z_cond1_filtered,
             aspect="auto",
             cmap=cmap,
@@ -675,21 +1049,21 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         )
         axes[3, 0].set_xticks([])
         axes[3, 0].set_yticks([])
-        # Add text to the left of the y-axis
+
         axes[3, 0].text(
             -0.2,
             0.5,
-            "M3b",  # Coordinates: (x, y)
-            transform=axes[3, 0].transAxes,  # Use axis-relative coordinates
+            "M3b",
+            transform=axes[3, 0].transAxes,
             ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
+            va="center",
+            rotation=0,
+            fontsize=8,
         )
 
-        mask = df["model"] == m4
+        mask = df_sorted["model"] == m4
         z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im4 = axes[4, 0].imshow(
+        axes[4, 0].imshow(
             z_cond1_filtered,
             aspect="auto",
             cmap=cmap,
@@ -704,17 +1078,17 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[4, 0].text(
             -0.2,
             0.5,
-            "M4",  # Coordinates: (x, y)
-            transform=axes[4, 0].transAxes,  # Use axis-relative coordinates
+            "M4",
+            transform=axes[4, 0].transAxes,
             ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
+            va="center",
+            rotation=0,
+            fontsize=8,
         )
 
-        mask = df["model"] == m5
+        mask = df_sorted["model"] == m5
         z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im5 = axes[5, 0].imshow(
+        axes[5, 0].imshow(
             z_cond1_filtered,
             aspect="auto",
             cmap=cmap,
@@ -731,17 +1105,17 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[5, 0].text(
             -0.2,
             0.5,
-            "M5",  # Coordinates: (x, y)
-            transform=axes[5, 0].transAxes,  # Use axis-relative coordinates
+            "M5",
+            transform=axes[5, 0].transAxes,
             ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
+            va="center",
+            rotation=0,
+            fontsize=8,
         )
 
-        mask = (df["model"] == m2) & (df["subclass"] == "b")
+        mask = (df_sorted["model"] == m2) & (df_sorted["subclass"] == "b")
         z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im6 = axes[0, 1].imshow(
+        axes[0, 1].imshow(
             z_cond2_filtered,
             aspect="auto",
             cmap=cmap,
@@ -755,9 +1129,9 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[0, 1].set_xticks([])
         axes[0, 1].set_yticks([])
 
-        mask = (df["model"] == m2) & (df["subclass"] == "c")
+        mask = (df_sorted["model"] == m2) & (df_sorted["subclass"] == "c")
         z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im7 = axes[1, 1].imshow(
+        axes[1, 1].imshow(
             z_cond2_filtered,
             aspect="auto",
             cmap=cmap,
@@ -770,11 +1144,11 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[1, 1].set_xticks([])
         axes[1, 1].set_yticks([])
 
-        mask = (df["model"] == m3) & (df["subclass"] == "a")
+        mask = (df_sorted["model"] == m3) & (df_sorted["subclass"] == "a")
         z_cond2_filtered = z_cond2[mask.to_numpy()].copy()
         if not self.show_unexpressed:
             z_cond2_filtered[:] = 0
-        im8 = axes[2, 1].imshow(
+        axes[2, 1].imshow(
             z_cond2_filtered,
             aspect="auto",
             cmap=cmap,
@@ -787,9 +1161,9 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[2, 1].set_xticks([])
         axes[2, 1].set_yticks([])
 
-        mask = (df["model"] == m3) & (df["subclass"] == "c")
+        mask = (df_sorted["model"] == m3) & (df_sorted["subclass"] == "c")
         z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im9 = axes[3, 1].imshow(
+        axes[3, 1].imshow(
             z_cond2_filtered,
             aspect="auto",
             cmap=cmap,
@@ -802,9 +1176,9 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[3, 1].set_xticks([])
         axes[3, 1].set_yticks([])
 
-        mask = df["model"] == m4
+        mask = df_sorted["model"] == m4
         z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im10 = axes[4, 1].imshow(
+        axes[4, 1].imshow(
             z_cond2_filtered,
             aspect="auto",
             cmap=cmap,
@@ -817,9 +1191,9 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[4, 1].set_xticks([])
         axes[4, 1].set_yticks([])
 
-        mask = df["model"] == m5
+        mask = df_sorted["model"] == m5
         z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im11 = axes[5, 1].imshow(
+        axes[5, 1].imshow(
             z_cond2_filtered,
             aspect="auto",
             cmap=cmap,
@@ -833,9 +1207,35 @@ def plot_heatmap(self, cmap: str = "bwr") -> None:
         axes[5, 1].set_yticks([])
         axes[5, 1].set_xlabel("Time(h)")
 
+        return fig
 
-@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
+
+@pydantic_dataclass(config=ConfigDict(arbitrary_types_allowed=True))
 class TimeSeriesExample:
+    """
+    Plot raw observations alongside cosinor model predictions for genes.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Table containing expression measurements and model metadata.
+    columns_cond1 : list[str]
+        Column names for condition 1 samples.
+    columns_cond2 : list[str]
+        Column names for condition 2 samples.
+    t_cond1 : numpy.ndarray
+        Zeitgeber times corresponding to condition 1 measurements.
+    t_cond2 : numpy.ndarray
+        Zeitgeber times corresponding to condition 2 measurements.
+    cond1_label : str, optional
+        Display label for condition 1, by default ``"cond1"``.
+    cond2_label : str, optional
+        Display label for condition 2, by default ``"cond2"``.
+    deduplicate_on_init : bool, optional
+        Whether the underlying dataset should deduplicate genes immediately, by default ``False``.
+
+    """
+
     df: pd.DataFrame
 
     columns_cond1: list[str]
@@ -847,10 +1247,28 @@ class TimeSeriesExample:
 
     deduplicate_on_init: bool = False
 
-    # --- validators ---
     @field_validator("t_cond1", "t_cond2", mode="before")
     @classmethod
-    def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
+    def _to_1d_f64(cls, v: object) -> np.ndarray:
+        """
+        Convert an iterable of time points into a one-dimensional ``float64`` array.
+
+        Parameters
+        ----------
+        v : object
+            Sequence-like input representing time points.
+
+        Returns
+        -------
+        numpy.ndarray
+            Flattened array of times in ``float64`` precision.
+
+        Raises
+        ------
+        ValueError
+            If the supplied object cannot be interpreted as one-dimensional.
+
+        """
         a = np.asarray(v, dtype=np.float64)
         if a.ndim != 1:
             text: str = "expected 1D array"
@@ -859,13 +1277,43 @@ def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
 
     @model_validator(mode="after")
     def _check_columns(self) -> Self:
+        """
+        Ensure both condition-specific column sets appear in the DataFrame.
+
+        Returns
+        -------
+        Self
+            The validated :class:`TimeSeriesExample` instance.
+
+        Raises
+        ------
+        ValueError
+            If any required column is missing from ``df``.
+
+        """
         missing = [c for c in (self.columns_cond1 + self.columns_cond2) if c not in self.df.columns]
         if missing:
-            text = f"Missing columns: {missing}"  # satisfies EM101 (no string literal in raise)
+            text = f"Missing columns: {missing}"
             raise ValueError(text)
         return self
 
     def plot_time_series(self, gene: str, xticks: np.ndarray | None = None) -> None:
+        """
+        Visualize observed expression values with corresponding model fits.
+
+        Parameters
+        ----------
+        gene : str
+            Gene identifier to visualize.
+        xticks : numpy.ndarray | None, optional
+            Custom x-axis tick positions, by default ``None`` for automatic values.
+
+        Raises
+        ------
+        ValueError
+            If the requested gene is absent from the DataFrame.
+
+        """
         if xticks is None:
             xticks = np.unique(np.concatenate((self.t_cond1, self.t_cond2))).astype(int)
         df: pd.DataFrame = self.df
@@ -910,7 +1358,7 @@ def plot_time_series(self, gene: str, xticks: np.ndarray | None = None) -> None:
         plt.plot(t_test, y_test_cond1)
         plt.ylabel("Expression Level")
         plt.xticks(xticks)
-        # plt.xlim(xticks[0], xticks[-1])
+
         plt.title(f"Time Series for {gene}")
         plt.xlabel("Time (h)")
         plt.subplot(1, 2, 2)
@@ -920,7 +1368,10 @@ def plot_time_series(self, gene: str, xticks: np.ndarray | None = None) -> None:
         plt.xlabel("Time (h)")
 
         plt.xticks(xticks)
-        plt.xlim(xticks[0] - 0.05 * (xticks[-1] - xticks[0]), xticks[-1] + 0.05 * (xticks[-1] - xticks[0]))
+        plt.xlim(
+            xticks[0] - 0.05 * (xticks[-1] - xticks[0]),
+            xticks[-1] + 0.05 * (xticks[-1] - xticks[0]),
+        )
         plt.tight_layout()
         plt.show()
 
@@ -932,8 +1383,32 @@ def get_test_function_expressed_both(
         t_cond2: np.ndarray,
         model: int,
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Produce fitted curves for genes expressed in both conditions.
+
+        Parameters
+        ----------
+        alpha_vec : numpy.ndarray
+            Expression values for condition 1 samples.
+        beta_vec : numpy.ndarray
+            Expression values for condition 2 samples.
+        t_cond1 : numpy.ndarray
+            Zeitgeber times for ``alpha_vec``.
+        t_cond2 : numpy.ndarray
+            Zeitgeber times for ``beta_vec``.
+        model : int
+            Model identifier selected for the gene.
+
+        Returns
+        -------
+        tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
+            Common time grid plus fitted values for condition 1 and condition 2.
+
+        """
         design: pd.DataFrame = build_design(alpha_vec, beta_vec, t_cond1, t_cond2)
         t_test: np.ndarray = np.linspace(0, 24, 100)
+        y_test_cond1: np.ndarray
+        y_test_cond2: np.ndarray
         if model == 0:
             print("No model selected")
             y_test_cond1 = np.full_like(t_test, np.nan)
@@ -941,8 +1416,12 @@ def get_test_function_expressed_both(
         else:
             model_formula: str = MODELS[model - 1].formula
             res = smf.ols(model_formula, data=design).fit()
-            df_cond1: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "alpha"}).dropna()
-            df_cond2: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "beta"}).dropna()
+            df_cond1: pd.DataFrame = pd.DataFrame(
+                {"time": t_test, "dataset": "alpha"},
+            ).dropna()
+            df_cond2: pd.DataFrame = pd.DataFrame(
+                {"time": t_test, "dataset": "beta"},
+            ).dropna()
             df_test: pd.DataFrame = pd.concat([df_cond1, df_cond2], ignore_index=True)
             df_test["constant"] = 1.0
             df_test["cos_wt"] = np.cos(W * df_test["time"].to_numpy().astype(float))
@@ -950,8 +1429,8 @@ def get_test_function_expressed_both(
             df_test["is_alpha"] = (df_test["dataset"] == "alpha").astype(int)
             df_test["is_beta"] = (df_test["dataset"] == "beta").astype(int)
             y_test = res.predict(exog=df_test)
-            y_test_cond1: np.ndarray = y_test[df_test["dataset"] == "alpha"].to_numpy()
-            y_test_cond2: np.ndarray = y_test[df_test["dataset"] == "beta"].to_numpy()
+            y_test_cond1 = y_test[df_test["dataset"] == "alpha"].to_numpy()
+            y_test_cond2 = y_test[df_test["dataset"] == "beta"].to_numpy()
         return t_test, y_test_cond1, y_test_cond2
 
     def get_test_function_expressed_cond1(
@@ -960,8 +1439,28 @@ def get_test_function_expressed_cond1(
         t_cond1: np.ndarray,
         model: int,
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Produce fitted curves for genes expressed only in condition 1.
+
+        Parameters
+        ----------
+        alpha_vec : numpy.ndarray
+            Expression values for condition 1 samples.
+        t_cond1 : numpy.ndarray
+            Zeitgeber times for ``alpha_vec``.
+        model : int
+            Model identifier selected for the gene.
+
+        Returns
+        -------
+        tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
+            Common time grid, fitted values for condition 1, and ``nan`` placeholders for condition 2.
+
+        """
         design: pd.DataFrame = build_design_cond1(alpha_vec, t_cond1)
         t_test: np.ndarray = np.linspace(0, 24, 100)
+        y_test_cond1: np.ndarray
+        y_test_cond2: np.ndarray
         if model == 0:
             print("No model selected")
             y_test_cond1 = np.full_like(t_test, np.nan)
@@ -969,18 +1468,18 @@ def get_test_function_expressed_cond1(
         else:
             print(f"Fitting model {model}")
             print(MODELS_ONE_CONDITION)
-            if model == 1:
-                model_formula: str = MODELS_ONE_CONDITION[0].formula
-            else:
-                model_formula: str = MODELS_ONE_CONDITION[1].formula
+            model_index: int = 0 if model == 1 else 1
+            model_formula: str = MODELS_ONE_CONDITION[model_index].formula
             res = smf.ols(model_formula, data=design).fit()
-            df_test: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "alpha"}).dropna()
+            df_test: pd.DataFrame = pd.DataFrame(
+                {"time": t_test, "dataset": "alpha"},
+            ).dropna()
             df_test["constant"] = 1.0
             df_test["cos_wt"] = np.cos(W * df_test["time"].to_numpy().astype(float))
             df_test["sin_wt"] = np.sin(W * df_test["time"].to_numpy().astype(float))
-            y_test = res.predict(exog=df_test)
-            y_test_cond1: np.ndarray = y_test.to_numpy()
-            y_test_cond2: np.ndarray = np.full_like(t_test, np.nan)
+            y_test = res.predict(exog=df_test).to_numpy()
+            y_test_cond1 = y_test
+            y_test_cond2 = np.full_like(t_test, np.nan)
         return t_test, y_test_cond1, y_test_cond2
 
     def get_test_function_expressed_cond2(
@@ -989,8 +1488,28 @@ def get_test_function_expressed_cond2(
         t_cond2: np.ndarray,
         model: int,
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Produce fitted curves for genes expressed only in condition 2.
+
+        Parameters
+        ----------
+        beta_vec : numpy.ndarray
+            Expression values for condition 2 samples.
+        t_cond2 : numpy.ndarray
+            Zeitgeber times for ``beta_vec``.
+        model : int
+            Model identifier selected for the gene.
+
+        Returns
+        -------
+        tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
+            Common time grid, ``nan`` placeholders for condition 1, and fitted values for condition 2.
+
+        """
         design: pd.DataFrame = build_design_cond2(beta_vec, t_cond2)
         t_test: np.ndarray = np.linspace(0, 24, 100)
+        y_test_cond1: np.ndarray
+        y_test_cond2: np.ndarray
         if model == 0:
             print("No model selected")
             y_test_cond1 = np.full_like(t_test, np.nan)
@@ -998,17 +1517,17 @@ def get_test_function_expressed_cond2(
         else:
             print(f"Fitting model {model}")
             print(MODELS_ONE_CONDITION)
-            if model == 1:
-                model_formula: str = MODELS_ONE_CONDITION[0].formula
-            else:
-                model_formula: str = MODELS_ONE_CONDITION[1].formula
+            model_index: int = 0 if model == 1 else 1
+            model_formula: str = MODELS_ONE_CONDITION[model_index].formula
             res = smf.ols(model_formula, data=design).fit()
-            df_test: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "alpha"}).dropna()
+            df_test: pd.DataFrame = pd.DataFrame(
+                {"time": t_test, "dataset": "alpha"},
+            ).dropna()
             df_test["constant"] = 1.0
             df_test["cos_wt"] = np.cos(W * df_test["time"].to_numpy().astype(float))
             df_test["sin_wt"] = np.sin(W * df_test["time"].to_numpy().astype(float))
-            y_test = res.predict(exog=df_test)
-            y_test_cond1: np.ndarray = np.full_like(t_test, np.nan)
-            y_test_cond2: np.ndarray = y_test.to_numpy()
+            y_test = res.predict(exog=df_test).to_numpy()
+            y_test_cond1 = np.full_like(t_test, np.nan)
+            y_test_cond2 = y_test
 
         return t_test, y_test_cond1, y_test_cond2
diff --git a/src/cosinor_lite/states_info.py b/src/cosinor_lite/states_info.py
deleted file mode 100644
index 63acc75..0000000
--- a/src/cosinor_lite/states_info.py
+++ /dev/null
@@ -1,25 +0,0 @@
-"""Utility functions for working with cities and states."""
-
-import json
-from pathlib import Path
-from typing import List
-
-THIS_DIR = Path(__file__).parent
-CITIES_JSON_FPATH = THIS_DIR / "cities.json"
-
-
-def is_city_capitol_of_state(city_name: str, state: str) -> bool:
-    """Return True if `city_name` is the capitol of `state`."""
-    cities_json_contents = CITIES_JSON_FPATH.read_text()
-    cities: List[dict] = json.loads(cities_json_contents)
-    matching_cities: List[dict] = [city for city in cities if city["city"] == city_name]
-    if len(matching_cities) == 0:
-        return False
-    matched_city = matching_cities[0]
-    return matched_city["state"] == state
-
-
-# pylint: disable=invalid-name
-def slow_add(a: int, b: int) -> int:
-    """Return the sum of `a` and `b`."""
-    return a + b
diff --git a/src/cosinor_lite/utils.py b/src/cosinor_lite/utils.py
deleted file mode 100644
index a71df0d..0000000
--- a/src/cosinor_lite/utils.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import numpy as np
-import pandas as pd
-
-W: float = 2 * np.pi / 24.0
-RAD2H: float = 24.0 / (2.0 * np.pi)
-
-
-def phase_from_ab(a: float, b: float) -> float:
-    return (np.arctan2(b, a) * RAD2H) % 24.0
-
-
-def amp_from_ab(a: float, b: float) -> float:
-    return float(np.hypot(a, b))
-
-
-def bic(llf: float, k: int, n: int) -> float:
-    return k * np.log(n) - 2.0 * llf
-
-
-def akaike_weights_from_bics(bics: np.ndarray) -> np.ndarray:
-    d: np.ndarray = bics - np.nanmin(bics)
-    w: np.ndarray = np.exp(-0.5 * d)
-    return w / np.nansum(w)
-
-
-def build_design(
-    alpha_vals: np.ndarray,
-    beta_vals: np.ndarray,
-    t_cond1: np.ndarray,
-    t_cond2: np.ndarray,
-) -> pd.DataFrame:
-    df_cond1: pd.DataFrame = pd.DataFrame({"y": alpha_vals, "time": t_cond1, "dataset": "alpha"}).dropna()
-    df_cond2: pd.DataFrame = pd.DataFrame({"y": beta_vals, "time": t_cond2, "dataset": "beta"}).dropna()
-    df: pd.DataFrame = pd.concat([df_cond1, df_cond2], ignore_index=True)
-    df["constant"] = 1.0
-    df["cos_wt"] = np.cos(W * df["time"].to_numpy().astype(float))
-    df["sin_wt"] = np.sin(W * df["time"].to_numpy().astype(float))
-    df["is_alpha"] = (df["dataset"] == "alpha").astype(int)
-    df["is_beta"] = (df["dataset"] == "beta").astype(int)
-    return df
-
-
-def build_design_cond1(
-    alpha_vals: np.ndarray,
-    t_cond1: np.ndarray,
-) -> pd.DataFrame:
-    df_cond1: pd.DataFrame = pd.DataFrame({"y": alpha_vals, "time": t_cond1, "dataset": "alpha"}).dropna()
-    df: pd.DataFrame = pd.concat([df_cond1], ignore_index=True)
-    df["constant"] = 1.0
-    df["cos_wt"] = np.cos(W * df["time"].to_numpy().astype(float))
-    df["sin_wt"] = np.sin(W * df["time"].to_numpy().astype(float))
-    return df
-
-
-def build_design_cond2(
-    beta_vals: np.ndarray,
-    t_cond2: np.ndarray,
-) -> pd.DataFrame:
-    df_cond2: pd.DataFrame = pd.DataFrame({"y": beta_vals, "time": t_cond2, "dataset": "beta"}).dropna()
-    df: pd.DataFrame = pd.concat([df_cond2], ignore_index=True)
-    df["constant"] = 1.0
-    df["cos_wt"] = np.cos(W * df["time"].to_numpy().astype(float))
-    df["sin_wt"] = np.sin(W * df["time"].to_numpy().astype(float))
-    return df
diff --git a/src/cosinor_lite/visualisation.py b/src/cosinor_lite/visualisation.py
deleted file mode 100644
index 996f9af..0000000
--- a/src/cosinor_lite/visualisation.py
+++ /dev/null
@@ -1,553 +0,0 @@
-from __future__ import annotations
-
-from typing import Self
-
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import statsmodels.formula.api as smf
-from pydantic import ConfigDict, field_validator, model_validator
-from pydantic.dataclasses import dataclass
-
-
-@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
-class OmicsHeatmap:
-    df: pd.DataFrame
-
-    columns_cond1: list[str]
-    columns_cond2: list[str]
-    t_cond1: np.ndarray
-    t_cond2: np.ndarray
-    cond1_label: str = "cond1"
-    cond2_label: str = "cond2"
-
-    deduplicate_on_init: bool = False
-
-    # --- validators ---
-    @field_validator("t_cond1", "t_cond2", mode="before")
-    @classmethod
-    def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
-        a = np.asarray(v, dtype=np.float64)
-        if a.ndim != 1:
-            text: str = "expected 1D array"
-            raise ValueError(text)
-        return a
-
-    @model_validator(mode="after")
-    def _check_columns(self) -> Self:
-        missing = [c for c in (self.columns_cond1 + self.columns_cond2) if c not in self.df.columns]
-        if missing:
-            text = f"Missing columns: {missing}"  # satisfies EM101 (no string literal in raise)
-            raise ValueError(text)
-        return self
-
-    def timepoint_means(self, df: pd.DataFrame, columns: list[str], times: np.ndarray) -> np.ndarray:
-        """
-        Compute mean expression across columns at each unique timepoint.
-
-        Args:
-            df: DataFrame with expression values.
-            columns: Subset of column names to use.
-            times: 1D array of timepoints, length must equal len(columns).
-
-        Returns:
-            np.ndarray of shape (n_genes, n_unique_times).
-
-        """
-        if len(columns) != len(times):
-            text: str = f"Length of columns ({len(columns)}) must match length of times ({len(times)})"
-            raise ValueError(text)
-
-        values: np.ndarray = df[columns].to_numpy()
-        unique_times: np.ndarray = np.unique(times)
-
-        result: np.ndarray = np.column_stack(
-            [values[:, times == t].mean(axis=1) for t in unique_times],
-        )
-
-        return result
-
-    def get_z_score(self, arr: np.ndarray) -> np.ndarray:
-        """Compute z-score normalization for each row in a 2D array."""
-        arr: np.ndarray = (arr - np.mean(arr, axis=1).reshape(-1, 1)) / np.where(
-            np.std(arr, axis=1).reshape(-1, 1) == 0,
-            1,
-            np.std(arr, axis=1).reshape(-1, 1),
-        )
-        return arr
-
-    def plot_heatmap(self, cmap: str = "bwr") -> None:
-        df: pd.DataFrame = self.df
-        df: pd.DataFrame = df.sort_values(by=["alpha_phase", "beta_phase"]).reset_index(drop=True)
-
-        t_unique: np.ndarray = np.unique(self.t_cond1).astype(int)
-
-        mean_cond1: np.ndarray = self.timepoint_means(df, self.columns_cond1, self.t_cond1)
-        mean_cond2: np.ndarray = self.timepoint_means(df, self.columns_cond2, self.t_cond2)
-
-        z_cond1: np.ndarray = self.get_z_score(mean_cond1)
-        z_cond2: np.ndarray = self.get_z_score(mean_cond2)
-
-        total_rows: int = (df["model"].isin([2, 3, 4, 5])).sum()
-
-        m2: int = 2
-        m3: int = 3
-        m4: int = 4
-        m5: int = 5
-
-        n_m2a: int = ((df["model"] == m2) & (df["subclass"] == "b")).sum()
-        n_m2b: int = ((df["model"] == m2) & (df["subclass"] == "c")).sum()
-        n_m3a: int = ((df["model"] == m3) & (df["subclass"] == "a")).sum()
-        n_m3b: int = ((df["model"] == m3) & (df["subclass"] == "c")).sum()
-        n_m4: int = (df["model"] == m4).sum()
-        n_m5: int = (df["model"] == m5).sum()
-
-        _fig, axes = plt.subplots(
-            nrows=6,
-            ncols=2,
-            gridspec_kw={
-                "height_ratios": [
-                    n_m2a / total_rows,
-                    n_m2b / total_rows,
-                    n_m3a / total_rows,
-                    n_m3b / total_rows,
-                    n_m4 / total_rows,
-                    n_m5 / total_rows,
-                ],
-                "width_ratios": [1, 1],  # Equal column widths
-            },
-            figsize=(12 / 2.54, 18 / 2.54),  # Adjust figure size as needed
-        )
-
-        vmin_global = -2.5
-        vmax_global = 2.5
-
-        mask = (df["model"] == m2) & (df["subclass"] == "b")
-        z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im1 = axes[0, 0].imshow(
-            z_cond1_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[0, 0].set_title("Alpha cells")
-        axes[0, 0].set_xticks([])
-        axes[0, 0].set_yticks([])
-
-        # Add text to the left of the y-axis
-        axes[0, 0].text(
-            -0.2,
-            0.5,
-            "M2a",  # Coordinates: (x, y)
-            transform=axes[0, 0].transAxes,  # Use axis-relative coordinates
-            ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
-        )
-
-        mask = (df["model"] == m2) & (df["subclass"] == "c")
-        z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im2 = axes[1, 0].imshow(
-            z_cond1_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-        axes[1, 0].set_xticks([])
-        axes[1, 0].set_yticks([])
-
-        # Add text to the left of the y-axis
-        axes[1, 0].text(
-            -0.2,
-            0.5,
-            "M2b",  # Coordinates: (x, y)
-            transform=axes[1, 0].transAxes,  # Use axis-relative coordinates
-            ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
-        )
-        mask = (df["model"] == m3) & (df["subclass"] == "a")
-        z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im2 = axes[2, 0].imshow(
-            z_cond1_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-        axes[2, 0].set_xticks([])
-        axes[2, 0].set_yticks([])
-
-        # Add text to the left of the y-axis
-        axes[2, 0].text(
-            -0.2,
-            0.5,
-            "M3a",  # Coordinates: (x, y)
-            transform=axes[2, 0].transAxes,  # Use axis-relative coordinates
-            ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
-        )
-        mask = (df["model"] == m3) & (df["subclass"] == "c")
-        z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im3 = axes[3, 0].imshow(
-            z_cond1_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-        axes[3, 0].set_xticks([])
-        axes[3, 0].set_yticks([])
-        # Add text to the left of the y-axis
-        axes[3, 0].text(
-            -0.2,
-            0.5,
-            "M3b",  # Coordinates: (x, y)
-            transform=axes[3, 0].transAxes,  # Use axis-relative coordinates
-            ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
-        )
-
-        mask = df["model"] == m4
-        z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im4 = axes[4, 0].imshow(
-            z_cond1_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-        axes[4, 0].set_xticks([])
-        axes[4, 0].set_yticks([])
-
-        axes[4, 0].text(
-            -0.2,
-            0.5,
-            "M4",  # Coordinates: (x, y)
-            transform=axes[4, 0].transAxes,  # Use axis-relative coordinates
-            ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
-        )
-
-        mask = df["model"] == m5
-        z_cond1_filtered = z_cond1[mask.to_numpy()]
-        im5 = axes[5, 0].imshow(
-            z_cond1_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[5, 0].set_xticks(range(len(t_unique)), t_unique)
-        axes[5, 0].set_yticks([])
-        axes[5, 0].set_xlabel("Time(h)")
-
-        axes[5, 0].text(
-            -0.2,
-            0.5,
-            "M5",  # Coordinates: (x, y)
-            transform=axes[5, 0].transAxes,  # Use axis-relative coordinates
-            ha="center",
-            va="center",  # Align text
-            rotation=0,  # Rotate text vertically
-            fontsize=8,  # Adjust font size as needed
-        )
-
-        mask = (df["model"] == m2) & (df["subclass"] == "b")
-        z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im6 = axes[0, 1].imshow(
-            z_cond2_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[0, 1].set_title("Beta cells")
-        axes[0, 1].set_xticks([])
-        axes[0, 1].set_yticks([])
-
-        mask = (df["model"] == m2) & (df["subclass"] == "c")
-        z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im7 = axes[1, 1].imshow(
-            z_cond2_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[1, 1].set_xticks([])
-        axes[1, 1].set_yticks([])
-
-        mask = (df["model"] == m3) & (df["subclass"] == "a")
-        z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im8 = axes[2, 1].imshow(
-            z_cond2_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[2, 1].set_xticks([])
-        axes[2, 1].set_yticks([])
-
-        mask = (df["model"] == m3) & (df["subclass"] == "c")
-        z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im9 = axes[3, 1].imshow(
-            z_cond2_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[3, 1].set_xticks([])
-        axes[3, 1].set_yticks([])
-
-        mask = df["model"] == m4
-        z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im10 = axes[4, 1].imshow(
-            z_cond2_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[4, 1].set_xticks([])
-        axes[4, 1].set_yticks([])
-
-        mask = df["model"] == m5
-        z_cond2_filtered = z_cond2[mask.to_numpy()]
-        im11 = axes[5, 1].imshow(
-            z_cond2_filtered,
-            aspect="auto",
-            cmap=cmap,
-            vmin=vmin_global,
-            vmax=vmax_global,
-            rasterized=False,
-            interpolation="none",
-        )
-
-        axes[5, 1].set_xticks(range(len(t_unique)), t_unique)
-        axes[5, 1].set_yticks([])
-        axes[5, 1].set_xlabel("Time(h)")
-
-
-@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
-class TimeSeriesExample:
-    df: pd.DataFrame
-
-    columns_cond1: list[str]
-    columns_cond2: list[str]
-    t_cond1: np.ndarray
-    t_cond2: np.ndarray
-    cond1_label: str = "cond1"
-    cond2_label: str = "cond2"
-
-    deduplicate_on_init: bool = False
-
-    # --- validators ---
-    @field_validator("t_cond1", "t_cond2", mode="before")
-    @classmethod
-    def _to_1d_f64(cls, v: object) -> np.ndarray:  # ← return type fixes ANN206
-        a = np.asarray(v, dtype=np.float64)
-        if a.ndim != 1:
-            text: str = "expected 1D array"
-            raise ValueError(text)
-        return a
-
-    @model_validator(mode="after")
-    def _check_columns(self) -> Self:
-        missing = [c for c in (self.columns_cond1 + self.columns_cond2) if c not in self.df.columns]
-        if missing:
-            text = f"Missing columns: {missing}"  # satisfies EM101 (no string literal in raise)
-            raise ValueError(text)
-        return self
-
-    def plot_time_series(self, gene: str, xticks: np.ndarray | None = None) -> None:
-        if xticks is None:
-            xticks = np.unique(np.concatenate((self.t_cond1, self.t_cond2))).astype(int)
-        df: pd.DataFrame = self.df
-        df_curr = df[df["Genes"] == gene]
-        if df_curr.empty:
-            msg = f"Gene '{gene}' not found in the DataFrame."
-            raise ValueError(msg)
-        if len(df_curr) > 1:
-            df_curr = df_curr.loc[[df_curr["mean_cond2"].idxmax()]]
-
-        alpha_vec: np.ndarray = df_curr[self.columns_cond1].to_numpy(float).flatten()
-        beta_vec: np.ndarray = df_curr[self.columns_cond2].to_numpy(float).flatten()
-
-        is_expressed_cond1: bool = df_curr["is_expressed_cond1"].to_numpy()[0]
-        is_expressed_cond2: bool = df_curr["is_expressed_cond2"].to_numpy()[0]
-
-        model: int = df_curr["model"].to_numpy()[0]
-
-        if is_expressed_cond1 and is_expressed_cond2:
-            t_test, y_test_cond1, y_test_cond2 = self.get_test_function_expressed_both(
-                alpha_vec,
-                beta_vec,
-                self.t_cond1,
-                self.t_cond2,
-                model,
-            )
-        elif is_expressed_cond1 and not is_expressed_cond2:
-            t_test, y_test_cond1, y_test_cond2 = self.get_test_function_expressed_cond1(
-                alpha_vec,
-                self.t_cond1,
-                model,
-            )
-        elif not is_expressed_cond1 and is_expressed_cond2:
-            t_test, y_test_cond1, y_test_cond2 = self.get_test_function_expressed_cond2(
-                beta_vec,
-                self.t_cond2,
-                model,
-            )
-        plt.figure(figsize=(12 / 2.54, 6 / 2.54))
-        plt.subplot(1, 2, 1)
-        plt.scatter(self.t_cond1, alpha_vec, s=4)
-        plt.plot(t_test, y_test_cond1)
-        plt.ylabel("Expression Level")
-        plt.xticks(xticks)
-        # plt.xlim(xticks[0], xticks[-1])
-        plt.title(f"Time Series for {gene}")
-        plt.xlabel("Time (h)")
-        plt.subplot(1, 2, 2)
-        plt.scatter(self.t_cond2, beta_vec, s=4, color="r")
-        plt.plot(t_test, y_test_cond2, color="r")
-        plt.title(f"Time Series for {gene}")
-        plt.xlabel("Time (h)")
-
-        plt.xticks(xticks)
-        plt.xlim(xticks[0] - 0.05 * (xticks[-1] - xticks[0]), xticks[-1] + 0.05 * (xticks[-1] - xticks[0]))
-        plt.tight_layout()
-        plt.show()
-
-    def get_test_function_expressed_both(
-        self,
-        alpha_vec: np.ndarray,
-        beta_vec: np.ndarray,
-        t_cond1: np.ndarray,
-        t_cond2: np.ndarray,
-        model: int,
-    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        design: pd.DataFrame = build_design(alpha_vec, beta_vec, t_cond1, t_cond2)
-        t_test: np.ndarray = np.linspace(0, 24, 100)
-        if model == 0:
-            print("No model selected")
-            y_test_cond1 = np.full_like(t_test, np.nan)
-            y_test_cond2 = np.full_like(t_test, np.nan)
-        else:
-            model_formula: str = MODELS[model - 1].formula
-            res = smf.ols(model_formula, data=design).fit()
-            df_cond1: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "alpha"}).dropna()
-            df_cond2: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "beta"}).dropna()
-            df_test: pd.DataFrame = pd.concat([df_cond1, df_cond2], ignore_index=True)
-            df_test["constant"] = 1.0
-            df_test["cos_wt"] = np.cos(W * df_test["time"].to_numpy().astype(float))
-            df_test["sin_wt"] = np.sin(W * df_test["time"].to_numpy().astype(float))
-            df_test["is_alpha"] = (df_test["dataset"] == "alpha").astype(int)
-            df_test["is_beta"] = (df_test["dataset"] == "beta").astype(int)
-            y_test = res.predict(exog=df_test)
-            print(y_test)
-            y_test_cond1: np.ndarray = y_test[df_test["dataset"] == "alpha"].to_numpy()
-            y_test_cond2: np.ndarray = y_test[df_test["dataset"] == "beta"].to_numpy()
-        return t_test, y_test_cond1, y_test_cond2
-
-    def get_test_function_expressed_cond1(
-        self,
-        alpha_vec: np.ndarray,
-        t_cond1: np.ndarray,
-        model: int,
-    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        design: pd.DataFrame = build_design_cond1(alpha_vec, t_cond1)
-        t_test: np.ndarray = np.linspace(0, 24, 100)
-        if model == 0:
-            print("No model selected")
-            y_test_cond1 = np.full_like(t_test, np.nan)
-            y_test_cond2 = np.full_like(t_test, np.nan)
-        else:
-            print(f"Fitting model {model}")
-            print(MODELS_ONE_CONDITION)
-            if model == 1:
-                model_formula: str = MODELS_ONE_CONDITION[0].formula
-            else:
-                model_formula: str = MODELS_ONE_CONDITION[1].formula
-            res = smf.ols(model_formula, data=design).fit()
-            df_test: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "alpha"}).dropna()
-            df_test["constant"] = 1.0
-            df_test["cos_wt"] = np.cos(W * df_test["time"].to_numpy().astype(float))
-            df_test["sin_wt"] = np.sin(W * df_test["time"].to_numpy().astype(float))
-            y_test = res.predict(exog=df_test)
-            print(y_test)
-            y_test_cond1: np.ndarray = y_test.to_numpy()
-            y_test_cond2: np.ndarray = np.full_like(t_test, np.nan)
-        return t_test, y_test_cond1, y_test_cond2
-
-    def get_test_function_expressed_cond2(
-        self,
-        beta_vec: np.ndarray,
-        t_cond2: np.ndarray,
-        model: int,
-    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        design: pd.DataFrame = build_design_cond2(beta_vec, t_cond2)
-        t_test: np.ndarray = np.linspace(0, 24, 100)
-        if model == 0:
-            print("No model selected")
-            y_test_cond1 = np.full_like(t_test, np.nan)
-            y_test_cond2 = np.full_like(t_test, np.nan)
-        else:
-            print(f"Fitting model {model}")
-            print(MODELS_ONE_CONDITION)
-            if model == 1:
-                model_formula: str = MODELS_ONE_CONDITION[0].formula
-            else:
-                model_formula: str = MODELS_ONE_CONDITION[1].formula
-            res = smf.ols(model_formula, data=design).fit()
-            df_test: pd.DataFrame = pd.DataFrame({"time": t_test, "dataset": "alpha"}).dropna()
-            df_test["constant"] = 1.0
-            df_test["cos_wt"] = np.cos(W * df_test["time"].to_numpy().astype(float))
-            df_test["sin_wt"] = np.sin(W * df_test["time"].to_numpy().astype(float))
-            y_test = res.predict(exog=df_test)
-            print(y_test)
-            y_test_cond1: np.ndarray = np.full_like(t_test, np.nan)
-            y_test_cond2: np.ndarray = y_test.to_numpy()
-
-        return t_test, y_test_cond1, y_test_cond2
diff --git a/test-reports/report.xml b/test-reports/report.xml
index 422ef87..241fda2 100644
--- a/test-reports/report.xml
+++ b/test-reports/report.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8"?><testsuites name="pytest tests"><testsuite name="pytest" errors="0" failures="0" skipped="0" tests="7" time="0.525" timestamp="2025-07-10T11:28:53.533818+02:00" hostname="SV-34M-019.local"><testcase classname="tests.unit_tests.test_data_loading" name="test_sample_csv_exists" time="0.001" /><testcase classname="tests.unit_tests.test_data_loading" name="test_bioluminescence_csv_can_be_loaded" time="0.023" /><testcase classname="tests.unit_tests.test_states_info" name="test__is_city_capitol_of_state[Montgomery-Alabama-True]" time="0.001" /><testcase classname="tests.unit_tests.test_states_info" name="test__is_city_capitol_of_state[Oklahoma City-Oklahoma-True]" time="0.001" /><testcase classname="tests.unit_tests.test_states_info" name="test__is_city_capitol_of_state[Salem-Oregon-True]" time="0.001" /><testcase classname="tests.unit_tests.test_states_info" name="test__is_city_capitol_of_state[Salt Lake City-Alabama-False]" time="0.001" /><testcase classname="tests.unit_tests.test_states_info" name="test__slow_add" time="0.001" /></testsuite></testsuites>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?><testsuites name="pytest tests"><testsuite name="pytest" errors="0" failures="0" skipped="0" tests="89" time="27.177" timestamp="2025-12-01T14:43:46.472854+01:00" hostname="SV-34M-019.local"><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_constant_model_returns_mesor" time="0.002" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_cosine_model_implementations_match_formulas" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_sanitize_xy_enforces_minimum_points" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_24_returns_expected_structure[bioluminescence_example.csv]" time="0.043" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_free_period_period_within_bounds[bioluminescence_example.csv]" time="0.037" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_damped_returns_non_negative_damp[bioluminescence_example.csv]" time="0.016" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_get_cosinor_fits_invalid_method_raises[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_exports_results[bioluminescence_example.csv]" time="3.268" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_to_2d_f64_valid[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_check_columns_valid[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_group1_ids_replicates_data[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_group2_ids_replicates_data[bioluminescence_example.csv]" time="0.002" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_linear_trend[bioluminescence_example.csv]" time="0.002" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_poly2_trend[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_moving_average_trend[bioluminescence_example.csv]" time="0.002" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_moving_average_trend_invalid_window[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[bioluminescence_example.csv-none]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[bioluminescence_example.csv-linear]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[bioluminescence_example.csv-poly2]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[bioluminescence_example.csv-moving_average]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_invalid_method[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data[bioluminescence_example.csv-group1]" time="2.463" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data[bioluminescence_example.csv-group2]" time="2.289" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data_invalid_group[bioluminescence_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_24_returns_expected_structure[qpcr_example.csv]" time="0.017" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_free_period_period_within_bounds[qpcr_example.csv]" time="0.008" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_damped_returns_non_negative_damp[qpcr_example.csv]" time="0.012" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_get_cosinor_fits_invalid_method_raises[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_exports_results[qpcr_example.csv]" time="0.900" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_to_2d_f64_valid[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_check_columns_valid[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_group1_ids_replicates_data[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_group2_ids_replicates_data[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_linear_trend[qpcr_example.csv]" time="0.002" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_poly2_trend[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_moving_average_trend[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_moving_average_trend_invalid_window[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[qpcr_example.csv-none]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[qpcr_example.csv-linear]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[qpcr_example.csv-poly2]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[qpcr_example.csv-moving_average]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_invalid_method[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data[qpcr_example.csv-group1]" time="0.858" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data[qpcr_example.csv-group2]" time="0.899" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data_invalid_group[qpcr_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_24_returns_expected_structure[single_cell_example.csv]" time="0.020" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_free_period_period_within_bounds[single_cell_example.csv]" time="0.015" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_damped_returns_non_negative_damp[single_cell_example.csv]" time="0.031" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_get_cosinor_fits_invalid_method_raises[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_cosinor_analysis" name="test_fit_cosinor_exports_results[single_cell_example.csv]" time="5.049" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_to_2d_f64_valid[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_check_columns_valid[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_group1_ids_replicates_data[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_group2_ids_replicates_data[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_linear_trend[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_poly2_trend[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_moving_average_trend[single_cell_example.csv]" time="0.002" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_moving_average_trend_invalid_window[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[single_cell_example.csv-none]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[single_cell_example.csv-linear]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[single_cell_example.csv-poly2]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_methods[single_cell_example.csv-moving_average]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_get_trend_invalid_method[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data[single_cell_example.csv-group1]" time="4.989" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data[single_cell_example.csv-group2]" time="0.022" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_plot_group_data_invalid_group[single_cell_example.csv]" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_to_2d_f64_invalid" time="0.001" /><testcase classname="tests.unit_tests.test_livecell_dataset" name="test_check_columns_invalid" time="0.003" /><testcase classname="tests.unit_tests.test_omics_dataset" name="test_detected_timepoint_counts_cond1_matches_manual" time="0.020" /><testcase classname="tests.unit_tests.test_omics_dataset" name="test_detected_timepoint_counts_cond2_matches_manual" time="0.004" /><testcase classname="tests.unit_tests.test_omics_dataset" name="test_detected_timepoint_counts_invalid_condition" time="0.001" /><testcase classname="tests.unit_tests.test_omics_dataset" name="test_mean_expression_columns_initialised" time="0.004" /><testcase classname="tests.unit_tests.test_omics_dataset" name="test_number_detected_columns_initialised" time="0.004" /><testcase classname="tests.unit_tests.test_omics_dataset" name="test_expression_histogram_returns_two_panels" time="0.171" /><testcase classname="tests.unit_tests.test_omics_dataset" name="test_replicate_scatterplot_title_matches_correlations" time="0.092" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_phase_from_ab_returns_expected_hours" time="0.001" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_amp_from_ab_matches_euclidean_norm" time="0.001" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_bic_prefers_lower_log_likelihood_penalized" time="0.001" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_akaike_weights_are_normalized_and_ranked" time="0.001" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_weight_mapping_populates_model_columns" time="0.001" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_build_design_includes_all_expected_columns" time="0.009" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_build_design_cond1_only_contains_alpha_rows" time="0.003" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_build_design_cond2_only_contains_beta_rows" time="0.004" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_omics_heatmap_timepoint_means_shape" time="0.008" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_omics_heatmap_get_z_score_standardizes_rows" time="0.005" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_omics_heatmap_plot_heatmap_returns_figure" time="0.160" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_time_series_example_get_test_function_expressed_both" time="0.029" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_time_series_example_conditional_predictions" time="0.023" /><testcase classname="tests.unit_tests.test_omics_differential_rhytmicity" name="test_time_series_example_plot_time_series_missing_gene" time="0.006" /></testsuite></testsuites>
\ No newline at end of file
diff --git a/tests/conftest.py b/tests/conftest.py
index fd33401..dffafdb 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,22 +1,8 @@
-"""
-Register pytest plugins, fixtures, and hooks to be used during test execution.
-
-Docs: https://stackoverflow.com/questions/34466027/in-pytest-what-is-the-use-of-conftest-py-files
-"""
-
-
-import sys
-from pathlib import Path
-
-THIS_DIR = Path(__file__).parent
-TESTS_DIR_PARENT = (THIS_DIR / "..").resolve()
-
-# add the parent directory of tests/ to PYTHONPATH
-# so that we can use "from tests.<module> import ..." in our tests and fixtures
-sys.path.insert(0, str(TESTS_DIR_PARENT))
+"""Register pytest plugins, fixtures, and hooks to be used during test execution."""
 
 # module import paths to python files containing fixtures
 pytest_plugins = [
-    # e.g. "tests/fixtures/example_fixture.py" should be registered as:
-    "tests.fixtures.example_fixture",
+    "tests.fixtures.livecell_dataset_fixture",
+    "tests.fixtures.cosinor_analysis_fixture",
+    "tests.fixtures.omics_dataset_fixture",
 ]
diff --git a/tests/fixtures/example_fixture.py b/tests/fixtures/example_fixture.py
deleted file mode 100644
index db837b5..0000000
--- a/tests/fixtures/example_fixture.py
+++ /dev/null
@@ -1,14 +0,0 @@
-"""Example pytest fixture."""
-
-from uuid import uuid4
-
-import pytest
-
-from tests.consts import PROJECT_DIR
-
-
-@pytest.fixture(scope="session")
-def test_session_id() -> str:
-    """Demonstrate how pytest fixtures are used."""
-    test_session_id = str(PROJECT_DIR.name) + str(uuid4())[:6]
-    return test_session_id
diff --git a/tests/unit_tests/test_data_loading.py b/tests/unit_tests/test_data_loading.py
deleted file mode 100644
index fc66ff7..0000000
--- a/tests/unit_tests/test_data_loading.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# %%
-from pathlib import Path
-
-import pandas as pd
-from pandas import DataFrame
-
-DATA_DIR = Path(__file__).parent.parent / "data"
-sample_csv = DATA_DIR / "Bioluminescence_test_data_1.csv"
-
-
-def test_sample_csv_exists() -> None:
-    if not sample_csv.exists():
-        raise FileNotFoundError(sample_csv)
-
-
-def test_bioluminescence_csv_can_be_loaded() -> None:
-    df_bioluminescence: DataFrame = pd.read_csv(sample_csv, header=None)
-    if df_bioluminescence.empty:
-        msg = "Loaded DataFrame is empty"
-        raise ValueError(msg)
-    if df_bioluminescence.shape[1] <= 0:
-        msg = "Loaded DataFrame has no columns"
-        raise ValueError(msg)
diff --git a/tests/unit_tests/test_states_info.py b/tests/unit_tests/test_states_info.py
deleted file mode 100644
index ce83135..0000000
--- a/tests/unit_tests/test_states_info.py
+++ /dev/null
@@ -1,28 +0,0 @@
-"""Tests for `cosinor_lite.states_info`."""
-
-
-import pytest
-from cosinor_lite.states_info import (
-    is_city_capitol_of_state,
-    slow_add,
-)
-
-
-@pytest.mark.parametrize(
-    argnames=("city_name", "state", "is_capitol"),
-    argvalues=[
-        ("Montgomery", "Alabama", True),
-        ("Oklahoma City", "Oklahoma", True),
-        ("Salem", "Oregon", True),
-        ("Salt Lake City", "Alabama", False),
-    ],
-)
-def test__is_city_capitol_of_state(city_name: str, state: str, is_capitol: bool):
-    """Assert `is_city_captio_of_state()` returns correct answer for city-state pairs."""
-    assert is_city_capitol_of_state(city_name=city_name, state=state) == is_capitol
-
-
-@pytest.mark.slow
-def test__slow_add():
-    """Test `slow_add()`."""
-    assert slow_add(1, 2) == 3
diff --git a/uv.lock b/uv.lock
index e9a0a40..fdba46f 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2,10 +2,29 @@ version = 1
 revision = 2
 requires-python = ">=3.11"
 resolution-markers = [
-    "python_full_version >= '3.12'",
+    "python_full_version >= '3.13'",
+    "python_full_version == '3.12.*'",
     "python_full_version < '3.12'",
 ]
 
+[[package]]
+name = "aiofiles"
+version = "24.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/03/a88171e277e8caa88a4c77808c20ebb04ba74cc4681bf1e9416c862de237/aiofiles-24.1.0.tar.gz", hash = "sha256:22a075c9e5a3810f0c2e48f3008c94d68c65d763b9b03857924c99e57355166c", size = 30247, upload-time = "2024-06-24T11:02:03.584Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/45/30bb92d442636f570cb5651bc661f52b610e2eec3f891a5dc3a4c3667db0/aiofiles-24.1.0-py3-none-any.whl", hash = "sha256:b4ec55f4195e3eb5d7abd1bf7e061763e864dd4954231fb8539a0ef8bb8260e5", size = 15896, upload-time = "2024-06-24T11:02:01.529Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -156,6 +175,62 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" },
 ]
 
+[[package]]
+name = "audioop-lts"
+version = "0.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/53/946db57842a50b2da2e0c1e34bd37f36f5aadba1a929a3971c5d7841dbca/audioop_lts-0.2.2.tar.gz", hash = "sha256:64d0c62d88e67b98a1a5e71987b7aa7b5bcffc7dcee65b635823dbdd0a8dbbd0", size = 30686, upload-time = "2025-08-05T16:43:17.409Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/d4/94d277ca941de5a507b07f0b592f199c22454eeaec8f008a286b3fbbacd6/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd3d4602dc64914d462924a08c1a9816435a2155d74f325853c1f1ac3b2d9800", size = 46523, upload-time = "2025-08-05T16:42:20.836Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/5a/656d1c2da4b555920ce4177167bfeb8623d98765594af59702c8873f60ec/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:550c114a8df0aafe9a05442a1162dfc8fec37e9af1d625ae6060fed6e756f303", size = 27455, upload-time = "2025-08-05T16:42:22.283Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/83/ea581e364ce7b0d41456fb79d6ee0ad482beda61faf0cab20cbd4c63a541/audioop_lts-0.2.2-cp313-abi3-macosx_11_0_arm64.whl", hash = "sha256:9a13dc409f2564de15dd68be65b462ba0dde01b19663720c68c1140c782d1d75", size = 26997, upload-time = "2025-08-05T16:42:23.849Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/3b/e8964210b5e216e5041593b7d33e97ee65967f17c282e8510d19c666dab4/audioop_lts-0.2.2-cp313-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51c916108c56aa6e426ce611946f901badac950ee2ddaf302b7ed35d9958970d", size = 85844, upload-time = "2025-08-05T16:42:25.208Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2e/0a1c52faf10d51def20531a59ce4c706cb7952323b11709e10de324d6493/audioop_lts-0.2.2-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47eba38322370347b1c47024defbd36374a211e8dd5b0dcbce7b34fdb6f8847b", size = 85056, upload-time = "2025-08-05T16:42:26.559Z" },
+    { url = "https://files.pythonhosted.org/packages/75/e8/cd95eef479656cb75ab05dfece8c1f8c395d17a7c651d88f8e6e291a63ab/audioop_lts-0.2.2-cp313-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba7c3a7e5f23e215cb271516197030c32aef2e754252c4c70a50aaff7031a2c8", size = 93892, upload-time = "2025-08-05T16:42:27.902Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/1e/a0c42570b74f83efa5cca34905b3eef03f7ab09fe5637015df538a7f3345/audioop_lts-0.2.2-cp313-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def246fe9e180626731b26e89816e79aae2276f825420a07b4a647abaa84becc", size = 96660, upload-time = "2025-08-05T16:42:28.9Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d5/8a0ae607ca07dbb34027bac8db805498ee7bfecc05fd2c148cc1ed7646e7/audioop_lts-0.2.2-cp313-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e160bf9df356d841bb6c180eeeea1834085464626dc1b68fa4e1d59070affdc3", size = 79143, upload-time = "2025-08-05T16:42:29.929Z" },
+    { url = "https://files.pythonhosted.org/packages/12/17/0d28c46179e7910bfb0bb62760ccb33edb5de973052cb2230b662c14ca2e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4b4cd51a57b698b2d06cb9993b7ac8dfe89a3b2878e96bc7948e9f19ff51dba6", size = 84313, upload-time = "2025-08-05T16:42:30.949Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ba/bd5d3806641564f2024e97ca98ea8f8811d4e01d9b9f9831474bc9e14f9e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4a53aa7c16a60a6857e6b0b165261436396ef7293f8b5c9c828a3a203147ed4a", size = 93044, upload-time = "2025-08-05T16:42:31.959Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/5e/435ce8d5642f1f7679540d1e73c1c42d933331c0976eb397d1717d7f01a3/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:3fc38008969796f0f689f1453722a0f463da1b8a6fbee11987830bfbb664f623", size = 78766, upload-time = "2025-08-05T16:42:33.302Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3b/b909e76b606cbfd53875693ec8c156e93e15a1366a012f0b7e4fb52d3c34/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_s390x.whl", hash = "sha256:15ab25dd3e620790f40e9ead897f91e79c0d3ce65fe193c8ed6c26cffdd24be7", size = 87640, upload-time = "2025-08-05T16:42:34.854Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e7/8f1603b4572d79b775f2140d7952f200f5e6c62904585d08a01f0a70393a/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:03f061a1915538fd96272bac9551841859dbb2e3bf73ebe4a23ef043766f5449", size = 86052, upload-time = "2025-08-05T16:42:35.839Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/96/c37846df657ccdda62ba1ae2b6534fa90e2e1b1742ca8dcf8ebd38c53801/audioop_lts-0.2.2-cp313-abi3-win32.whl", hash = "sha256:3bcddaaf6cc5935a300a8387c99f7a7fbbe212a11568ec6cf6e4bc458c048636", size = 26185, upload-time = "2025-08-05T16:42:37.04Z" },
+    { url = "https://files.pythonhosted.org/packages/34/a5/9d78fdb5b844a83da8a71226c7bdae7cc638861085fff7a1d707cb4823fa/audioop_lts-0.2.2-cp313-abi3-win_amd64.whl", hash = "sha256:a2c2a947fae7d1062ef08c4e369e0ba2086049a5e598fda41122535557012e9e", size = 30503, upload-time = "2025-08-05T16:42:38.427Z" },
+    { url = "https://files.pythonhosted.org/packages/34/25/20d8fde083123e90c61b51afb547bb0ea7e77bab50d98c0ab243d02a0e43/audioop_lts-0.2.2-cp313-abi3-win_arm64.whl", hash = "sha256:5f93a5db13927a37d2d09637ccca4b2b6b48c19cd9eda7b17a2e9f77edee6a6f", size = 24173, upload-time = "2025-08-05T16:42:39.704Z" },
+    { url = "https://files.pythonhosted.org/packages/58/a7/0a764f77b5c4ac58dc13c01a580f5d32ae8c74c92020b961556a43e26d02/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:73f80bf4cd5d2ca7814da30a120de1f9408ee0619cc75da87d0641273d202a09", size = 47096, upload-time = "2025-08-05T16:42:40.684Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ed/ebebedde1a18848b085ad0fa54b66ceb95f1f94a3fc04f1cd1b5ccb0ed42/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:106753a83a25ee4d6f473f2be6b0966fc1c9af7e0017192f5531a3e7463dce58", size = 27748, upload-time = "2025-08-05T16:42:41.992Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/6e/11ca8c21af79f15dbb1c7f8017952ee8c810c438ce4e2b25638dfef2b02c/audioop_lts-0.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fbdd522624141e40948ab3e8cdae6e04c748d78710e9f0f8d4dae2750831de19", size = 27329, upload-time = "2025-08-05T16:42:42.987Z" },
+    { url = "https://files.pythonhosted.org/packages/84/52/0022f93d56d85eec5da6b9da6a958a1ef09e80c39f2cc0a590c6af81dcbb/audioop_lts-0.2.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:143fad0311e8209ece30a8dbddab3b65ab419cbe8c0dde6e8828da25999be911", size = 92407, upload-time = "2025-08-05T16:42:44.336Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1d/48a889855e67be8718adbc7a01f3c01d5743c325453a5e81cf3717664aad/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfbbc74ec68a0fd08cfec1f4b5e8cca3d3cd7de5501b01c4b5d209995033cde9", size = 91811, upload-time = "2025-08-05T16:42:45.325Z" },
+    { url = "https://files.pythonhosted.org/packages/98/a6/94b7213190e8077547ffae75e13ed05edc488653c85aa5c41472c297d295/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cfcac6aa6f42397471e4943e0feb2244549db5c5d01efcd02725b96af417f3fe", size = 100470, upload-time = "2025-08-05T16:42:46.468Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/e9/78450d7cb921ede0cfc33426d3a8023a3bda755883c95c868ee36db8d48d/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:752d76472d9804ac60f0078c79cdae8b956f293177acd2316cd1e15149aee132", size = 103878, upload-time = "2025-08-05T16:42:47.576Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/e2/cd5439aad4f3e34ae1ee852025dc6aa8f67a82b97641e390bf7bd9891d3e/audioop_lts-0.2.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:83c381767e2cc10e93e40281a04852facc4cd9334550e0f392f72d1c0a9c5753", size = 84867, upload-time = "2025-08-05T16:42:49.003Z" },
+    { url = "https://files.pythonhosted.org/packages/68/4b/9d853e9076c43ebba0d411e8d2aa19061083349ac695a7d082540bad64d0/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c0022283e9556e0f3643b7c3c03f05063ca72b3063291834cca43234f20c60bb", size = 90001, upload-time = "2025-08-05T16:42:50.038Z" },
+    { url = "https://files.pythonhosted.org/packages/58/26/4bae7f9d2f116ed5593989d0e521d679b0d583973d203384679323d8fa85/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a2d4f1513d63c795e82948e1305f31a6d530626e5f9f2605408b300ae6095093", size = 99046, upload-time = "2025-08-05T16:42:51.111Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/67/a9f4fb3e250dda9e9046f8866e9fa7d52664f8985e445c6b4ad6dfb55641/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:c9c8e68d8b4a56fda8c025e538e639f8c5953f5073886b596c93ec9b620055e7", size = 84788, upload-time = "2025-08-05T16:42:52.198Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f7/3de86562db0121956148bcb0fe5b506615e3bcf6e63c4357a612b910765a/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:96f19de485a2925314f5020e85911fb447ff5fbef56e8c7c6927851b95533a1c", size = 94472, upload-time = "2025-08-05T16:42:53.59Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/32/fd772bf9078ae1001207d2df1eef3da05bea611a87dd0e8217989b2848fa/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e541c3ef484852ef36545f66209444c48b28661e864ccadb29daddb6a4b8e5f5", size = 92279, upload-time = "2025-08-05T16:42:54.632Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/41/affea7181592ab0ab560044632571a38edaf9130b84928177823fbf3176a/audioop_lts-0.2.2-cp313-cp313t-win32.whl", hash = "sha256:d5e73fa573e273e4f2e5ff96f9043858a5e9311e94ffefd88a3186a910c70917", size = 26568, upload-time = "2025-08-05T16:42:55.627Z" },
+    { url = "https://files.pythonhosted.org/packages/28/2b/0372842877016641db8fc54d5c88596b542eec2f8f6c20a36fb6612bf9ee/audioop_lts-0.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:9191d68659eda01e448188f60364c7763a7ca6653ed3f87ebb165822153a8547", size = 30942, upload-time = "2025-08-05T16:42:56.674Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/baf2b9cc7e96c179bb4a54f30fcd83e6ecb340031bde68f486403f943768/audioop_lts-0.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:c174e322bb5783c099aaf87faeb240c8d210686b04bd61dfd05a8e5a83d88969", size = 24603, upload-time = "2025-08-05T16:42:57.571Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/73/413b5a2804091e2c7d5def1d618e4837f1cb82464e230f827226278556b7/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f9ee9b52f5f857fbaf9d605a360884f034c92c1c23021fb90b2e39b8e64bede6", size = 47104, upload-time = "2025-08-05T16:42:58.518Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8c/daa3308dc6593944410c2c68306a5e217f5c05b70a12e70228e7dd42dc5c/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:49ee1a41738a23e98d98b937a0638357a2477bc99e61b0f768a8f654f45d9b7a", size = 27754, upload-time = "2025-08-05T16:43:00.132Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/86/c2e0f627168fcf61781a8f72cab06b228fe1da4b9fa4ab39cfb791b5836b/audioop_lts-0.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b00be98ccd0fc123dcfad31d50030d25fcf31488cde9e61692029cd7394733b", size = 27332, upload-time = "2025-08-05T16:43:01.666Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/bd/35dce665255434f54e5307de39e31912a6f902d4572da7c37582809de14f/audioop_lts-0.2.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6d2e0f9f7a69403e388894d4ca5ada5c47230716a03f2847cfc7bd1ecb589d6", size = 92396, upload-time = "2025-08-05T16:43:02.991Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/d2/deeb9f51def1437b3afa35aeb729d577c04bcd89394cb56f9239a9f50b6f/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9b0b8a03ef474f56d1a842af1a2e01398b8f7654009823c6d9e0ecff4d5cfbf", size = 91811, upload-time = "2025-08-05T16:43:04.096Z" },
+    { url = "https://files.pythonhosted.org/packages/76/3b/09f8b35b227cee28cc8231e296a82759ed80c1a08e349811d69773c48426/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2b267b70747d82125f1a021506565bdc5609a2b24bcb4773c16d79d2bb260bbd", size = 100483, upload-time = "2025-08-05T16:43:05.085Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/15/05b48a935cf3b130c248bfdbdea71ce6437f5394ee8533e0edd7cfd93d5e/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0337d658f9b81f4cd0fdb1f47635070cc084871a3d4646d9de74fdf4e7c3d24a", size = 103885, upload-time = "2025-08-05T16:43:06.197Z" },
+    { url = "https://files.pythonhosted.org/packages/83/80/186b7fce6d35b68d3d739f228dc31d60b3412105854edb975aa155a58339/audioop_lts-0.2.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:167d3b62586faef8b6b2275c3218796b12621a60e43f7e9d5845d627b9c9b80e", size = 84899, upload-time = "2025-08-05T16:43:07.291Z" },
+    { url = "https://files.pythonhosted.org/packages/49/89/c78cc5ac6cb5828f17514fb12966e299c850bc885e80f8ad94e38d450886/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0d9385e96f9f6da847f4d571ce3cb15b5091140edf3db97276872647ce37efd7", size = 89998, upload-time = "2025-08-05T16:43:08.335Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/4b/6401888d0c010e586c2ca50fce4c903d70a6bb55928b16cfbdfd957a13da/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:48159d96962674eccdca9a3df280e864e8ac75e40a577cc97c5c42667ffabfc5", size = 99046, upload-time = "2025-08-05T16:43:09.367Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f8/c874ca9bb447dae0e2ef2e231f6c4c2b0c39e31ae684d2420b0f9e97ee68/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fefe5868cd082db1186f2837d64cfbfa78b548ea0d0543e9b28935ccce81ce9", size = 84843, upload-time = "2025-08-05T16:43:10.749Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/c0/0323e66f3daebc13fd46b36b30c3be47e3fc4257eae44f1e77eb828c703f/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:58cf54380c3884fb49fdd37dfb7a772632b6701d28edd3e2904743c5e1773602", size = 94490, upload-time = "2025-08-05T16:43:12.131Z" },
+    { url = "https://files.pythonhosted.org/packages/98/6b/acc7734ac02d95ab791c10c3f17ffa3584ccb9ac5c18fd771c638ed6d1f5/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:088327f00488cdeed296edd9215ca159f3a5a5034741465789cad403fcf4bec0", size = 92297, upload-time = "2025-08-05T16:43:13.139Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c3/c3dc3f564ce6877ecd2a05f8d751b9b27a8c320c2533a98b0c86349778d0/audioop_lts-0.2.2-cp314-cp314t-win32.whl", hash = "sha256:068aa17a38b4e0e7de771c62c60bbca2455924b67a8814f3b0dee92b5820c0b3", size = 27331, upload-time = "2025-08-05T16:43:14.19Z" },
+    { url = "https://files.pythonhosted.org/packages/72/bb/b4608537e9ffcb86449091939d52d24a055216a36a8bf66b936af8c3e7ac/audioop_lts-0.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a5bf613e96f49712073de86f20dbdd4014ca18efd4d34ed18c75bd808337851b", size = 31697, upload-time = "2025-08-05T16:43:15.193Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" },
+]
+
 [[package]]
 name = "babel"
 version = "2.17.0"
@@ -195,6 +270,54 @@ css = [
     { name = "tinycss2" },
 ]
 
+[[package]]
+name = "brotli"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/16/c92ca344d646e71a43b8bb353f0a6490d7f6e06210f8554c8f874e454285/brotli-1.2.0.tar.gz", hash = "sha256:e310f77e41941c13340a95976fe66a8a95b01e783d430eeaf7a2f87e0a57dd0a", size = 7388632, upload-time = "2025-11-05T18:39:42.86Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/ef/f285668811a9e1ddb47a18cb0b437d5fc2760d537a2fe8a57875ad6f8448/brotli-1.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:15b33fe93cedc4caaff8a0bd1eb7e3dab1c61bb22a0bf5bdfdfd97cd7da79744", size = 863110, upload-time = "2025-11-05T18:38:12.978Z" },
+    { url = "https://files.pythonhosted.org/packages/50/62/a3b77593587010c789a9d6eaa527c79e0848b7b860402cc64bc0bc28a86c/brotli-1.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:898be2be399c221d2671d29eed26b6b2713a02c2119168ed914e7d00ceadb56f", size = 445438, upload-time = "2025-11-05T18:38:14.208Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/e1/7fadd47f40ce5549dc44493877db40292277db373da5053aff181656e16e/brotli-1.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:350c8348f0e76fff0a0fd6c26755d2653863279d086d3aa2c290a6a7251135dd", size = 1534420, upload-time = "2025-11-05T18:38:15.111Z" },
+    { url = "https://files.pythonhosted.org/packages/12/8b/1ed2f64054a5a008a4ccd2f271dbba7a5fb1a3067a99f5ceadedd4c1d5a7/brotli-1.2.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1ad3fda65ae0d93fec742a128d72e145c9c7a99ee2fcd667785d99eb25a7fe", size = 1632619, upload-time = "2025-11-05T18:38:16.094Z" },
+    { url = "https://files.pythonhosted.org/packages/89/5a/7071a621eb2d052d64efd5da2ef55ecdac7c3b0c6e4f9d519e9c66d987ef/brotli-1.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:40d918bce2b427a0c4ba189df7a006ac0c7277c180aee4617d99e9ccaaf59e6a", size = 1426014, upload-time = "2025-11-05T18:38:17.177Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6d/0971a8ea435af5156acaaccec1a505f981c9c80227633851f2810abd252a/brotli-1.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2a7f1d03727130fc875448b65b127a9ec5d06d19d0148e7554384229706f9d1b", size = 1489661, upload-time = "2025-11-05T18:38:18.41Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/75/c1baca8b4ec6c96a03ef8230fab2a785e35297632f402ebb1e78a1e39116/brotli-1.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9c79f57faa25d97900bfb119480806d783fba83cd09ee0b33c17623935b05fa3", size = 1599150, upload-time = "2025-11-05T18:38:19.792Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/1a/23fcfee1c324fd48a63d7ebf4bac3a4115bdb1b00e600f80f727d850b1ae/brotli-1.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:844a8ceb8483fefafc412f85c14f2aae2fb69567bf2a0de53cdb88b73e7c43ae", size = 1493505, upload-time = "2025-11-05T18:38:20.913Z" },
+    { url = "https://files.pythonhosted.org/packages/36/e5/12904bbd36afeef53d45a84881a4810ae8810ad7e328a971ebbfd760a0b3/brotli-1.2.0-cp311-cp311-win32.whl", hash = "sha256:aa47441fa3026543513139cb8926a92a8e305ee9c71a6209ef7a97d91640ea03", size = 334451, upload-time = "2025-11-05T18:38:21.94Z" },
+    { url = "https://files.pythonhosted.org/packages/02/8b/ecb5761b989629a4758c394b9301607a5880de61ee2ee5fe104b87149ebc/brotli-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:022426c9e99fd65d9475dce5c195526f04bb8be8907607e27e747893f6ee3e24", size = 369035, upload-time = "2025-11-05T18:38:22.941Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ee/b0a11ab2315c69bb9b45a2aaed022499c9c24a205c3a49c3513b541a7967/brotli-1.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:35d382625778834a7f3061b15423919aa03e4f5da34ac8e02c074e4b75ab4f84", size = 861543, upload-time = "2025-11-05T18:38:24.183Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2f/29c1459513cd35828e25531ebfcbf3e92a5e49f560b1777a9af7203eb46e/brotli-1.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a61c06b334bd99bc5ae84f1eeb36bfe01400264b3c352f968c6e30a10f9d08b", size = 444288, upload-time = "2025-11-05T18:38:25.139Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/6f/feba03130d5fceadfa3a1bb102cb14650798c848b1df2a808356f939bb16/brotli-1.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acec55bb7c90f1dfc476126f9711a8e81c9af7fb617409a9ee2953115343f08d", size = 1528071, upload-time = "2025-11-05T18:38:26.081Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/38/f3abb554eee089bd15471057ba85f47e53a44a462cfce265d9bf7088eb09/brotli-1.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:260d3692396e1895c5034f204f0db022c056f9e2ac841593a4cf9426e2a3faca", size = 1626913, upload-time = "2025-11-05T18:38:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a7/03aa61fbc3c5cbf99b44d158665f9b0dd3d8059be16c460208d9e385c837/brotli-1.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:072e7624b1fc4d601036ab3f4f27942ef772887e876beff0301d261210bca97f", size = 1419762, upload-time = "2025-11-05T18:38:28.295Z" },
+    { url = "https://files.pythonhosted.org/packages/21/1b/0374a89ee27d152a5069c356c96b93afd1b94eae83f1e004b57eb6ce2f10/brotli-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adedc4a67e15327dfdd04884873c6d5a01d3e3b6f61406f99b1ed4865a2f6d28", size = 1484494, upload-time = "2025-11-05T18:38:29.29Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/57/69d4fe84a67aef4f524dcd075c6eee868d7850e85bf01d778a857d8dbe0a/brotli-1.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7a47ce5c2288702e09dc22a44d0ee6152f2c7eda97b3c8482d826a1f3cfc7da7", size = 1593302, upload-time = "2025-11-05T18:38:30.639Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/3b/39e13ce78a8e9a621c5df3aeb5fd181fcc8caba8c48a194cd629771f6828/brotli-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:af43b8711a8264bb4e7d6d9a6d004c3a2019c04c01127a868709ec29962b6036", size = 1487913, upload-time = "2025-11-05T18:38:31.618Z" },
+    { url = "https://files.pythonhosted.org/packages/62/28/4d00cb9bd76a6357a66fcd54b4b6d70288385584063f4b07884c1e7286ac/brotli-1.2.0-cp312-cp312-win32.whl", hash = "sha256:e99befa0b48f3cd293dafeacdd0d191804d105d279e0b387a32054c1180f3161", size = 334362, upload-time = "2025-11-05T18:38:32.939Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/4e/bc1dcac9498859d5e353c9b153627a3752868a9d5f05ce8dedd81a2354ab/brotli-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:b35c13ce241abdd44cb8ca70683f20c0c079728a36a996297adb5334adfc1c44", size = 369115, upload-time = "2025-11-05T18:38:33.765Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/d4/4ad5432ac98c73096159d9ce7ffeb82d151c2ac84adcc6168e476bb54674/brotli-1.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9e5825ba2c9998375530504578fd4d5d1059d09621a02065d1b6bfc41a8e05ab", size = 861523, upload-time = "2025-11-05T18:38:34.67Z" },
+    { url = "https://files.pythonhosted.org/packages/91/9f/9cc5bd03ee68a85dc4bc89114f7067c056a3c14b3d95f171918c088bf88d/brotli-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0cf8c3b8ba93d496b2fae778039e2f5ecc7cff99df84df337ca31d8f2252896c", size = 444289, upload-time = "2025-11-05T18:38:35.6Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b6/fe84227c56a865d16a6614e2c4722864b380cb14b13f3e6bef441e73a85a/brotli-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8565e3cdc1808b1a34714b553b262c5de5fbda202285782173ec137fd13709f", size = 1528076, upload-time = "2025-11-05T18:38:36.639Z" },
+    { url = "https://files.pythonhosted.org/packages/55/de/de4ae0aaca06c790371cf6e7ee93a024f6b4bb0568727da8c3de112e726c/brotli-1.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:26e8d3ecb0ee458a9804f47f21b74845cc823fd1bb19f02272be70774f56e2a6", size = 1626880, upload-time = "2025-11-05T18:38:37.623Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/16/a1b22cbea436642e071adcaf8d4b350a2ad02f5e0ad0da879a1be16188a0/brotli-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67a91c5187e1eec76a61625c77a6c8c785650f5b576ca732bd33ef58b0dff49c", size = 1419737, upload-time = "2025-11-05T18:38:38.729Z" },
+    { url = "https://files.pythonhosted.org/packages/46/63/c968a97cbb3bdbf7f974ef5a6ab467a2879b82afbc5ffb65b8acbb744f95/brotli-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4ecdb3b6dc36e6d6e14d3a1bdc6c1057c8cbf80db04031d566eb6080ce283a48", size = 1484440, upload-time = "2025-11-05T18:38:39.916Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9d/102c67ea5c9fc171f423e8399e585dabea29b5bc79b05572891e70013cdd/brotli-1.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3e1b35d56856f3ed326b140d3c6d9db91740f22e14b06e840fe4bb1923439a18", size = 1593313, upload-time = "2025-11-05T18:38:41.24Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/4a/9526d14fa6b87bc827ba1755a8440e214ff90de03095cacd78a64abe2b7d/brotli-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54a50a9dad16b32136b2241ddea9e4df159b41247b2ce6aac0b3276a66a8f1e5", size = 1487945, upload-time = "2025-11-05T18:38:42.277Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e8/3fe1ffed70cbef83c5236166acaed7bb9c766509b157854c80e2f766b38c/brotli-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1b1d6a4efedd53671c793be6dd760fcf2107da3a52331ad9ea429edf0902f27a", size = 334368, upload-time = "2025-11-05T18:38:43.345Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/91/e739587be970a113b37b821eae8097aac5a48e5f0eca438c22e4c7dd8648/brotli-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:b63daa43d82f0cdabf98dee215b375b4058cce72871fd07934f179885aad16e8", size = 369116, upload-time = "2025-11-05T18:38:44.609Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/298c2ddf786bb7347a1cd71d63a347a79e5712a7c0cba9e3c3458ebd976f/brotli-1.2.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6c12dad5cd04530323e723787ff762bac749a7b256a5bece32b2243dd5c27b21", size = 863080, upload-time = "2025-11-05T18:38:45.503Z" },
+    { url = "https://files.pythonhosted.org/packages/84/0c/aac98e286ba66868b2b3b50338ffbd85a35c7122e9531a73a37a29763d38/brotli-1.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3219bd9e69868e57183316ee19c84e03e8f8b5a1d1f2667e1aa8c2f91cb061ac", size = 445453, upload-time = "2025-11-05T18:38:46.433Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/f1/0ca1f3f99ae300372635ab3fe2f7a79fa335fee3d874fa7f9e68575e0e62/brotli-1.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:963a08f3bebd8b75ac57661045402da15991468a621f014be54e50f53a58d19e", size = 1528168, upload-time = "2025-11-05T18:38:47.371Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a6/2ebfc8f766d46df8d3e65b880a2e220732395e6d7dc312c1e1244b0f074a/brotli-1.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9322b9f8656782414b37e6af884146869d46ab85158201d82bab9abbcb971dc7", size = 1627098, upload-time = "2025-11-05T18:38:48.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/2f/0976d5b097ff8a22163b10617f76b2557f15f0f39d6a0fe1f02b1a53e92b/brotli-1.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf9cba6f5b78a2071ec6fb1e7bd39acf35071d90a81231d67e92d637776a6a63", size = 1419861, upload-time = "2025-11-05T18:38:49.372Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/97/d76df7176a2ce7616ff94c1fb72d307c9a30d2189fe877f3dd99af00ea5a/brotli-1.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7547369c4392b47d30a3467fe8c3330b4f2e0f7730e45e3103d7d636678a808b", size = 1484594, upload-time = "2025-11-05T18:38:50.655Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/93/14cf0b1216f43df5609f5b272050b0abd219e0b54ea80b47cef9867b45e7/brotli-1.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1530af5c3c275b8524f2e24841cbe2599d74462455e9bae5109e9ff42e9361", size = 1593455, upload-time = "2025-11-05T18:38:51.624Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/73/3183c9e41ca755713bdf2cc1d0810df742c09484e2e1ddd693bee53877c1/brotli-1.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d2d085ded05278d1c7f65560aae97b3160aeb2ea2c0b3e26204856beccb60888", size = 1488164, upload-time = "2025-11-05T18:38:53.079Z" },
+    { url = "https://files.pythonhosted.org/packages/64/6a/0c78d8f3a582859236482fd9fa86a65a60328a00983006bcf6d83b7b2253/brotli-1.2.0-cp314-cp314-win32.whl", hash = "sha256:832c115a020e463c2f67664560449a7bea26b0c1fdd690352addad6d0a08714d", size = 339280, upload-time = "2025-11-05T18:38:54.02Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/10/56978295c14794b2c12007b07f3e41ba26acda9257457d7085b0bb3bb90c/brotli-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:e7c0af964e0b4e3412a0ebf341ea26ec767fa0b4cf81abb5e897c9338b5ad6a3", size = 375639, upload-time = "2025-11-05T18:38:55.67Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.7.9"
@@ -306,6 +429,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload-time = "2025-05-02T08:34:40.053Z" },
 ]
 
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -387,9 +522,11 @@ version = "0.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "astropy" },
+    { name = "gradio" },
     { name = "jupyterlab" },
     { name = "matplotlib" },
     { name = "numpy" },
+    { name = "openpyxl" },
     { name = "pandas" },
     { name = "pandas-stubs" },
     { name = "pingouin" },
@@ -410,9 +547,11 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "astropy" },
+    { name = "gradio", specifier = ">=5.50.0" },
     { name = "jupyterlab" },
     { name = "matplotlib" },
     { name = "numpy" },
+    { name = "openpyxl", specifier = ">=3.1.5" },
     { name = "pandas" },
     { name = "pandas-stubs" },
     { name = "pingouin" },
@@ -546,6 +685,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973, upload-time = "2024-10-09T18:35:44.272Z" },
 ]
 
+[[package]]
+name = "et-xmlfile"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" },
+]
+
 [[package]]
 name = "executing"
 version = "2.2.0"
@@ -555,6 +703,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702, upload-time = "2025-01-22T15:41:25.929Z" },
 ]
 
+[[package]]
+name = "fastapi"
+version = "0.122.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/de/3ee97a4f6ffef1fb70bf20561e4f88531633bb5045dc6cebc0f8471f764d/fastapi-0.122.0.tar.gz", hash = "sha256:cd9b5352031f93773228af8b4c443eedc2ac2aa74b27780387b853c3726fb94b", size = 346436, upload-time = "2025-11-24T19:17:47.95Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/93/aa8072af4ff37b795f6bbf43dcaf61115f40f49935c7dbb180c9afc3f421/fastapi-0.122.0-py3-none-any.whl", hash = "sha256:a456e8915dfc6c8914a50d9651133bd47ec96d331c5b44600baa635538a30d67", size = 110671, upload-time = "2025-11-24T19:17:45.96Z" },
+]
+
 [[package]]
 name = "fastjsonschema"
 version = "2.21.1"
@@ -564,6 +727,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924, upload-time = "2024-12-02T10:55:07.599Z" },
 ]
 
+[[package]]
+name = "ffmpy"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/d2/1c4c582d71bcc65c76fa69fab85de6257d50fdf6fd4a2317c53917e9a581/ffmpy-1.0.0.tar.gz", hash = "sha256:b12932e95435c8820f1cd041024402765f821971e4bae753b327fc02a6e12f8b", size = 5101, upload-time = "2025-11-11T06:24:23.856Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/56/dd3669eccebb6d8ac81e624542ebd53fe6f08e1b8f2f8d50aeb7e3b83f99/ffmpy-1.0.0-py3-none-any.whl", hash = "sha256:5640e5f0fd03fb6236d0e119b16ccf6522db1c826fdf35dcb87087b60fd7504f", size = 5614, upload-time = "2025-11-11T06:24:22.818Z" },
+]
+
 [[package]]
 name = "filelock"
 version = "3.18.0"
@@ -615,6 +787,79 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" },
 ]
 
+[[package]]
+name = "fsspec"
+version = "2025.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/7f/2747c0d332b9acfa75dc84447a066fdf812b5a6b8d30472b74d309bfe8cb/fsspec-2025.10.0.tar.gz", hash = "sha256:b6789427626f068f9a83ca4e8a3cc050850b6c0f71f99ddb4f542b8266a26a59", size = 309285, upload-time = "2025-10-30T14:58:44.036Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/02/a6b21098b1d5d6249b7c5ab69dde30108a71e4e819d4a9778f1de1d5b70d/fsspec-2025.10.0-py3-none-any.whl", hash = "sha256:7c7712353ae7d875407f97715f0e1ffcc21e33d5b24556cb1e090ae9409ec61d", size = 200966, upload-time = "2025-10-30T14:58:42.53Z" },
+]
+
+[[package]]
+name = "gradio"
+version = "5.50.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiofiles" },
+    { name = "anyio" },
+    { name = "audioop-lts", marker = "python_full_version >= '3.13'" },
+    { name = "brotli" },
+    { name = "fastapi" },
+    { name = "ffmpy" },
+    { name = "gradio-client" },
+    { name = "groovy" },
+    { name = "httpx" },
+    { name = "huggingface-hub" },
+    { name = "jinja2" },
+    { name = "markupsafe" },
+    { name = "numpy" },
+    { name = "orjson" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "pillow" },
+    { name = "pydantic" },
+    { name = "pydub" },
+    { name = "python-multipart" },
+    { name = "pyyaml" },
+    { name = "ruff" },
+    { name = "safehttpx" },
+    { name = "semantic-version" },
+    { name = "starlette" },
+    { name = "tomlkit" },
+    { name = "typer" },
+    { name = "typing-extensions" },
+    { name = "uvicorn" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/04/8daf96bd6d2470f03e2a15a9fc900c7ecf6549619173f16c5944c7ec15a7/gradio-5.50.0-py3-none-any.whl", hash = "sha256:d06770d57cdda9b703ef9cf767ac93a890a0e12d82679a310eef74203a3673f4", size = 63530991, upload-time = "2025-11-21T18:07:19.239Z" },
+]
+
+[[package]]
+name = "gradio-client"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fsspec" },
+    { name = "httpx" },
+    { name = "huggingface-hub" },
+    { name = "packaging" },
+    { name = "typing-extensions" },
+    { name = "websockets" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/8a/f2a47134c5b5a7f3bad27eae749589a80d81efaaad8f59af47c136712bf6/gradio_client-1.14.0-py3-none-any.whl", hash = "sha256:9a2f5151978411e0f8b55a2d38cddd0a94491851149d14db4af96f5a09774825", size = 325555, upload-time = "2025-11-21T18:04:21.834Z" },
+]
+
+[[package]]
+name = "groovy"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/36/bbdede67400277bef33d3ec0e6a31750da972c469f75966b4930c753218f/groovy-0.1.2.tar.gz", hash = "sha256:25c1dc09b3f9d7e292458aa762c6beb96ea037071bf5e917fc81fb78d2231083", size = 17325, upload-time = "2025-02-28T20:24:56.068Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/27/3d6dcadc8a3214d8522c1e7f6a19554e33659be44546d44a2f7572ac7d2a/groovy-0.1.2-py3-none-any.whl", hash = "sha256:7f7975bab18c729a257a8b1ae9dcd70b7cafb1720481beae47719af57c35fa64", size = 14090, upload-time = "2025-02-28T20:24:55.152Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -624,6 +869,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
 ]
 
+[[package]]
+name = "hf-xet"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/6e/0f11bacf08a67f7fb5ee09740f2ca54163863b07b70d579356e9222ce5d8/hf_xet-1.2.0.tar.gz", hash = "sha256:a8c27070ca547293b6890c4bf389f713f80e8c478631432962bb7f4bc0bd7d7f", size = 506020, upload-time = "2025-10-24T19:04:32.129Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/a5/85ef910a0aa034a2abcfadc360ab5ac6f6bc4e9112349bd40ca97551cff0/hf_xet-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ceeefcd1b7aed4956ae8499e2199607765fbd1c60510752003b6cc0b8413b649", size = 2861870, upload-time = "2025-10-24T19:04:11.422Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/40/e2e0a7eb9a51fe8828ba2d47fe22a7e74914ea8a0db68a18c3aa7449c767/hf_xet-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b70218dd548e9840224df5638fdc94bd033552963cfa97f9170829381179c813", size = 2717584, upload-time = "2025-10-24T19:04:09.586Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/7d/daf7f8bc4594fdd59a8a596f9e3886133fdc68e675292218a5e4c1b7e834/hf_xet-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d40b18769bb9a8bc82a9ede575ce1a44c75eb80e7375a01d76259089529b5dc", size = 3315004, upload-time = "2025-10-24T19:04:00.314Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/ba/45ea2f605fbf6d81c8b21e4d970b168b18a53515923010c312c06cd83164/hf_xet-1.2.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd3a6027d59cfb60177c12d6424e31f4b5ff13d8e3a1247b3a584bf8977e6df5", size = 3222636, upload-time = "2025-10-24T19:03:58.111Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/1d/04513e3cab8f29ab8c109d309ddd21a2705afab9d52f2ba1151e0c14f086/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6de1fc44f58f6dd937956c8d304d8c2dea264c80680bcfa61ca4a15e7b76780f", size = 3408448, upload-time = "2025-10-24T19:04:20.951Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7c/60a2756d7feec7387db3a1176c632357632fbe7849fce576c5559d4520c7/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f182f264ed2acd566c514e45da9f2119110e48a87a327ca271027904c70c5832", size = 3503401, upload-time = "2025-10-24T19:04:22.549Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/64/48fffbd67fb418ab07451e4ce641a70de1c40c10a13e25325e24858ebe5a/hf_xet-1.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:293a7a3787e5c95d7be1857358a9130694a9c6021de3f27fa233f37267174382", size = 2900866, upload-time = "2025-10-24T19:04:33.461Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/51/f7e2caae42f80af886db414d4e9885fac959330509089f97cccb339c6b87/hf_xet-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:10bfab528b968c70e062607f663e21e34e2bba349e8038db546646875495179e", size = 2861861, upload-time = "2025-10-24T19:04:19.01Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/1d/a641a88b69994f9371bd347f1dd35e5d1e2e2460a2e350c8d5165fc62005/hf_xet-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a212e842647b02eb6a911187dc878e79c4aa0aa397e88dd3b26761676e8c1f8", size = 2717699, upload-time = "2025-10-24T19:04:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/df/e0/e5e9bba7d15f0318955f7ec3f4af13f92e773fbb368c0b8008a5acbcb12f/hf_xet-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30e06daccb3a7d4c065f34fc26c14c74f4653069bb2b194e7f18f17cbe9939c0", size = 3314885, upload-time = "2025-10-24T19:04:07.642Z" },
+    { url = "https://files.pythonhosted.org/packages/21/90/b7fe5ff6f2b7b8cbdf1bd56145f863c90a5807d9758a549bf3d916aa4dec/hf_xet-1.2.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:29c8fc913a529ec0a91867ce3d119ac1aac966e098cf49501800c870328cc090", size = 3221550, upload-time = "2025-10-24T19:04:05.55Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/cb/73f276f0a7ce46cc6a6ec7d6c7d61cbfe5f2e107123d9bbd0193c355f106/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e159cbfcfbb29f920db2c09ed8b660eb894640d284f102ada929b6e3dc410a", size = 3408010, upload-time = "2025-10-24T19:04:28.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/1e/d642a12caa78171f4be64f7cd9c40e3ca5279d055d0873188a58c0f5fbb9/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c91d5ae931510107f148874e9e2de8a16052b6f1b3ca3c1b12f15ccb491390f", size = 3503264, upload-time = "2025-10-24T19:04:30.397Z" },
+    { url = "https://files.pythonhosted.org/packages/17/b5/33764714923fa1ff922770f7ed18c2daae034d21ae6e10dbf4347c854154/hf_xet-1.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:210d577732b519ac6ede149d2f2f34049d44e8622bf14eb3d63bbcd2d4b332dc", size = 2901071, upload-time = "2025-10-24T19:04:37.463Z" },
+    { url = "https://files.pythonhosted.org/packages/96/2d/22338486473df5923a9ab7107d375dbef9173c338ebef5098ef593d2b560/hf_xet-1.2.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:46740d4ac024a7ca9b22bebf77460ff43332868b661186a8e46c227fdae01848", size = 2866099, upload-time = "2025-10-24T19:04:15.366Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/8c/c5becfa53234299bc2210ba314eaaae36c2875e0045809b82e40a9544f0c/hf_xet-1.2.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:27df617a076420d8845bea087f59303da8be17ed7ec0cd7ee3b9b9f579dff0e4", size = 2722178, upload-time = "2025-10-24T19:04:13.695Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/92/cf3ab0b652b082e66876d08da57fcc6fa2f0e6c70dfbbafbd470bb73eb47/hf_xet-1.2.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3651fd5bfe0281951b988c0facbe726aa5e347b103a675f49a3fa8144c7968fd", size = 3320214, upload-time = "2025-10-24T19:04:03.596Z" },
+    { url = "https://files.pythonhosted.org/packages/46/92/3f7ec4a1b6a65bf45b059b6d4a5d38988f63e193056de2f420137e3c3244/hf_xet-1.2.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d06fa97c8562fb3ee7a378dd9b51e343bc5bc8190254202c9771029152f5e08c", size = 3229054, upload-time = "2025-10-24T19:04:01.949Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/dd/7ac658d54b9fb7999a0ccb07ad863b413cbaf5cf172f48ebcd9497ec7263/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4c1428c9ae73ec0939410ec73023c4f842927f39db09b063b9482dac5a3bb737", size = 3413812, upload-time = "2025-10-24T19:04:24.585Z" },
+    { url = "https://files.pythonhosted.org/packages/92/68/89ac4e5b12a9ff6286a12174c8538a5930e2ed662091dd2572bbe0a18c8a/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a55558084c16b09b5ed32ab9ed38421e2d87cf3f1f89815764d1177081b99865", size = 3508920, upload-time = "2025-10-24T19:04:26.927Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735, upload-time = "2025-10-24T19:04:35.928Z" },
+]
+
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -652,6 +926,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
+[[package]]
+name = "huggingface-hub"
+version = "1.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "fsspec" },
+    { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
+    { name = "httpx" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "shellingham" },
+    { name = "tqdm" },
+    { name = "typer-slim" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fb/02/c3d534d7498ba2792da1d2ce56b5d38bbcbcbbba62071c90ee289b408e8d/huggingface_hub-1.1.5.tar.gz", hash = "sha256:40ba5c9a08792d888fde6088920a0a71ab3cd9d5e6617c81a797c657f1fd9968", size = 607199, upload-time = "2025-11-20T15:49:32.809Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/f4/124858007ddf3c61e9b144107304c9152fa80b5b6c168da07d86fe583cc1/huggingface_hub-1.1.5-py3-none-any.whl", hash = "sha256:e88ecc129011f37b868586bbcfae6c56868cae80cd56a79d61575426a3aa0d7d", size = 516000, upload-time = "2025-11-20T15:49:30.926Z" },
+]
+
 [[package]]
 name = "identify"
 version = "2.6.12"
@@ -1060,6 +1355,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213, upload-time = "2024-12-24T18:30:40.019Z" },
 ]
 
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
 [[package]]
 name = "markupsafe"
 version = "3.0.2"
@@ -1163,6 +1470,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" },
 ]
 
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
 [[package]]
 name = "mistune"
 version = "3.1.3"
@@ -1315,6 +1631,86 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/48/6b/1c6b515a83d5564b1698a61efa245727c8feecf308f4091f565988519d20/numpy-2.3.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e610832418a2bc09d974cc9fecebfa51e9532d6190223bc5ef6a7402ebf3b5cb", size = 12927246, upload-time = "2025-06-21T12:27:38.618Z" },
 ]
 
+[[package]]
+name = "openpyxl"
+version = "3.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "et-xmlfile" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" },
+]
+
+[[package]]
+name = "orjson"
+version = "3.11.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c6/fe/ed708782d6709cc60eb4c2d8a361a440661f74134675c72990f2c48c785f/orjson-3.11.4.tar.gz", hash = "sha256:39485f4ab4c9b30a3943cfe99e1a213c4776fb69e8abd68f66b83d5a0b0fdc6d", size = 5945188, upload-time = "2025-10-24T15:50:38.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/1d/1ea6005fffb56715fd48f632611e163d1604e8316a5bad2288bee9a1c9eb/orjson-3.11.4-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:5e59d23cd93ada23ec59a96f215139753fbfe3a4d989549bcb390f8c00370b39", size = 243498, upload-time = "2025-10-24T15:48:48.101Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d7/ffed10c7da677f2a9da307d491b9eb1d0125b0307019c4ad3d665fd31f4f/orjson-3.11.4-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:5c3aedecfc1beb988c27c79d52ebefab93b6c3921dbec361167e6559aba2d36d", size = 128961, upload-time = "2025-10-24T15:48:49.571Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/96/3e4d10a18866d1368f73c8c44b7fe37cc8a15c32f2a7620be3877d4c55a3/orjson-3.11.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da9e5301f1c2caa2a9a4a303480d79c9ad73560b2e7761de742ab39fe59d9175", size = 130321, upload-time = "2025-10-24T15:48:50.713Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/1f/465f66e93f434f968dd74d5b623eb62c657bdba2332f5a8be9f118bb74c7/orjson-3.11.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8873812c164a90a79f65368f8f96817e59e35d0cc02786a5356f0e2abed78040", size = 129207, upload-time = "2025-10-24T15:48:52.193Z" },
+    { url = "https://files.pythonhosted.org/packages/28/43/d1e94837543321c119dff277ae8e348562fe8c0fafbb648ef7cb0c67e521/orjson-3.11.4-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5d7feb0741ebb15204e748f26c9638e6665a5fa93c37a2c73d64f1669b0ddc63", size = 136323, upload-time = "2025-10-24T15:48:54.806Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/04/93303776c8890e422a5847dd012b4853cdd88206b8bbd3edc292c90102d1/orjson-3.11.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01ee5487fefee21e6910da4c2ee9eef005bee568a0879834df86f888d2ffbdd9", size = 137440, upload-time = "2025-10-24T15:48:56.326Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/ef/75519d039e5ae6b0f34d0336854d55544ba903e21bf56c83adc51cd8bf82/orjson-3.11.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d40d46f348c0321df01507f92b95a377240c4ec31985225a6668f10e2676f9a", size = 136680, upload-time = "2025-10-24T15:48:57.476Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/18/bf8581eaae0b941b44efe14fee7b7862c3382fbc9a0842132cfc7cf5ecf4/orjson-3.11.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95713e5fc8af84d8edc75b785d2386f653b63d62b16d681687746734b4dfc0be", size = 136160, upload-time = "2025-10-24T15:48:59.631Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/35/a6d582766d351f87fc0a22ad740a641b0a8e6fc47515e8614d2e4790ae10/orjson-3.11.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ad73ede24f9083614d6c4ca9a85fe70e33be7bf047ec586ee2363bc7418fe4d7", size = 140318, upload-time = "2025-10-24T15:49:00.834Z" },
+    { url = "https://files.pythonhosted.org/packages/76/b3/5a4801803ab2e2e2d703bce1a56540d9f99a9143fbec7bf63d225044fef8/orjson-3.11.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:842289889de515421f3f224ef9c1f1efb199a32d76d8d2ca2706fa8afe749549", size = 406330, upload-time = "2025-10-24T15:49:02.327Z" },
+    { url = "https://files.pythonhosted.org/packages/80/55/a8f682f64833e3a649f620eafefee175cbfeb9854fc5b710b90c3bca45df/orjson-3.11.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3b2427ed5791619851c52a1261b45c233930977e7de8cf36de05636c708fa905", size = 149580, upload-time = "2025-10-24T15:49:03.517Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/e4/c132fa0c67afbb3eb88274fa98df9ac1f631a675e7877037c611805a4413/orjson-3.11.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3c36e524af1d29982e9b190573677ea02781456b2e537d5840e4538a5ec41907", size = 139846, upload-time = "2025-10-24T15:49:04.761Z" },
+    { url = "https://files.pythonhosted.org/packages/54/06/dc3491489efd651fef99c5908e13951abd1aead1257c67f16135f95ce209/orjson-3.11.4-cp311-cp311-win32.whl", hash = "sha256:87255b88756eab4a68ec61837ca754e5d10fa8bc47dc57f75cedfeaec358d54c", size = 135781, upload-time = "2025-10-24T15:49:05.969Z" },
+    { url = "https://files.pythonhosted.org/packages/79/b7/5e5e8d77bd4ea02a6ac54c42c818afb01dd31961be8a574eb79f1d2cfb1e/orjson-3.11.4-cp311-cp311-win_amd64.whl", hash = "sha256:e2d5d5d798aba9a0e1fede8d853fa899ce2cb930ec0857365f700dffc2c7af6a", size = 131391, upload-time = "2025-10-24T15:49:07.355Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/dc/9484127cc1aa213be398ed735f5f270eedcb0c0977303a6f6ddc46b60204/orjson-3.11.4-cp311-cp311-win_arm64.whl", hash = "sha256:6bb6bb41b14c95d4f2702bce9975fda4516f1db48e500102fc4d8119032ff045", size = 126252, upload-time = "2025-10-24T15:49:08.869Z" },
+    { url = "https://files.pythonhosted.org/packages/63/51/6b556192a04595b93e277a9ff71cd0cc06c21a7df98bcce5963fa0f5e36f/orjson-3.11.4-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:d4371de39319d05d3f482f372720b841c841b52f5385bd99c61ed69d55d9ab50", size = 243571, upload-time = "2025-10-24T15:49:10.008Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/2c/2602392ddf2601d538ff11848b98621cd465d1a1ceb9db9e8043181f2f7b/orjson-3.11.4-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:e41fd3b3cac850eaae78232f37325ed7d7436e11c471246b87b2cd294ec94853", size = 128891, upload-time = "2025-10-24T15:49:11.297Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/47/bf85dcf95f7a3a12bf223394a4f849430acd82633848d52def09fa3f46ad/orjson-3.11.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:600e0e9ca042878c7fdf189cf1b028fe2c1418cc9195f6cb9824eb6ed99cb938", size = 130137, upload-time = "2025-10-24T15:49:12.544Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/4d/a0cb31007f3ab6f1fd2a1b17057c7c349bc2baf8921a85c0180cc7be8011/orjson-3.11.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7bbf9b333f1568ef5da42bc96e18bf30fd7f8d54e9ae066d711056add508e415", size = 129152, upload-time = "2025-10-24T15:49:13.754Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ef/2811def7ce3d8576b19e3929fff8f8f0d44bc5eb2e0fdecb2e6e6cc6c720/orjson-3.11.4-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4806363144bb6e7297b8e95870e78d30a649fdc4e23fc84daa80c8ebd366ce44", size = 136834, upload-time = "2025-10-24T15:49:15.307Z" },
+    { url = "https://files.pythonhosted.org/packages/00/d4/9aee9e54f1809cec8ed5abd9bc31e8a9631d19460e3b8470145d25140106/orjson-3.11.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad355e8308493f527d41154e9053b86a5be892b3b359a5c6d5d95cda23601cb2", size = 137519, upload-time = "2025-10-24T15:49:16.557Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ea/67bfdb5465d5679e8ae8d68c11753aaf4f47e3e7264bad66dc2f2249e643/orjson-3.11.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c8a7517482667fb9f0ff1b2f16fe5829296ed7a655d04d68cd9711a4d8a4e708", size = 136749, upload-time = "2025-10-24T15:49:17.796Z" },
+    { url = "https://files.pythonhosted.org/packages/01/7e/62517dddcfce6d53a39543cd74d0dccfcbdf53967017c58af68822100272/orjson-3.11.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97eb5942c7395a171cbfecc4ef6701fc3c403e762194683772df4c54cfbb2210", size = 136325, upload-time = "2025-10-24T15:49:19.347Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ae/40516739f99ab4c7ec3aaa5cc242d341fcb03a45d89edeeaabc5f69cb2cf/orjson-3.11.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:149d95d5e018bdd822e3f38c103b1a7c91f88d38a88aada5c4e9b3a73a244241", size = 140204, upload-time = "2025-10-24T15:49:20.545Z" },
+    { url = "https://files.pythonhosted.org/packages/82/18/ff5734365623a8916e3a4037fcef1cd1782bfc14cf0992afe7940c5320bf/orjson-3.11.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:624f3951181eb46fc47dea3d221554e98784c823e7069edb5dbd0dc826ac909b", size = 406242, upload-time = "2025-10-24T15:49:21.884Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/43/96436041f0a0c8c8deca6a05ebeaf529bf1de04839f93ac5e7c479807aec/orjson-3.11.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:03bfa548cf35e3f8b3a96c4e8e41f753c686ff3d8e182ce275b1751deddab58c", size = 150013, upload-time = "2025-10-24T15:49:23.185Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/48/78302d98423ed8780479a1e682b9aecb869e8404545d999d34fa486e573e/orjson-3.11.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:525021896afef44a68148f6ed8a8bf8375553d6066c7f48537657f64823565b9", size = 139951, upload-time = "2025-10-24T15:49:24.428Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/7b/ad613fdcdaa812f075ec0875143c3d37f8654457d2af17703905425981bf/orjson-3.11.4-cp312-cp312-win32.whl", hash = "sha256:b58430396687ce0f7d9eeb3dd47761ca7d8fda8e9eb92b3077a7a353a75efefa", size = 136049, upload-time = "2025-10-24T15:49:25.973Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/3c/9cf47c3ff5f39b8350fb21ba65d789b6a1129d4cbb3033ba36c8a9023520/orjson-3.11.4-cp312-cp312-win_amd64.whl", hash = "sha256:c6dbf422894e1e3c80a177133c0dda260f81428f9de16d61041949f6a2e5c140", size = 131461, upload-time = "2025-10-24T15:49:27.259Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/3b/e2425f61e5825dc5b08c2a5a2b3af387eaaca22a12b9c8c01504f8614c36/orjson-3.11.4-cp312-cp312-win_arm64.whl", hash = "sha256:d38d2bc06d6415852224fcc9c0bfa834c25431e466dc319f0edd56cca81aa96e", size = 126167, upload-time = "2025-10-24T15:49:28.511Z" },
+    { url = "https://files.pythonhosted.org/packages/23/15/c52aa7112006b0f3d6180386c3a46ae057f932ab3425bc6f6ac50431cca1/orjson-3.11.4-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:2d6737d0e616a6e053c8b4acc9eccea6b6cce078533666f32d140e4f85002534", size = 243525, upload-time = "2025-10-24T15:49:29.737Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/38/05340734c33b933fd114f161f25a04e651b0c7c33ab95e9416ade5cb44b8/orjson-3.11.4-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:afb14052690aa328cc118a8e09f07c651d301a72e44920b887c519b313d892ff", size = 128871, upload-time = "2025-10-24T15:49:31.109Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b9/ae8d34899ff0c012039b5a7cb96a389b2476e917733294e498586b45472d/orjson-3.11.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38aa9e65c591febb1b0aed8da4d469eba239d434c218562df179885c94e1a3ad", size = 130055, upload-time = "2025-10-24T15:49:33.382Z" },
+    { url = "https://files.pythonhosted.org/packages/33/aa/6346dd5073730451bee3681d901e3c337e7ec17342fb79659ec9794fc023/orjson-3.11.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f2cf4dfaf9163b0728d061bebc1e08631875c51cd30bf47cb9e3293bfbd7dcd5", size = 129061, upload-time = "2025-10-24T15:49:34.935Z" },
+    { url = "https://files.pythonhosted.org/packages/39/e4/8eea51598f66a6c853c380979912d17ec510e8e66b280d968602e680b942/orjson-3.11.4-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:89216ff3dfdde0e4070932e126320a1752c9d9a758d6a32ec54b3b9334991a6a", size = 136541, upload-time = "2025-10-24T15:49:36.923Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/47/cb8c654fa9adcc60e99580e17c32b9e633290e6239a99efa6b885aba9dbc/orjson-3.11.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9daa26ca8e97fae0ce8aa5d80606ef8f7914e9b129b6b5df9104266f764ce436", size = 137535, upload-time = "2025-10-24T15:49:38.307Z" },
+    { url = "https://files.pythonhosted.org/packages/43/92/04b8cc5c2b729f3437ee013ce14a60ab3d3001465d95c184758f19362f23/orjson-3.11.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c8b2769dc31883c44a9cd126560327767f848eb95f99c36c9932f51090bfce9", size = 136703, upload-time = "2025-10-24T15:49:40.795Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/fd/d0733fcb9086b8be4ebcfcda2d0312865d17d0d9884378b7cffb29d0763f/orjson-3.11.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1469d254b9884f984026bd9b0fa5bbab477a4bfe558bba6848086f6d43eb5e73", size = 136293, upload-time = "2025-10-24T15:49:42.347Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/d7/3c5514e806837c210492d72ae30ccf050ce3f940f45bf085bab272699ef4/orjson-3.11.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:68e44722541983614e37117209a194e8c3ad07838ccb3127d96863c95ec7f1e0", size = 140131, upload-time = "2025-10-24T15:49:43.638Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/dd/ba9d32a53207babf65bd510ac4d0faaa818bd0df9a9c6f472fe7c254f2e3/orjson-3.11.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:8e7805fda9672c12be2f22ae124dcd7b03928d6c197544fe12174b86553f3196", size = 406164, upload-time = "2025-10-24T15:49:45.498Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/f9/f68ad68f4af7c7bde57cd514eaa2c785e500477a8bc8f834838eb696a685/orjson-3.11.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:04b69c14615fb4434ab867bf6f38b2d649f6f300af30a6705397e895f7aec67a", size = 149859, upload-time = "2025-10-24T15:49:46.981Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d2/7f847761d0c26818395b3d6b21fb6bc2305d94612a35b0a30eae65a22728/orjson-3.11.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:639c3735b8ae7f970066930e58cf0ed39a852d417c24acd4a25fc0b3da3c39a6", size = 139926, upload-time = "2025-10-24T15:49:48.321Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/37/acd14b12dc62db9a0e1d12386271b8661faae270b22492580d5258808975/orjson-3.11.4-cp313-cp313-win32.whl", hash = "sha256:6c13879c0d2964335491463302a6ca5ad98105fc5db3565499dcb80b1b4bd839", size = 136007, upload-time = "2025-10-24T15:49:49.938Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/a9/967be009ddf0a1fffd7a67de9c36656b28c763659ef91352acc02cbe364c/orjson-3.11.4-cp313-cp313-win_amd64.whl", hash = "sha256:09bf242a4af98732db9f9a1ec57ca2604848e16f132e3f72edfd3c5c96de009a", size = 131314, upload-time = "2025-10-24T15:49:51.248Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/db/399abd6950fbd94ce125cb8cd1a968def95174792e127b0642781e040ed4/orjson-3.11.4-cp313-cp313-win_arm64.whl", hash = "sha256:a85f0adf63319d6c1ba06fb0dbf997fced64a01179cf17939a6caca662bf92de", size = 126152, upload-time = "2025-10-24T15:49:52.922Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e3/54ff63c093cc1697e758e4fceb53164dd2661a7d1bcd522260ba09f54533/orjson-3.11.4-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:42d43a1f552be1a112af0b21c10a5f553983c2a0938d2bbb8ecd8bc9fb572803", size = 243501, upload-time = "2025-10-24T15:49:54.288Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/7d/e2d1076ed2e8e0ae9badca65bf7ef22710f93887b29eaa37f09850604e09/orjson-3.11.4-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:26a20f3fbc6c7ff2cb8e89c4c5897762c9d88cf37330c6a117312365d6781d54", size = 128862, upload-time = "2025-10-24T15:49:55.961Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/37/ca2eb40b90621faddfa9517dfe96e25f5ae4d8057a7c0cdd613c17e07b2c/orjson-3.11.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e3f20be9048941c7ffa8fc523ccbd17f82e24df1549d1d1fe9317712d19938e", size = 130047, upload-time = "2025-10-24T15:49:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/62/1021ed35a1f2bad9040f05fa4cc4f9893410df0ba3eaa323ccf899b1c90a/orjson-3.11.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aac364c758dc87a52e68e349924d7e4ded348dedff553889e4d9f22f74785316", size = 129073, upload-time = "2025-10-24T15:49:58.782Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/3f/f84d966ec2a6fd5f73b1a707e7cd876813422ae4bf9f0145c55c9c6a0f57/orjson-3.11.4-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d5c54a6d76e3d741dcc3f2707f8eeb9ba2a791d3adbf18f900219b62942803b1", size = 136597, upload-time = "2025-10-24T15:50:00.12Z" },
+    { url = "https://files.pythonhosted.org/packages/32/78/4fa0aeca65ee82bbabb49e055bd03fa4edea33f7c080c5c7b9601661ef72/orjson-3.11.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f28485bdca8617b79d44627f5fb04336897041dfd9fa66d383a49d09d86798bc", size = 137515, upload-time = "2025-10-24T15:50:01.57Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/9d/0c102e26e7fde40c4c98470796d050a2ec1953897e2c8ab0cb95b0759fa2/orjson-3.11.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bfc2a484cad3585e4ba61985a6062a4c2ed5c7925db6d39f1fa267c9d166487f", size = 136703, upload-time = "2025-10-24T15:50:02.944Z" },
+    { url = "https://files.pythonhosted.org/packages/df/ac/2de7188705b4cdfaf0b6c97d2f7849c17d2003232f6e70df98602173f788/orjson-3.11.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e34dbd508cb91c54f9c9788923daca129fe5b55c5b4eebe713bf5ed3791280cf", size = 136311, upload-time = "2025-10-24T15:50:04.441Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/52/847fcd1a98407154e944feeb12e3b4d487a0e264c40191fb44d1269cbaa1/orjson-3.11.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b13c478fa413d4b4ee606ec8e11c3b2e52683a640b006bb586b3041c2ca5f606", size = 140127, upload-time = "2025-10-24T15:50:07.398Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ae/21d208f58bdb847dd4d0d9407e2929862561841baa22bdab7aea10ca088e/orjson-3.11.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:724ca721ecc8a831b319dcd72cfa370cc380db0bf94537f08f7edd0a7d4e1780", size = 406201, upload-time = "2025-10-24T15:50:08.796Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/55/0789d6de386c8366059db098a628e2ad8798069e94409b0d8935934cbcb9/orjson-3.11.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:977c393f2e44845ce1b540e19a786e9643221b3323dae190668a98672d43fb23", size = 149872, upload-time = "2025-10-24T15:50:10.234Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/1d/7ff81ea23310e086c17b41d78a72270d9de04481e6113dbe2ac19118f7fb/orjson-3.11.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1e539e382cf46edec157ad66b0b0872a90d829a6b71f17cb633d6c160a223155", size = 139931, upload-time = "2025-10-24T15:50:11.623Z" },
+    { url = "https://files.pythonhosted.org/packages/77/92/25b886252c50ed64be68c937b562b2f2333b45afe72d53d719e46a565a50/orjson-3.11.4-cp314-cp314-win32.whl", hash = "sha256:d63076d625babab9db5e7836118bdfa086e60f37d8a174194ae720161eb12394", size = 136065, upload-time = "2025-10-24T15:50:13.025Z" },
+    { url = "https://files.pythonhosted.org/packages/63/b8/718eecf0bb7e9d64e4956afaafd23db9f04c776d445f59fe94f54bdae8f0/orjson-3.11.4-cp314-cp314-win_amd64.whl", hash = "sha256:0a54d6635fa3aaa438ae32e8570b9f0de36f3f6562c308d2a2a452e8b0592db1", size = 131310, upload-time = "2025-10-24T15:50:14.46Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/bf/def5e25d4d8bfce296a9a7c8248109bf58622c21618b590678f945a2c59c/orjson-3.11.4-cp314-cp314-win_arm64.whl", hash = "sha256:78b999999039db3cf58f6d230f524f04f75f129ba3d1ca2ed121f8657e575d3d", size = 126151, upload-time = "2025-10-24T15:50:15.878Z" },
+]
+
 [[package]]
 name = "overrides"
 version = "7.7.0"
@@ -1723,6 +2119,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload-time = "2025-04-23T18:33:30.645Z" },
 ]
 
+[[package]]
+name = "pydub"
+version = "0.25.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/9a/e6bca0eed82db26562c73b5076539a4a08d3cffd19c3cc5913a3e61145fd/pydub-0.25.1.tar.gz", hash = "sha256:980a33ce9949cab2a569606b65674d748ecbca4f0796887fd6f46173a7b0d30f", size = 38326, upload-time = "2021-03-10T02:09:54.659Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/53/d78dc063216e62fc55f6b2eebb447f6a4b0a59f55c8406376f76bf959b08/pydub-0.25.1-py2.py3-none-any.whl", hash = "sha256:65617e33033874b59d87db603aa1ed450633288aefead953b30bded59cb599a6", size = 32327, upload-time = "2021-03-10T02:09:53.503Z" },
+]
+
 [[package]]
 name = "pyerfa"
 version = "2.0.1.5"
@@ -1810,6 +2215,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/08/20/0f2523b9e50a8052bc6a8b732dfc8568abbdc42010aef03a2d750bdab3b2/python_json_logger-3.3.0-py3-none-any.whl", hash = "sha256:dd980fae8cffb24c13caf6e158d3d61c0d6d22342f932cb6e9deedab3d35eec7", size = 15163, upload-time = "2025-03-07T07:08:25.627Z" },
 ]
 
+[[package]]
+name = "python-multipart"
+version = "0.0.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" },
+]
+
 [[package]]
 name = "pytz"
 version = "2025.2"
@@ -1977,6 +2391,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" },
 ]
 
+[[package]]
+name = "rich"
+version = "14.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" },
+]
+
 [[package]]
 name = "rpds-py"
 version = "0.26.0"
@@ -2103,6 +2530,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e2/1f/72d2946e3cc7456bb837e88000eb3437e55f80db339c840c04015a11115d/ruff-0.12.2-py3-none-win_arm64.whl", hash = "sha256:48d6c6bfb4761df68bc05ae630e24f506755e702d4fb08f08460be778c7ccb12", size = 10735334, upload-time = "2025-07-03T16:40:17.677Z" },
 ]
 
+[[package]]
+name = "safehttpx"
+version = "0.1.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/89/d1/4282284d9cf1ee873607a46442da977fc3c985059315ab23610be31d5885/safehttpx-0.1.7.tar.gz", hash = "sha256:db201c0978c41eddb8bb480f3eee59dd67304fdd91646035e9d9a720049a9d23", size = 10385, upload-time = "2025-10-24T18:30:09.783Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/a3/0f0b7d78e2f1eb9e8e1afbff1d2bff8d60144aee17aca51c065b516743dd/safehttpx-0.1.7-py3-none-any.whl", hash = "sha256:c4f4a162db6993464d7ca3d7cc4af0ffc6515a606dfd220b9f82c6945d869cde", size = 8959, upload-time = "2025-10-24T18:30:08.733Z" },
+]
+
 [[package]]
 name = "scikit-learn"
 version = "1.7.0"
@@ -2197,6 +2636,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" },
 ]
 
+[[package]]
+name = "semantic-version"
+version = "2.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/31/f2289ce78b9b473d582568c234e104d2a342fd658cc288a7553d83bb8595/semantic_version-2.10.0.tar.gz", hash = "sha256:bdabb6d336998cbb378d4b9db3a4b56a1e3235701dc05ea2690d9a997ed5041c", size = 52289, upload-time = "2022-05-26T13:35:23.454Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/23/8146aad7d88f4fcb3a6218f41a60f6c2d4e3a72de72da1825dc7c8f7877c/semantic_version-2.10.0-py2.py3-none-any.whl", hash = "sha256:de78a3b8e0feda74cabc54aab2da702113e33ac9d9eb9d2389bcf1f58b7d9177", size = 15552, upload-time = "2022-05-26T13:35:21.206Z" },
+]
+
 [[package]]
 name = "send2trash"
 version = "1.8.3"
@@ -2215,6 +2663,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" },
 ]
 
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
 [[package]]
 name = "six"
 version = "1.17.0"
@@ -2256,6 +2713,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
 ]
 
+[[package]]
+name = "starlette"
+version = "0.50.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca", size = 2646985, upload-time = "2025-11-01T15:25:27.516Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload-time = "2025-11-01T15:25:25.461Z" },
+]
+
 [[package]]
 name = "statsmodels"
 version = "0.14.5"
@@ -2287,6 +2757,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1e/48/973da1ee8bc0743519759e74c3615b39acdc3faf00e0a0710f8c856d8c9d/statsmodels-0.14.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a085d47c8ef5387279a991633883d0e700de2b0acc812d7032d165888627bef", size = 10453538, upload-time = "2025-07-07T14:24:06.959Z" },
     { url = "https://files.pythonhosted.org/packages/c7/d6/18903fb707afd31cf1edaec5201964dbdacb2bfae9a22558274647a7c88f/statsmodels-0.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f866b2ebb2904b47c342d00def83c526ef2eb1df6a9a3c94ba5fe63d0005aec", size = 10681584, upload-time = "2025-07-07T14:24:21.038Z" },
     { url = "https://files.pythonhosted.org/packages/44/d6/80df1bbbfcdc50bff4152f43274420fa9856d56e234d160d6206eb1f5827/statsmodels-0.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:2a06bca03b7a492f88c8106103ab75f1a5ced25de90103a89f3a287518017939", size = 9604641, upload-time = "2025-07-07T12:08:36.23Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/6c/0fb40a89d715412160097c6f3387049ed88c9bd866c8838a8852c705ae2f/statsmodels-0.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:07c4dad25bbb15864a31b4917a820f6d104bdc24e5ddadcda59027390c3bed9e", size = 10211256, upload-time = "2025-10-30T13:46:58.591Z" },
+    { url = "https://files.pythonhosted.org/packages/88/4a/e36fe8b19270ab3e80df357da924c6c029cab0fb9a0fbd28aaf49341707d/statsmodels-0.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:babb067c852e966c2c933b79dbb5d0240919d861941a2ef6c0e13321c255528d", size = 10110933, upload-time = "2025-10-30T13:47:11.774Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/bf/1b7e7b1a6c09a88a9c5c9e60622c050dfd08af11c2e6d4a42dbc71b32ee1/statsmodels-0.14.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:110194b137286173cc676d7bad0119a197778de6478fc6cbdc3b33571165ac1e", size = 10253981, upload-time = "2025-10-30T16:32:22.399Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/d0/f95da95524bdd99613923ca61a3036d1308cee1290e5e8acb89f51736a8c/statsmodels-0.14.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c8a9c384a60c80731b278e7fd18764364c8817f4995b13a175d636f967823d1", size = 10460450, upload-time = "2025-10-30T16:32:44.985Z" },
+    { url = "https://files.pythonhosted.org/packages/28/bb/59e7be0271be264b7b541baf3973f97747740950bfd5115de731f63da8ab/statsmodels-0.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:557df3a870a57248df744fdfcc444ecbc5bdbf1c042b8a8b5d8e3e797830dc2a", size = 10694060, upload-time = "2025-10-30T16:33:07.656Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/c0/b28d0fd0347ea38d3610052f479e4b922eb33bb8790817f93cd89e6e08ba/statsmodels-0.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:95af7a9c4689d514f4341478b891f867766f3da297f514b8c4adf08f4fa61d03", size = 9648961, upload-time = "2025-10-30T13:47:24.303Z" },
 ]
 
 [[package]]
@@ -2372,6 +2848,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" },
 ]
 
+[[package]]
+name = "tomlkit"
+version = "0.13.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/18/0bbf3884e9eaa38819ebe46a7bd25dcd56b67434402b66a58c4b8e552575/tomlkit-0.13.3.tar.gz", hash = "sha256:430cf247ee57df2b94ee3fbe588e71d362a941ebb545dec29b53961d61add2a1", size = 185207, upload-time = "2025-06-05T07:13:44.947Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bd/75/8539d011f6be8e29f339c42e633aae3cb73bffa95dd0f9adec09b9c58e85/tomlkit-0.13.3-py3-none-any.whl", hash = "sha256:c89c649d79ee40629a9fda55f8ace8c6a1b42deb912b2a8fd8d942ddadb606b0", size = 38901, upload-time = "2025-06-05T07:13:43.546Z" },
+]
+
 [[package]]
 name = "tornado"
 version = "6.5.1"
@@ -2412,6 +2897,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
 ]
 
+[[package]]
+name = "typer"
+version = "0.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8f/28/7c85c8032b91dbe79725b6f17d2fffc595dff06a35c7a30a37bef73a1ab4/typer-0.20.0.tar.gz", hash = "sha256:1aaf6494031793e4876fb0bacfa6a912b551cf43c1e63c800df8b1a866720c37", size = 106492, upload-time = "2025-10-20T17:03:49.445Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/64/7713ffe4b5983314e9d436a90d5bd4f63b6054e2aca783a3cfc44cb95bbf/typer-0.20.0-py3-none-any.whl", hash = "sha256:5b463df6793ec1dca6213a3cf4c0f03bc6e322ac5e16e13ddd622a889489784a", size = 47028, upload-time = "2025-10-20T17:03:47.617Z" },
+]
+
+[[package]]
+name = "typer-slim"
+version = "0.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8e/45/81b94a52caed434b94da65729c03ad0fb7665fab0f7db9ee54c94e541403/typer_slim-0.20.0.tar.gz", hash = "sha256:9fc6607b3c6c20f5c33ea9590cbeb17848667c51feee27d9e314a579ab07d1a3", size = 106561, upload-time = "2025-10-20T17:03:46.642Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/dd/5cbf31f402f1cc0ab087c94d4669cfa55bd1e818688b910631e131d74e75/typer_slim-0.20.0-py3-none-any.whl", hash = "sha256:f42a9b7571a12b97dddf364745d29f12221865acef7a2680065f9bb29c7dc89d", size = 47087, upload-time = "2025-10-20T17:03:44.546Z" },
+]
+
 [[package]]
 name = "types-python-dateutil"
 version = "2.9.0.20250708"
@@ -2478,6 +2991,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" },
 ]
 
+[[package]]
+name = "uvicorn"
+version = "0.38.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" },
+]
+
 [[package]]
 name = "virtualenv"
 version = "20.31.2"
@@ -2528,6 +3054,48 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826, upload-time = "2024-04-23T22:16:14.422Z" },
 ]
 
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
+    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
+    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]
+
 [[package]]
 name = "xarray"
 version = "2025.7.0"