






'''simple docstring'''




import warnings

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







class    __lowercase       (__lowerCamelCase     ):
	_lowerCamelCase														=	['''image_processor''', '''tokenizer''']
	_lowerCamelCase														=	'''ChineseCLIPImageProcessor'''
	_lowerCamelCase														=	('''BertTokenizer''', '''BertTokenizerFast''')

	def __init__(   self :    Optional[Any]	,       UpperCAmelCase_ :    Optional[Any]=None	,       UpperCAmelCase_ :    Optional[int]=None	,       **UpperCAmelCase_ :    int):
			UpperCamelCase__					:       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.'	,       lowerCamelCase__	,       )
					UpperCamelCase__					:       Dict       =       kwargs.pop('feature_extractor')

			UpperCamelCase__					:       Any       =       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__					:       Tuple       =       self.image_processor

	def __call__(   self :    int	,       UpperCAmelCase_ :    Dict=None	,       UpperCAmelCase_ :    Union[str, Any]=None	,       UpperCAmelCase_ :    str=None	,       **UpperCAmelCase_ :    Dict):

			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__					:       Union[str, Any]       =       self.tokenizer(lowerCamelCase__	,       return_tensors=lowerCamelCase__	,       **lowerCamelCase__)

			if images is not None:
					UpperCamelCase__					:       int       =       self.image_processor(lowerCamelCase__	,       return_tensors=lowerCamelCase__	,       **lowerCamelCase__)

			if text is not None and images is not None:
					UpperCamelCase__					:       Dict       =       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 :    Optional[int]	,       *UpperCAmelCase_ :    Dict	,       **UpperCAmelCase_ :    Tuple):
			return self.tokenizer.batch_decode(*lowerCamelCase__	,       **lowerCamelCase__)

	def   __UpperCamelCase				(   self :    Union[str, Any]	,       *UpperCAmelCase_ :    Any	,       **UpperCAmelCase_ :    Optional[int]):
			return self.tokenizer.decode(*lowerCamelCase__	,       **lowerCamelCase__)

	@property
	def   __UpperCamelCase				(   self :    int):
			UpperCamelCase__					:       List[str]       =       self.tokenizer.model_input_names
			UpperCamelCase__					:       Optional[int]       =       self.image_processor.model_input_names
			return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))





	@property
	def   __UpperCamelCase				(   self :    Dict):
			warnings.warn(
			    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'	,       lowerCamelCase__	,       )
			return self.image_processor_class










def      lowerCamelCase_						(			)	->			List[str]:





				"""simple docstring"""


				__lowerCamelCase									=       0
				for i in range(1					,	1001 ):
								total += i**i
				return str(UpperCamelCase__ )[-10:]


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


