import math



def 	__A		(      _A       ):



 """simple docstring"""


 if not isinstance(_A				,					_A       ):
  __a							=	f"""Input value of [number={number}] must be an integer"""
  raise TypeError(_A       )

 if number < 1:
  __a							=	f"""Input value of [number={number}] must be > 0"""
  raise ValueError(_A       )
 elif number == 1:
  return 3
 elif number == 2:
  return 5
 else:
  __a							=	int(math.log(number // 3				,					2       )       ) + 2

  __a							=	[3, 5]
  __a							=	2
  __a							=	3
  for block in range(1				,					_A       ):
   for _ in range(_A       ):
    proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1]       )
    proth_index += 1
   increment *= 2

 return proth_list[number - 1]


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  for number in range(11):
    SCREAMING_SNAKE_CASE			:						Tuple				  =		0
    try:
      SCREAMING_SNAKE_CASE			:						Optional[int]				  =		proth(number)
    except ValueError:
      print(f'''ValueError: there is no {number}th Proth number''')
      continue

    print(f'''The {number}th Proth number: {value}''')



import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      ["""image_processor""", """tokenizer"""]
  _SCREAMING_SNAKE_CASE     					=      """ChineseCLIPImageProcessor"""
  _SCREAMING_SNAKE_CASE     					=      ("""BertTokenizer""", """BertTokenizerFast""")

  def __init__(		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   Any=None  ,				__SCREAMING_SNAKE_CASE			:   Tuple=None  ,				**__SCREAMING_SNAKE_CASE			:   List[Any]							):
   __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."  ,				__SCREAMING_SNAKE_CASE  ,				)
    __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__(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)
   __a							=	self.image_processor

  def __call__(		self			:   Optional[int]  ,				__SCREAMING_SNAKE_CASE			:   Dict=None  ,				__SCREAMING_SNAKE_CASE			:   Dict=None  ,				__SCREAMING_SNAKE_CASE			:   Tuple=None  ,				**__SCREAMING_SNAKE_CASE			:   List[Any]							):

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

   if images is not None:
    __a							=	self.image_processor(__SCREAMING_SNAKE_CASE  ,				return_tensors=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

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

  def 		_UpperCAmelCase (		self			:   int  ,				*__SCREAMING_SNAKE_CASE			:   Optional[Any]  ,				**__SCREAMING_SNAKE_CASE			:   str							):
   return self.tokenizer.batch_decode(*__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   List[Any]  ,				*__SCREAMING_SNAKE_CASE			:   Optional[int]  ,				**__SCREAMING_SNAKE_CASE			:   Optional[int]							):
   return self.tokenizer.decode(*__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  @property
  def 		_UpperCAmelCase (		self			:   Union[str, Any]							):
   __a							=	self.tokenizer.model_input_names
   __a							=	self.image_processor.model_input_names
   return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names							)							)

  @property
  def 		_UpperCAmelCase (		self			:   Any							):
   warnings.warn(
       "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."  ,				__SCREAMING_SNAKE_CASE  ,				)
   return self.image_processor_class


