





'''simple docstring'''




from functools import lru_cache






def 	_lowerCAmelCase      (  __snake_case  :			int      )					->					set:
     __A						:			Union[str, Any]								=	2
     __A						:			Union[str, Any]								=	set()
     while i * i <= n:
          if n % i:
               i += 1
          else:
               n //= i
               factors.add(__snake_case      )
     if n > 1:
          factors.add(__snake_case      )
     return factors






@lru_cache
def 	_lowerCAmelCase      (  __snake_case  :			int      )					->					int:
     return len(unique_prime_factors(__snake_case      )      )






def 	_lowerCAmelCase      (  __snake_case  :			list      )					->					bool:
     return len(set(__snake_case      )      ) in (0, 1)






def 	_lowerCAmelCase      (  __snake_case  :			int      )					->					list:
     __A						:			Union[str, Any]								=	2

     while True:
          # Increment each value of a generated range
          __A						:			Union[str, Any]								=	[base + i for i in range(__snake_case      )]

          # Run elements through out unique_prime_factors function
          # Append our target number to the end.
          __A						:			str								=	[upf_len(__snake_case      ) for x in group]
          checker.append(__snake_case      )

          # If all numbers in the list are equal, return the group variable.
          if equality(__snake_case      ):
               return group

          # Increment our base variable by 1
          base += 1






def 	_lowerCAmelCase      (  __snake_case  :			int = 4      )					->					int:
     __A						:			Optional[int]								=	run(__snake_case      )
     return results[0] if len(__snake_case      ) else None


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






'''simple docstring'''




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


class 			SCREAMING_SNAKE_CASE   (a__							):
     lowerCAmelCase		      =	['''image_processor''', '''tokenizer''']
     lowerCAmelCase		      =	'''AutoImageProcessor'''
     lowerCAmelCase		      =	'''AutoTokenizer'''


     def __init__(						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          super().__init__(_UpperCAmelCase						,     _UpperCAmelCase)
          __A						:			Tuple								=	self.image_processor


     def __call__(						self						,     _UpperCAmelCase=None						,     _UpperCAmelCase=None						,     _UpperCAmelCase=None						,     **_UpperCAmelCase):

          '''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:
               __A						:			Any								=	self.tokenizer(_UpperCAmelCase						,     return_tensors=_UpperCAmelCase						,     **_UpperCAmelCase)

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

          if text is not None and images is not None:
               __A						:			Optional[int]								=	image_features.pixel_values
               return encoding
          elif text is not None:
               return encoding
          else:
               return BatchEncoding(data=dict(**_UpperCAmelCase)						,     tensor_type=_UpperCAmelCase)


     def 							SCREAMING_SNAKE_CASE  (						self						,     *_UpperCAmelCase						,     **_UpperCAmelCase):

          '''simple docstring'''






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


     def 							SCREAMING_SNAKE_CASE  (						self						,     *_UpperCAmelCase						,     **_UpperCAmelCase):

          '''simple docstring'''






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


     @property
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          return ["input_ids", "attention_mask", "pixel_values"]