


import copy

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


_snake_case				=			logging.get_logger(__name__)




class  A_ (			a_  ):







 """simple docstring"""





 _UpperCamelCase					:			str     	=       '''hybrid-clip'''
 _UpperCamelCase					:			Dict     	=       True
 def __init__(      self       :			Any							,     _a       :			Union[str, Any]=5_1_2							,     **_a       :			str					)     ->      List[str]:
      super().__init__(**_a					)

      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`."					)

      UpperCAmelCase    :					Dict			=      kwargs.pop("text_config"					)
      UpperCAmelCase    :					List[str]			=      kwargs.pop("vision_config"					)

      UpperCAmelCase    :					Any			=      text_config.pop("model_type"					)
      UpperCAmelCase    :					Optional[Any]			=      vision_config.pop("model_type"					)

      from transformers import AutoConfig

      UpperCAmelCase    :					Dict			=      AutoConfig.for_model(_a							,     **_a					)

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

           UpperCAmelCase    :					List[Any]			=      CLIPVisionConfig(**_a					)
      else:
           UpperCAmelCase    :					Tuple			=      AutoConfig.for_model(_a							,     **_a					)

      UpperCAmelCase    :					int			=      projection_dim
      UpperCAmelCase    :					str			=      1.0
 @classmethod
 def 	_UpperCamelCase     (      cls       :			List[str]							,     _a       :			PretrainedConfig							,     _a       :			PretrainedConfig							,     **_a       :			Union[str, Any]					)     ->      str:
      return cls(text_config=text_config.to_dict()							,     vision_config=vision_config.to_dict()							,     **_a					)

 def 	_UpperCamelCase     (      self       :			Optional[Any]					)     ->      Tuple:
      UpperCAmelCase    :					int			=      copy.deepcopy(self.__dict__					)
      UpperCAmelCase    :					Dict			=      self.text_config.to_dict()
      UpperCAmelCase    :					str			=      self.vision_config.to_dict()
      UpperCAmelCase    :					List[str]			=      self.__class__.model_type
      return output







def 	A (		A__			):
     UpperCAmelCase    :					Dict			=      9

     while num > 0:
          if num % 1_0 != digit:
               return False
          num //= 1_0_0
          digit -= 1

     return True







def 	A (		):
     UpperCAmelCase    :					Optional[Any]			=      1_3_8_9_0_2_6_6_3

     while not is_square_form(num * num			):
          if num % 1_0 == 3:
               num -= 6  # (3 - 6) % 10 = 7
          else:
               num -= 4  # (7 - 4) % 10 = 3

     return num * 1_0


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



