

def      _lowerCAmelCase(	__A			):
  UpperCAmelCase					      =  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      _lowerCAmelCase(	__A			):

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

  UpperCAmelCase					      =  []
  for current_row_idx in range(__A			):
    UpperCAmelCase					      =  populate_current_row(__A   ,       __A			)
    triangle.append(__A			)
  return triangle
def      _lowerCAmelCase(	__A   ,       __A			):
  UpperCAmelCase					      =  [-1] * (current_row_idx + 1)
  # first and last elements of current row are equal to 1
  UpperCAmelCase      ,	UpperCAmelCase					      =  1, 1
  for current_col_idx in range(1   ,       __A			):
    calculate_current_element(
        __A   ,       __A   ,       __A   ,       __A			)
  return current_row
def      _lowerCAmelCase(	__A   ,       __A   ,       __A   ,       __A   ,       ):
  UpperCAmelCase					      =  triangle[current_row_idx - 1][current_col_idx - 1]
  UpperCAmelCase					      =  triangle[current_row_idx - 1][current_col_idx]
  UpperCAmelCase					      =  above_to_left_elt + above_to_right_elt
def      _lowerCAmelCase(	__A			):

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

  UpperCAmelCase					      =  [[1]]

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

  return result
def      _lowerCAmelCase(	):
  from collections.abc import Callable
  from timeit import timeit

  def benchmark_a_function(__A   ,       __A			) -> None:
    UpperCAmelCase					      =  F"{func.__name__}({value})"
    UpperCAmelCase					      =  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()






def      _lowerCAmelCase(	__A   ,       __A   ,       __A			):
  if n == 0:
    return 1

  elif n % 2 == 1:
    return (binary_exponentiation(__A   ,       n - 1   ,       __A			) * a) % mod

  else:
    UpperCAmelCase					      =  binary_exponentiation(__A   ,       n / 2   ,       __A			)
    return (b * b) % mod


# a prime number
lowerCAmelCase__       = 701

lowerCAmelCase__       = 1000000000
lowerCAmelCase__       = 10

# using binary exponentiation function, O(log(p)):
print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p)





print((a / b) % p == (a * b ** (p - 2)) % p)



