


"""simple docstring"""


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			generate_pascal_triangle(_UpperCamelCase      )
			for row_idx in range(_UpperCamelCase      ):
						# Print left spaces
						for _ in range(num_rows - row_idx - 1      ):
									print(end=" "      )
						# Print row values
						for col_idx in range(row_idx + 1      ):
									if col_idx != row_idx:
												print(triangle[row_idx][col_idx]    , end=" "      )
									else:
												print(triangle[row_idx][col_idx]    , end=""      )
						print()


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			if not isinstance(_UpperCamelCase    , _UpperCamelCase      ):
						raise TypeError("The input value of 'num_rows' should be 'int'"      )

			if num_rows == 0:
						return []
			elif num_rows < 0:
						raise ValueError(
						    "The input value of 'num_rows' should be greater than or equal to 0"      )

			__lowerCAmelCase				    =			[]
			for current_row_idx in range(_UpperCamelCase      ):
						__lowerCAmelCase				    =			populate_current_row(_UpperCamelCase    , _UpperCamelCase      )
						triangle.append(_UpperCamelCase      )
			return triangle


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			[-1] * (current_row_idx + 1)
			# first and last elements of current row are equal to 1
			__lowerCAmelCase    ,	__lowerCAmelCase				    =			1, 1
			for current_col_idx in range(1    , _UpperCamelCase      ):
						calculate_current_element(
						    _UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase      )
			return current_row


def _lowerCamelCase	(		_UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase    , _UpperCamelCase    , ):

			'''simple docstring'''




			__lowerCAmelCase				    =			triangle[current_row_idx - 1][current_col_idx - 1]
			__lowerCAmelCase				    =			triangle[current_row_idx - 1][current_col_idx]
			__lowerCAmelCase				    =			above_to_left_elt + above_to_right_elt


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			if not isinstance(_UpperCamelCase    , _UpperCamelCase      ):
						raise TypeError("The input value of 'num_rows' should be 'int'"      )

			if num_rows == 0:
						return []
			elif num_rows < 0:
						raise ValueError(
						    "The input value of 'num_rows' should be greater than or equal to 0"      )

			__lowerCAmelCase				    =			[[1]]

			for row_index in range(1    , _UpperCamelCase      ):
						__lowerCAmelCase				    =			[0] + result[-1] + [0]
						__lowerCAmelCase				    =			row_index + 1
						# Calculate the number of distinct elements in a row
						__lowerCAmelCase				    =			sum(divmod(_UpperCamelCase    , 2      )      )
						__lowerCAmelCase				    =			[
						    temp_row[i - 1] + temp_row[i] for i in range(1    , distinct_elements + 1      )
						]
						__lowerCAmelCase				    =			row_first_half[: (row_index + 1) // 2]
						row_second_half.reverse()
						__lowerCAmelCase				    =			row_first_half + row_second_half
						result.append(_UpperCamelCase      )

			return result


def _lowerCamelCase	(		):

			'''simple docstring'''




			from collections.abc import Callable
			from timeit import timeit

			def benchmark_a_function(_UpperCamelCase    , _UpperCamelCase      ) -> None:
						__lowerCAmelCase				    =			f"{func.__name__}({value})"
						__lowerCAmelCase				    =			timeit(f"__main__.{call}"    , setup="import __main__"      )
						# print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
						print(f"{call:38} -- {timing:.4f} seconds"      )

			for value in range(15      ):  # (1, 7, 14):
						for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
									benchmark_a_function(_UpperCamelCase    , _UpperCamelCase      )
						print()


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	benchmark()








"""simple docstring"""






import math
def      lowerCamelCase       (     _UpperCamelCase		:      int							)		->       list[int]:

							'''simple docstring'''



							__UpperCAmelCase   :						List[Any]      							=					[]
							__UpperCAmelCase   :						Dict      							=					2
							__UpperCAmelCase   :						Union[str, Any]      							=					int(math.sqrt(_UpperCamelCase							)							)  # Size of every segment
							__UpperCAmelCase   :						Tuple      							=					[True] * (end + 1)
							__UpperCAmelCase   :						int      							=					[]

							while start <= end:
														if temp[start] is True:
																					in_prime.append(_UpperCamelCase							)
																					for i in range(start * start       ,			end + 1       ,			_UpperCamelCase							):
																												__UpperCAmelCase   :						Dict      							=					False
														start += 1
							prime += in_prime

							__UpperCAmelCase   :						Optional[int]      							=					end + 1
							__UpperCAmelCase   :						Dict      							=					min(2 * end       ,			_UpperCamelCase							)

							while low <= n:
														__UpperCAmelCase   :						Union[str, Any]      							=					[True] * (high - low + 1)
														for each in in_prime:
																					__UpperCAmelCase   :						Dict      							=					math.floor(low / each							) * each
																					if t < low:
																												t += each

																					for j in range(_UpperCamelCase       ,			high + 1       ,			_UpperCamelCase							):
																												__UpperCAmelCase   :						Tuple      							=					False

														for j in range(len(_UpperCamelCase							)							):
																					if temp[j] is True:
																												prime.append(j + low							)

														__UpperCAmelCase   :						Tuple      							=					high + 1
														__UpperCAmelCase   :						Optional[int]      							=					min(high + end       ,			_UpperCamelCase							)

							return prime
print(sieve(10**6))
