⚡️ Speed up method AsyncCallInstrumenter.visit_ClassDef by 26% in PR #739 (get-throughput-from-output)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #739

If you approve this dependent PR, these changes will be merged into the original PR branch get-throughput-from-output.

This PR will be automatically closed if the original PR is merged.

---

📄 26% (0.26x) speedup for AsyncCallInstrumenter.visit_ClassDef in codeflash/code_utils/instrument_existing_tests.py

⏱️ Runtime : 17.4 milliseconds → 13.9 milliseconds (best of 141 runs)

📝 Explanation and details

The optimization achieves a 25% speedup by eliminating redundant AST node creation inside the loop.

Key change: The timeout_decorator AST node is now created once before the loop instead of being recreated for every test method that needs it. In the original code, this AST structure was built 3,411 times during profiling, consuming significant time in object allocation and initialization.

Why this works: AST nodes are immutable once created, so the same timeout_decorator instance can be safely appended to multiple method decorator lists. This eliminates:

• Repeated ast.Call() constructor calls
• Redundant ast.Name() and ast.Constant() object creation
• Multiple attribute assignments for the same decorator structure

Performance characteristics: The optimization is most effective for large test classes with many test methods (showing 24-33% improvements in tests with 500+ methods), while having minimal impact on classes with few or no test methods. This makes it particularly valuable for comprehensive test suites where classes commonly contain dozens of test methods.

The line profiler shows the AST node creation operations dropped from ~3,400 hits to just ~25 hits, directly correlating with the observed speedup.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import ast

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Dummy classes for dependencies
class FunctionToOptimize:
    def __init__(self, function_name, parents=None, top_level_parent_name=None):
        self.function_name = function_name
        self.parents = parents or []
        self.top_level_parent_name = top_level_parent_name

class CodePosition:
    pass

class TestingMode:
    BEHAVIOR = "BEHAVIOR"
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Helper to create a test class AST node
def make_classdef(name, method_defs):
    return ast.ClassDef(
        name=name,
        bases=[],
        keywords=[],
        body=method_defs,
        decorator_list=[]
    )

def make_functiondef(name, decorators=None):
    return ast.FunctionDef(
        name=name,
        args=ast.arguments(posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]),
        body=[ast.Pass()],
        decorator_list=decorators or [],
        returns=None,
        type_comment=None
    )

def make_timeout_decorator(value=15):
    return ast.Call(
        func=ast.Name(id="timeout_decorator.timeout", ctx=ast.Load()),
        args=[ast.Constant(value=value)],
        keywords=[]
    )

# --------- UNIT TESTS ---------

# 1. Basic Test Cases

def test_adds_timeout_decorator_to_test_methods_unittest():
    # Test that timeout decorator is added to test_ methods for unittest framework
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    test_method = make_functiondef("test_example")
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 15.6μs -> 15.2μs (2.84% faster)
    dec = result.body[0].decorator_list[0]

