




import copy

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import logging


UpperCamelCase__       				=	logging.get_logger(__name__)
class 							__lowercase   (			_A    ):
     _lowerCAmelCase		       =						"hybrid-clip"
     _lowerCAmelCase		       =						True



     def __init__(  self   :							str      ,		lowercase__   :							str=5_1_2      ,		**lowercase__   :							str       ):
       super().__init__(**__SCREAMING_SNAKE_CASE       )

       if "text_config" not in kwargs:
         raise ValueError('''`text_config` can not be `None`.'''       )

       if "vision_config" not in kwargs:
         raise ValueError('''`vision_config` can not be `None`.'''       )

       a_		    =  kwargs.pop('''text_config'''       )
       a_		    =  kwargs.pop('''vision_config'''       )

       a_		    =  text_config.pop('''model_type'''       )
       a_		    =  vision_config.pop('''model_type'''       )

       from transformers import AutoConfig

       a_		    =  AutoConfig.for_model(__SCREAMING_SNAKE_CASE      ,		**__SCREAMING_SNAKE_CASE       )

       if vision_model_type == "clip":
         a_		    =  AutoConfig.for_model(__SCREAMING_SNAKE_CASE      ,		**__SCREAMING_SNAKE_CASE       ).vision_config
       elif vision_model_type == "clip_vision_model":
         from transformers import CLIPVisionConfig

         a_		    =  CLIPVisionConfig(**__SCREAMING_SNAKE_CASE       )
       else:
         a_		    =  AutoConfig.for_model(__SCREAMING_SNAKE_CASE      ,		**__SCREAMING_SNAKE_CASE       )

       a_		    =  projection_dim
       a_		    =  1.0



     @classmethod
     def 				__magic_name__		(  cls   :							List[Any]      ,		lowercase__   :							PretrainedConfig      ,		lowercase__   :							PretrainedConfig      ,		**lowercase__   :							Union[str, Any]       ):
       return cls(text_config=text_config.to_dict()      ,		vision_config=vision_config.to_dict()      ,		**__SCREAMING_SNAKE_CASE       )



     def 				__magic_name__		(  self   :							Optional[Any]       ):
       a_		    =  copy.deepcopy(self.__dict__       )
       a_		    =  self.text_config.to_dict()
       a_		    =  self.vision_config.to_dict()
       a_		    =  self.__class__.model_type
       return output



"""simple docstring"""




import sys

sys.set_int_max_str_digits(0)  # type: ignore
def   __SCREAMING_SNAKE_CASE		(		lowercase__ ):
					"""simple docstring"""
					A     =   [0] * 11
					A     =   [0] * 11

					# mark last 9 numbers
					for _ in range(9 ):
										A     =   1
										A     =   number // 10
					# flag
					A     =   True

					# check last 9 numbers for pandigitality

					for x in range(9 ):
										if not check_last[x + 1]:
															A     =   False
					if not f:
										return f

					# mark first 9 numbers
					A     =   int(str(lowercase__ )[:9] )

					for _ in range(9 ):
										A     =   1
										A     =   number // 10

					# check first 9 numbers for pandigitality

					for x in range(9 ):
										if not check_front[x + 1]:
															A     =   False
					return f
def   __SCREAMING_SNAKE_CASE		(		lowercase__ ):
					"""simple docstring"""
					A     =   [0] * 11

					# mark last 9 numbers
					for _ in range(9 ):
										A     =   1
										A     =   number // 10
					# flag
					A     =   True

					# check last 9 numbers for pandigitality

					for x in range(9 ):
										if not check_last[x + 1]:
															A     =   False
					return f
def   __SCREAMING_SNAKE_CASE		(		):
					"""simple docstring"""
					A     =   1
					A     =   1
					A     =   2
					# temporary Fibonacci numbers

					A     =   1
					A     =   1
					A     =   2
					# temporary Fibonacci numbers mod 1e9

					# mod m=1e9, done for fast optimisation
					A     =   [0] * 1_000_000
					A     =   1_000_000_000

					for x in range(1_000_000 ):
										A     =   (aa + ba) % m
										A     =   ba % m
										A     =   ca % m
										if checka(lowercase__ ):
															A     =   1

					for x in range(1_000_000 ):
										A     =   a + b
										A     =   b
										A     =   c
										# perform check only if in tocheck
										if tocheck[x + 3] and check(lowercase__ ):
															return x + 3  # first 2 already done
					return -1


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





