⚡️ Speed up function _stdev by 512%

[codeflash-ai]

📄 512% (5.12x) speedup for _stdev in unstructured/metrics/utils.py

⏱️ Runtime : 6.59 milliseconds → 1.08 milliseconds (best of 79 runs)

📝 Explanation and details

The optimized code achieves a 512% speedup (6.59ms → 1.08ms) by replacing the list comprehension and two-pass algorithm with Welford's online algorithm for computing standard deviation in a single pass.

Key Optimizations

1. Single-Pass Computation with Welford's Algorithm

• Original: Creates a filtered list via comprehension [score for score in scores if score is not None], then calls statistics.stdev() which makes another pass through the data
• Optimized: Computes mean and variance incrementally in one loop, filtering None values on-the-fly without allocating intermediate lists
• Why it's faster: Avoids list allocation overhead and reduces cache misses by processing data once

2. Eliminated Redundant List Creation
The line profiler shows the original spent 5.2% of time (1.19ms) just building the filtered list. The optimized version eliminates this entirely by checking if score is None: continue during iteration.

3. Direct Math Operations vs. Library Calls

• Original: Calls statistics.stdev() twice (86.4% and 7.8% of time in profiler)
• Optimized: Uses direct math.sqrt() and arithmetic operations (only 0.7% of time)
• Why it's faster: Avoids Python function call overhead and internal validation that statistics.stdev() performs

Performance Characteristics

Based on the annotated tests, the optimization excels at:

• Large datasets: 500-value test shows 795% speedup (1.01ms → 112μs)
• Lists with many None values: Efficient skip logic without list rebuilding
• Default use cases: Most tests show 400-800% speedup for typical 3-100 element lists
• No-rounding cases: 1068-2435% speedup when rounding=0/None/False since direct float return avoids round() overhead

Minor slowdowns (30-40%) occur only for edge cases returning None (empty/single-element lists) where the loop setup overhead exceeds the trivial original computation, but these are non-performance-critical paths.

Edge Case Handling

The code preserves correctness by falling back to the original statistics.stdev() path when encountering NaN values (via math.isnan() check), ensuring identical behavior including proper ValueError propagation for invalid inputs.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 5 Passed
🌀 Generated Regression Tests	✅ 74 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 1 Passed
📊 Tests Coverage	100.0%

⚙️ Click to see Existing Unit Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
metrics/test_utils.py::test_stats	73.5μs	16.9μs	335%✅

🌀 Click to see Generated Regression Tests

import math  # used for math operations like sqrt and isnan

# function to test
# imports
import pytest  # used for our unit tests

from unstructured.metrics.utils import _stdev

# -----------------------
# unit tests
# -----------------------


# Helper used by tests: compute sample standard deviation manually
def _manual_sample_stdev(values):
    # compute sample standard deviation using definition:
    # sqrt( sum((x - mean)^2) / (n - 1) ) for n > 1
    n = len(values)
    if n <= 1:
        return None
    mean = sum(values) / n
    ss = sum((x - mean) ** 2 for x in values)
    return math.sqrt(ss / (n - 1))


def test_basic_two_values_default_rounding():
    # Basic: two numeric values should yield a stdev rounded to 3 decimals by default
    scores = [2.0, 4.0]
    # Expected: sample stdev = sqrt(((2-3)^2 + (4-3)^2) / (2-1)) = sqrt(2)
    expected = round(math.sqrt(2), 3)
    codeflash_output = _stdev(scores)
    result = codeflash_output  # 47.1μs -> 4.84μs (875% faster)


def test_default_rounding_three_values_mixed_types():
    # Basic: mix of int and float should be handled the same way
    scores = [0, 2.5, 5]
    # Manually compute expected sample stdev and round to 3 decimals
    expected = round(_manual_sample_stdev([float(x) for x in scores]), 3)
    codeflash_output = _stdev(scores)
    result = codeflash_output  # 55.3μs -> 5.01μs (1004% faster)


def test_none_values_ignored_and_single_element_after_filter_returns_none():
    # Edge: None values are filtered out. If only one non-None element remains, return None.
    scores = [None, 5.0, None]
    # After filtering we have only [5.0] -> length <= 1 -> None expected
    codeflash_output = _stdev(scores)  # 1.93μs -> 2.96μs (34.7% slower)


