def 					snake_case						(__lowercase						)       ->       Optional[Any]:

						'''simple docstring'''



						_snake_case						:     Optional[int]				=    len(__lowercase						)
						for i in range(length - 1						):
												_snake_case						:     str				=    False
												for j in range(length - 1 - i						):
																		if collection[j] > collection[j + 1]:
																								_snake_case						:     Union[str, Any]				=    True
																								_snake_case				,_snake_case						:     List[str]				=    collection[j + 1], collection[j]
												if not swapped:
																		break  # Stop iteration if the collection is sorted.
						return collection


if __name__ == "__main__":
				import doctest
				import time

				doctest.testmod()

				__SCREAMING_SNAKE_CASE						:    int     = input('Enter numbers separated by a comma:').strip()
				__SCREAMING_SNAKE_CASE						:    List[Any]     = [int(item) for item in user_input.split(',')]
				__SCREAMING_SNAKE_CASE						:    Union[str, Any]     = time.process_time()
				print(*bubble_sort(unsorted), sep=',')
				print(F'''Processing time: {(time.process_time() - start)%1E9 + 7}''')
from __future__ import annotations

from PIL import Image

# Define the first generation of cells
# fmt: off
__SCREAMING_SNAKE_CASE						:    Optional[int]     = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
def 					snake_case						(__lowercase						)       ->       list[int]:

						'''simple docstring'''



						return [int(__lowercase						) for c in F"""{ruleset:08}"""[:8]]
def 					snake_case						(__lowercase					,			__lowercase					,			__lowercase						)       ->       list[int]:

						'''simple docstring'''



						_snake_case						:     Any				=    len(cells[0]						)  # 31
						_snake_case						:     str				=    []
						for i in range(__lowercase						):
												# Get the neighbors of each cell
												# Handle neighbours outside bounds by using 0 as their value
												_snake_case						:     Any				=    0 if i == 0 else cells[time][i - 1]
												_snake_case						:     List[str]				=    0 if i == population - 1 else cells[time][i + 1]
												# Define a new cell and add it to the new generation
												_snake_case						:     str				=    7 - int(F"""{left_neighbor}{cells[time][i]}{right_neighbor}"""					,			2						)
												next_generation.append(rule[situation]						)
						return next_generation
def 					snake_case						(__lowercase						)       ->       Image.Image:

						'''simple docstring'''



						_snake_case						:     str				=    Image.new("RGB"					,			(len(cells[0]						), len(__lowercase						))						)
						_snake_case						:     int				=    img.load()
						# Generates image
						for w in range(img.width						):
												for h in range(img.height						):
																		_snake_case						:     List[Any]				=    255 - int(255 * cells[h][w]						)
																		_snake_case						:     Union[str, Any]				=    (color, color, color)
						return img


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE						:    Any     = bin(int(input('Rule:\n').strip()))[2:]
				__SCREAMING_SNAKE_CASE						:    Tuple     = format_ruleset(int(rule_num))
				for time in range(1_6):
								CELLS.append(new_generation(CELLS, rule, time))
				__SCREAMING_SNAKE_CASE						:    List[Any]     = generate_image(CELLS)
				# Uncomment to save the image
				# img.save(f"rule_{rule_num}.png")
				img.show()