⚡️ Speed up function merge_strings by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for merge_strings in doctr/models/recognition/utils.py

⏱️ Runtime : 7.12 milliseconds → 6.09 milliseconds (best of 208 runs)

📝 Explanation and details

The optimized code achieves a 16% speedup through several targeted micro-optimizations:

Key Performance Improvements:

1. Eliminated expensive list comprehension for Hamming distance calculation: The original code used a list comprehension that called Hamming.distance() for every potential overlap (37.8% of total time). The optimized version replaces this with a manual loop that includes string equality checks before calling Hamming, avoiding expensive distance calculations when strings are identical.

2. Pre-cached string lengths: Added len_a_crop and len_b_crop variables to avoid repeated len() calls during substring operations.

3. Replaced lambda-based min() with manual loop: The original code used min(zero_matches, key=lambda x: abs(x - expected_overlap)) which was expensive (13.7% of time). The optimized version uses a simple loop to find the minimum, eliminating function call overhead.

4. Optimized final scoring loop: Instead of creating a combined_scores list and then finding its minimum index (5.9% of time), the optimized code scans through scores once, tracking the best score and index directly.

5. Manual zero-matches collection: Replaced list comprehension for finding zero scores with a manual loop and append(), reducing overhead.

Performance Characteristics by Test Case:

• Large-scale tests with repeated patterns: Show the biggest improvements (13-89% faster) due to the string equality shortcuts
• Small strings and edge cases: Show minor improvements or slight regressions due to additional overhead from extra variables and checks
• Perfect overlap scenarios: Benefit significantly from the string equality optimizations

The optimizations are most effective for cases with longer strings and repeated character patterns, where the string equality checks can bypass expensive Hamming distance calculations.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
common/test_models_recognition_utils.py::test_merge_strings	102μs	104μs	-1.34%⚠️

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from doctr.models.recognition.utils import merge_strings
from rapidfuzz.distance import Hamming

# unit tests

# --- BASIC TEST CASES ---

def test_basic_perfect_overlap():
    # Perfect overlap, overlap_ratio matches actual overlap
    codeflash_output = merge_strings('abcd', 'cdefgh', 0.5) # 7.13μs -> 6.99μs (2.02% faster)
    codeflash_output = merge_strings('hello', 'llo world', 0.4) # 3.44μs -> 3.62μs (5.16% slower)
    codeflash_output = merge_strings('abc', 'bc', 0.5) # 2.14μs -> 2.38μs (10.0% slower)
    codeflash_output = merge_strings('abcde', 'cde', 0.6) # 1.94μs -> 2.00μs (2.86% slower)

def test_basic_no_overlap():
    # No overlap between a and b
    codeflash_output = merge_strings('abc', 'xyz', 0.0) # 4.72μs -> 4.82μs (2.24% slower)
    codeflash_output = merge_strings('hello', 'world', 0.0) # 3.02μs -> 3.23μs (6.50% slower)

def test_basic_partial_overlap():
    # Partial overlap, overlap_ratio less than actual overlap
    codeflash_output = merge_strings('abcdef', 'defghi', 0.3) # 5.76μs -> 5.92μs (2.65% slower)
    codeflash_output = merge_strings('12345', '34567', 0.4) # 2.91μs -> 2.89μs (0.865% faster)

def test_basic_overlap_with_repeats():
    # Overlap with repeated characters
    codeflash_output = merge_strings('aaaaa', 'aaaab', 0.8) # 6.97μs -> 6.16μs (13.3% faster)
    codeflash_output = merge_strings('mississ', 'ississippi', 0.5) # 4.75μs -> 4.58μs (3.65% faster)
    codeflash_output = merge_strings('banana', 'anana', 0.7) # 3.00μs -> 2.72μs (10.4% faster)

def test_basic_overlap_ratio_extremes():
    # Overlap ratio at extremes
    codeflash_output = merge_strings('abc', 'bc', 1.0) # 4.16μs -> 4.27μs (2.71% slower)
    codeflash_output = merge_strings('abc', 'bc', 0.0) # 1.87μs -> 1.86μs (0.539% faster)
    codeflash_output = merge_strings('abc', 'bc', -1.0) # 1.30μs -> 1.27μs (2.12% faster)

# --- EDGE TEST CASES ---

