




"""simple docstring"""




import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union

import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn

from transformers import (
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaForPreTraining,
    is_apex_available,
    trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices


if is_apex_available():
			from apex import amp

if version.parse(version.parse(torch.__version__).base_version) >= version.parse('1.6'):
			a_        =       True
			from torch.cuda.amp import autocast


a_        =       logging.getLogger(__name__)

@dataclass
class   UpperCAmelCase_    :
		UpperCamelCase							=field(
		    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}		)
		UpperCamelCase							=field(
		    default=snake_case   ,					metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}   ,					)
		UpperCamelCase							=field(
		    default=snake_case   ,					metadata={"help": "Whether to freeze the feature extractor layers of the model."}		)
		UpperCamelCase							=field(
		    default=snake_case   ,					metadata={"help": "Whether to log verbose messages or not."}   ,					)
		UpperCamelCase							=field(
		    default=2.0   ,					metadata={"help": "Maximum temperature for gumbel softmax."}		)
		UpperCamelCase							=field(
		    default=0.5   ,					metadata={"help": "Minimum temperature for gumbel softmax."}		)
		UpperCamelCase							=field(
		    default=0.999_995   ,					metadata={"help": "Decay of gumbel temperature during training."}		)







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase	):
			logging.basicConfig(
			    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s'''	,				datefmt='''%m/%d/%Y %H:%M:%S'''	,				handlers=[logging.StreamHandler(sys.stdout	)]	,				)
			__lowercase			:  Tuple								=       logging.WARNING
			if model_args.verbose_logging:
						__lowercase			:  str								=       logging.DEBUG
			elif trainer_utils.is_main_process(training_args.local_rank	):
						__lowercase			:  Optional[Any]								=       logging.INFO
			logger.setLevel(__UpperCamelCase	)

@dataclass
class   UpperCAmelCase_    :
		UpperCamelCase							=field(
		    default=snake_case   ,					metadata={"help": "The name of the dataset to use (via the datasets library)."}		)
		UpperCamelCase							=field(
		    default=snake_case   ,					metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}		)
		UpperCamelCase							=field(
		    default="train"   ,					metadata={
		        "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
		    }   ,					)
		UpperCamelCase							=field(
		    default="validation"   ,					metadata={
		        "help": (
		            "The name of the validation data set split to use (via the datasets library). Defaults to 'validation'"
		        )
		    }   ,					)
		UpperCamelCase							=field(
		    default="file"   ,					metadata={"help": "Column in the dataset that contains speech file path. Defaults to 'file'"}   ,					)
		UpperCamelCase							=field(
		    default=snake_case   ,					metadata={"help": "Overwrite the cached preprocessed datasets or not."}		)
		UpperCamelCase							=field(
		    default=1   ,					metadata={
		        "help": "The percentage of the train set used as validation set in case there's no validation split"
		    }   ,					)
		UpperCamelCase							=field(
		    default=snake_case   ,					metadata={"help": "The number of processes to use for the preprocessing."}   ,					)
		UpperCamelCase							=field(
		    default=20.0   ,					metadata={"help": "Filter audio files that are longer than `max_duration_in_seconds` seconds"}		)


@dataclass
class   UpperCAmelCase_    :
		UpperCamelCase							=42
		UpperCamelCase							=42
		UpperCamelCase							="longest"
		UpperCamelCase							=None
		UpperCamelCase							=None
		def __call__(						self				,						UpperCamelCase_       )						->       Dict[str, torch.Tensor]:
					# reformat list to dict and set to pytorch format
					__lowercase			:  Optional[Any]								=       self.feature_extractor.pad(
					    UpperCamelCase_				,						max_length=self.max_length				,						padding=self.padding				,						pad_to_multiple_of=self.pad_to_multiple_of				,						return_tensors='''pt'''				,						)
					__lowercase			:  List[Any]								=       self.model._get_feat_extract_output_lengths(batch['''input_values'''].shape[-1]       )

					__lowercase			:  List[Any]								=       batch['''input_values'''].shape[0]

					# make sure that no loss is computed on padded inputs
					if batch["attention_mask"] is not None:
								# compute real output lengths according to convolution formula
								__lowercase			:  Any								=       self.model._get_feat_extract_output_lengths(batch['''attention_mask'''].sum(-1       )       ).to(
								    torch.long       )

								__lowercase			:  Dict								=       torch.zeros(
								    (batch_size, mask_indices_seq_length)				,						dtype=torch.long				,						device=batch['''input_values'''].device       )

								# these two operations makes sure that all values
								# before the output lengths indices are attended to
								__lowercase			:  str								=       1
								__lowercase			:  List[str]								=       attention_mask.flip([-1]       ).cumsum(-1       ).flip([-1]       ).bool()

					# sample randomly masked indices
					__lowercase			:  str								=       _compute_mask_indices(
					    (batch_size, mask_indices_seq_length)				,						self.model.config.mask_time_prob				,						self.model.config.mask_time_length				,						attention_mask=UpperCamelCase_				,						min_masks=2				,						)

					return batch


class   UpperCAmelCase_    (			snake_case		):
		def __init__(						self				,						*UpperCamelCase_				,						UpperCamelCase_=1				,						UpperCamelCase_=0				,						UpperCamelCase_=1.0				,						**UpperCamelCase_       )						->       Tuple:
					super().__init__(*UpperCamelCase_				,						**UpperCamelCase_       )
					__lowercase			:  Tuple								=       0
					__lowercase			:  Optional[Any]								=       max_gumbel_temp
					__lowercase			:  Optional[int]								=       min_gumbel_temp
					__lowercase			:  Tuple								=       gumbel_temp_decay
		def 	_lowerCamelCase							(						self				,						UpperCamelCase_				,						UpperCamelCase_       )						->       torch.Tensor:
					model.train()
					__lowercase			:  Optional[int]								=       self._prepare_inputs(UpperCamelCase_       )

					if self.use_amp:
								with autocast():
											__lowercase			:  Optional[Any]								=       self.compute_loss(UpperCamelCase_				,						UpperCamelCase_       )
					else:
								__lowercase			:  int								=       self.compute_loss(UpperCamelCase_				,						UpperCamelCase_       )

					if self.args.n_gpu > 1 or self.deepspeed:
								if model.module.config.ctc_loss_reduction == "mean":
											__lowercase			:  str								=       loss.mean()
								elif model.module.config.ctc_loss_reduction == "sum":
											__lowercase			:  Any								=       loss.sum() / (inputs['''mask_time_indices''']).sum()
								else:
											raise ValueError(F"""{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']"""       )

					if self.args.gradient_accumulation_steps > 1:
								__lowercase			:  Dict								=       loss / self.args.gradient_accumulation_steps

					if self.use_amp:
								self.scaler.scale(UpperCamelCase_       ).backward()
					elif self.use_apex:
								with amp.scale_loss(UpperCamelCase_				,						self.optimizer       ) as scaled_loss:
											scaled_loss.backward()
					elif self.deepspeed:
								self.deepspeed.backward(UpperCamelCase_       )
					else:
								loss.backward()

					self.num_update_step += 1
					# make sure gumbel softmax temperature is decayed
					if self.args.n_gpu > 1 or self.deepspeed:
								model.module.set_gumbel_temperature(
								    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step				,						self.min_gumbel_temp       )       )
					else:
								model.set_gumbel_temperature(
								    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step				,						self.min_gumbel_temp       )       )

					return loss.detach()







def      __UpperCAmelCase     ( ):
			# See all possible arguments in src/transformers/training_args.py
			# or by passing the --help flag to this script.
			# We now keep distinct sets of args, for a cleaner separation of concerns.

			__lowercase			:  Optional[Any]								=       HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)	)

			__lowercase			,__lowercase			,__lowercase			:  List[Any]								=       parser.parse_args_into_dataclasses()
			configure_logger(__UpperCamelCase	,				__UpperCamelCase	)

			# Downloading and loading a dataset from the hub.
			__lowercase			:  Union[str, Any]								=       load_dataset(data_args.dataset_name	,				data_args.dataset_config_name	,				cache_dir=model_args.cache_dir	)

			if "validation" not in datasets.keys():
						# make sure only "validation" and "train" keys remain"
						__lowercase			:  Optional[Any]								=       DatasetDict()
						__lowercase			:  Any								=       load_dataset(
						    data_args.dataset_name	,				data_args.dataset_config_name	,				split=f"""{data_args.train_split_name}[:{data_args.validation_split_percentage}%]"""	,				cache_dir=model_args.cache_dir	,				)
						__lowercase			:  List[Any]								=       load_dataset(
						    data_args.dataset_name	,				data_args.dataset_config_name	,				split=f"""{data_args.train_split_name}[{data_args.validation_split_percentage}%:]"""	,				cache_dir=model_args.cache_dir	,				)
			else:
						# make sure only "validation" and "train" keys remain"
						__lowercase			:  Dict								=       DatasetDict()
						__lowercase			:  List[Any]								=       load_dataset(
						    data_args.dataset_name	,				data_args.dataset_config_name	,				split='''validation'''	,				cache_dir=model_args.cache_dir	,				)
						__lowercase			:  Any								=       load_dataset(
						    data_args.dataset_name	,				data_args.dataset_config_name	,				split=f"""{data_args.train_split_name}"""	,				cache_dir=model_args.cache_dir	,				)

			# only normalized-inputs-training is supported
			__lowercase			:  str								=       WavaVecaFeatureExtractor.from_pretrained(
			    model_args.model_name_or_path	,				cache_dir=model_args.cache_dir	,				do_normalize=__UpperCamelCase	)

			def prepare_dataset(__UpperCamelCase	):
						# check that all files have the correct sampling rate
						__lowercase			,__lowercase			:  Union[str, Any]								=       librosa.load(batch[data_args.speech_file_column]	,				sr=feature_extractor.sampling_rate	)
						return batch

			# load audio files into numpy arrays
			__lowercase			:  Tuple								=       datasets.map(
			    __UpperCamelCase	,				num_proc=data_args.preprocessing_num_workers	,				remove_columns=datasets['''train'''].column_names	)

			# filter audio files that are too long
			__lowercase			:  Optional[Any]								=       vectorized_datasets.filter(
			    lambda __UpperCamelCase	: len(data['''speech''']	) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate	)	)

			def normalize(__UpperCamelCase	):
						return feature_extractor(batch['''speech''']	,				sampling_rate=feature_extractor.sampling_rate	)

			# normalize and transform to `BatchFeatures`
			__lowercase			:  List[str]								=       vectorized_datasets.map(
			    __UpperCamelCase	,				batched=__UpperCamelCase	,				num_proc=data_args.preprocessing_num_workers	,				load_from_cache_file=not data_args.overwrite_cache	,				remove_columns=vectorized_datasets['''train'''].column_names	,				)

			# pretraining is only supported for "newer" stable layer norm architecture
			# apply_spec_augment has to be True, mask_feature_prob has to be 0.0
			__lowercase			:  str								=       WavaVecaConfig.from_pretrained(
			    model_args.model_name_or_path	,				cache_dir=model_args.cache_dir	,				gradient_checkpointing=training_args.gradient_checkpointing	,				)

			if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
						raise ValueError(
						    '''PreTraining is only supported for ``config.do_stable_layer_norm=True`` and'''
						    ''' ``config.feat_extract_norm=\'layer\''''	)

			__lowercase			:  Optional[Any]								=       WavaVecaForPreTraining(__UpperCamelCase	)

			__lowercase			:  List[str]								=       DataCollatorForWavaVecaPretraining(model=__UpperCamelCase	,				feature_extractor=__UpperCamelCase	)

			__lowercase			:  Union[str, Any]								=       WavaVecaPreTrainer(
			    model=__UpperCamelCase	,				data_collator=__UpperCamelCase	,				args=__UpperCamelCase	,				train_dataset=vectorized_datasets['''train''']	,				eval_dataset=vectorized_datasets['''validation''']	,				tokenizer=__UpperCamelCase	,				max_gumbel_temp=model_args.max_gumbel_temperature	,				min_gumbel_temp=model_args.min_gumbel_temperature	,				gumbel_temp_decay=model_args.gumbel_temperature_decay	,				)
			trainer.train()


if __name__ == "__main__":
			main()








def 		lowerCAmelCase__     (       UpperCamelCase_					:							int						)->	int:
    A__					=       1
    for i in range(1			,							num + 1						):
        fact *= i
    return fact



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int						)->	int:
    A__					=       0
    while number > 0:
        A__					=       number % 1_0
        sum_of_digits += last_digit
        A__					=       number // 1_0  # Removing the last_digit from the given number
    return sum_of_digits



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int = 1_0_0						)->	int:
    A__					=       factorial(UpperCamelCase_						)
    A__					=       split_and_add(UpperCamelCase_						)
    return result


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