import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


UpperCAmelCase      		=					logging.get_logger(__name__)




class  __lowerCAmelCase	(							a_    ):



 '''simple docstring'''
 _lowerCamelCase    :						Optional[int]					     =			'speech-encoder-decoder'
 _lowerCamelCase    :						str					     =			True

 def __init__(      self							:		int							,      **lowerCamelCase							:		Optional[Any]	)			->				Optional[int]:
        super().__init__(**lowerCamelCase	)
        if "encoder" not in kwargs or "decoder" not in kwargs:
               raise ValueError(
                   f"A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and"
                   f" `decoder` sub-configurations are passed, but only {kwargs}"	)

        _UpperCamelCase  :							Any	    =	kwargs.pop('encoder'	)
        _UpperCamelCase  :							List[Any]	    =	encoder_config.pop('model_type'	)
        _UpperCamelCase  :							Union[str, Any]	    =	kwargs.pop('decoder'	)
        _UpperCamelCase  :							Optional[Any]	    =	decoder_config.pop('model_type'	)

        _UpperCamelCase  :							Dict	    =	AutoConfig.for_model(lowerCamelCase							,      **lowerCamelCase	)
        _UpperCamelCase  :							Dict	    =	AutoConfig.for_model(lowerCamelCase							,      **lowerCamelCase	)
        _UpperCamelCase  :							List[Any]	    =	True

 @classmethod
 def        __snake_case       (      cls							:		Union[str, Any]							,      lowerCamelCase							:		PretrainedConfig							,      lowerCamelCase							:		PretrainedConfig							,      **lowerCamelCase							:		Any	)			->				PretrainedConfig:
        logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'	)
        _UpperCamelCase  :							str	    =	True
        _UpperCamelCase  :							Optional[int]	    =	True

        return cls(encoder=encoder_config.to_dict()							,      decoder=decoder_config.to_dict()							,      **lowerCamelCase	)

 def        __snake_case       (      self							:		List[Any]	)			->				Optional[Any]:
        _UpperCamelCase  :							Optional[Any]	    =	copy.deepcopy(self.__dict__	)
        _UpperCamelCase  :							List[Any]	    =	self.encoder.to_dict()
        _UpperCamelCase  :							Optional[Any]	    =	self.decoder.to_dict()
        _UpperCamelCase  :							List[Any]	    =	self.__class__.model_type
        return output







"""simple docstring"""


from math import factorial






def   a__			(					__lowercase  ,      __lowercase )						->						List[Any]:
				return factorial(__lowercase ) / (factorial(__lowercase ) * factorial(n - r ))






def   a__			(					)						->						List[str]:
				_A       	=      0

				for i in range(1  ,      101 ):
								for j in range(1  ,      i + 1 ):
												if combinations(__lowercase  ,      __lowercase ) > 1E6:
																total += 1
				return total


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