def test_edge_empty_strings():
    # One or both strings empty
    codeflash_output = merge_strings('', '', 0.5) # 1.02μs -> 980ns (3.88% faster)
    codeflash_output = merge_strings('abc', '', 0.5) # 529ns -> 552ns (4.17% slower)
    codeflash_output = merge_strings('', 'xyz', 0.5) # 348ns -> 320ns (8.75% faster)

def test_edge_single_character_strings():
    # Strings of length 1
    codeflash_output = merge_strings('a', 'a', 1.0) # 989ns -> 931ns (6.23% faster)
    codeflash_output = merge_strings('a', 'b', 0.5) # 489ns -> 437ns (11.9% faster)
    codeflash_output = merge_strings('a', '', 0.5) # 442ns -> 407ns (8.60% faster)
    codeflash_output = merge_strings('', 'b', 0.5) # 338ns -> 339ns (0.295% slower)

def test_edge_overlap_longer_than_strings():
    # Overlap ratio >1 or calculated overlap larger than string lengths
    codeflash_output = merge_strings('abc', 'abc', 2.0) # 5.31μs -> 5.43μs (2.25% slower)
    codeflash_output = merge_strings('abc', 'abc', 10.0) # 2.23μs -> 2.11μs (5.82% faster)
    codeflash_output = merge_strings('abc', 'def', 2.0) # 3.04μs -> 3.13μs (2.59% slower)

def test_edge_non_ascii_characters():
    # Unicode and special characters
    codeflash_output = merge_strings('héllo', 'llo world', 0.5) # 6.16μs -> 6.38μs (3.40% slower)
    codeflash_output = merge_strings('你好世界', '世界你好', 0.5) # 3.93μs -> 4.09μs (4.01% slower)
    codeflash_output = merge_strings('😀😁', '😁😂', 0.5) # 1.88μs -> 1.92μs (1.98% slower)

def test_edge_overlap_ratio_negative():
    # Negative overlap ratios
    codeflash_output = merge_strings('abc', 'bc', -0.5) # 4.29μs -> 4.40μs (2.57% slower)
    codeflash_output = merge_strings('abc', 'def', -1.0) # 2.84μs -> 3.18μs (10.7% slower)

def test_edge_overlap_ratio_zero():
    # Zero overlap ratio
    codeflash_output = merge_strings('abc', 'cde', 0.0) # 4.27μs -> 4.66μs (8.45% slower)

def test_edge_overlap_ratio_just_enough():
    # Overlap ratio just enough to merge
    codeflash_output = merge_strings('abcde', 'cde', 0.6) # 4.74μs -> 4.64μs (2.18% faster)
    codeflash_output = merge_strings('abcde', 'de', 0.4) # 2.30μs -> 2.71μs (15.3% slower)

def test_edge_overlap_with_typo():
    # Overlap but with a typo in the overlap
    codeflash_output = merge_strings('abcdef', 'decghi', 0.5) # 5.87μs -> 6.05μs (2.99% slower)
    codeflash_output = merge_strings('abcdef', 'defg', 0.5) # 2.83μs -> 2.81μs (0.675% faster)

def test_edge_overlap_with_substitution():
    # Overlap with one character substitution
    codeflash_output = merge_strings('abcdef', 'dxfgh', 0.5) # 5.19μs -> 5.60μs (7.39% slower)

def test_edge_overlap_with_insertions():
    # Overlap with extra character inserted
    codeflash_output = merge_strings('abcdef', 'decfgh', 0.5) # 5.60μs -> 5.76μs (2.73% slower)

def test_edge_overlap_with_deletions():
    # Overlap with missing character
    codeflash_output = merge_strings('abcdef', 'dfgh', 0.5) # 4.82μs -> 5.36μs (10.1% slower)

def test_edge_overlap_ratio_rounding():
    # Overlap ratio causing rounding issues
    codeflash_output = merge_strings('abcdef', 'defgh', 0.33333) # 5.34μs -> 5.53μs (3.47% slower)
    codeflash_output = merge_strings('abcdef', 'defgh', 0.66667) # 2.75μs -> 2.87μs (3.94% slower)

