




import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class      _UpperCamelCase (			lowerCAmelCase						):
      UpperCAmelCase_            =						["""image_processor""", """tokenizer"""]
      UpperCAmelCase_            =						"""VideoMAEImageProcessor"""
      UpperCAmelCase_            =						("""CLIPTokenizer""", """CLIPTokenizerFast""")
      def __init__(     self				:Any	, lowerCamelCase				:Any=None	, lowerCamelCase				:Tuple=None	, **lowerCamelCase				:Any )       ->     int:
       UpperCAmelCase__								=  None
       if "feature_extractor" in kwargs:
        warnings.warn(
            "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
            " instead."	, lowerCamelCase	, )
        UpperCAmelCase__								=  kwargs.pop("feature_extractor" )

       UpperCAmelCase__								=  image_processor if image_processor is not None else feature_extractor
       if image_processor is None:
        raise ValueError("You need to specify an `image_processor`." )
       if tokenizer is None:
        raise ValueError("You need to specify a `tokenizer`." )

       super().__init__(lowerCamelCase	, lowerCamelCase )
       UpperCAmelCase__								=  self.image_processor
      def __call__(     self				:int	, lowerCamelCase				:List[str]=None	, lowerCamelCase				:int=None	, lowerCamelCase				:Tuple=None	, **lowerCamelCase				:List[str] )       ->     Optional[Any]:

       if text is None and videos is None:
        raise ValueError("You have to specify either text or videos. Both cannot be none." )

       if text is not None:
        UpperCAmelCase__								=  self.tokenizer(lowerCamelCase	, return_tensors=lowerCamelCase	, **lowerCamelCase )

       if videos is not None:
        UpperCAmelCase__								=  self.image_processor(lowerCamelCase	, return_tensors=lowerCamelCase	, **lowerCamelCase )

       if text is not None and videos is not None:
        UpperCAmelCase__								=  image_features.pixel_values
        return encoding
       elif text is not None:
        return encoding
       else:
        return BatchEncoding(data=dict(**lowerCamelCase )	, tensor_type=lowerCamelCase )
      def 		UpperCAmelCase_  (     self				:Tuple	, *lowerCamelCase				:Optional[Any]	, **lowerCamelCase				:Optional[Any] )       ->     List[Any]:
       return self.tokenizer.batch_decode(*lowerCamelCase	, **lowerCamelCase )
      def 		UpperCAmelCase_  (     self				:List[str]	, *lowerCamelCase				:Tuple	, **lowerCamelCase				:int )       ->     Tuple:
       return self.tokenizer.decode(*lowerCamelCase	, **lowerCamelCase )
      @property
      def 		UpperCAmelCase_  (     self				:int )       ->     Dict:
       return ["input_ids", "attention_mask", "position_ids", "pixel_values"]
      @property
      def 		UpperCAmelCase_  (     self				:int )       ->     Optional[int]:
       warnings.warn(
           "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."	, lowerCamelCase	, )
       return self.image_processor_class







      @property
      def 		UpperCAmelCase_  (     self				:Optional[Any] )       ->     Optional[Any]:
       warnings.warn(
           "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."	, lowerCamelCase	, )
       return self.image_processor











def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







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



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







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



def   lowerCAmelCase						(						_lowerCAmelCase							:				int		):




 """simple docstring"""







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


if __name__ == "__main__":
  _lowerCAmelCase  :				Dict						=				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.''')





