






import argparse

import torch
from saprl.hub import distilhubert

from transformers import HubertConfig, HubertModel, WavaVecaFeatureExtractor, logging


logging.set_verbosity_info()
a_			=      logging.get_logger(__name__)

a_			=      {
    '''post_extract_proj''': '''feature_projection.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.layer_norm''': '''encoder.layer_norm''',
    '''mask_emb''': '''masked_spec_embed''',
}


def     _a					(       UpperCamelCase_   :			Optional[int]      ,				UpperCamelCase_   :			Union[str, Any]      ,				UpperCamelCase_   :			Union[str, Any]      ,				UpperCamelCase_   :			Any      ,				UpperCamelCase_   :			Dict				)	->				Dict:
						"""simple docstring"""







						for attribute in key.split("."				):
												lowerCAmelCase__	 =  getattr(__UpperCamelCase      ,				__UpperCamelCase				)

						if weight_type is not None:
												lowerCAmelCase__	 =  getattr(__UpperCamelCase      ,				__UpperCamelCase				).shape
						else:
												lowerCAmelCase__	 =  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":
												lowerCAmelCase__	 =  value
						elif weight_type == "weight_g":
												lowerCAmelCase__	 =  value
						elif weight_type == "weight_v":
												lowerCAmelCase__	 =  value
						elif weight_type == "bias":
												lowerCAmelCase__	 =  value
						else:
												lowerCAmelCase__	 =  value

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


def     _a					(       UpperCamelCase_   :			Any      ,				UpperCamelCase_   :			List[str]				)	->				Tuple:
						"""simple docstring"""







						lowerCAmelCase__	 =  []
						lowerCAmelCase__	 =  fairseq_model.state_dict()

						lowerCAmelCase__	 =  hf_model.feature_extractor

						for name, value in fairseq_dict.items():
												lowerCAmelCase__	 =  False
												if "conv_layers" in name:
																		load_conv_layer(
																		    __UpperCamelCase      ,				__UpperCamelCase      ,				__UpperCamelCase      ,				__UpperCamelCase      ,				hf_model.config.feat_extract_norm == "group"      ,				)
																		lowerCAmelCase__	 =  True
												else:
																		for key, mapped_key in MAPPING.items():
																								lowerCAmelCase__	 =  mapped_key

																								if key in name:
																														lowerCAmelCase__	 =  True
																														if "*" in mapped_key:
																																				lowerCAmelCase__	 =  name.split(__UpperCamelCase				)[0].split("."				)[-2]
																																				lowerCAmelCase__	 =  mapped_key.replace("*"      ,				__UpperCamelCase				)
																														if "weight_g" in name:
																																				lowerCAmelCase__	 =  "weight_g"
																														elif "weight_v" in name:
																																				lowerCAmelCase__	 =  "weight_v"
																														elif "weight" in name:
																																				lowerCAmelCase__	 =  "weight"
																														elif "bias" in name:
																																				lowerCAmelCase__	 =  "bias"
																														else:
																																				lowerCAmelCase__	 =  None
																														set_recursively(__UpperCamelCase      ,				__UpperCamelCase      ,				__UpperCamelCase      ,				__UpperCamelCase      ,				__UpperCamelCase				)
																								continue
												if not is_used:
																		unused_weights.append(__UpperCamelCase				)

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


def     _a					(       UpperCamelCase_   :			Optional[Any]      ,				UpperCamelCase_   :			Any      ,				UpperCamelCase_   :			Dict      ,				UpperCamelCase_   :			Optional[int]      ,				UpperCamelCase_   :			int				)	->				Any:
						"""simple docstring"""







						lowerCAmelCase__	 =  full_name.split("conv_layers."				)[-1]
						lowerCAmelCase__	 =  name.split("."				)
						lowerCAmelCase__	 =  int(items[0]				)
						lowerCAmelCase__	 =  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."
																		)
																		lowerCAmelCase__	 =  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."
																		)
																		lowerCAmelCase__	 =  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."
																		)
																		lowerCAmelCase__	 =  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."
																		)
																		lowerCAmelCase__	 =  value
																		logger.info(F"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."				)
						else:
												unused_weights.append(__UpperCamelCase				)


