





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'):
							__lowerCAmelCase :Any     =    True
							from torch.cuda.amp import autocast


__lowerCAmelCase :List[str]     =    logging.getLogger(__name__)






@dataclass
class        _a:
		lowerCamelCase__     :str   				=		field(
		    metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'}    )
		lowerCamelCase__     :Optional[str]   				=		field(
		    default=__A	,   metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}	,   )
		lowerCamelCase__     :Optional[bool]   				=		field(
		    default=__A	,   metadata={'help': 'Whether to freeze the feature extractor layers of the model.'}    )
		lowerCamelCase__     :Optional[bool]   				=		field(
		    default=__A	,   metadata={'help': 'Whether to log verbose messages or not.'}	,   )
		lowerCamelCase__     :Optional[float]   				=		field(
		    default=2.0	,   metadata={'help': 'Maximum temperature for gumbel softmax.'}    )
		lowerCamelCase__     :Optional[float]   				=		field(
		    default=0.5	,   metadata={'help': 'Minimum temperature for gumbel softmax.'}    )
		lowerCamelCase__     :Optional[float]   				=		field(
		    default=0.99_9995	,   metadata={'help': 'Decay of gumbel temperature during training.'}    )







def    A				(							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				)]  ,  )
					_snake_case       :					Tuple				       =   logging.WARNING
					if model_args.verbose_logging:
										_snake_case       :					Dict				       =   logging.DEBUG
					elif trainer_utils.is_main_process(training_args.local_rank				):
										_snake_case       :					Tuple				       =   logging.INFO
					logger.setLevel(UpperCAmelCase				)






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






@dataclass
class        _a:
		lowerCamelCase__     :WavaVecaForPreTraining
		lowerCamelCase__     :WavaVecaFeatureExtractor
		lowerCamelCase__     :Union[bool, str]   				=		"longest"
		lowerCamelCase__     :Optional[int]   				=		None
		lowerCamelCase__     :Optional[int]   				=		None







		def __call__(    self ,						__snake_case				)      ->      Dict[str, torch.Tensor]:


							'''simple docstring'''

							_snake_case       :					Union[str, Any]				       =   self.feature_extractor.pad(
							    __snake_case ,						max_length=self.max_length ,						padding=self.padding ,						pad_to_multiple_of=self.pad_to_multiple_of ,						return_tensors="pt" ,						)
							_snake_case       :					Any				       =   self.model._get_feat_extract_output_lengths(batch["input_values"].shape[-1]				)

							_snake_case       :					Optional[int]				       =   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
												_snake_case       :					Optional[int]				       =   self.model._get_feat_extract_output_lengths(batch["attention_mask"].sum(-1				)				).to(
												    torch.long				)

												_snake_case       :					str				       =   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
												_snake_case       :					Any				       =   1
												_snake_case       :					str				       =   attention_mask.flip([-1]				).cumsum(-1				).flip([-1]				).bool()

							# sample randomly masked indices
							_snake_case       :					List[Any]				       =   _compute_mask_indices(
							    (batch_size, mask_indices_seq_length) ,						self.model.config.mask_time_prob ,						self.model.config.mask_time_length ,						attention_mask=__snake_case ,						min_masks=2 ,						)

							return batch






class        _a(    __A    ):







		def __init__(    self ,						*__snake_case ,						__snake_case=1 ,						__snake_case=0 ,						__snake_case=1.0 ,						**__snake_case				)      ->      List[str]:


							'''simple docstring'''

							super().__init__(*__snake_case ,						**__snake_case				)
							_snake_case       :					Any				       =   0
							_snake_case       :					List[str]				       =   max_gumbel_temp
							_snake_case       :					List[str]				       =   min_gumbel_temp
							_snake_case       :					str				       =   gumbel_temp_decay







		def        lowercase       (    self ,						__snake_case ,						__snake_case				)      ->      torch.Tensor:


							'''simple docstring'''

							model.train()
							_snake_case       :					Union[str, Any]				       =   self._prepare_inputs(__snake_case				)

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

							if self.args.n_gpu > 1 or self.deepspeed:
												if model.module.config.ctc_loss_reduction == "mean":
																	_snake_case       :					str				       =   loss.mean()
												elif model.module.config.ctc_loss_reduction == "sum":
																	_snake_case       :					Union[str, 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:
												_snake_case       :					int				       =   loss / self.args.gradient_accumulation_steps

							if self.use_amp:
												self.scaler.scale(__snake_case				).backward()
							elif self.use_apex:
												with amp.scale_loss(__snake_case ,						self.optimizer				) as scaled_loss:
																	scaled_loss.backward()
							elif self.deepspeed:
												self.deepspeed.backward(__snake_case				)
							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    A				(							):
					# 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.

					_snake_case       :					int				       =   HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)

					_snake_case       , _snake_case       , _snake_case       :					str				       =   parser.parse_args_into_dataclasses()
					configure_logger(UpperCAmelCase  ,  UpperCAmelCase				)

					# Downloading and loading a dataset from the hub.
					_snake_case       :					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"
										_snake_case       :					List[Any]				       =   DatasetDict()
										_snake_case       :					str				       =   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  ,  )
										_snake_case       :					Optional[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"
										_snake_case       :					Dict				       =   DatasetDict()
										_snake_case       :					Tuple				       =   load_dataset(
										    data_args.dataset_name  ,  data_args.dataset_config_name  ,  split="validation"  ,  cache_dir=model_args.cache_dir  ,  )
										_snake_case       :					Optional[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
					_snake_case       :					Optional[Any]				       =   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
										_snake_case       , _snake_case       :					Dict				       =   librosa.load(batch[data_args.speech_file_column]  ,  sr=feature_extractor.sampling_rate				)
										return batch

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

					# filter audio files that are too long
					_snake_case       :					int				       =   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`
					_snake_case       :					Union[str, Any]				       =   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
					_snake_case       :					List[Any]				       =   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'"				)

					_snake_case       :					Optional[Any]				       =   WavaVecaForPreTraining(UpperCAmelCase				)

					_snake_case       :					Union[str, Any]				       =   DataCollatorForWavaVecaPretraining(model=UpperCAmelCase  ,  feature_extractor=UpperCAmelCase				)

					_snake_case       :					Optional[int]				       =   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    A				(							UpperCAmelCase				):
					if n == 1 or not isinstance(UpperCAmelCase  ,  UpperCAmelCase				):
										return 0
					elif n == 2:
										return 1
					else:
										_snake_case       :					List[Any]				       =   [0, 1]
										for i in range(2  ,  n + 1				):
															sequence.append(sequence[i - 1] + sequence[i - 2]				)

										return sequence[n]







def    A				(							UpperCAmelCase				):
					_snake_case       :					Tuple				       =   0
					_snake_case       :					Optional[Any]				       =   2

					while digits < n:
										index += 1
										_snake_case       :					str				       =   len(str(fibonacci(UpperCAmelCase				)				)				)

					return index







def    A				(							UpperCAmelCase = 1_000				):
					return fibonacci_digits_index(UpperCAmelCase				)


if __name__ == "__main__":
							print(solution(int(str(input()).strip())))