def test_edge_overlap_ratio_float_precision():
    # Float precision edge cases
    codeflash_output = merge_strings('abcdef', 'defgh', 0.499999) # 5.12μs -> 5.31μs (3.71% slower)
    codeflash_output = merge_strings('abcdef', 'defgh', 0.500001) # 2.63μs -> 2.78μs (5.54% slower)

# --- LARGE SCALE TEST CASES ---

def test_large_scale_long_strings_perfect_overlap():
    # Large strings with perfect overlap
    a = 'a' * 500 + 'b' * 500
    b = 'b' * 500 + 'c' * 500
    # overlap_ratio is 0.5 (500/1000)
    codeflash_output = merge_strings(a, b, 0.5); result = codeflash_output # 372μs -> 329μs (13.3% faster)

def test_large_scale_long_strings_partial_overlap():
    # Large strings with partial overlap
    a = 'x' * 400 + 'y' * 300 + 'z' * 300
    b = 'y' * 300 + 'z' * 300 + 'w' * 400
    codeflash_output = merge_strings(a, b, 0.6); result = codeflash_output # 331μs -> 361μs (8.26% slower)

def test_large_scale_long_strings_no_overlap():
    # Large strings with no overlap
    a = 'a' * 1000
    b = 'b' * 1000
    codeflash_output = merge_strings(a, b, 0.0); result = codeflash_output # 334μs -> 360μs (7.36% slower)

def test_large_scale_long_strings_with_typo_in_overlap():
    # Large strings with a typo in the overlap region
    a = 'a' * 400 + 'b' * 300 + 'c' * 300
    b = 'b' * 299 + 'x' + 'c' * 300 + 'd' * 100
    codeflash_output = merge_strings(a, b, 0.6); result = codeflash_output # 252μs -> 263μs (4.28% slower)

def test_large_scale_long_strings_repeated_patterns():
    # Large strings with repeated patterns
    a = ('abc' * 333) + 'd'
    b = ('bc' * 333) + 'de'
    codeflash_output = merge_strings(a, b, 0.5); result = codeflash_output # 195μs -> 213μs (8.23% slower)

def test_large_scale_overlap_ratio_extremes():
    # Large strings, extreme overlap ratios
    a = 'x' * 999
    b = 'x' * 999
    codeflash_output = merge_strings(a, b, 1.0) # 394μs -> 220μs (78.6% faster)
    codeflash_output = merge_strings(a, b, 0.0) # 375μs -> 199μs (88.8% faster)

def test_large_scale_non_ascii():
    # Large strings with non-ASCII characters
    a = '你好' * 500
    b = '好世' * 500
    codeflash_output = merge_strings(a, b, 0.5); result = codeflash_output # 443μs -> 479μs (7.43% slower)

def test_large_scale_performance():
    # Test that function runs efficiently (does not hang)
    a = 'a' * 1000
    b = 'a' * 1000
    codeflash_output = merge_strings(a, b, 0.5); result = codeflash_output # 387μs -> 212μs (82.9% faster)

# --- DETERMINISM TEST CASE ---

def test_determinism():
    # Ensure repeated calls with same inputs produce same outputs
    for a, b, ratio in [
        ('abcdef', 'defgh', 0.5),
        ('hello', 'llo world', 0.4),
        ('abc', 'xyz', 0.0),
        ('', '', 0.5),
        ('a' * 500, 'a' * 500, 1.0),
    ]:
        codeflash_output = merge_strings(a, b, ratio); out1 = codeflash_output # 176μs -> 116μs (51.9% faster)
        codeflash_output = merge_strings(a, b, ratio); out2 = codeflash_output # 166μs -> 103μs (59.9% faster)

# --- INVALID INPUTS TEST CASES ---

def test_invalid_types():
    # Should raise TypeError if non-string inputs are given
    with pytest.raises(TypeError):
        merge_strings(123, 'abc', 0.5) # 1.54μs -> 1.43μs (7.40% faster)
    with pytest.raises(TypeError):
        merge_strings('abc', 456, 0.5) # 942ns -> 913ns (3.18% faster)
    with pytest.raises(TypeError):
        merge_strings('abc', 'def', 'not_a_float') # 5.34μs -> 5.65μs (5.57% slower)