def test_all_none_returns_none():
    # Edge: list with only None values should return None
    scores = [None, None]
    codeflash_output = _stdev(scores)  # 1.68μs -> 1.05μs (60.3% faster)


def test_no_rounding_when_rounding_is_zero():
    # Edge: rounding=0 is falsy, so the function should bypass rounding and return the raw statistics.stdev value
    scores = [1.0, 2.0, 3.0]
    # Compute expected using manual sample stdev
    expected_raw = _manual_sample_stdev(scores)
    # Use isclose for floating point comparison
    codeflash_output = _stdev(scores, rounding=0)
    result = codeflash_output  # 47.0μs -> 4.02μs (1068% faster)


def test_rounding_none_and_false_behave_as_no_rounding():
    # Edge: rounding=None and rounding=False are falsy -> function should return unrounded stdev
    scores = [0.1, 0.2, 0.4]
    expected_raw = _manual_sample_stdev(scores)

    # rounding=None should behave as no rounding
    codeflash_output = _stdev(scores, rounding=None)
    result_none = codeflash_output  # 76.7μs -> 3.92μs (1856% faster)

    # rounding=False should also behave as no rounding (False is falsy)
    codeflash_output = _stdev(scores, rounding=False)
    result_false = codeflash_output  # 51.3μs -> 2.02μs (2435% faster)


def test_negative_rounding_works():
    # Edge: negative rounding values are passed through to round(); ensure correct result
    scores = [10.0, 20.0, 30.0]
    # Compute the raw sample stdev manually
    raw = _manual_sample_stdev(scores)
    # Round with -1 digits (to tens)
    expected = round(raw, -1)
    codeflash_output = _stdev(scores, rounding=-1)
    result = codeflash_output  # 47.7μs -> 5.08μs (838% faster)


def test_large_scale_performance_and_accuracy():
    # Large Scale: use a moderately large list under 1000 elements to verify scalability and correctness.
    # Generate 500 values (well under the 1000 limit) monotonically increasing.
    n = 500
    scores = [i * 0.1 for i in range(n)]  # deterministic sequence with floats
    # Compute expected sample stdev manually then round to default 3 decimals
    expected = round(_manual_sample_stdev(scores), 3)
    codeflash_output = _stdev(scores)
    result = codeflash_output  # 1.01ms -> 112μs (795% faster)


def test_input_list_not_mutated():
    # Edge: the input list object should not be mutated by the function (filtering is local)
    original = [1.0, None, 3.0]
    copy_before = list(original)  # shallow copy of list contents
    codeflash_output = _stdev(original)
    _ = codeflash_output  # 48.8μs -> 7.24μs (574% faster)


def test_invalid_non_numeric_raises_type_error():
    # Edge: non-numeric entries (other than None) should propagate TypeError from statistics.stdev
    scores = [1, "a", 3]
    with pytest.raises(TypeError):
        _stdev(scores)  # 13.8μs -> 4.66μs (197% faster)

import statistics

# imports
from unstructured.metrics.utils import _stdev


