





from __future__ import annotations

from PIL import Image

# Define glider example
_lowercase		:  int			       =[
    [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		:  List[Any]			       =[[0, 1, 0], [0, 1, 0], [0, 1, 0]]


def 		_SCREAMING_SNAKE_CASE     ( lowerCAmelCase__						):
		lowerCamelCase_	:     Optional[int] 						=      []
		for i in range(len(lowerCAmelCase__						)						):
				lowerCamelCase_	:     str 						=      []
				for j in range(len(cells[i]						)						):
						# Get the number of live neighbours
						lowerCamelCase_	:     List[str] 						=      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.
						lowerCamelCase_	:     int 						=      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 		_SCREAMING_SNAKE_CASE     ( lowerCAmelCase__							,lowerCAmelCase__						):
		lowerCamelCase_	:     Optional[int] 						=      []
		for _ in range(lowerCAmelCase__						):
				# Create output image
				lowerCamelCase_	:     int 						=      Image.new('RGB'							,(len(cells[0]						), len(lowerCAmelCase__						))						)
				lowerCamelCase_	:     Tuple 						=      img.load()

				# Save cells to image
				for x in range(len(lowerCAmelCase__						)						):
						for y in range(len(cells[0]						)						):
								lowerCamelCase_	:     str 						=      2_55 - cells[y][x] * 2_55
								lowerCamelCase_	:     str 						=      (colour, colour, colour)

        # Save image
				images.append(lowerCAmelCase__						)
				lowerCamelCase_	:     Optional[int] 						=      new_generation(lowerCAmelCase__						)
		return images


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







def 		_SCREAMING_SNAKE_CASE     ( lowerCAmelCase__=2_81_23						):
		lowerCamelCase_	:     Any 						=      [1] * (limit + 1)

		for i in range(2							,int(limit**0.5						) + 1						):
				sum_divs[i * i] += i
				for k in range(i + 1							,limit // i + 1						):
						sum_divs[k * i] += k + i

		lowerCamelCase_	:     List[str] 						=      set()
		lowerCamelCase_	:     List[str] 						=      0

		for n in range(1							,limit + 1						):
				if sum_divs[n] > n:
						abundants.add(lowerCAmelCase__						)

				if not any((n - a in abundants) for a in abundants						):
						res += n

		return res


if __name__ == "__main__":
		print(solution())
