






'''simple docstring'''





import copy

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


_UpperCamelCase		:		Tuple								=			logging.get_logger(__name__)


class 				snake_case__     (			UpperCamelCase):
					a_       =			"hybrid-clip"
					a_       =			True




					def __init__(       self       :						Any							,				_A       :						int=5_12							,				**_A       :						Optional[Any]     )  ->    Dict:
								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_     :   Union[str, Any]       =   kwargs.pop('''text_config'''     )
								UpperCAmelCase_     :   Optional[int]       =   kwargs.pop('''vision_config'''     )

								UpperCAmelCase_     :   Any       =   text_config.pop('''model_type'''     )
								UpperCAmelCase_     :   Any       =   vision_config.pop('''model_type'''     )

								from transformers import AutoConfig

								UpperCAmelCase_     :   Union[str, Any]       =   AutoConfig.for_model(_A							,				**_A     )

								if vision_model_type == "clip":
											UpperCAmelCase_     :   Any       =   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_     :   Optional[Any]       =   AutoConfig.for_model(_A							,				**_A     )

								UpperCAmelCase_     :   List[str]       =   projection_dim
								UpperCAmelCase_     :   str       =   1.0




					@classmethod
					def 						A     (       cls       :						Dict							,				_A       :						PretrainedConfig							,				_A       :						PretrainedConfig							,				**_A       :						Any     )  ->    Dict:
								return cls(text_config=text_config.to_dict()							,				vision_config=vision_config.to_dict()							,				**_A     )





					def 						A     (       self       :						int     )  ->    int:
								UpperCAmelCase_     :   Dict       =   copy.deepcopy(self.__dict__     )
								UpperCAmelCase_     :   str       =   self.text_config.to_dict()
								UpperCAmelCase_     :   Any       =   self.vision_config.to_dict()
								UpperCAmelCase_     :   int       =   self.__class__.model_type
								return output










'''simple docstring'''





def __UpperCAmelCase (			)  -> Optional[Any]:
			UpperCAmelCase_     :   Union[str, Any]       =   1

			while True:
						if (
						    sorted(str(A						)						)
						    == sorted(str(2 * i						)						)
						    == sorted(str(3 * i						)						)
						    == sorted(str(4 * i						)						)
						    == sorted(str(5 * i						)						)
						    == sorted(str(6 * i						)						)
						):
									return i

						i += 1


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