class TestStdevBasicFunctionality:
    """Test basic functionality of _stdev with normal inputs."""

    def test_two_identical_values(self):
        """Test that two identical values have zero standard deviation."""
        codeflash_output = _stdev([5.0, 5.0])
        result = codeflash_output  # 50.6μs -> 7.54μs (571% faster)

    def test_two_different_values(self):
        """Test standard deviation with two different values."""
        codeflash_output = _stdev([1.0, 3.0])
        result = codeflash_output  # 48.5μs -> 7.24μs (570% faster)
        # Expected: stdev of [1, 3] = 1.414..., rounded to 3 decimals = 1.414
        expected = round(statistics.stdev([1.0, 3.0]), 3)

    def test_three_values_simple_sequence(self):
        """Test standard deviation with three simple values."""
        codeflash_output = _stdev([1.0, 2.0, 3.0])
        result = codeflash_output  # 49.5μs -> 7.82μs (533% faster)
        expected = round(statistics.stdev([1.0, 2.0, 3.0]), 3)

    def test_multiple_values_default_rounding(self):
        """Test that default rounding parameter is 3."""
        scores = [10.0, 20.0, 30.0, 40.0, 50.0]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 52.4μs -> 8.09μs (548% faster)
        expected = round(statistics.stdev(scores), 3)

    def test_negative_values(self):
        """Test standard deviation with negative values."""
        codeflash_output = _stdev([-5.0, -2.0, 1.0, 4.0])
        result = codeflash_output  # 51.5μs -> 8.04μs (541% faster)
        expected = round(statistics.stdev([-5.0, -2.0, 1.0, 4.0]), 3)

    def test_mixed_positive_negative_values(self):
        """Test standard deviation with mixed positive and negative values."""
        codeflash_output = _stdev([-10.0, -5.0, 0.0, 5.0, 10.0])
        result = codeflash_output  # 53.1μs -> 8.11μs (555% faster)
        expected = round(statistics.stdev([-10.0, -5.0, 0.0, 5.0, 10.0]), 3)

    def test_float_precision_values(self):
        """Test standard deviation with high-precision float values."""
        codeflash_output = _stdev([1.234567, 2.345678, 3.456789])
        result = codeflash_output  # 73.1μs -> 7.56μs (868% faster)
        expected = round(statistics.stdev([1.234567, 2.345678, 3.456789]), 3)

    def test_large_magnitude_values(self):
        """Test standard deviation with large magnitude numbers."""
        codeflash_output = _stdev([1000000.0, 2000000.0, 3000000.0])
        result = codeflash_output  # 52.1μs -> 7.69μs (578% faster)
        expected = round(statistics.stdev([1000000.0, 2000000.0, 3000000.0]), 3)

    def test_small_magnitude_values(self):
        """Test standard deviation with very small magnitude numbers."""
        codeflash_output = _stdev([0.001, 0.002, 0.003])
        result = codeflash_output  # 68.6μs -> 7.65μs (796% faster)
        expected = round(statistics.stdev([0.001, 0.002, 0.003]), 3)