def test_invalid_overlap_ratio():
    # Should handle overlap_ratio out of bounds gracefully
    codeflash_output = merge_strings('abc', 'abc', -100) # 5.44μs -> 5.05μs (7.58% faster)
    codeflash_output = merge_strings('abc', 'abc', 100) # 2.46μs -> 2.27μs (8.20% faster)

# --- BOUNDARY CONDITIONS ---

def test_boundary_minimum_length():
    # Both strings of minimum non-empty length
    codeflash_output = merge_strings('a', 'b', 0.5) # 1.07μs -> 995ns (7.44% faster)
    codeflash_output = merge_strings('a', 'a', 1.0) # 468ns -> 449ns (4.23% faster)
    codeflash_output = merge_strings('a', '', 0.0) # 451ns -> 439ns (2.73% faster)
    codeflash_output = merge_strings('', 'a', 0.0) # 352ns -> 349ns (0.860% faster)

def test_boundary_maximum_length():
    # Strings at maximum allowed length (1000)
    a = 'x' * 1000
    b = 'x' * 1000
    codeflash_output = merge_strings(a, b, 1.0) # 399μs -> 226μs (76.3% faster)
    codeflash_output = merge_strings(a, b, 0.0) # 375μs -> 200μs (87.6% faster)

# --- DOCUMENTATION EXAMPLES ---

def test_documentation_examples():
    # Test the examples from the docstring
    codeflash_output = merge_strings('abcd', 'cdefgh', 0.5) # 7.30μs -> 7.33μs (0.355% slower)
    codeflash_output = merge_strings('abcdi', 'cdefgh', 0.5) # 3.29μs -> 3.40μs (3.03% slower)

# --- SANITY CHECK ---

def test_sanity_merge_strings_identity():
    # Merging a string with itself should return the string
    codeflash_output = merge_strings('abc', 'abc', 1.0) # 4.94μs -> 4.84μs (1.90% faster)
    codeflash_output = merge_strings('abc', 'abc', 0.0) # 2.24μs -> 2.14μs (4.81% faster)
    codeflash_output = merge_strings('', '', 1.0) # 506ns -> 490ns (3.27% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from doctr.models.recognition.utils import merge_strings
from rapidfuzz.distance import Hamming

# unit tests

# ----------------------
# Basic Test Cases
# ----------------------

def test_basic_partial_overlap():
    # Overlapping 'cd'
    codeflash_output = merge_strings('abcd', 'cdefgh', 0.5) # 7.47μs -> 7.62μs (1.97% slower)
    # Overlapping 'cde'
    codeflash_output = merge_strings('abcdef', 'cdefghi', 0.5) # 3.91μs -> 4.12μs (5.22% slower)
    # Overlapping 'bc'
    codeflash_output = merge_strings('abc', 'bcd', 0.5) # 2.19μs -> 2.31μs (5.03% slower)

def test_basic_exact_overlap():
    # Full overlap, b is suffix of a
    codeflash_output = merge_strings('hello', 'llo', 0.6) # 4.98μs -> 4.92μs (1.12% faster)
    # Full overlap, a is prefix of b
    codeflash_output = merge_strings('abc', 'abcdef', 1.0) # 2.43μs -> 2.44μs (0.205% slower)

def test_basic_no_overlap():
    # No overlap, should concatenate
    codeflash_output = merge_strings('abc', 'def', 0.0) # 4.55μs -> 4.83μs (5.88% slower)
    # No overlap, empty overlap_ratio
    codeflash_output = merge_strings('abc', 'xyz', 0.0) # 2.12μs -> 2.10μs (0.951% faster)

def test_basic_one_char_overlap():
    # Overlap of one character
    codeflash_output = merge_strings('abc', 'cde', 0.3) # 4.33μs -> 4.54μs (4.48% slower)
    codeflash_output = merge_strings('1234', '4567', 0.25) # 2.75μs -> 2.83μs (2.76% slower)

def test_basic_identical_strings():
    # Identical strings, should not duplicate
    codeflash_output = merge_strings('abc', 'abc', 1.0) # 4.52μs -> 4.53μs (0.199% slower)

# ----------------------
# Edge Test Cases
# ----------------------

def test_edge_empty_strings():
    # Both empty
    codeflash_output = merge_strings('', '', 0.5) # 982ns -> 961ns (2.19% faster)
    # First empty
    codeflash_output = merge_strings('', 'abc', 0.5) # 523ns -> 478ns (9.41% faster)
    # Second empty
    codeflash_output = merge_strings('abc', '', 0.5) # 423ns -> 380ns (11.3% faster)

