





'''simple docstring'''

from __future__ import annotations

from PIL import Image

# Define glider example
lowercase_					= [
    [0, 1, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0, 0, 0, 0],
    [1, 1, 1, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
]

# Define blinker example
lowercase_					= [[0, 1, 0], [0, 1, 0], [0, 1, 0]]





def lowerCamelCase						(     __lowerCamelCase :    list[list[int]]    )						->list[list[int]]:
    _SCREAMING_SNAKE_CASE									=			[]
    for i in range(len(__lowerCamelCase    )    ):
        _SCREAMING_SNAKE_CASE									=			[]
        for j in range(len(cells[i]    )    ):
            # Get the number of live neighbours
            _SCREAMING_SNAKE_CASE									=			0
            if i > 0 and j > 0:
                neighbour_count += cells[i - 1][j - 1]
            if i > 0:
                neighbour_count += cells[i - 1][j]
            if i > 0 and j < len(cells[i]    ) - 1:
                neighbour_count += cells[i - 1][j + 1]
            if j > 0:
                neighbour_count += cells[i][j - 1]
            if j < len(cells[i]    ) - 1:
                neighbour_count += cells[i][j + 1]
            if i < len(__lowerCamelCase    ) - 1 and j > 0:
                neighbour_count += cells[i + 1][j - 1]
            if i < len(__lowerCamelCase    ) - 1:
                neighbour_count += cells[i + 1][j]
            if i < len(__lowerCamelCase    ) - 1 and j < len(cells[i]    ) - 1:
                neighbour_count += cells[i + 1][j + 1]

            # Rules of the game of life (excerpt from Wikipedia):
            # 1. Any live cell with two or three live neighbours survives.
            # 2. Any dead cell with three live neighbours becomes a live cell.
            # 3. All other live cells die in the next generation.
            #    Similarly, all other dead cells stay dead.
            _SCREAMING_SNAKE_CASE									=			cells[i][j] == 1
            if (
                (alive and 2 <= neighbour_count <= 3)
                or not alive
                and neighbour_count == 3
            ):
                next_generation_row.append(1    )
            else:
                next_generation_row.append(0    )

        next_generation.append(__lowerCamelCase    )
    return next_generation





def lowerCamelCase						(     __lowerCamelCase :    list[list[int]]					,       __lowerCamelCase :    int    )						->list[Image.Image]:
    _SCREAMING_SNAKE_CASE									=			[]
    for _ in range(__lowerCamelCase    ):
        # Create output image
        _SCREAMING_SNAKE_CASE									=			Image.new("""RGB"""					,       (len(cells[0]    ), len(__lowerCamelCase    ))    )
        _SCREAMING_SNAKE_CASE									=			img.load()

        # Save cells to image
        for x in range(len(__lowerCamelCase    )    ):
            for y in range(len(cells[0]    )    ):
                _SCREAMING_SNAKE_CASE									=			255 - cells[y][x] * 255
                _SCREAMING_SNAKE_CASE									=			(colour, colour, colour)

        # Save image
        images.append(__lowerCamelCase    )
        _SCREAMING_SNAKE_CASE									=			new_generation(__lowerCamelCase    )
    return images


if __name__ == "__main__":
      lowercase_					= generate_images(GLIDER, 16)
      images[0].save("""out.gif""", save_all=True, append_images=images[1:])










'''simple docstring'''

from collections.abc import Sequence





def lowerCamelCase						(     __lowerCamelCase :    Sequence[float]					,       __lowerCamelCase :    bool = False    )						->float:
    if not arr:
        return 0

    _SCREAMING_SNAKE_CASE									=			0 if allow_empty_subarrays else float("""-inf"""    )
    _SCREAMING_SNAKE_CASE									=			0.0
    for num in arr:
        _SCREAMING_SNAKE_CASE									=			max(0 if allow_empty_subarrays else num					,       curr_sum + num    )
        _SCREAMING_SNAKE_CASE									=			max(__lowerCamelCase					,       __lowerCamelCase    )

    return max_sum


if __name__ == "__main__":
      from doctest import testmod

      testmod()

      lowercase_					= [-2, 1, -3, 4, -1, 2, 1, -5, 4]
      print(f"""{max_subarray_sum(nums) = }""")



