




'''simple docstring'''







import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class     _a						(			__a				):
       __a       :  List[Any]            =      ["""image_processor""", """tokenizer"""]
       __a       :  Any            =      """CLIPImageProcessor"""
       __a       :  Any            =      ("""CLIPTokenizer""", """CLIPTokenizerFast""")
       def __init__(			self		:			Optional[int]     ,       lowercase		:			Union[str, Any]=None     ,       lowercase		:			Optional[int]=None     ,       **lowercase		:			Dict       ):



           '''simple docstring'''

           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.'''     ,       lowercase     ,       )
               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__(lowercase     ,       lowercase       )
       def __call__(			self		:			List[Any]     ,       lowercase		:			int=None     ,       lowercase		:			Union[str, Any]=None     ,       lowercase		:			str=None     ,       **lowercase		:			str       ):



           '''simple docstring'''

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

           if text is not None:
               UpperCAmelCase     =	self.tokenizer(lowercase     ,       return_tensors=lowercase     ,       **lowercase       )

           if images is not None:
               UpperCAmelCase     =	self.image_processor(lowercase     ,       return_tensors=lowercase     ,       **lowercase       )

           if text is not None and images is not None:
               UpperCAmelCase     =	image_features.pixel_values
               return encoding
           elif text is not None:
               return encoding
           else:
               return BatchEncoding(data=dict(**lowercase       )     ,       tensor_type=lowercase       )
       def 					A   (			self		:			List[str]     ,       *lowercase		:			Dict     ,       **lowercase		:			Optional[int]       ):



           '''simple docstring'''

           return self.tokenizer.batch_decode(*lowercase     ,       **lowercase       )
       def 					A   (			self		:			str     ,       *lowercase		:			Any     ,       **lowercase		:			List[str]       ):



           '''simple docstring'''

           return self.tokenizer.decode(*lowercase     ,       **lowercase       )
       @property
       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.tokenizer.model_input_names
           UpperCAmelCase     =	self.image_processor.model_input_names
           return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names       )       )
       @property
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

           warnings.warn(
               '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''     ,       lowercase     ,       )
           return self.image_processor_class







       @property
       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           warnings.warn(
               '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''     ,       lowercase     ,       )
           return self.image_processor










'''simple docstring'''







def 		snake_case_							():
    for n in range(1					,     1_0_0_0_0_0_0  ):
        yield n * (n + 1) // 2





def 		snake_case_							(_a			:							Union[str, Any]  ):
    UpperCAmelCase     =	1
    UpperCAmelCase     =	2
    while i * i <= n:
        UpperCAmelCase     =	0
        while n % i == 0:
            n //= i
            multiplicity += 1
        divisors_count *= multiplicity + 1
        i += 1
    if n > 1:
        divisors_count *= 2
    return divisors_count





def 		snake_case_							():
    return next(i for i in triangle_number_generator() if count_divisors(_a  ) > 5_0_0  )


if __name__ == "__main__":
   print(solution())




