


"""simple docstring"""






def 				A_       ( snake_case__		)					->  int:
			if n == 1 or not isinstance(snake_case__       ,					snake_case__		):
						return 0
			elif n == 2:
						return 1
			else:
						_UpperCamelCase					:Tuple					     =	[0, 1]
						for i in range(2       ,					n + 1		):
									sequence.append(sequence[i - 1] + sequence[i - 2]		)

						return sequence[n]





def 				A_       ( snake_case__		)					->  int:
			_UpperCamelCase					:Any					     =	0
			_UpperCamelCase					:Dict					     =	2

			while digits < n:
						index += 1
						_UpperCamelCase					:Tuple					     =	len(str(fibonacci(snake_case__		)		)		)

			return index





def 				A_       ( snake_case__ = 10_00		)					->  int:
			return fibonacci_digits_index(snake_case__		)


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





"""simple docstring"""






import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

# Register SEW's fairseq modules
from sew_asapp import tasks  # noqa: F401

from transformers import (
    SEWConfig,
    SEWForCTC,
    SEWModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


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

UpperCamelCase__				:int			   =	{
    """post_extract_proj""": """feature_projection""",
    """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
    """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""",
    """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""",
    """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""",
    """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""",
    """self_attn_layer_norm""": """encoder.layers.*.layer_norm""",
    """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""",
    """fc2""": """encoder.layers.*.feed_forward.output_dense""",
    """final_layer_norm""": """encoder.layers.*.final_layer_norm""",
    """encoder.upsample.0""": """encoder.upsample.projection""",
    """encoder.layer_norm""": """encoder.layer_norm""",
    """w2v_model.layer_norm""": """layer_norm""",
    """w2v_encoder.proj""": """lm_head""",
    """mask_emb""": """masked_spec_embed""",
}





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  Tuple:
			for attribute in key.split('''.'''		):
						_UpperCamelCase					:Any					     =	getattr(snake_case__       ,					snake_case__		)

			if weight_type is not None:
						_UpperCamelCase					:Any					     =	getattr(snake_case__       ,					snake_case__		).shape
			else:
						_UpperCamelCase					:Optional[int]					     =	hf_pointer.shape

			assert hf_shape == value.shape, (
			    f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
			    f" {value.shape} for {full_name}"
			)

			if weight_type == "weight":
						_UpperCamelCase					:str					     =	value
			elif weight_type == "weight_g":
						_UpperCamelCase					:Dict					     =	value
			elif weight_type == "weight_v":
						_UpperCamelCase					:Optional[Any]					     =	value
			elif weight_type == "bias":
						_UpperCamelCase					:str					     =	value
			else:
						_UpperCamelCase					:int					     =	value

			logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."		)





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__		)					->  Tuple:
			_UpperCamelCase					:Optional[int]					     =	[]
			_UpperCamelCase					:List[str]					     =	fairseq_model.state_dict()

			_UpperCamelCase					:str					     =	hf_model.sew.feature_extractor if is_finetuned else hf_model.feature_extractor

			for name, value in fairseq_dict.items():
						_UpperCamelCase					:Optional[Any]					     =	False
						if "conv_layers" in name:
									load_conv_layer(
									    snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					hf_model.config.feat_extract_norm == '''group'''       ,					)
									_UpperCamelCase					:Dict					     =	True
						else:
									for key, mapped_key in MAPPING.items():
												_UpperCamelCase					:Optional[int]					     =	'''sew.''' + mapped_key if (is_finetuned and mapped_key != '''lm_head''') else mapped_key

												if key in name or key.split('''w2v_model.'''		)[-1] == name.split('''.'''		)[0]:
															_UpperCamelCase					:List[str]					     =	True
															if "*" in mapped_key:
																		_UpperCamelCase					:List[str]					     =	name.split(snake_case__		)[0].split('''.'''		)[-2]
																		_UpperCamelCase					:Tuple					     =	mapped_key.replace('''*'''       ,					snake_case__		)
															if "weight_g" in name:
																		_UpperCamelCase					:List[Any]					     =	'''weight_g'''
															elif "weight_v" in name:
																		_UpperCamelCase					:Union[str, Any]					     =	'''weight_v'''
															elif "weight" in name:
																		_UpperCamelCase					:List[Any]					     =	'''weight'''
															elif "bias" in name:
																		_UpperCamelCase					:List[Any]					     =	'''bias'''
															else:
																		_UpperCamelCase					:List[Any]					     =	None
															set_recursively(snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)
												continue
						if not is_used:
									unused_weights.append(snake_case__		)

			logger.warning(f"Unused weights: {unused_weights}"		)





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  Optional[Any]:
			_UpperCamelCase					:Optional[int]					     =	full_name.split('''conv_layers.'''		)[-1]
			_UpperCamelCase					:Optional[int]					     =	name.split('''.'''		)
			_UpperCamelCase					:Optional[Any]					     =	int(items[0]		)
			_UpperCamelCase					:List[str]					     =	int(items[1]		)

			if type_id == 0:
						if "bias" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
									    f"{full_name} has size {value.shape}, but"
									    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
									)
									_UpperCamelCase					:Optional[int]					     =	value
									logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."		)
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
									    f"{full_name} has size {value.shape}, but"
									    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
									)
									_UpperCamelCase					:Optional[Any]					     =	value
									logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."		)
			elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
						if "bias" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
									    f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
									    " found."
									)
									_UpperCamelCase					:int					     =	value
									logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."		)
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
									    f"{full_name} has size {value.shape}, but"
									    f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
									)
									_UpperCamelCase					:Dict					     =	value
									logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."		)
			else:
						unused_weights.append(snake_case__		)





def 				A_       ( snake_case__       ,					snake_case__		)					->  List[str]:
			_UpperCamelCase					:str					     =	SEWConfig()
			if is_finetuned:
						_UpperCamelCase					:Optional[int]					     =	model.wav_encoder.wav_model.cfg
			else:
						_UpperCamelCase					:Dict					     =	model.cfg

			_UpperCamelCase					:Dict					     =	fs_config.conv_bias
			_UpperCamelCase					:int					     =	eval(fs_config.conv_feature_layers		)
			_UpperCamelCase					:List[Any]					     =	[x[0] for x in conv_layers]
			_UpperCamelCase					:Optional[int]					     =	[x[1] for x in conv_layers]
			_UpperCamelCase					:Optional[int]					     =	[x[2] for x in conv_layers]
			_UpperCamelCase					:str					     =	'''gelu'''
			_UpperCamelCase					:Optional[int]					     =	'''layer''' if fs_config.extractor_mode == '''layer_norm''' else '''group'''
			_UpperCamelCase					:List[Any]					     =	0.0
			_UpperCamelCase					:Optional[int]					     =	fs_config.activation_fn.name
			_UpperCamelCase					:str					     =	fs_config.encoder_embed_dim
			_UpperCamelCase					:Dict					     =	0.02
			_UpperCamelCase					:Optional[int]					     =	fs_config.encoder_ffn_embed_dim
			_UpperCamelCase					:str					     =	1E-5
			_UpperCamelCase					:int					     =	fs_config.encoder_layerdrop
			_UpperCamelCase					:Union[str, Any]					     =	fs_config.encoder_attention_heads
			_UpperCamelCase					:List[str]					     =	fs_config.conv_pos_groups
			_UpperCamelCase					:List[Any]					     =	fs_config.conv_pos
			_UpperCamelCase					:List[str]					     =	len(snake_case__		)
			_UpperCamelCase					:Optional[int]					     =	fs_config.encoder_layers
			_UpperCamelCase					:Optional[int]					     =	fs_config.squeeze_factor

			# take care of any params that are overridden by the Wav2VecCtc model
			if is_finetuned:
						_UpperCamelCase					:List[Any]					     =	model.cfg
						_UpperCamelCase					:List[Any]					     =	fs_config.final_dropout
						_UpperCamelCase					:Dict					     =	fs_config.layerdrop
			_UpperCamelCase					:Any					     =	fs_config.activation_dropout
			_UpperCamelCase					:List[str]					     =	fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
			_UpperCamelCase					:Optional[Any]					     =	fs_config.attention_dropout
			_UpperCamelCase					:List[Any]					     =	fs_config.dropout_input
			_UpperCamelCase					:Dict					     =	fs_config.dropout
			_UpperCamelCase					:int					     =	fs_config.mask_channel_length
			_UpperCamelCase					:Tuple					     =	fs_config.mask_channel_prob
			_UpperCamelCase					:int					     =	fs_config.mask_length
			_UpperCamelCase					:Dict					     =	fs_config.mask_prob

			_UpperCamelCase					:List[Any]					     =	'''Wav2Vec2FeatureExtractor'''
			_UpperCamelCase					:Optional[Any]					     =	'''Wav2Vec2CTCTokenizer'''

			return config





@torch.no_grad()
def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__=None       ,					snake_case__=None       ,					snake_case__=True		)					->  int:

			if is_finetuned:
						_UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase					:List[Any]					     =	fairseq.checkpoint_utils.load_model_ensemble_and_task(
						    [checkpoint_path]       ,					arg_overrides={'''data''': '''/'''.join(dict_path.split('''/'''		)[:-1]		)}		)
			else:
						_UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase					:str					     =	fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]		)

			if config_path is not None:
						_UpperCamelCase					:Any					     =	SEWConfig.from_pretrained(snake_case__		)
			else:
						_UpperCamelCase					:List[str]					     =	convert_config(model[0]       ,					snake_case__		)
			_UpperCamelCase					:List[str]					     =	model[0].eval()

			_UpperCamelCase					:Optional[Any]					     =	True if config.feat_extract_norm == '''layer''' else False
			_UpperCamelCase					:str					     =	WavaVecaFeatureExtractor(
			    feature_size=1       ,					sampling_rate=1_60_00       ,					padding_value=0       ,					do_normalize=snake_case__       ,					return_attention_mask=snake_case__       ,					)

			if is_finetuned:
						if dict_path:
									_UpperCamelCase					:int					     =	Dictionary.load(snake_case__		)

									# important change bos & pad token id since CTC symbol is <pad> and
									# not <s> as in fairseq
									_UpperCamelCase					:List[Any]					     =	target_dict.pad_index
									_UpperCamelCase					:str					     =	target_dict.bos_index
									_UpperCamelCase					:int					     =	target_dict.pad_index
									_UpperCamelCase					:Dict					     =	target_dict.bos_index
									_UpperCamelCase					:int					     =	target_dict.eos_index
									_UpperCamelCase					:str					     =	len(target_dict.symbols		)
									_UpperCamelCase					:Optional[int]					     =	os.path.join(snake_case__       ,					'''vocab.json'''		)
									if not os.path.isdir(snake_case__		):
												logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(snake_case__		)		)
												return
									os.makedirs(snake_case__       ,					exist_ok=snake_case__		)
									with open(snake_case__       ,					'''w'''       ,					encoding='''utf-8'''		) as vocab_handle:
												json.dump(target_dict.indices       ,					snake_case__		)
									_UpperCamelCase					:int					     =	WavaVecaCTCTokenizer(
									    snake_case__       ,					unk_token=target_dict.unk_word       ,					pad_token=target_dict.pad_word       ,					bos_token=target_dict.bos_word       ,					eos_token=target_dict.eos_word       ,					word_delimiter_token='''|'''       ,					do_lower_case=snake_case__       ,					)
									_UpperCamelCase					:Dict					     =	WavaVecaProcessor(feature_extractor=snake_case__       ,					tokenizer=snake_case__		)
									processor.save_pretrained(snake_case__		)

						_UpperCamelCase					:Tuple					     =	SEWForCTC(snake_case__		)
			else:
						_UpperCamelCase					:str					     =	SEWModel(snake_case__		)
						feature_extractor.save_pretrained(snake_case__		)

			recursively_load_weights(snake_case__       ,					snake_case__       ,					snake_case__		)

			hf_model.save_pretrained(snake_case__		)


if __name__ == "__main__":
					UpperCamelCase__				:List[str]			   =	argparse.ArgumentParser()
					parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
					parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
					parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
					parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
					parser.add_argument(
					    """--is_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
					)
					UpperCamelCase__				:Tuple			   =	parser.parse_args()
					convert_sew_checkpoint(
					    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
					)