def     _a					(       UpperCamelCase_   :			Dict				)	->				Optional[int]:
						"""simple docstring"""







						lowerCAmelCase__	 =  HubertConfig()
						lowerCAmelCase__	 =  model.config

						lowerCAmelCase__	 =  fs_config.activation_dropout
						lowerCAmelCase__	 =  False
						lowerCAmelCase__	 =  fs_config.attention_dropout
						lowerCAmelCase__	 =  False
						lowerCAmelCase__	 =  eval(fs_config.extractor_conv_feature_layers				)
						lowerCAmelCase__	 =  [x[0] for x in conv_layers]
						lowerCAmelCase__	 =  [x[1] for x in conv_layers]
						lowerCAmelCase__	 =  [x[2] for x in conv_layers]
						lowerCAmelCase__	 =  "gelu"
						lowerCAmelCase__	 =  "layer" if fs_config.extractor_mode == "layer_norm" else "group"
						lowerCAmelCase__	 =  False
						lowerCAmelCase__	 =  0.0
						lowerCAmelCase__	 =  0.0
						lowerCAmelCase__	 =  fs_config.activation_fn
						lowerCAmelCase__	 =  fs_config.dropout
						lowerCAmelCase__	 =  fs_config.encoder_embed_dim
						lowerCAmelCase__	 =  0.02
						lowerCAmelCase__	 =  fs_config.encoder_ffn_embed_dim
						lowerCAmelCase__	 =  1e-5
						lowerCAmelCase__	 =  0.0
						lowerCAmelCase__	 =  fs_config.encoder_attention_heads
						lowerCAmelCase__	 =  fs_config.conv_pos_groups
						lowerCAmelCase__	 =  fs_config.conv_pos
						lowerCAmelCase__	 =  len(__UpperCamelCase				)
						lowerCAmelCase__	 =  fs_config.encoder_layers

						return config


@torch.no_grad()
def     _a					(       UpperCamelCase_   :			Optional[Any]      ,				UpperCamelCase_   :			Optional[int]=None				)	->				Tuple:
						"""simple docstring"""







						lowerCAmelCase__	 =  distilhubert().model.model

						if config_path is not None:
												lowerCAmelCase__	 =  HubertConfig.from_pretrained(__UpperCamelCase				)
						else:
												lowerCAmelCase__	 =  convert_config(__UpperCamelCase				)
						lowerCAmelCase__	 =  model.eval()

						lowerCAmelCase__	 =  WavaVecaFeatureExtractor(
						    feature_size=1      ,				sampling_rate=16_000      ,				padding_value=0      ,				do_normalize=__UpperCamelCase      ,				return_attention_mask=__UpperCamelCase      ,				)
						lowerCAmelCase__	 =  HubertModel(__UpperCamelCase				)

						recursively_load_weights(__UpperCamelCase      ,				__UpperCamelCase				)

						feature_extractor.save_pretrained(__UpperCamelCase				)
						hf_model.save_pretrained(__UpperCamelCase				)


if __name__ == "__main__":
	a_			=      argparse.ArgumentParser()
	parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
	parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
	a_			=      parser.parse_args()
	convert_hubert_checkpoint(args.pytorch_dump_folder_path, args.config_path)














def     _a					(       UpperCamelCase_   :			int = 100				)	->				int:
						"""simple docstring"""







						lowerCAmelCase__	 =  1
						lowerCAmelCase__	 =  0
						for i in range(1      ,				num + 1				):
												fact *= i

						for j in str(UpperCamelCase_				):
												result += int(UpperCamelCase_				)

						return result


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






