






import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
   import torch

   from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
   import pyanvml.pyanvml as nvml


A_		:		Union[str, Any]			= logging.get_logger(__name__)




class 				_lowerCAmelCase(       UpperCAmelCase_					):





       """simple docstring"""







       a				:		str									=42
       a				:		Tuple									=42
       a				:		Any									='''PyTorch'''





       @property
       def 			_a    (					self							):
         return torch.__version__





       def 			_a    (					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase							):
         UpperCamelCase_:					int          =				self._prepare_inference_func(__A  ,			__A  ,			__A							)
         return self._measure_speed(_inference							)





       def 			_a    (					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase							):
         UpperCamelCase_:					Dict          =				self._prepare_inference_func(__A  ,			__A  ,			__A							)
         return self._measure_memory(_inference							)





       def 			_a    (					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase							):
         UpperCamelCase_:					List[Any]          =				self._prepare_train_func(__A  ,			__A  ,			__A							)
         return self._measure_speed(_train							)





       def 			_a    (					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase							):
         UpperCamelCase_:					Tuple          =				self._prepare_train_func(__A  ,			__A  ,			__A							)
         return self._measure_memory(_train							)





       def 			_a    (					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase							):
         UpperCamelCase_:					Tuple          =				self.config_dict[model_name]

         if self.args.torchscript:
           UpperCamelCase_:					Union[str, Any]          =				True

         UpperCamelCase_:					Optional[int]          =				(
             hasattr(__A  ,			'architectures'							)
             and isinstance(config.architectures  ,			__A							)
             and len(config.architectures							) > 0
         )
         if not self.args.only_pretrain_model and has_model_class_in_config:
           try:
             UpperCamelCase_:					List[Any]          =				config.architectures[0]
             UpperCamelCase_:					int          =				__import__('transformers'  ,			fromlist=[model_class]							)
             UpperCamelCase_:					Any          =				getattr(__A  ,			__A							)
             UpperCamelCase_:					Any          =				model_cls(__A							)
           except ImportError:
             raise ImportError(
                 f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
                 ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.'							)
         else:
           UpperCamelCase_:					str          =				MODEL_MAPPING[config.__class__](__A							)

         model.eval()
         model.to(self.args.device							)

         # encoder-decoder has vocab size saved differently
         UpperCamelCase_:					Optional[int]          =				config.vocab_size if hasattr(__A  ,			'vocab_size'							) else config.encoder.vocab_size
         UpperCamelCase_:					Union[str, Any]          =				torch.randint(__A  ,			(batch_size, sequence_length)  ,			dtype=torch.long  ,			device=self.args.device							)

         if self.args.fpaa:
           logger.info('Running training in Mixed Precision...'							)
           if not self.args.is_gpu:
             raise ValueError('Mixed precision is possible only for GPU.'							)
           # amp seems to have memory leaks so that memory usage
           # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
           model.half()

         if self.args.torchscript:
           with torch.no_grad():
             UpperCamelCase_:					List[Any]          =				torch.jit.trace(__A  ,			__A							)
         else:
           UpperCamelCase_:					Any          =				model

         def encoder_decoder_forward():
           with torch.no_grad():
             UpperCamelCase_:					Tuple          =				inference_model(__A  ,			decoder_input_ids=__A							)
           return outputs

         def encoder_forward():
           with torch.no_grad():
             UpperCamelCase_:					str          =				inference_model(__A							)
           return outputs

         UpperCamelCase_:					int          =				encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
         return _forward





       def 			_a    (					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase							):
         UpperCamelCase_:					Union[str, Any]          =				self.config_dict[model_name]

         UpperCamelCase_:					Optional[Any]          =				(
             hasattr(__A  ,			'architectures'							)
             and isinstance(config.architectures  ,			__A							)
             and len(config.architectures							) > 0
         )
         if not self.args.only_pretrain_model and has_model_class_in_config:
           try:
             UpperCamelCase_:					Tuple          =				config.architectures[0]
             UpperCamelCase_:					Any          =				__import__('transformers'  ,			fromlist=[model_class]							)
             UpperCamelCase_:					Dict          =				getattr(__A  ,			__A							)
             UpperCamelCase_:					str          =				model_cls(__A							)
           except ImportError:
             raise ImportError(
                 f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
                 ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.'							)
         else:
           UpperCamelCase_:					str          =				MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__A							)

         if self.args.torchscript:
           raise NotImplementedError('Training for torchscript is currently not implemented'							)
         else:
           UpperCamelCase_:					Tuple          =				model

         model.train()
         model.to(self.args.device							)

         # encoder-decoder has vocab size saved differently
         UpperCamelCase_:					Optional[Any]          =				config.vocab_size if hasattr(__A  ,			'vocab_size'							) else config.encoder.vocab_size
         UpperCamelCase_:					Optional[int]          =				torch.randint(__A  ,			(batch_size, sequence_length)  ,			dtype=torch.long  ,			device=self.args.device							)

         if self.args.fpaa:
           logger.info('Running training in Mixed Precision...'							)
           if not self.args.is_gpu:
             raise ValueError('Mixed precision is possible only for GPU.'							)

           # amp seems to have memory leaks so that memory usage
           # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
           model.half()

         def compute_loss_and_backprob_encoder():
           UpperCamelCase_:					Any          =				train_model(__A  ,			labels=__A							)[0]
           loss.backward()
           return loss

         def compute_loss_and_backprob_encoder_decoder():
           UpperCamelCase_:					int          =				train_model(__A  ,			decoder_input_ids=__A  ,			labels=__A							)[0]
           loss.backward()
           return loss

         UpperCamelCase_:					str          =				(
             compute_loss_and_backprob_encoder_decoder
             if config.is_encoder_decoder
             else compute_loss_and_backprob_encoder
         )
         return _train





       def 			_a    (					self  ,			_lowerCamelCase							):
         try:
           if self.args.is_tpu or self.args.torchscript:
             # run additional 10 times to stabilize compilation for tpu and torchscript
             logger.info('Do inference on TPU or torchscript. Running model 5 times to stabilize compilation'							)
             timeit.repeat(
                 __A  ,			repeat=1  ,			number=5  ,			)

           # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
           UpperCamelCase_:					List[Any]          =				timeit.repeat(
               __A  ,			repeat=self.args.repeat  ,			number=1_0  ,			)

           if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
             import torch_xla.debug.metrics as met

             self.print_fn(met.metrics_report()							)

           return min(__A							) / 1_0.0
         except RuntimeError as e:
           self.print_fn(f'''Doesn\'t fit on GPU. {e}'''							)
           return "N/A"





       def 			_a    (					self  ,			_lowerCamelCase							):
         try:
           if self.args.trace_memory_line_by_line:
             UpperCamelCase_:					List[Any]          =				start_memory_tracing('transformers'							)

           if self.args.is_tpu:
             # tpu
             raise NotImplementedError(
                 'Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with'
                 ' `--no-memory` or `args.memory=False`'							)
           elif self.args.is_gpu:
             if not is_pyanvml_available():
               logger.warning(
                   'py3nvml not installed, we won\'t log GPU memory usage. '
                   'Install py3nvml (pip install py3nvml) to log information about GPU.'							)
               UpperCamelCase_:					Optional[Any]          =				'N/A'
             else:
               logger.info(
                   'Measuring total GPU usage on GPU device. Make sure to not have additional processes running'
                   ' on the same GPU.'							)
               # init nvml
               nvml.nvmlInit()
               func()
               UpperCamelCase_:					int          =				nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx							)
               UpperCamelCase_:					int          =				nvml.nvmlDeviceGetMemoryInfo(__A							)
               UpperCamelCase_:					List[Any]          =				meminfo.used
               UpperCamelCase_:					Optional[int]          =				Memory(__A							)
               # shutdown nvml
               nvml.nvmlShutdown()
           else:
             # cpu
             UpperCamelCase_:					int          =				measure_peak_memory_cpu(__A							)
             UpperCamelCase_:					Optional[Any]          =				Memory(__A							) if isinstance(__A  ,			__A							) else memory_bytes

           if self.args.trace_memory_line_by_line:
             UpperCamelCase_:					List[str]          =				stop_memory_tracing(__A							)
           else:
             UpperCamelCase_:					Optional[Any]          =				None

           return memory, summary
         except RuntimeError as e:
           self.print_fn(f'''Doesn\'t fit on GPU. {e}'''							)
           return "N/A", None







from math import factorial




def    __A    (   _lowercase    ,	_lowercase       ):

					'''simple docstring'''







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




def    __A    (   ):

					'''simple docstring'''







					_A									=       0

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


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



