





def  __magic_name__  (				lowercase				)				-> List[Any]:

							"""simple docstring"""



							lowercase_	:   Optional[Any]  				=     generate_pascal_triangle(_A				)
							for row_idx in range(_A				):
														# 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  __magic_name__  (				lowercase				)				-> Optional[Any]:

							"""simple docstring"""



							if not isinstance(_A				,       _A				):
														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"""				)

							lowercase_	:   list[list[int]]  				=     []
							for current_row_idx in range(_A				):
														lowercase_	:   int  				=     populate_current_row(_A				,       _A				)
														triangle.append(_A				)
							return triangle





def  __magic_name__  (				lowercase				,       lowercase				)				-> Optional[int]:

							"""simple docstring"""



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





def  __magic_name__  (				lowercase				,       lowercase				,       lowercase				,       lowercase				,       )				-> List[Any]:

							"""simple docstring"""



							lowercase_	:   List[Any]  				=     triangle[current_row_idx - 1][current_col_idx - 1]
							lowercase_	:   Any  				=     triangle[current_row_idx - 1][current_col_idx]
							lowercase_	:   Optional[Any]  				=     above_to_left_elt + above_to_right_elt





def  __magic_name__  (				lowercase				)				-> str:

							"""simple docstring"""



							if not isinstance(_A				,       _A				):
														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"""				)

							lowercase_	:   list[list[int]]  				=     [[1]]

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

							return result





def  __magic_name__  (				)				-> Optional[Any]:

							"""simple docstring"""



							from collections.abc import Callable
							from timeit import timeit

							def benchmark_a_function(lowercase				,       lowercase				) -> None:
														lowercase_	:   int  				=     f"""{func.__name__}({value})"""
														lowercase_	:   Optional[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(_A				,       _A				)
														print()


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							benchmark()




'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowerCAmelCase:   List[str]					=		{
    'configuration_falcon': ['FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FalconConfig'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:   str					=		[
         'FALCON_PRETRAINED_MODEL_ARCHIVE_LIST',
         'FalconForCausalLM',
         'FalconModel',
         'FalconPreTrainedModel',
         'FalconForSequenceClassification',
         'FalconForTokenClassification',
         'FalconForQuestionAnswering',
     ]


if TYPE_CHECKING:
     from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_falcon import (
              FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
              FalconForCausalLM,
              FalconForQuestionAnswering,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconModel,
              FalconPreTrainedModel,
          )


else:
     import sys

     lowerCAmelCase:   Optional[int]					=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)