def test_edge_single_character_strings():
    # Both single character, no overlap
    codeflash_output = merge_strings('a', 'b', 0.5) # 936ns -> 930ns (0.645% faster)
    # Both single character, same character
    codeflash_output = merge_strings('x', 'x', 1.0) # 494ns -> 465ns (6.24% faster)
    # First single, second longer
    codeflash_output = merge_strings('a', 'abc', 0.5) # 448ns -> 434ns (3.23% faster)
    # Second single, first longer
    codeflash_output = merge_strings('abc', 'c', 0.5) # 389ns -> 381ns (2.10% faster)

def test_edge_overlap_ratio_extremes():
    # Overlap ratio 0.0 (should concatenate)
    codeflash_output = merge_strings('abc', 'bcd', 0.0) # 5.14μs -> 5.52μs (6.85% slower)
    # Overlap ratio 1.0 (should maximize overlap)
    codeflash_output = merge_strings('abc', 'bcd', 1.0) # 3.81μs -> 3.25μs (17.2% faster)
    # Overlap ratio > 1.0 (should behave as 1.0)
    codeflash_output = merge_strings('abc', 'bcd', 1.5) # 2.33μs -> 2.00μs (16.4% faster)
    # Negative overlap ratio (should concatenate)
    codeflash_output = merge_strings('abc', 'bcd', -1.0) # 1.70μs -> 1.73μs (1.62% slower)

def test_edge_repeated_characters():
    # Multiple possible perfect overlaps
    codeflash_output = merge_strings('aaaaa', 'aaaaa', 0.8) # 7.36μs -> 5.75μs (27.8% faster)
    # Overlap in the middle
    codeflash_output = merge_strings('aaaab', 'aabaa', 0.5) # 3.22μs -> 3.88μs (16.9% slower)
    # Overlap with repeated chars, ambiguous
    codeflash_output = merge_strings('abcabc', 'bcabca', 0.5) # 2.70μs -> 3.13μs (13.7% slower)

def test_edge_off_by_one_overlap():
    # Overlap is off by one character
    codeflash_output = merge_strings('abcdef', 'defg', 0.4) # 5.01μs -> 5.18μs (3.36% slower)
    # Overlap is almost full, but one character differs
    codeflash_output = merge_strings('abcde', 'cdefg', 0.6) # 2.78μs -> 2.88μs (3.54% slower)

def test_edge_case_sensitive():
    # Case sensitivity
    codeflash_output = merge_strings('Abc', 'bcD', 0.5) # 4.40μs -> 4.58μs (3.87% slower)
    # Overlap is case-insensitive in data, but function is case-sensitive
    codeflash_output = merge_strings('Hello', 'hello', 1.0) # 3.15μs -> 3.39μs (7.03% slower)

def test_edge_non_ascii_characters():
    # Unicode characters
    codeflash_output = merge_strings('café', 'féline', 0.5) # 6.87μs -> 6.81μs (0.896% faster)
    # Emojis
    codeflash_output = merge_strings('hello😀', '😀world', 0.5) # 4.62μs -> 4.70μs (1.55% slower)

def test_edge_overlap_larger_than_strings():
    # Overlap ratio larger than possible, should not fail
    codeflash_output = merge_strings('abc', 'abc', 10.0) # 4.57μs -> 4.43μs (3.14% faster)
    # Overlap ratio negative, should concatenate
    codeflash_output = merge_strings('abc', 'def', -2.0) # 2.61μs -> 2.81μs (7.18% slower)

def test_edge_overlap_at_start_and_end():
    # Overlap at the very start (prefix)
    codeflash_output = merge_strings('abc', 'abc', 1.0) # 4.30μs -> 4.28μs (0.397% faster)
    # Overlap at the very end (suffix)
    codeflash_output = merge_strings('xyz', 'yz', 0.7) # 2.59μs -> 2.82μs (8.19% slower)

def test_edge_overlap_smaller_than_cropping():
    # Overlap smaller than cropping, should concatenate
    codeflash_output = merge_strings('ab', 'cd', 0.1) # 3.99μs -> 4.04μs (1.19% slower)
    codeflash_output = merge_strings('a', 'b', 0.1) # 678ns -> 640ns (5.94% faster)