def test_does_not_add_timeout_to_non_test_methods_unittest():
    # Should not add decorator to non-test_ methods
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    method = make_functiondef("helper_method")
    class_node = make_classdef("TestClass", [method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 5.37μs -> 7.42μs (27.7% slower)

def test_does_not_add_timeout_when_already_present():
    # Should not add duplicate timeout decorator if already present
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    timeout_decorator = make_timeout_decorator()
    test_method = make_functiondef("test_example", decorators=[timeout_decorator])
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 13.7μs -> 15.5μs (11.5% slower)
    dec = result.body[0].decorator_list[0]

def test_no_action_for_non_unittest_framework():
    # Should not add any decorator for pytest framework
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "pytest", [])
    test_method = make_functiondef("test_example")
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 10.1μs -> 9.99μs (1.20% faster)

# 2. Edge Test Cases

def test_class_with_no_methods():
    # Should not fail or add anything if class has no methods
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    class_node = make_classdef("TestClass", [])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 3.12μs -> 5.28μs (41.0% slower)

def test_method_with_multiple_decorators():
    # Should add timeout if not present among multiple decorators
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    other_decorator = ast.Name(id="other_decorator", ctx=ast.Load())
    test_method = make_functiondef("test_example", decorators=[other_decorator])
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 15.0μs -> 14.6μs (3.02% faster)
    # Should now have two decorators: original and timeout
    names = [d.func.id if isinstance(d, ast.Call) and isinstance(d.func, ast.Name) else (d.id if isinstance(d, ast.Name) else None) for d in result.body[0].decorator_list]

def test_method_with_similar_decorator_name():
    # Should not treat similar decorator names as timeout_decorator.timeout
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    similar_decorator = ast.Call(
        func=ast.Name(id="timeout_decorator", ctx=ast.Load()),
        args=[ast.Constant(value=15)],
        keywords=[]
    )
    test_method = make_functiondef("test_example", decorators=[similar_decorator])
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 14.3μs -> 14.1μs (1.43% faster)
    # Should have two decorators now: similar_decorator and timeout_decorator.timeout
    names = [d.func.id if isinstance(d, ast.Call) and isinstance(d.func, ast.Name) else None for d in result.body[0].decorator_list]

def test_method_with_timeout_decorator_with_different_value():
    # Should not add a second timeout_decorator.timeout even if value is different
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    timeout_decorator = make_timeout_decorator(value=30)
    test_method = make_functiondef("test_example", decorators=[timeout_decorator])
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 12.8μs -> 14.8μs (13.5% slower)
    # Should still have only one timeout_decorator.timeout
    timeout_decorators = [d for d in result.body[0].decorator_list if isinstance(d, ast.Call) and isinstance(d.func, ast.Name) and d.func.id == "timeout_decorator.timeout"]

def test_method_with_non_call_decorator():
    # Should add timeout_decorator.timeout even if other decorator is not a Call node
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    non_call_decorator = ast.Name(id="some_decorator", ctx=ast.Load())
    test_method = make_functiondef("test_example", decorators=[non_call_decorator])
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 14.3μs -> 13.9μs (2.30% faster)
    names = [d.func.id if isinstance(d, ast.Call) and isinstance(d.func, ast.Name) else (d.id if isinstance(d, ast.Name) else None) for d in result.body[0].decorator_list]

def test_method_with_decorator_as_attribute():
    # Should not treat attribute decorator as timeout_decorator.timeout
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    attr_decorator = ast.Call(
        func=ast.Attribute(value=ast.Name(id="timeout_decorator", ctx=ast.Load()), attr="timeout", ctx=ast.Load()),
        args=[ast.Constant(value=15)],
        keywords=[]
    )
    test_method = make_functiondef("test_example", decorators=[attr_decorator])
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 14.1μs -> 13.9μs (1.66% faster)
    # Should add a second timeout_decorator.timeout as ast.Name
    timeout_decorators = [d for d in result.body[0].decorator_list if isinstance(d, ast.Call) and isinstance(d.func, ast.Name) and d.func.id == "timeout_decorator.timeout"]

def test_class_with_mixed_methods():
    # Should only add decorator to test_ methods
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    test_method = make_functiondef("test_example")
    helper_method = make_functiondef("helper_method")
    class_node = make_classdef("TestClass", [test_method, helper_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 15.1μs -> 14.6μs (3.92% faster)

def test_class_with_test_method_named_exactly_test_():
    # Should add decorator to method named 'test_'
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    test_method = make_functiondef("test_")
    class_node = make_classdef("TestClass", [test_method])
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 13.8μs -> 13.6μs (1.55% faster)
    dec = result.body[0].decorator_list[0]

# 3. Large Scale Test Cases

def test_large_class_many_methods():
    # Should efficiently process a class with many methods
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    methods = [make_functiondef(f"test_{i}") for i in range(500)] + [make_functiondef(f"helper_{i}") for i in range(500)]
    class_node = make_classdef("TestClass", methods)
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 2.51ms -> 2.01ms (24.7% faster)
    # First 500 should have the decorator, rest should not
    for i in range(500):
        dec = result.body[i].decorator_list[0]
    for i in range(500, 1000):
        pass

def test_large_class_with_some_decorated_methods():
    # Some test_ methods already have the decorator, some don't
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    methods = []
    for i in range(250):
        methods.append(make_functiondef(f"test_{i}", decorators=[make_timeout_decorator()]))
    for i in range(250, 500):
        methods.append(make_functiondef(f"test_{i}"))
    for i in range(500, 1000):
        methods.append(make_functiondef(f"helper_{i}"))
    class_node = make_classdef("TestClass", methods)
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 2.34ms -> 2.10ms (11.4% faster)
    # First 250 should have only one decorator
    for i in range(250):
        dec = result.body[i].decorator_list[0]
    # Next 250 should now have the decorator
    for i in range(250, 500):
        dec = result.body[i].decorator_list[0]
    # Rest should have no decorator
    for i in range(500, 1000):
        pass

def test_large_class_all_methods_have_multiple_decorators():
    # All test_ methods have two non-timeout decorators, should add timeout
    func = FunctionToOptimize(function_name="foo")
    instrumenter = AsyncCallInstrumenter(func, "mod.py", "unittest", [])
    other_decorator1 = ast.Name(id="decorator1", ctx=ast.Load())
    other_decorator2 = ast.Name(id="decorator2", ctx=ast.Load())
    methods = [make_functiondef(f"test_{i}", decorators=[other_decorator1, other_decorator2]) for i in range(1000)]
    class_node = make_classdef("TestClass", methods)
    codeflash_output = instrumenter.visit_ClassDef(class_node); result = codeflash_output # 4.76ms -> 3.67ms (29.7% faster)
    for i in range(1000):
        names = [d.func.id if isinstance(d, ast.Call) and isinstance(d.func, ast.Name) else (d.id if isinstance(d, ast.Name) else None) for d in result.body[i].decorator_list]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

import ast

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Dummy classes for dependencies
class FunctionParent:
    def __init__(self, type):
        self.type = type

class FunctionToOptimize:
    def __init__(self, function_name, parents, top_level_parent_name):
        self.function_name = function_name
        self.parents = parents
        self.top_level_parent_name = top_level_parent_name

class CodePosition:
    pass

class TestingMode:
    BEHAVIOR = "BEHAVIOR"
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Helper function to create a test class AST node
def make_classdef_with_tests(test_names, decorators=None):
    body = []
    for test_name in test_names:
        func = ast.FunctionDef(
            name=test_name,
            args=ast.arguments(posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]),
            body=[ast.Pass()],
            decorator_list=decorators[test_name] if decorators and test_name in decorators else [],
        )
        body.append(func)
    return ast.ClassDef(name="TestClass", bases=[], keywords=[], body=body, decorator_list=[])

# Helper to check if timeout decorator is present
def has_timeout_decorator(funcdef):
    for d in funcdef.decorator_list:
        if (
            isinstance(d, ast.Call)
            and isinstance(d.func, ast.Name)
            and d.func.id == "timeout_decorator.timeout"
            and len(d.args) == 1
            and isinstance(d.args[0], ast.Constant)
            and d.args[0].value == 15
        ):
            return True
    return False

# Basic Test Cases

def test_adds_timeout_decorator_to_single_test_function():
    # Test that a single test function gets the timeout decorator added
    class_node = make_classdef_with_tests(["test_example"])
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 15.9μs -> 15.4μs (3.06% faster)
    test_func = next(f for f in new_node.body if f.name == "test_example")

def test_does_not_add_decorator_if_already_present():
    # Test that if the timeout decorator is already present, it is not duplicated
    timeout_decorator = ast.Call(
        func=ast.Name(id="timeout_decorator.timeout", ctx=ast.Load()),
        args=[ast.Constant(value=15)],
        keywords=[],
    )
    class_node = make_classdef_with_tests(
        ["test_already"], decorators={"test_already": [timeout_decorator]}
    )
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 13.7μs -> 15.6μs (12.6% slower)
    test_func = next(f for f in new_node.body if f.name == "test_already")

def test_does_not_add_decorator_to_non_test_functions():
    # Test that functions not starting with 'test_' do not get the decorator
    class_node = make_classdef_with_tests(["helper", "test_real"])
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 15.6μs -> 15.3μs (2.23% faster)
    helper_func = next(f for f in new_node.body if f.name == "helper")
    test_func = next(f for f in new_node.body if f.name == "test_real")

def test_does_nothing_if_framework_not_unittest():
    # Test that no decorator is added if the framework is not 'unittest'
    class_node = make_classdef_with_tests(["test_example"])
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "pytest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 10.1μs -> 10.1μs (0.605% faster)
    test_func = next(f for f in new_node.body if f.name == "test_example")

# Edge Test Cases

def test_class_with_no_functions():
    # Test that a class with no functions does not raise or change
    class_node = ast.ClassDef(name="EmptyClass", bases=[], keywords=[], body=[], decorator_list=[])
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "EmptyClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 3.04μs -> 5.38μs (43.6% slower)

def test_class_with_non_function_body_items():
    # Test that non-function items (e.g. assignments) are ignored
    assign = ast.Assign(targets=[ast.Name(id="x", ctx=ast.Store())], value=ast.Constant(value=1))
    class_node = ast.ClassDef(name="MixedClass", bases=[], keywords=[], body=[assign], decorator_list=[])
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "MixedClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 14.6μs -> 15.3μs (4.72% slower)

def test_function_with_other_decorators():
    # Test that other decorators are not affected and timeout is appended
    other_decorator = ast.Name(id="other_decorator", ctx=ast.Load())
    class_node = make_classdef_with_tests(
        ["test_multi"], decorators={"test_multi": [other_decorator]}
    )
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 15.0μs -> 14.9μs (0.805% faster)
    test_func = next(f for f in new_node.body if f.name == "test_multi")

def test_function_with_similar_named_decorator():
    # Test that a decorator named 'timeout_decorator' but not a call is ignored
    similar_decorator = ast.Name(id="timeout_decorator", ctx=ast.Load())
    class_node = make_classdef_with_tests(
        ["test_similar"], decorators={"test_similar": [similar_decorator]}
    )
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 14.3μs -> 14.2μs (0.847% faster)
    test_func = next(f for f in new_node.body if f.name == "test_similar")

def test_function_with_timeout_decorator_wrong_args():
    # Test that a timeout_decorator with wrong arguments does not prevent adding the correct one
    wrong_timeout = ast.Call(
        func=ast.Name(id="timeout_decorator.timeout", ctx=ast.Load()),
        args=[ast.Constant(value=10)],
        keywords=[],
    )
    class_node = make_classdef_with_tests(
        ["test_wrong"], decorators={"test_wrong": [wrong_timeout]}
    )
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 12.9μs -> 14.6μs (11.5% slower)
    test_func = next(f for f in new_node.body if f.name == "test_wrong")

# Large Scale Test Cases

def test_large_number_of_test_functions():
    # Test that a large number of test functions all get the decorator
    num_tests = 500
    test_names = [f"test_{i}" for i in range(num_tests)]
    class_node = make_classdef_with_tests(test_names)
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 2.25ms -> 1.70ms (32.1% faster)
    for test_func in new_node.body:
        pass

def test_large_mixed_class():
    # Test a class with a mix of test and non-test functions, and non-function items
    num_tests = 250
    num_helpers = 250
    test_names = [f"test_{i}" for i in range(num_tests)]
    helper_names = [f"helper_{i}" for i in range(num_helpers)]
    body = []
    for name in test_names:
        func = ast.FunctionDef(
            name=name,
            args=ast.arguments(posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]),
            body=[ast.Pass()],
            decorator_list=[],
        )
        body.append(func)
    for name in helper_names:
        func = ast.FunctionDef(
            name=name,
            args=ast.arguments(posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]),
            body=[ast.Pass()],
            decorator_list=[],
        )
        body.append(func)
    # Add some assignments
    for i in range(10):
        body.append(ast.Assign(targets=[ast.Name(id=f"x{i}", ctx=ast.Store())], value=ast.Constant(value=i)))
    class_node = ast.ClassDef(name="BigClass", bases=[], keywords=[], body=body, decorator_list=[])
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "BigClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 1.34ms -> 1.07ms (24.8% faster)
    # Check all test functions have decorator, helpers do not
    for func in new_node.body:
        if isinstance(func, ast.FunctionDef):
            if func.name.startswith("test_"):
                pass
            else:
                pass
        else:
            pass

def test_performance_on_large_class(monkeypatch):
    # Test performance: ensure visit_ClassDef runs in reasonable time for large class
    import time
    num_tests = 900
    class_node = make_classdef_with_tests([f"test_{i}" for i in range(num_tests)])
    instrumenter = AsyncCallInstrumenter(
        FunctionToOptimize("func", [FunctionParent("ClassDef")], "TestClass"),
        "module.py", "unittest", [], TestingMode.BEHAVIOR
    )
    start = time.time()
    codeflash_output = instrumenter.visit_ClassDef(class_node); new_node = codeflash_output # 3.99ms -> 3.05ms (30.7% faster)
    elapsed = time.time() - start
# 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-pr739-2025-09-22T19.41.32 and push.