⚡️ Speed up method GraphicsContextPdf.fill by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for GraphicsContextPdf.fill in lib/matplotlib/backends/backend_pdf.py

⏱️ Runtime : 590 microseconds → 555 microseconds (best of 61 runs)

📝 Explanation and details

The optimization replaces if len(args): with if args: in the condition check. This change provides a 6% speedup by eliminating the overhead of calling the len() function.

Key optimization:

• What: Changed if len(args): to if args:
• Why: In Python, checking truthiness of a collection (if args:) is faster than computing its length (if len(args):). The len() function call adds unnecessary overhead when we only need to know if the collection is non-empty.
• Performance impact: The line profiler shows the condition check time decreased from 567,824ns to 464,596ns (18% faster on that specific line), contributing to the overall 6% speedup.

How it works:

• Both expressions are functionally equivalent for determining if args contains elements
• if args: directly checks if the tuple is truthy (non-empty), which is a simple pointer/size check
• if len(args): requires a function call to compute the length, then checks if that result is truthy

Test case analysis:
The optimization shows consistent improvements across most test scenarios:

• Best gains (8-15%) when hatch is set or fillcolor is None, where the condition is evaluated but the function returns early
• Moderate gains (2-7%) for typical color tuple cases
• Minimal impact on edge cases with very large tuples, suggesting the optimization doesn't hurt worst-case performance

This is a micro-optimization that provides measurable benefits in a graphics context where the fill() method is likely called frequently during rendering operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from matplotlib.backends.backend_pdf import GraphicsContextPdf


# function to test
# Minimal implementation of GraphicsContextBase for testing
class GraphicsContextBase:
    def __init__(self):
        self._alpha = 1.0
        self._forced_alpha = False
        self._antialiased = 1
        self._capstyle = "butt"
        self._cliprect = None
        self._clippath = None
        self._dashes = 0, None
        self._joinstyle = "round"
        self._linestyle = "solid"
        self._linewidth = 1
        self._rgb = (0.0, 0.0, 0.0, 1.0)
        self._hatch = None
        self._hatch_color = (0.0, 0.0, 0.0, 1.0)
        self._hatch_linewidth = 1.0
        self._url = None
        self._gid = None
        self._snap = None
        self._sketch = None


# unit tests

# --- Basic Test Cases ---


def test_fill_with_default_fillcolor():
    """Test fill with default _fillcolor (should fill, as _fillcolor is (0,0,0))"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill()  # 919ns -> 872ns (5.39% faster)


def test_fill_with_explicit_rgb_fillcolor():
    """Test fill with explicit RGB fillcolor (length 3, no alpha)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((1.0, 0.5, 0.2))  # 1.03μs -> 974ns (5.54% faster)