# ----------------------
# Large Scale Test Cases
# ----------------------

def test_large_scale_long_strings_perfect_overlap():
    # Two long strings with perfect overlap
    a = 'a' * 500 + 'b' * 500
    b = 'b' * 500 + 'c' * 500
    # Overlap is 500 'b's
    expected = 'a' * 500 + 'b' * 500 + 'c' * 500
    codeflash_output = merge_strings(a, b, 0.5) # 374μs -> 330μs (13.3% faster)

def test_large_scale_long_strings_no_overlap():
    # Two long strings with no overlap
    a = 'x' * 1000
    b = 'y' * 1000
    expected = a + b
    codeflash_output = merge_strings(a, b, 0.0) # 332μs -> 363μs (8.41% slower)

def test_large_scale_long_strings_partial_overlap():
    # Two long strings with partial overlap
    a = 'abc' * 333 + 'xyz'
    b = 'xyz' + 'def' * 333
    expected = 'abc' * 333 + 'xyz' + 'def' * 333
    codeflash_output = merge_strings(a, b, 0.003) # 335μs -> 359μs (6.75% slower)

def test_large_scale_repeated_patterns():
    # Repeated patterns with ambiguous overlap
    a = ('ab' * 500) + 'cd'
    b = 'cd' + ('ab' * 500)
    expected = ('ab' * 500) + 'cd' + ('ab' * 500)
    codeflash_output = merge_strings(a, b, 0.5) # 409μs -> 413μs (0.905% slower)

def test_large_scale_overlap_at_various_points():
    # Overlap not at start or end
    a = 'a' * 400 + 'b' * 300 + 'c' * 300
    b = 'b' * 300 + 'c' * 300 + 'd' * 400
    expected = 'a' * 400 + 'b' * 300 + 'c' * 300 + 'd' * 400
    codeflash_output = merge_strings(a, b, 0.5) # 334μs -> 360μs (7.40% slower)

def test_large_scale_identical_strings():
    # Identical long strings, should not duplicate
    s = 'abc' * 333 + 'd'
    codeflash_output = merge_strings(s, s, 1.0) # 361μs -> 330μs (9.20% faster)

def test_large_scale_one_empty():
    # One empty, one large
    a = ''
    b = 'x' * 999
    codeflash_output = merge_strings(a, b, 0.5) # 1.33μs -> 1.24μs (7.17% faster)
    a = 'y' * 999
    b = ''
    codeflash_output = merge_strings(a, b, 0.5) # 775ns -> 757ns (2.38% faster)

def test_large_scale_overlap_ratio_extremes():
    # Very high overlap ratio
    a = 'a' * 500 + 'b' * 499
    b = 'b' * 499 + 'c' * 1
    expected = 'a' * 500 + 'b' * 499 + 'c'
    codeflash_output = merge_strings(a, b, 2.0) # 170μs -> 108μs (56.3% faster)
    # Very low overlap ratio
    codeflash_output = merge_strings(a, b, -2.0) # 160μs -> 95.2μs (68.0% faster)

# ----------------------
# Mutation Testing Guards
# ----------------------

@pytest.mark.parametrize(
    "a,b,overlap_ratio,expected",
    [
        # Changing overlap_ratio should change output for ambiguous overlaps
        ("abcde", "cdefg", 0.6, "abcdefg"),
        ("abcde", "cdefg", 0.1, "abcdedefg"),
        # Changing a single character in overlap should change output
        ("abcde", "cdfg", 0.5, "abcdcdfg"),
        # Swapping input order should affect output
        ("abc", "bcd", 0.5, "abcd"),
        ("bcd", "abc", 0.5, "bcdabc"),
        # Overlap at different positions
        ("12345", "34567", 0.4, "1234567"),
        ("12345", "23456", 0.8, "123456"),
    ]
)
def test_mutation_guards(a, b, overlap_ratio, expected):
    # These tests are designed to fail if the function's logic is mutated
    codeflash_output = merge_strings(a, b, overlap_ratio) # 40.0μs -> 41.3μs (3.19% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-merge_strings-mg7ihvjw and push.