

import warnings

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

class     a__  (    snake_case	):
			"""simple docstring"""







			__lowerCamelCase       				=				['image_processor', 'tokenizer']
			__lowerCamelCase       				=				'ViTImageProcessor'
			__lowerCamelCase       				=				('CLIPTokenizer', 'CLIPTokenizerFast')


			def __init__(			self					,					lowercase=None					,					lowercase=None					,					**lowercase				)     ->  List[Any]:
							'''simple docstring'''






							A__						=	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					,					)
											A__						=	kwargs.pop("feature_extractor"				)

							A__						=	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					,					lowercase=None					,					lowercase=None					,					lowercase=None					,					lowercase=None					,					**lowercase				)     ->  Any:
							'''simple docstring'''






							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:
											A__						=	self.tokenizer(lowercase					,					return_tensors=lowercase					,					**lowercase				)

							if visual_prompt is not None:
											A__						=	self.image_processor(lowercase					,					return_tensors=lowercase					,					**lowercase				)

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

							if visual_prompt is not None and images is not None:
											A__						=	{
											    "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:
											A__						=	image_features.pixel_values
											return encoding
							elif text is not None:
											return encoding
							elif visual_prompt is not None:
											A__						=	{
											    "conditional_pixel_values": prompt_features.pixel_values,
											}
											return encoding
							else:
											return BatchEncoding(data=dict(**lowercase				)					,					tensor_type=lowercase				)


			def    UpperCamelCase						(			self					,					*lowercase					,					**lowercase				)     ->  List[str]:
							'''simple docstring'''






							return self.tokenizer.batch_decode(*lowercase					,					**lowercase				)


			def    UpperCamelCase						(			self					,					*lowercase					,					**lowercase				)     ->  Union[str, Any]:
							'''simple docstring'''






							return self.tokenizer.decode(*lowercase					,					**lowercase				)


			@property
			def    UpperCamelCase						(			self				)     ->  int:
							'''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    UpperCamelCase						(			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 				UpperCamelCase_			(    A__					:   int					):
  '''simple docstring'''





  lowerCAmelCase_			:      Union[str, Any]			=   (1 + 24 * n) ** 0.5
  return ((1 + root) / 6) % 1 == 0







def 				UpperCamelCase_			(    A__					:   int = 50_00					):
  '''simple docstring'''





  lowerCAmelCase_			:      Optional[int]			=   [(i * (3 * i - 1)) // 2 for i in range(1							,    A__					)]
  for i, pentagonal_i in enumerate(A__					):
    for j in range(A__							,    len(A__					)					):
      lowerCAmelCase_			:      int			=   pentagonal_nums[j]
      lowerCAmelCase_			:      Union[str, Any]			=   pentagonal_i + pentagonal_j
      lowerCAmelCase_			:      List[Any]			=   pentagonal_j - pentagonal_i
      if is_pentagonal(A__					) and is_pentagonal(A__					):
        return b

  return -1


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



