



"""simple docstring"""

import warnings

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




class        _UpperCAmelCase       (			lowerCAmelCase__):
 _lowerCAmelCase   :			Any							=		["""image_processor""", """tokenizer"""]
 _lowerCAmelCase   :			Optional[Any]							=		"""ViTImageProcessor"""
 _lowerCAmelCase   :			Any							=		("""CLIPTokenizer""", """CLIPTokenizerFast""")

 def __init__(     self		:       Optional[int]  ,     lowercase_		:       Any=None  ,     lowercase_		:       str=None  ,     **lowercase_		:       Tuple				):
     snake_case_ :     Tuple				=	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_  ,     )
         snake_case_ :     Tuple				=	kwargs.pop('''feature_extractor'''				)

     snake_case_ :     int				=	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		:       Tuple  ,     lowercase_		:       Dict=None  ,     lowercase_		:       Union[str, Any]=None  ,     lowercase_		:       List[str]=None  ,     lowercase_		:       str=None  ,     **lowercase_		:       Union[str, Any]				):
     if text is None and visual_prompt is None and images is None:
         raise ValueError('''You have to specify either text, visual prompt or images.'''				)

     if text is not None and visual_prompt is not None:
         raise ValueError('''You have to specify exactly one type of prompt. Either text or visual prompt.'''				)

     if text is not None:
         snake_case_ :     Tuple				=	self.tokenizer(lowercase_  ,     return_tensors=lowercase_  ,     **lowercase_				)

     if visual_prompt is not None:
         snake_case_ :     Tuple				=	self.image_processor(lowercase_  ,     return_tensors=lowercase_  ,     **lowercase_				)

     if images is not None:
         snake_case_ :     Tuple				=	self.image_processor(lowercase_  ,     return_tensors=lowercase_  ,     **lowercase_				)

     if visual_prompt is not None and images is not None:
         snake_case_ :     str				=	{
             '''pixel_values''': image_features.pixel_values,
             '''conditional_pixel_values''': prompt_features.pixel_values,
         }
         return encoding
     elif text is not None and images is not None:
         snake_case_ :     Any				=	image_features.pixel_values
         return encoding
     elif text is not None:
         return encoding
     elif visual_prompt is not None:
         snake_case_ :     Optional[int]				=	{
             '''conditional_pixel_values''': prompt_features.pixel_values,
         }
         return encoding
     else:
         return BatchEncoding(data=dict(**lowercase_				)  ,     tensor_type=lowercase_				)

 def 						_snake_case					(     self		:       Union[str, Any]  ,     *lowercase_		:       Union[str, Any]  ,     **lowercase_		:       Optional[Any]				):
     return self.tokenizer.batch_decode(*lowercase_  ,     **lowercase_				)

 def 						_snake_case					(     self		:       List[Any]  ,     *lowercase_		:       Dict  ,     **lowercase_		:       Optional[Any]				):
     return self.tokenizer.decode(*lowercase_  ,     **lowercase_				)

 @property
 def 						_snake_case					(     self		:       Optional[Any]				):
     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 						_snake_case					(     self		:       Optional[Any]				):
     warnings.warn(
         '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''  ,     lowercase_  ,     )
     return self.image_processor










"""simple docstring"""

import sys

lowercase__    :  Dict							    =	(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)




def __lowercase			(							_a    ):
    snake_case_ :     List[Any]				=	1
    for digit in s:
        product *= int(_a    )
    return product




def __lowercase			(							_a = N    ):
    snake_case_ :     Optional[int]				=	-sys.maxsize - 1
    snake_case_ :     str				=	n[:13]
    snake_case_ :     List[Any]				=	13
    while cur_index < len(_a    ) - 13:
        if int(n[cur_index]    ) >= int(substr[0]    ):
            snake_case_ :     int				=	substr[1:] + n[cur_index]
            cur_index += 1
        else:
            snake_case_ :     Optional[Any]				=	max(_a		,			str_eval(_a    )    )
            snake_case_ :     Any				=	n[cur_index : cur_index + 13]
            cur_index += 13
    return largest_product


if __name__ == "__main__":
     print(f'{solution() = }')





