



def        a( A			:       int					,	A			:       int			)						->			Tuple:
					"""simple docstring"""





					if a < b:
										return gcd(A_					,	A_			)
					if a % b == 0:
										return b
					return gcd(A_					,	a % b			)






def        a( A			:       int					,	A			:       int					,	A			:       int			)						->			Dict:
					"""simple docstring"""





					if y == 0:
										return 1
					a   	=  power(A_					,	y // 2					,	A_			) % mod
					a   	=  (temp * temp) % mod
					if y % 2 == 1:
										a   	=  (temp * x) % mod
					return temp






def        a( A			:       int			)						->			Tuple:
					"""simple docstring"""





					a   	=  2
					while b < n:
										if gcd(A_					,	A_			) == 1 and power(A_					,	n - 1					,	A_			) != 1:
															return False
										b += 1
					return True


if __name__ == "__main__":
				_lowercase:					Tuple      =						int(input("Enter number: ").strip())
				if is_carmichael_number(number):
								print(F"""{number} is a Carmichael Number.""")
				else:
								print(F"""{number} is not a Carmichael Number.""")








"""simple docstring"""


from __future__ import annotations




def      snake_case    (A_ :list[int | float]      ,     A_ :int      ,     A_ :int ):







  '''simple docstring'''

  if len(A_ ) == 0:
    raise ValueError('find_min() arg is an empty sequence' )
  if (
      left >= len(A_ )
      or left < -len(A_ )
      or right >= len(A_ )
      or right < -len(A_ )
  ):
    raise IndexError('list index out of range' )
  if left == right:
    return nums[left]
  a	:     Optional[Any]							=  (left + right) >> 1  # the middle
  a	:     List[str]							=  find_min(A_      ,     A_      ,     A_ )  # find min in range[left, mid]
  a	:     Union[str, Any]							=  find_min(A_      ,     mid + 1      ,     A_ )  # find min in range[mid + 1, right]

  return left_min if left_min <= right_min else right_min


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)




