



def     __lowerCamelCase							(   __magic_name__						:	list[list[int]]  ,			__magic_name__						:	list[list[int]]    ):
							a__:							Optional[Any]									=[]
							a__:							Optional[int]									=len(__magic_name__    )
							for i in range(__magic_name__    ):
														a__:							List[str]									=[]
														for j in range(__magic_name__    ):
																					a__:							List[str]									=0
																					for k in range(__magic_name__    ):
																												a__:							List[str]									=val + matrix_a[i][k] * matrix_b[k][j]
																					list_a.append(__magic_name__    )
														matrix_c.append(__magic_name__    )
							return matrix_c





def     __lowerCamelCase							(   __magic_name__						:	int    ):
							return [[int(row == column    ) for column in range(__magic_name__    )] for row in range(__magic_name__    )]





def     __lowerCamelCase							(   __magic_name__						:	int    ):
							if n <= 1:
														return n
							a__:							List[str]									=identity(2    )
							a__:							Union[str, Any]									=[[1, 1], [1, 0]]
							a__:							Any									=n - 1
							while n > 0:
														if n % 2 == 1:
																					a__:							Any									=multiply(__magic_name__  ,			__magic_name__    )
														a__:							Tuple									=multiply(__magic_name__  ,			__magic_name__    )
														a__:							Dict									=int(n / 2    )
							return res_matrix[0][0]





def     __lowerCamelCase							(   __magic_name__						:	int    ):
							if n <= 1:
														return n
							a__:							Dict									=0
							a__:							str									=1
							for _ in range(2  ,			n + 1    ):
														a__				,      a__:							Optional[int]									=fiba, fiba + fiba
							return fiba





def     __lowerCamelCase							(   ):
							for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
														a__:							str									=int("".join(c for c in ordinal if c in "0123456789"    )    )  # 1000th --> 1000
														print(
														    F"{ordinal} fibonacci number using matrix exponentiation is "
														    F"{nth_fibonacci_matrix(__magic_name__    )} and using bruteforce is "
														    F"{nth_fibonacci_bruteforce(__magic_name__    )}\n"    )
							# from timeit import timeit
							# print(timeit("nth_fibonacci_matrix(1000000)",
							#              "from main import nth_fibonacci_matrix", number=5))
							# print(timeit("nth_fibonacci_bruteforce(1000000)",
							#              "from main import nth_fibonacci_bruteforce", number=5))
							# 2.3342058970001744
							# 57.256506615000035


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()










from __future__ import annotations





def     __lowerCamelCase							(   __magic_name__						:	int    ):
							for r in range(1  ,			__magic_name__    ):
														a__:							List[str]									=[]
														for x in range(n - 1    ):
																					a__:							int									=pow(__magic_name__  ,			__magic_name__  ,			__magic_name__    )
																					if val in li:
																												break
																					li.append(__magic_name__    )
														else:
																					return r
							return None


if __name__ == "__main__":
		__UpperCAmelCase    	=  int(input('''Enter a prime number q: '''))
		__UpperCAmelCase    	=  find_primitive(q)
		if a is None:
				print(f"""Cannot find the primitive for the value: {a!r}""")
		else:
				__UpperCAmelCase    	=  int(input('''Enter private key of A: '''))
				__UpperCAmelCase    	=  pow(a, a_private, q)
				__UpperCAmelCase    	=  int(input('''Enter private key of B: '''))
				__UpperCAmelCase    	=  pow(a, b_private, q)

				__UpperCAmelCase    	=  pow(b_public, a_private, q)
				__UpperCAmelCase    	=  pow(a_public, b_private, q)

				print('''The key value generated by A is: ''', a_secret)
				print('''The key value generated by B is: ''', b_secret)





