

import copy

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


lowerCAmelCase       :				Tuple         =					logging.get_logger(__name__)
class 	_A						(					lowercase_):
  SCREAMING_SNAKE_CASE      : Tuple    =					'''hybrid-clip'''
  SCREAMING_SNAKE_CASE      : List[Any]    =					True

  def __init__(			self	,   _SCREAMING_SNAKE_CASE=512	,   **_SCREAMING_SNAKE_CASE   ):





        """simple docstring"""







        super().__init__(**UpperCamelCase_   )

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

        SCREAMING_SNAKE_CASE_			:					int          =       kwargs.pop('text_config'   )
        SCREAMING_SNAKE_CASE_			:					int          =       kwargs.pop('vision_config'   )

        SCREAMING_SNAKE_CASE_			:					Dict          =       text_config.pop('model_type'   )
        SCREAMING_SNAKE_CASE_			:					int          =       vision_config.pop('model_type'   )

        from transformers import AutoConfig

        SCREAMING_SNAKE_CASE_			:					Tuple          =       AutoConfig.for_model(UpperCamelCase_	,   **UpperCamelCase_   )

        if vision_model_type == "clip":
              SCREAMING_SNAKE_CASE_			:					List[Any]          =       AutoConfig.for_model(UpperCamelCase_	,   **UpperCamelCase_   ).vision_config
        elif vision_model_type == "clip_vision_model":
              from transformers import CLIPVisionConfig

              SCREAMING_SNAKE_CASE_			:					int          =       CLIPVisionConfig(**UpperCamelCase_   )
        else:
              SCREAMING_SNAKE_CASE_			:					Optional[Any]          =       AutoConfig.for_model(UpperCamelCase_	,   **UpperCamelCase_   )

        SCREAMING_SNAKE_CASE_			:					str          =       projection_dim
        SCREAMING_SNAKE_CASE_			:					Tuple          =       1.0

  @classmethod
  def 	UpperCAmelCase      (			cls	,   _SCREAMING_SNAKE_CASE	,   _SCREAMING_SNAKE_CASE	,   **_SCREAMING_SNAKE_CASE   ):





        """simple docstring"""







        return cls(text_config=text_config.to_dict()	,   vision_config=vision_config.to_dict()	,   **UpperCamelCase_   )



  def 	UpperCAmelCase      (			self   ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_			:					int          =       copy.deepcopy(self.__dict__   )
        SCREAMING_SNAKE_CASE_			:					Tuple          =       self.text_config.to_dict()
        SCREAMING_SNAKE_CASE_			:					Tuple          =       self.vision_config.to_dict()
        SCREAMING_SNAKE_CASE_			:					int          =       self.__class__.model_type
        return output





from math import factorial

def 				A_					(							a   ,				a					):

      """simple docstring"""



      return factorial(a					) / (factorial(a					) * factorial(n - r					))

def 				A_					(							):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_			:					Union[str, Any]          =       0

      for i in range(1   ,				1_0_1					):
            for j in range(1   ,				i + 1					):
                  if combinations(a   ,				a					) > 1e6:
                        total += 1
      return total


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