class TestStdevEdgeCases:
    """Test edge cases and boundary conditions."""

    def test_empty_list(self):
        """Test that empty list returns None."""
        codeflash_output = _stdev([])
        result = codeflash_output  # 1.62μs -> 1.02μs (58.7% faster)

    def test_single_value(self):
        """Test that single value returns None."""
        codeflash_output = _stdev([5.0])
        result = codeflash_output  # 1.69μs -> 2.82μs (40.2% slower)

    def test_single_none_value(self):
        """Test that list with only None returns None."""
        codeflash_output = _stdev([None])
        result = codeflash_output  # 1.59μs -> 1.04μs (52.4% faster)

    def test_all_none_values(self):
        """Test that list with all None values returns None."""
        codeflash_output = _stdev([None, None, None])
        result = codeflash_output  # 1.68μs -> 1.15μs (46.6% faster)

    def test_one_none_one_value(self):
        """Test that list with one None and one value returns None."""
        codeflash_output = _stdev([None, 5.0])
        result = codeflash_output  # 1.84μs -> 2.88μs (36.1% slower)

    def test_one_none_multiple_values(self):
        """Test that None values are filtered out correctly."""
        codeflash_output = _stdev([None, 1.0, None, 2.0, None, 3.0])
        result = codeflash_output  # 51.2μs -> 8.29μs (518% faster)
        expected = round(statistics.stdev([1.0, 2.0, 3.0]), 3)

    def test_zero_rounding(self):
        """Test that rounding=0 returns unrounded standard deviation."""
        scores = [1.0, 2.0, 3.0, 4.0, 5.0]
        codeflash_output = _stdev(scores, rounding=0)
        result = codeflash_output  # 48.8μs -> 5.62μs (769% faster)
        expected = statistics.stdev(scores)

    def test_rounding_none(self):
        """Test that rounding=None returns unrounded standard deviation."""
        scores = [1.0, 2.0, 3.0, 4.0, 5.0]
        codeflash_output = _stdev(scores, rounding=None)
        result = codeflash_output  # 48.4μs -> 5.55μs (771% faster)
        expected = statistics.stdev(scores)

    def test_rounding_one_decimal(self):
        """Test custom rounding to 1 decimal place."""
        scores = [1.0, 2.0, 3.0, 4.0, 5.0]
        codeflash_output = _stdev(scores, rounding=1)
        result = codeflash_output  # 52.2μs -> 8.95μs (483% faster)
        expected = round(statistics.stdev(scores), 1)

    def test_rounding_five_decimals(self):
        """Test custom rounding to 5 decimal places."""
        scores = [1.0, 2.0, 3.0, 4.0, 5.0]
        codeflash_output = _stdev(scores, rounding=5)
        result = codeflash_output  # 52.4μs -> 8.77μs (498% faster)
        expected = round(statistics.stdev(scores), 5)

    def test_rounding_zero_decimals(self):
        """Test rounding to 0 decimal places (integer)."""
        scores = [10.0, 20.0, 30.0, 40.0, 50.0]
        codeflash_output = _stdev(scores, rounding=0)
        result = codeflash_output  # 49.5μs -> 5.54μs (795% faster)
        expected = statistics.stdev(scores)

    def test_very_close_values(self):
        """Test with values that are very close to each other."""
        codeflash_output = _stdev([1.0, 1.0000001, 1.0000002])
        result = codeflash_output  # 69.5μs -> 8.34μs (734% faster)
        expected = round(statistics.stdev([1.0, 1.0000001, 1.0000002]), 3)

    def test_all_zeros(self):
        """Test that list of all zeros has zero standard deviation."""
        codeflash_output = _stdev([0.0, 0.0, 0.0])
        result = codeflash_output  # 49.7μs -> 7.88μs (530% faster)

    def test_negative_zero(self):
        """Test handling of negative zero with positive zeros."""
        codeflash_output = _stdev([0.0, -0.0, 0.0])
        result = codeflash_output  # 49.6μs -> 7.83μs (534% faster)

    def test_mixed_none_and_zeros(self):
        """Test filtering None values with zeros."""
        codeflash_output = _stdev([None, 0.0, None, 0.0])
        result = codeflash_output  # 48.8μs -> 7.51μs (550% faster)

    def test_high_rounding_value(self):
        """Test with very high rounding value (more decimals than needed)."""
        scores = [1.0, 2.0, 3.0]
        codeflash_output = _stdev(scores, rounding=10)
        result = codeflash_output  # 50.4μs -> 8.60μs (486% faster)
        expected = round(statistics.stdev(scores), 10)

    def test_negative_rounding_value(self):
        """Test behavior with negative rounding value (rounds to left of decimal)."""
        scores = [10.0, 20.0, 30.0, 40.0, 50.0]
        codeflash_output = _stdev(scores, rounding=-1)
        result = codeflash_output  # 53.3μs -> 8.88μs (500% faster)
        expected = round(statistics.stdev(scores), -1)


class TestStdevReturnTypes:
    """Test return type consistency."""

    def test_return_type_none_empty_list(self):
        """Verify None is returned for empty list."""
        codeflash_output = _stdev([])
        result = codeflash_output  # 1.63μs -> 961ns (69.2% faster)

    def test_return_type_none_single_value(self):
        """Verify None is returned for single value."""
        codeflash_output = _stdev([5.0])
        result = codeflash_output  # 1.79μs -> 2.70μs (33.6% slower)

    def test_return_type_float_normal_case(self):
        """Verify float is returned for normal case."""
        codeflash_output = _stdev([1.0, 2.0, 3.0])
        result = codeflash_output  # 50.7μs -> 8.03μs (532% faster)

    def test_return_type_float_with_rounding_zero(self):
        """Verify float is returned even when rounding=0."""
        codeflash_output = _stdev([1.0, 2.0, 3.0], rounding=0)
        result = codeflash_output  # 46.9μs -> 5.04μs (831% faster)

    def test_return_type_float_with_custom_rounding(self):
        """Verify float is returned with custom rounding."""
        codeflash_output = _stdev([1.0, 2.0, 3.0], rounding=5)
        result = codeflash_output  # 50.3μs -> 8.54μs (489% faster)


