

"""simple docstring"""







def   __UpperCAmelCase    (   UpperCAmelCase_   :    Any  )							->      None:

	'''simple docstring'''





	__snake_case      :							Optional[int]						=			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   __UpperCAmelCase    (   UpperCAmelCase_   :    Optional[Any]  )							->      list[list[int]]:

	'''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'  )

	__snake_case      :							Union[str, Any]						=			[]
	for current_row_idx in range(UpperCAmelCase_  ):
		__snake_case      :							str						=			populate_current_row(UpperCAmelCase_      ,							UpperCAmelCase_  )
		triangle.append(UpperCAmelCase_  )
	return triangle
def   __UpperCAmelCase    (   UpperCAmelCase_   :    Tuple      ,							UpperCAmelCase_   :    int  )							->      list[int]:

	'''simple docstring'''





	__snake_case      :							int						=			[-1] * (current_row_idx + 1)
	# first and last elements of current row are equal to 1
	__snake_case		,    __snake_case      :							Optional[int]						=			1, 1
	for current_col_idx in range(1      ,							UpperCAmelCase_  ):
		calculate_current_element(
		    UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )
	return current_row
def   __UpperCAmelCase    (   UpperCAmelCase_   :    Any      ,							UpperCAmelCase_   :    List[Any]      ,							UpperCAmelCase_   :    Union[str, Any]      ,							UpperCAmelCase_   :    str      ,							)							->      None:

	'''simple docstring'''





	__snake_case      :							List[Any]						=			triangle[current_row_idx - 1][current_col_idx - 1]
	__snake_case      :							int						=			triangle[current_row_idx - 1][current_col_idx]
	__snake_case      :							int						=			above_to_left_elt + above_to_right_elt
def   __UpperCAmelCase    (   UpperCAmelCase_   :    Union[str, Any]  )							->      list[list[int]]:

	'''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'  )

	__snake_case      :							Optional[int]						=			[[1]]

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

	return result
def   __UpperCAmelCase    (   )							->      None:

	'''simple docstring'''





	from collections.abc import Callable
	from timeit import timeit

	def benchmark_a_function(UpperCAmelCase_   :    List[str]      ,							UpperCAmelCase_   :    str  ) -> None:
		__snake_case      :							Any						=			F"{func.__name__}({value})"
		__snake_case      :							int						=			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"""







def   __UpperCAmelCase    (   UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int  )							->      int:

	'''simple docstring'''





	while a != 0:
		__snake_case		,    __snake_case      :							Union[str, Any]						=			b % a, a
	return b

def   __UpperCAmelCase    (   UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int  )							->      int:

	'''simple docstring'''





	if gcd(UpperCAmelCase_      ,							UpperCAmelCase_  ) != 1:
		__snake_case      :							Union[str, Any]						=			F"mod inverse of {a!r} and {m!r} does not exist"
		raise ValueError(UpperCAmelCase_  )
	__snake_case		,    __snake_case		,    __snake_case      :							List[str]						=			1, 0, a
	__snake_case		,    __snake_case		,    __snake_case      :							Dict						=			0, 1, m
	while va != 0:
		__snake_case      :							List[str]						=			ua // va
		__snake_case		,    __snake_case		,    __snake_case		,    __snake_case		,    __snake_case		,    __snake_case      :							List[str]						=			(ua - q * va), (ua - q * va), (ua - q * va), va, va, va
	return ua % m





