code: 
  
  import timeit
  
  
  
  
  
  
  class     lowerCamelCase_			:
  
  
  
  
  	def __init__(    self	:    Any				,			__A	:    Dict       ):
  		if isinstance(__A				,			__A       ):  # Initializes a matrix identical to the one provided.
  			__A   : Optional[int]								= arg
  			__A   : Union[str, Any]								= len(__A       )
  		else:  # Initializes a square matrix of the given size and set values to zero.
  			__A   : int								= arg
  			__A   : Tuple								= [[0 for _ in range(self.n       )] for _ in range(self.n       )]
  
  
  
  
  	def __mul__(    self	:    Optional[Any]				,			__A	:    Any       ):
  		__A   : Union[str, Any]								= Matrix(self.n       )
  		for i in range(self.n       ):
  			for j in range(self.n       ):
  				for k in range(self.n       ):
  					matrix.t[i][j] += self.t[i][k] * b.t[k][j]
  		return matrix
  
  
  
  
  
  
  def        __SCREAMING_SNAKE_CASE    (      a__						:      Dict ,a__						:      Optional[Any]					)				->							str:
  	__A   : Optional[Any]								= Matrix([[1, 0], [0, 1]]					)
  	while b > 0:
  		if b & 1:
  			matrix *= a
  		a *= a
  		b >>= 1
  	return matrix
  def        __SCREAMING_SNAKE_CASE    (      a__						:      Dict ,a__						:      Union[str, Any] ,a__						:      List[str]					)				->							Union[str, Any]:
  	# Trivial Cases
  	if n == 1:
  		return fa
  	elif n == 2:
  		return fa
  	__A   : str								= Matrix([[1, 1], [1, 0]]					)
  	__A   : int								= modular_exponentiation(a__ ,n - 2					)
  	return fa * matrix.t[0][0] + fa * matrix.t[0][1]
  def        __SCREAMING_SNAKE_CASE    (      a__						:      List[str] ,a__						:      Any ,a__						:      List[str]					)				->							List[Any]:
  	# Trivial Cases
  	if n == 1:
  		return fa
  	elif n == 2:
  		return fa
  
  	__A   : str								= fa
  	__A   : str								= fa
  	n -= 2
  
  	while n > 0:
  		__A						,							__A   : Tuple								= fn_a + fn_a, fn_a
  		n -= 1
  
  	return fn_a
  def        __SCREAMING_SNAKE_CASE    (      )				->							Optional[int]:
  	__A   : Any								= """
  from random import randint
  from __main__ import fibonacci_with_matrix_exponentiation
  """
  	__A   : Optional[Any]								= """fibonacci_with_matrix_exponentiation(randint(1,70000), 1, 1)"""
  	__A   : List[Any]								= timeit.timeit(setup=a__ ,stmt=a__ ,number=100					)
  	print("""With matrix exponentiation the average execution time is """ ,exec_time / 100					)
  	return exec_time
  def        __SCREAMING_SNAKE_CASE    (      )				->							Union[str, Any]:
  	__A   : int								= """
  from random import randint
  from __main__ import simple_fibonacci
  """
  	__A   : Optional[Any]								= """simple_fibonacci(randint(1,70000), 1, 1)"""
  	__A   : List[Any]								= timeit.timeit(setup=a__ ,stmt=a__ ,number=100					)
  	print(
  	    """Without matrix exponentiation the average execution time is """ ,exec_time / 100					)
  	return exec_time
  def        __SCREAMING_SNAKE_CASE    (      )				->							List[Any]:
  	matrix_exponentiation_time()
  	simple_fibonacci_time()
  
  
  if __name__ == "__main__":
  			main()
  
  
  
  
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  UpperCAmelCase_       :				Optional[Any]		   =      {
      '''configuration_prophetnet''': ['''PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ProphetNetConfig'''],
      '''tokenization_prophetnet''': ['''ProphetNetTokenizer'''],
  }
  
  try:
  			if not is_torch_available():
  						raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  			pass
  else:
  			UpperCAmelCase_       :				List[str]		   =      [
  			    '''PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
  			    '''ProphetNetDecoder''',
  			    '''ProphetNetEncoder''',
  			    '''ProphetNetForCausalLM''',
  			    '''ProphetNetForConditionalGeneration''',
  			    '''ProphetNetModel''',
  			    '''ProphetNetPreTrainedModel''',
  			]
  
  
  if TYPE_CHECKING:
  			from .configuration_prophetnet import PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ProphetNetConfig
  			from .tokenization_prophetnet import ProphetNetTokenizer
  
  			try:
  						if not is_torch_available():
  									raise OptionalDependencyNotAvailable()
  			except OptionalDependencyNotAvailable:
  						pass
  			else:
  						from .modeling_prophetnet import (
  						    PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
  						    ProphetNetDecoder,
  						    ProphetNetEncoder,
  						    ProphetNetForCausalLM,
  						    ProphetNetForConditionalGeneration,
  						    ProphetNetModel,
  						    ProphetNetPreTrainedModel,
  						)
  
  else:
  			import sys
  
  			UpperCAmelCase_       :				Any		   =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
  
  