class TestStdevNoneHandling:
    """Test None value filtering and handling."""

    def test_none_at_beginning(self):
        """Test None values at the beginning of list."""
        codeflash_output = _stdev([None, None, 1.0, 2.0, 3.0])
        result = codeflash_output  # 49.7μs -> 8.10μs (514% faster)
        expected = round(statistics.stdev([1.0, 2.0, 3.0]), 3)

    def test_none_at_end(self):
        """Test None values at the end of list."""
        codeflash_output = _stdev([1.0, 2.0, 3.0, None, None])
        result = codeflash_output  # 50.0μs -> 8.11μs (516% faster)
        expected = round(statistics.stdev([1.0, 2.0, 3.0]), 3)

    def test_none_interspersed(self):
        """Test None values interspersed throughout list."""
        codeflash_output = _stdev([1.0, None, 2.0, None, 3.0, None, 4.0])
        result = codeflash_output  # 50.8μs -> 8.21μs (518% faster)
        expected = round(statistics.stdev([1.0, 2.0, 3.0, 4.0]), 3)

    def test_majority_none_values(self):
        """Test list with majority None values but enough valid values."""
        codeflash_output = _stdev([None, None, None, 1.0, 2.0, None, None, None])
        result = codeflash_output  # 48.5μs -> 7.91μs (513% faster)
        expected = round(statistics.stdev([1.0, 2.0]), 3)

    def test_alternating_none_and_values(self):
        """Test alternating None and valid values."""
        codeflash_output = _stdev([1.0, None, 2.0, None, 3.0, None, 4.0, None, 5.0])
        result = codeflash_output  # 51.8μs -> 8.24μs (528% faster)
        expected = round(statistics.stdev([1.0, 2.0, 3.0, 4.0, 5.0]), 3)


class TestStdevLargeScale:
    """Test function performance and scalability with large datasets."""

    def test_large_dataset_100_values(self):
        """Test standard deviation calculation with 100 values."""
        scores = [float(i) for i in range(1, 101)]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 133μs -> 28.3μs (372% faster)
        expected = round(statistics.stdev(scores), 3)

    def test_large_dataset_500_values(self):
        """Test standard deviation calculation with 500 values."""
        scores = [float(i) for i in range(1, 501)]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 494μs -> 115μs (326% faster)
        expected = round(statistics.stdev(scores), 3)

    def test_large_dataset_with_none_values(self):
        """Test large dataset with interspersed None values."""
        scores = [float(i) if i % 3 != 0 else None for i in range(1, 301)]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 222μs -> 53.3μs (318% faster)
        # Filter to get expected values
        filtered = [float(i) for i in range(1, 301) if i % 3 != 0]
        expected = round(statistics.stdev(filtered), 3)

    def test_large_dataset_high_precision_floats(self):
        """Test large dataset with high-precision float values."""
        scores = [i * 0.123456789 for i in range(1, 101)]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 391μs -> 28.5μs (1273% faster)
        expected = round(statistics.stdev(scores), 3)

    def test_large_dataset_negative_values(self):
        """Test large dataset with negative values."""
        scores = [float(i - 250) for i in range(1, 501)]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 492μs -> 115μs (327% faster)
        expected = round(statistics.stdev(scores), 3)

    def test_large_dataset_mixed_magnitudes(self):
        """Test large dataset with mixed magnitude values."""
        scores = [float(i) if i % 2 == 0 else float(i) * 1000 for i in range(1, 201)]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 234μs -> 49.4μs (374% faster)
        expected = round(statistics.stdev(scores), 3)

    def test_large_dataset_custom_rounding(self):
        """Test large dataset with custom rounding parameter."""
        scores = [float(i) for i in range(1, 251)]
        codeflash_output = _stdev(scores, rounding=2)
        result = codeflash_output  # 263μs -> 60.6μs (336% faster)
        expected = round(statistics.stdev(scores), 2)

    def test_large_dataset_rounding_zero(self):
        """Test large dataset with rounding=0 (no rounding)."""
        scores = [float(i) for i in range(1, 151)]
        codeflash_output = _stdev(scores, rounding=0)
        result = codeflash_output  # 174μs -> 35.8μs (388% faster)
        expected = statistics.stdev(scores)

    def test_large_dataset_with_duplicates(self):
        """Test large dataset containing duplicate values."""
        scores = [1.0] * 100 + [2.0] * 100 + [3.0] * 100
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 280μs -> 71.3μs (294% faster)
        expected = round(statistics.stdev(scores), 3)

    def test_large_dataset_extreme_range(self):
        """Test large dataset with extreme range of values."""
        scores = [0.00001, 1000000.0, 0.5, 999999.5] + [float(i) for i in range(1, 97)]
        codeflash_output = _stdev(scores)
        result = codeflash_output  # 199μs -> 28.3μs (606% faster)
        expected = round(statistics.stdev(scores), 3)


