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





class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       UpperCAmelCase_				       =["image_processor", "tokenizer"]
       UpperCAmelCase_				       ="EfficientNetImageProcessor"
       UpperCAmelCase_				       =("BertTokenizer", "BertTokenizerFast")



       def __init__(							self ,     _A ,     _A	)				->				Optional[Any]:
          super().__init__(_A ,     _A	)



       def __call__(							self ,     _A=None ,     _A=None ,     _A="max_length" ,     _A=64 ,     _A=None ,     **_A	)				->				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:
             SCREAMING_SNAKE_CASE_	=      self.tokenizer(
                 _A ,     padding=_A ,     max_length=_A ,     return_tensors=_A ,     **_A	)

          if images is not None:
             SCREAMING_SNAKE_CASE_	=      self.image_processor(_A ,     return_tensors=_A ,     **_A	)

          if text is not None and images is not None:
             SCREAMING_SNAKE_CASE_	=      image_features.pixel_values
             return encoding
          elif text is not None:
             return encoding
          else:
             return BatchEncoding(data=dict(**_A	) ,     tensor_type=_A	)



       def     _UpperCamelCase	(							self ,     *_A ,     **_A	)				->				Optional[int]:
          return self.tokenizer.batch_decode(*_A ,     **_A	)



       def     _UpperCamelCase	(							self ,     *_A ,     **_A	)				->				Optional[Any]:
          return self.tokenizer.decode(*_A ,     **_A	)




       @property
       def     _UpperCamelCase	(							self	)				->				Optional[int]:
          SCREAMING_SNAKE_CASE_	=      self.tokenizer.model_input_names
          SCREAMING_SNAKE_CASE_	=      self.image_processor.model_input_names
          return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names	)	)




from math import sqrt


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      [1]
   for i in range(2,  int(sqrt(__lowerCamelCase						)						) + 1,  1						):
      if number % i == 0:
         values.append(__lowerCamelCase						)
         if int(number // i						) != i:
            values.append(int(number // i						)						)
   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase						):
   return sum(factors(__lowerCamelCase						)						) > n


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      factors(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      [[0 for i in range(number + 1						)] for j in range(r + 1						)]
   for i in range(r + 1						):
      SCREAMING_SNAKE_CASE_	=      True

   for i in range(1,  number + 1						):
      SCREAMING_SNAKE_CASE_	=      False

   for i in range(1,  r + 1						):
      for j in range(1,  number + 1						):
         if j < values[i - 1]:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j]
         else:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

   return subset[r][number] != 0


def  A__ (       __lowerCamelCase						):
   return abundant(__lowerCamelCase						) and not semi_perfect(__lowerCamelCase						)


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   for number in (69, 70, 71):
      print(F"""{number} is {'' if weird(number) else 'not '}weird.""")


