import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..bit import BitConfig


SCREAMING_SNAKE_CASE__		:       Optional[int]       						=       logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__		:       List[str]       						=       {
    "Intel/dpt-large": "https://huggingface.co/Intel/dpt-large/resolve/main/config.json",
    # See all DPT models at https://huggingface.co/models?filter=dpt
}

class    snake_case       (   UpperCamelCase_    ):
  lowercase_								=  'dpt'




  def __init__(   self  :						str  ,			a_  :						Any=768  ,			a_  :						Dict=12  ,			a_  :						Tuple=12  ,			a_  :						Tuple=3072  ,			a_  :						Optional[Any]="gelu"  ,			a_  :						List[str]=0.0  ,			a_  :						Dict=0.0  ,			a_  :						List[Any]=0.02  ,			a_  :						List[Any]=1e-1_2  ,			a_  :						Union[str, Any]=384  ,			a_  :						Optional[Any]=16  ,			a_  :						int=3  ,			a_  :						Optional[int]=False  ,			a_  :						str=True  ,			a_  :						List[str]=[2, 5, 8, 11]  ,			a_  :						Any="project"  ,			a_  :						List[Any]=[4, 2, 1, 0.5]  ,			a_  :						int=[96, 192, 384, 768]  ,			a_  :						List[str]=256  ,			a_  :						Tuple=-1  ,			a_  :						int=False  ,			a_  :						Union[str, Any]=True  ,			a_  :						List[Any]=0.4  ,			a_  :						str=255  ,			a_  :						Optional[Any]=0.1  ,			a_  :						Tuple=[1, 1024, 24, 24]  ,			a_  :						Any=[0, 1]  ,			a_  :						Union[str, Any]=None  ,			**a_  :						List[str]  ,			)->							Dict:




       """simple docstring"""
       super().__init__(**a_					)

       SCREAMING_SNAKE_CASE__					:					Any      =		hidden_size
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		is_hybrid

       if self.is_hybrid:
            if backbone_config is None:
                 logger.info('Initializing the config with a `BiT` backbone.'					)
                 SCREAMING_SNAKE_CASE__					:					Any      =		{
                     'global_padding': 'same',
                     'layer_type': 'bottleneck',
                     'depths': [3, 4, 9],
                     'out_features': ['stage1', 'stage2', 'stage3'],
                     'embedding_dynamic_padding': True,
                 }
                 SCREAMING_SNAKE_CASE__					:					Any      =		BitConfig(**a_					)
            elif isinstance(a_  ,			a_					):
                 logger.info('Initializing the config with a `BiT` backbone.'					)
                 SCREAMING_SNAKE_CASE__					:					int      =		BitConfig(**a_					)
            elif isinstance(a_  ,			a_					):
                 SCREAMING_SNAKE_CASE__					:					Dict      =		backbone_config
            else:
                 raise ValueError(
                     F'''backbone_config must be a dictionary or a `PretrainedConfig`, got {backbone_config.__class__}.'''					)

            SCREAMING_SNAKE_CASE__					:					str      =		backbone_featmap_shape
            SCREAMING_SNAKE_CASE__					:					List[str]      =		neck_ignore_stages

            if readout_type != "project":
                 raise ValueError('Readout type must be \'project\' when using `DPT-hybrid` mode.'					)
       else:
            SCREAMING_SNAKE_CASE__					:					List[Any]      =		None
            SCREAMING_SNAKE_CASE__					:					str      =		None
            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		[]

       SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		num_hidden_layers
       SCREAMING_SNAKE_CASE__					:					Any      =		num_attention_heads
       SCREAMING_SNAKE_CASE__					:					Any      =		intermediate_size
       SCREAMING_SNAKE_CASE__					:					Dict      =		hidden_act
       SCREAMING_SNAKE_CASE__					:					List[str]      =		hidden_dropout_prob
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__					:					Dict      =		initializer_range
       SCREAMING_SNAKE_CASE__					:					int      =		layer_norm_eps
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		image_size
       SCREAMING_SNAKE_CASE__					:					Dict      =		patch_size
       SCREAMING_SNAKE_CASE__					:					Any      =		num_channels
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		qkv_bias
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		backbone_out_indices
       if readout_type not in ["ignore", "add", "project"]:
            raise ValueError('Readout_type must be one of [\'ignore\', \'add\', \'project\']'					)
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		readout_type
       SCREAMING_SNAKE_CASE__					:					Tuple      =		reassemble_factors
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		neck_hidden_sizes
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		fusion_hidden_size
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		head_in_index
       SCREAMING_SNAKE_CASE__					:					str      =		use_batch_norm_in_fusion_residual
       # auxiliary head attributes (semantic segmentation)
       SCREAMING_SNAKE_CASE__					:					Any      =		use_auxiliary_head
       SCREAMING_SNAKE_CASE__					:					Dict      =		auxiliary_loss_weight
       SCREAMING_SNAKE_CASE__					:					Any      =		semantic_loss_ignore_index
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		semantic_classifier_dropout




  def 						__lowercase(   self  :						Optional[Any]					)->							Dict:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					int      =		copy.deepcopy(self.__dict__					)

       if output["backbone_config"] is not None:
            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		self.backbone_config.to_dict()

       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		self.__class__.model_type
       return output





def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int)   ->       int:






							'''simple docstring'''





							__UpperCamelCase      :  Tuple       =   1
							for i in range(1		,    num + 1):
														fact *= i
							return fact




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int)   ->       int:






							'''simple docstring'''





							__UpperCamelCase      :  Dict       =   0
							while number > 0:
														__UpperCamelCase      :  List[Any]       =   number % 10
														sum_of_digits += last_digit
														__UpperCamelCase      :  List[Any]       =   number // 10  # Removing the last_digit from the given number
							return sum_of_digits




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int = 100)   ->       int:






							'''simple docstring'''





							__UpperCamelCase      :  Optional[Any]       =   factorial(_lowerCamelCase)
							__UpperCamelCase      :  Tuple       =   split_and_add(_lowerCamelCase)
							return result


if __name__ == "__main__":
		print(solution(int(input('Enter the Number: ').strip())))