class TestStdevRoundingBehavior:
    """Test rounding behavior in detail."""

    def test_rounding_truncation_down(self):
        """Test that rounding truncates appropriately."""
        # Create values that result in specific decimal places
        scores = [1.0, 1.01, 1.02]
        codeflash_output = _stdev(scores, rounding=2)
        result = codeflash_output  # 77.4μs -> 8.28μs (835% faster)
        expected = round(statistics.stdev(scores), 2)

    def test_rounding_consistency(self):
        """Test that rounding is applied consistently."""
        scores = [10.111, 20.222, 30.333]
        codeflash_output = _stdev(scores, rounding=3)
        result_3 = codeflash_output  # 80.7μs -> 8.38μs (863% faster)
        codeflash_output = _stdev(scores, rounding=4)
        result_4 = codeflash_output  # 54.0μs -> 2.84μs (1804% faster)

    def test_rounding_preserves_value_type(self):
        """Test that rounding always returns float type."""
        scores = [1.0, 2.0, 3.0]
        for rounding_value in [0, 1, 2, 3, 5, 10]:
            codeflash_output = _stdev(scores, rounding=rounding_value)
            result = codeflash_output  # 168μs -> 18.5μs (811% faster)

    def test_different_rounding_parameters_same_data(self):
        """Test that different rounding parameters give consistent results."""
        scores = [5.0, 10.0, 15.0, 20.0]
        codeflash_output = _stdev(scores, rounding=1)
        result_1 = codeflash_output  # 51.4μs -> 8.16μs (530% faster)
        codeflash_output = _stdev(scores, rounding=1)
        result_2 = codeflash_output  # 28.0μs -> 2.89μs (870% faster)


class TestStdevDataIntegrity:
    """Test that input data is not modified and function is pure."""

    def test_input_list_not_modified(self):
        """Test that the input list is not modified by the function."""
        original_scores = [1.0, 2.0, None, 3.0]
        scores_copy = original_scores.copy()
        _stdev(original_scores)  # 49.9μs -> 7.84μs (536% faster)

    def test_function_idempotent(self):
        """Test that calling function multiple times gives same result."""
        scores = [1.0, 2.0, 3.0, 4.0, 5.0]
        codeflash_output = _stdev(scores)
        result1 = codeflash_output  # 52.8μs -> 7.99μs (561% faster)
        codeflash_output = _stdev(scores)
        result2 = codeflash_output  # 28.8μs -> 3.00μs (859% faster)
        codeflash_output = _stdev(scores)
        result3 = codeflash_output  # 25.8μs -> 2.48μs (941% faster)

    def test_same_data_same_result(self):
        """Test that same data always produces same result."""
        scores1 = [5.0, 10.0, 15.0]
        scores2 = [5.0, 10.0, 15.0]
        codeflash_output = _stdev(scores1, rounding=3)
        result1 = codeflash_output  # 50.8μs -> 8.44μs (502% faster)
        codeflash_output = _stdev(scores2, rounding=3)
        result2 = codeflash_output  # 27.3μs -> 2.78μs (881% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from unstructured.metrics.utils import _stdev


def test__stdev():
    _stdev([], rounding=0)

🔎 Click to see Concolic Coverage Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_xdo_puqm/tmpn23zqd7a/test_concolic_coverage.py::test__stdev	2.04μs	1.49μs	36.6%✅

To edit these changes git checkout codeflash/optimize-_stdev-mks5a1q0 and push.