def test_fill_with_explicit_rgba_fillcolor_nonzero_alpha():
    """Test fill with explicit RGBA fillcolor (length 4, alpha != 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((0.8, 0.1, 0.1, 0.5))  # 1.17μs -> 1.15μs (1.39% faster)


def test_fill_with_explicit_rgba_fillcolor_zero_alpha():
    """Test fill with explicit RGBA fillcolor (length 4, alpha == 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((0.8, 0.1, 0.1, 0.0))  # 1.18μs -> 1.15μs (2.71% faster)


def test_fill_with_hatch_set():
    """Test fill when _hatch is set (should always fill regardless of fillcolor)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = "x"
    codeflash_output = gc.fill()  # 731ns -> 636ns (14.9% faster)


def test_fill_with_fillcolor_none_and_no_hatch():
    """Test fill when _fillcolor is None and no hatch (should not fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._fillcolor = None
    gc._hatch = None
    codeflash_output = gc.fill()  # 727ns -> 670ns (8.51% faster)


def test_fill_with_fillcolor_none_and_hatch():
    """Test fill when _fillcolor is None but hatch is set (should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._fillcolor = None
    gc._hatch = "o"
    codeflash_output = gc.fill()  # 722ns -> 660ns (9.39% faster)


# --- Edge Test Cases ---


def test_fill_with_empty_tuple_fillcolor():
    """Test fill with empty tuple as fillcolor (length 0, should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill(())  # 1.06μs -> 1.04μs (1.72% faster)


def test_fill_with_single_value_fillcolor():
    """Test fill with single value tuple as fillcolor (length 1, should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((0.5,))  # 1.05μs -> 1.03μs (2.34% faster)


def test_fill_with_two_value_tuple_fillcolor():
    """Test fill with two value tuple as fillcolor (length 2, should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((0.5, 0.5))  # 1.05μs -> 1.02μs (3.13% faster)


def test_fill_with_long_tuple_fillcolor_nonzero_alpha():
    """Test fill with long tuple fillcolor (length > 4, alpha != 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    fillcolor = (0.1, 0.2, 0.3, 0.4, 0.5)
    # length > 3, but fillcolor[3] != 0, so should fill
    codeflash_output = gc.fill(fillcolor)  # 1.17μs -> 1.20μs (2.17% slower)


def test_fill_with_long_tuple_fillcolor_zero_alpha():
    """Test fill with long tuple fillcolor (length > 4, alpha == 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    fillcolor = (0.1, 0.2, 0.3, 0.0, 0.5)
    # length > 3, fillcolor[3] == 0, so should not fill
    codeflash_output = gc.fill(fillcolor)  # 1.21μs -> 1.17μs (3.85% faster)


def test_fill_with_fillcolor_none_explicit():
    """Test fill with explicit None as fillcolor (should not fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill(None)  # 984ns -> 852ns (15.5% faster)


def test_fill_with_fillcolor_tuple_with_alpha_zero():
    """Test fill with tuple where alpha is zero (should not fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((1.0, 1.0, 1.0, 0.0))  # 1.19μs -> 1.18μs (0.848% faster)


def test_fill_with_fillcolor_tuple_with_alpha_nonzero():
    """Test fill with tuple where alpha is nonzero (should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((1.0, 1.0, 1.0, 0.9))  # 1.18μs -> 1.17μs (0.854% faster)


def test_fill_with_list_fillcolor():
    """Test fill with list instead of tuple as fillcolor (should work)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill([0.1, 0.2, 0.3])  # 1.06μs -> 990ns (7.27% faster)


def test_fill_with_tuple_fillcolor_and_hatch():
    """Test fill with tuple fillcolor and hatch set (should return hatch value)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = "stripe"
    codeflash_output = gc.fill((0.1, 0.2, 0.3, 0.0))  # 856ns -> 753ns (13.7% faster)


# --- Large Scale Test Cases ---


def test_fill_with_large_rgb_tuple():
    """Test fill with large tuple (length 1000, alpha at index 3 != 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    fillcolor = tuple([0.1] * 3 + [0.5] + [0.1] * 996)
    codeflash_output = gc.fill(fillcolor)  # 1.17μs -> 1.18μs (0.677% slower)


def test_fill_with_large_rgb_tuple_alpha_zero():
    """Test fill with large tuple (length 1000, alpha at index 3 == 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    fillcolor = tuple([0.1] * 3 + [0.0] + [0.1] * 996)
    codeflash_output = gc.fill(fillcolor)  # 1.23μs -> 1.20μs (2.17% faster)


def test_fill_with_large_list_fillcolor():
    """Test fill with large list (length 1000, alpha at index 3 != 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    fillcolor = [0.2] * 3 + [0.7] + [0.2] * 996
    codeflash_output = gc.fill(fillcolor)  # 1.24μs -> 1.21μs (2.90% faster)


def test_fill_with_large_list_fillcolor_alpha_zero():
    """Test fill with large list (length 1000, alpha at index 3 == 0)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    fillcolor = [0.2] * 3 + [0.0] + [0.2] * 996
    codeflash_output = gc.fill(fillcolor)  # 1.26μs -> 1.24μs (1.37% faster)


def test_fill_performance_large_scale():
    """Test fill performance with many calls (scalability, should not error)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    fillcolor = (0.1, 0.2, 0.3, 0.8)
    # Run up to 1000 calls to check for performance issues
    for _ in range(1000):
        codeflash_output = gc.fill(fillcolor)  # 251μs -> 235μs (6.50% faster)


# --- Additional Edge Cases ---


def test_fill_with_fillcolor_tuple_length_3():
    """Test fill with tuple of length 3 (should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((0.1, 0.2, 0.3))  # 1.07μs -> 1.04μs (2.89% faster)


def test_fill_with_fillcolor_tuple_length_4_alpha_zero():
    """Test fill with tuple of length 4, alpha zero (should not fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((0.1, 0.2, 0.3, 0.0))  # 1.13μs -> 1.17μs (2.92% slower)


def test_fill_with_fillcolor_tuple_length_4_alpha_nonzero():
    """Test fill with tuple of length 4, alpha nonzero (should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill((0.1, 0.2, 0.3, 0.5))  # 1.16μs -> 1.09μs (6.23% faster)


def test_fill_with_fillcolor_tuple_length_5_alpha_nonzero():
    """Test fill with tuple of length 5, alpha nonzero (should fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill(
        (0.1, 0.2, 0.3, 0.5, 0.6)
    )  # 1.14μs -> 1.07μs (6.35% faster)


def test_fill_with_fillcolor_tuple_length_5_alpha_zero():
    """Test fill with tuple of length 5, alpha zero (should not fill)"""
    gc = GraphicsContextPdf(file=None)
    gc._hatch = None
    codeflash_output = gc.fill(
        (0.1, 0.2, 0.3, 0.0, 0.6)
    )  # 1.17μs -> 1.16μs (0.345% 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

# function to test
from matplotlib.backends.backend_pdf import GraphicsContextPdf

# unit tests


# Helper: Dummy file object for init
class DummyFile:
    pass


@pytest.fixture
def gc_pdf():
    # Returns a fresh GraphicsContextPdf for each test
    return GraphicsContextPdf(DummyFile())


# 1. BASIC TEST CASES


def test_fill_default_returns_true(gc_pdf):
    # By default, _fillcolor is (0,0,0), _hatch is None, so should fill
    codeflash_output = gc_pdf.fill()  # 857ns -> 909ns (5.72% slower)


def test_fill_with_explicit_rgb_color(gc_pdf):
    # 3-tuple color (RGB), should fill
    codeflash_output = gc_pdf.fill((1.0, 0.5, 0.2))  # 1.06μs -> 1.07μs (0.562% slower)


def test_fill_with_explicit_rgba_color_nonzero_alpha(gc_pdf):
    # 4-tuple color (RGBA), alpha != 0, should fill
    codeflash_output = gc_pdf.fill(
        (0.1, 0.2, 0.3, 0.4)
    )  # 1.17μs -> 1.15μs (1.57% faster)


def test_fill_with_explicit_rgba_color_zero_alpha(gc_pdf):
    # 4-tuple color (RGBA), alpha == 0, should NOT fill
    codeflash_output = gc_pdf.fill(
        (0.1, 0.2, 0.3, 0.0)
    )  # 1.20μs -> 1.21μs (0.828% slower)


def test_fill_with_explicit_none_color(gc_pdf):
    # None color disables fill
    codeflash_output = gc_pdf.fill(None)  # 928ns -> 820ns (13.2% faster)


def test_fill_with_hatch(gc_pdf):
    # If _hatch is set, always fill, regardless of color/alpha
    gc_pdf._hatch = "x"
    codeflash_output = gc_pdf.fill()  # 705ns -> 630ns (11.9% faster)
    # Even if color is None or alpha==0, hatch takes precedence
    codeflash_output = gc_pdf.fill(None)  # 569ns -> 470ns (21.1% faster)
    codeflash_output = gc_pdf.fill(
        (0.2, 0.3, 0.4, 0.0)
    )  # 210ns -> 199ns (5.53% faster)
    gc_pdf._hatch = None  # reset


# 2. EDGE TEST CASES


def test_fill_with_empty_tuple(gc_pdf):
    # Empty tuple as color: len=0 <=3, so should fill
    codeflash_output = gc_pdf.fill(())  # 1.07μs -> 1.05μs (1.33% faster)


def test_fill_with_single_value_tuple(gc_pdf):
    # (0.5,) as color: len=1 <=3, so should fill
    codeflash_output = gc_pdf.fill((0.5,))  # 1.05μs -> 1.06μs (0.944% slower)


def test_fill_with_long_tuple(gc_pdf):
    # (1,2,3,4,5): len>3, index 3 = 4, !=0 so should fill
    codeflash_output = gc_pdf.fill((1, 2, 3, 4, 5))  # 1.29μs -> 1.25μs (3.53% faster)


def test_fill_with_long_tuple_zero_alpha(gc_pdf):
    # (1,2,3,0,5): len>3, index 3 = 0, so should NOT fill
    codeflash_output = gc_pdf.fill((1, 2, 3, 0, 5))  # 1.23μs -> 1.25μs (0.963% slower)


def test_fill_with_tuple_of_len_3(gc_pdf):
    # (0.1,0.2,0.3): len=3, should fill
    codeflash_output = gc_pdf.fill((0.1, 0.2, 0.3))  # 1.04μs -> 1.04μs (0.000% faster)


def test_fill_with_tuple_of_len_4_alpha_zero(gc_pdf):
    # (0.1,0.2,0.3,0.0): len=4, alpha=0, should NOT fill
    codeflash_output = gc_pdf.fill(
        (0.1, 0.2, 0.3, 0.0)
    )  # 1.18μs -> 1.17μs (1.03% faster)


def test_fill_with_tuple_of_len_4_alpha_nonzero(gc_pdf):
    # (0.1,0.2,0.3,0.5): len=4, alpha=0.5, should fill
    codeflash_output = gc_pdf.fill(
        (0.1, 0.2, 0.3, 0.5)
    )  # 1.19μs -> 1.18μs (0.507% faster)


def test_fill_with_color_is_none_and_hatch_is_none(gc_pdf):
    # Both color and hatch None disables fill
    gc_pdf._hatch = None
    codeflash_output = gc_pdf.fill(None)  # 904ns -> 771ns (17.3% faster)


def test_fill_with_color_is_none_and_hatch_is_truthy(gc_pdf):
    # Hatch set, color None: fill returns hatch
    gc_pdf._hatch = "///"
    codeflash_output = gc_pdf.fill(None)  # 894ns -> 781ns (14.5% faster)
    gc_pdf._hatch = None  # reset


def test_fill_with_color_is_falsey_but_not_none(gc_pdf):
    # (0,0,0,0): len=4, alpha=0, should NOT fill
    codeflash_output = gc_pdf.fill((0, 0, 0, 0))  # 1.31μs -> 1.25μs (5.37% faster)


def test_fill_with_color_is_falsey_but_len_3(gc_pdf):
    # (0,0,0): len=3, should fill
    codeflash_output = gc_pdf.fill((0, 0, 0))  # 1.06μs -> 1.00μs (6.19% faster)


def test_fill_with_color_is_int(gc_pdf):
    # Passing int as color: should raise TypeError on len()
    with pytest.raises(TypeError):
        gc_pdf.fill(5)  # 1.97μs -> 1.85μs (6.04% faster)


def test_fill_with_color_is_list(gc_pdf):
    # [0.1,0.2,0.3,0.0]: len=4, alpha=0, should NOT fill
    codeflash_output = gc_pdf.fill(
        [0.1, 0.2, 0.3, 0.0]
    )  # 1.27μs -> 1.23μs (3.91% faster)


def test_fill_with_color_is_list_len_3(gc_pdf):
    # [0.1,0.2,0.3]: len=3, should fill
    codeflash_output = gc_pdf.fill([0.1, 0.2, 0.3])  # 1.05μs -> 995ns (5.93% faster)


def test_fill_with_color_is_list_len_5_alpha_nonzero(gc_pdf):
    # [1,2,3,5,6]: len>3, index 3 != 0, should fill
    codeflash_output = gc_pdf.fill([1, 2, 3, 5, 6])  # 1.27μs -> 1.24μs (3.08% faster)


def test_fill_with_color_is_list_len_5_alpha_zero(gc_pdf):
    # [1,2,3,0,6]: len>3, index 3 == 0, should NOT fill
    codeflash_output = gc_pdf.fill([1, 2, 3, 0, 6])  # 1.37μs -> 1.23μs (11.1% faster)


def test_fill_with_color_is_tuple_alpha_negative(gc_pdf):
    # (1,2,3,-0.1): len=4, alpha=-0.1, should fill (alpha != 0)
    codeflash_output = gc_pdf.fill((1, 2, 3, -0.1))  # 1.19μs -> 1.18μs (0.084% faster)


def test_fill_with_color_is_tuple_alpha_zero_float(gc_pdf):
    # (1,2,3,0.0): len=4, alpha=0.0, should NOT fill
    codeflash_output = gc_pdf.fill((1, 2, 3, 0.0))  # 1.20μs -> 1.12μs (6.87% faster)


def test_fill_with_color_is_tuple_alpha_zero_int(gc_pdf):
    # (1,2,3,0): len=4, alpha=0, should NOT fill
    codeflash_output = gc_pdf.fill((1, 2, 3, 0))  # 1.27μs -> 1.20μs (6.25% faster)


def test_fill_with_color_is_tuple_alpha_near_zero(gc_pdf):
    # (1,2,3,1e-10): len=4, alpha != 0, should fill
    codeflash_output = gc_pdf.fill((1, 2, 3, 1e-10))  # 1.22μs -> 1.13μs (7.71% faster)


def test_fill_with_color_is_tuple_alpha_nan(gc_pdf):
    # (1,2,3,float('nan')): len=4, alpha != 0, nan != 0, should fill
    codeflash_output = gc_pdf.fill(
        (1, 2, 3, float("nan"))
    )  # 1.19μs -> 1.16μs (2.85% faster)


def test_fill_with_color_is_tuple_alpha_inf(gc_pdf):
    # (1,2,3,float('inf')): len=4, alpha != 0, should fill
    codeflash_output = gc_pdf.fill(
        (1, 2, 3, float("inf"))
    )  # 1.20μs -> 1.14μs (4.90% faster)


def test_fill_with_color_is_tuple_alpha_minus_inf(gc_pdf):
    # (1,2,3,float('-inf')): len=4, alpha != 0, should fill
    codeflash_output = gc_pdf.fill(
        (1, 2, 3, float("-inf"))
    )  # 1.16μs -> 1.13μs (2.21% faster)


def test_fill_with_color_is_tuple_alpha_string(gc_pdf):
    # (1,2,3,"0"): len=4, alpha is string, != 0, should fill
    codeflash_output = gc_pdf.fill((1, 2, 3, "0"))  # 1.21μs -> 1.20μs (1.51% faster)


# 3. LARGE SCALE TEST CASES


def test_fill_large_list_alpha_zero(gc_pdf):
    # Large list, len=1000, index 3 = 0, should NOT fill
    color = [1] * 1000
    color[3] = 0
    codeflash_output = gc_pdf.fill(color)  # 1.35μs -> 1.30μs (3.61% faster)


def test_fill_large_list_alpha_nonzero(gc_pdf):
    # Large list, len=1000, index 3 = 1, should fill
    color = [0] * 1000
    color[3] = 1
    codeflash_output = gc_pdf.fill(color)  # 1.36μs -> 1.32μs (2.49% faster)


def test_fill_large_tuple_alpha_zero(gc_pdf):
    # Large tuple, len=1000, index 3 = 0, should NOT fill
    color = tuple([1] * 1000)
    color = color[:3] + (0,) + color[4:]
    codeflash_output = gc_pdf.fill(color)  # 1.36μs -> 1.26μs (7.96% faster)


def test_fill_large_tuple_alpha_nonzero(gc_pdf):
    # Large tuple, len=1000, index 3 = 0.5, should fill
    color = tuple([0] * 1000)
    color = color[:3] + (0.5,) + color[4:]
    codeflash_output = gc_pdf.fill(color)  # 1.22μs -> 1.21μs (0.830% faster)


def test_fill_large_tuple_len_3(gc_pdf):
    # Large tuple, len=3, should fill (len <= 3)
    color = tuple([0.1, 0.2, 0.3])
    codeflash_output = gc_pdf.fill(color)  # 1.07μs -> 1.03μs (3.48% faster)


def test_fill_large_tuple_len_4_alpha_zero(gc_pdf):
    # Large tuple, len=4, alpha=0, should NOT fill
    color = tuple([0.1, 0.2, 0.3, 0.0])
    codeflash_output = gc_pdf.fill(color)  # 1.17μs -> 1.12μs (3.74% faster)


def test_fill_large_tuple_len_4_alpha_nonzero(gc_pdf):
    # Large tuple, len=4, alpha=0.2, should fill
    color = tuple([0.1, 0.2, 0.3, 0.2])
    codeflash_output = gc_pdf.fill(color)  # 1.14μs -> 1.18μs (2.97% slower)


def test_fill_large_tuple_all_zero(gc_pdf):
    # Large tuple, all zero, len=1000, index 3 = 0, should NOT fill
    color = tuple([0] * 1000)
    codeflash_output = gc_pdf.fill(color)  # 1.33μs -> 1.28μs (4.30% faster)


def test_fill_large_tuple_all_one(gc_pdf):
    # Large tuple, all one, len=1000, index 3 = 1, should fill
    color = tuple([1] * 1000)
    codeflash_output = gc_pdf.fill(color)  # 1.28μs -> 1.28μs (0.156% slower)


def test_fill_large_tuple_with_hatch(gc_pdf):
    # Large tuple, hatch set, should always fill (returns hatch)
    gc_pdf._hatch = "large"
    color = tuple([0] * 1000)
    codeflash_output = gc_pdf.fill(color)  # 830ns -> 757ns (9.64% faster)
    gc_pdf._hatch = None  # reset


def test_fill_performance_large_number_of_calls(gc_pdf):
    # Performance: call fill 1000 times with different colors, should not raise
    for i in range(1000):
        color = (i % 2, i % 3, i % 5, i % 7)
        codeflash_output = gc_pdf.fill(color)
        result = codeflash_output  # 263μs -> 246μs (6.78% faster)
        # Should be True unless color[3] == 0
        if color[3] == 0:
            pass
        else:
            pass


# 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-GraphicsContextPdf.fill-miyn76s7 and push.