




"""simple docstring"""




import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConfig,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaForCTC,
    WavaVecaForPreTraining,
    WavaVecaProcessor,
    logging,
)
from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification


logging.set_verbosity_info()
lowerCAmelCase				:     List[Any]					=				logging.get_logger(__name__)

lowerCAmelCase				:     List[Any]					=				{
    """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""",
    """adapter_layer""": """encoder.layers.*.adapter_layer""",
    """w2v_model.layer_norm""": """feature_projection.layer_norm""",
    """quantizer.weight_proj""": """quantizer.weight_proj""",
    """quantizer.vars""": """quantizer.codevectors""",
    """project_q""": """project_q""",
    """final_proj""": """project_hid""",
    """w2v_encoder.proj""": """lm_head""",
    """mask_emb""": """masked_spec_embed""",
    """pooling_layer.linear""": """projector""",
    """pooling_layer.projection""": """classifier""",
}
lowerCAmelCase				:     List[Any]					=				[
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
    """projector""",
    """classifier""",
]



def        a__					(							snake_case__							)		->   List[str]:
			lowerCamelCase      =   {}
			with open(snake_case__			,					"""r"""							) as file:
						for line_number, line in enumerate(snake_case__							):
									lowerCamelCase      =   line.strip()
									if line:
												lowerCamelCase      =   line.split()
												lowerCamelCase      =   line_number
												lowerCamelCase      =   words[0]
												lowerCamelCase      =   value
			return result



def        a__					(							snake_case__			,					snake_case__			,					snake_case__			,					snake_case__			,					snake_case__							)		->   Optional[Any]:
			for attribute in key.split("""."""							):
						lowerCamelCase      =   getattr(snake_case__			,					snake_case__							)

			lowerCamelCase      =   None
			for param_key in PARAM_MAPPING.keys():
						if full_name.endswith(snake_case__							):
									lowerCamelCase      =   PARAM_MAPPING[full_name.split("""."""							)[-1]]
									lowerCamelCase      =   """param"""

			if weight_type is not None and weight_type != "param":
						lowerCamelCase      =   getattr(snake_case__			,					snake_case__							).shape
			elif weight_type is not None and weight_type == "param":
						lowerCamelCase      =   hf_pointer
						for attribute in hf_param_name.split("""."""							):
									lowerCamelCase      =   getattr(snake_case__			,					snake_case__							)
						lowerCamelCase      =   shape_pointer.shape

						# let's reduce dimension
						lowerCamelCase      =   value[0]
			else:
						lowerCamelCase      =   hf_pointer.shape

			if hf_shape != value.shape:
						raise ValueError(
						    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
			elif weight_type == "param":
						for attribute in hf_param_name.split("""."""							):
									lowerCamelCase      =   getattr(snake_case__			,					snake_case__							)
						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__					(							snake_case__			,					snake_case__			,					snake_case__			,					snake_case__			,					snake_case__							)		->   int:
			lowerCamelCase      =   None
			for param_key in PARAM_MAPPING.keys():
						if full_name.endswith(snake_case__							):
									lowerCamelCase      =   PARAM_MAPPING[full_name.split("""."""							)[-1]]
									lowerCamelCase      =   """param"""

			if weight_type is not None and weight_type != "param":
						lowerCamelCase      =   """.""".join([key, weight_type]							)
			elif weight_type is not None and weight_type == "param":
						lowerCamelCase      =   """.""".join([key, hf_param_name]							)
			else:
						lowerCamelCase      =   key

			lowerCamelCase      =   value if """lm_head""" in full_key else value[0]


lowerCAmelCase				:     Optional[Any]					=				{
    """W_a""": """linear_1.weight""",
    """W_b""": """linear_2.weight""",
    """b_a""": """linear_1.bias""",
    """b_b""": """linear_2.bias""",
    """ln_W""": """norm.weight""",
    """ln_b""": """norm.bias""",
}



def        a__					(							snake_case__			,					snake_case__			,					snake_case__=None			,					snake_case__=None							)		->   Dict:
			lowerCamelCase      =   False
			for key, mapped_key in MAPPING.items():
						lowerCamelCase      =   """wav2vec2.""" + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
						if key in name or key.split("""w2v_model."""							)[-1] == name.split("""."""							)[0]:
									lowerCamelCase      =   True
									if "*" in mapped_key:
												lowerCamelCase      =   name.split(snake_case__							)[0].split("""."""							)[-2]
												lowerCamelCase      =   mapped_key.replace("""*"""			,					snake_case__							)
									if "weight_g" in name:
												lowerCamelCase      =   """weight_g"""
									elif "weight_v" in name:
												lowerCamelCase      =   """weight_v"""
									elif "bias" in name:
												lowerCamelCase      =   """bias"""
									elif "weight" in name:
												# TODO: don't match quantizer.weight_proj
												lowerCamelCase      =   """weight"""
									else:
												lowerCamelCase      =   None
									if hf_dict is not None:
												rename_dict(snake_case__			,					snake_case__			,					snake_case__			,					snake_case__			,					snake_case__							)
									else:
												set_recursively(snake_case__			,					snake_case__			,					snake_case__			,					snake_case__			,					snake_case__							)
									return is_used
			return is_used



def        a__					(							snake_case__			,					snake_case__			,					snake_case__							)		->   Optional[Any]:
			lowerCamelCase      =   []
			lowerCamelCase      =   fairseq_model.state_dict()

			lowerCamelCase      =   hf_model.wavaveca.feature_extractor

			for name, value in fairseq_dict.items():
						lowerCamelCase      =   False
						if "conv_layers" in name:
									load_conv_layer(
									    snake_case__			,					snake_case__			,					snake_case__			,					snake_case__			,					hf_model.config.feat_extract_norm == """group"""			,					)
									lowerCamelCase      =   True
						else:
									lowerCamelCase      =   load_wavaveca_layer(snake_case__			,					snake_case__			,					snake_case__							)
						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]:
			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:
									if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
												raise ValueError(
												    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:
									if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
												raise ValueError(
												    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:
									if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
												raise ValueError(
												    F'{full_name} has size {value.shape}, but'
												    F' {feature_extractor.conv_layers[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:
									if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
												raise ValueError(
												    F'{full_name} has size {value.shape}, but'
												    F' {feature_extractor.conv_layers[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(snake_case__							)



@torch.no_grad()
def        a__					(							snake_case__			,					snake_case__			,					snake_case__=None			,					snake_case__=None			,					snake_case__=True			,					snake_case__=False							)		->   Any:
			if config_path is not None:
						lowerCamelCase      =   WavaVecaConfig.from_pretrained(snake_case__							)
			else:
						lowerCamelCase      =   WavaVecaConfig()

			if is_seq_class:
						lowerCamelCase      =   read_txt_into_dict(snake_case__							)
						lowerCamelCase      =   idalabel
						lowerCamelCase      =   WavaVecaForSequenceClassification(snake_case__							)
						lowerCamelCase      =   WavaVecaFeatureExtractor(
						    feature_size=1			,					sampling_rate=1_60_00			,					padding_value=0			,					do_normalize=snake_case__			,					return_attention_mask=snake_case__			,					)
						feature_extractor.save_pretrained(snake_case__							)

			elif is_finetuned:
						if dict_path:
									lowerCamelCase      =   Dictionary.load(snake_case__							)

									# important change bos & pad token id since CTC symbol is <pad> and
									# not <s> as in fairseq
									lowerCamelCase      =   target_dict.pad_index
									lowerCamelCase      =   target_dict.bos_index
									lowerCamelCase      =   target_dict.eos_index
									lowerCamelCase      =   len(target_dict.symbols							)
									lowerCamelCase      =   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__							)
									lowerCamelCase      =   target_dict.indices

									# fairseq has the <pad> and <s> switched
									lowerCamelCase      =   0
									lowerCamelCase      =   1
									with open(snake_case__			,					"""w"""			,					encoding="""utf-8"""							) as vocab_handle:
												json.dump(snake_case__			,					snake_case__							)
									lowerCamelCase      =   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__			,					)
									lowerCamelCase      =   True if config.feat_extract_norm == """layer""" else False
									lowerCamelCase      =   WavaVecaFeatureExtractor(
									    feature_size=1			,					sampling_rate=1_60_00			,					padding_value=0			,					do_normalize=snake_case__			,					return_attention_mask=snake_case__			,					)
									lowerCamelCase      =   WavaVecaProcessor(feature_extractor=snake_case__			,					tokenizer=snake_case__							)
									processor.save_pretrained(snake_case__							)

						lowerCamelCase      =   WavaVecaForCTC(snake_case__							)
			else:
						lowerCamelCase      =   WavaVecaForPreTraining(snake_case__							)

			if is_finetuned or is_seq_class:
						lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase      =   fairseq.checkpoint_utils.load_model_ensemble_and_task(
						    [checkpoint_path]			,					arg_overrides={"""data""": """/""".join(dict_path.split("""/"""							)[:-1]							)}							)
			else:
						lowerCamelCase      =   argparse.Namespace(task="""audio_pretraining"""							)
						lowerCamelCase      =   fairseq.tasks.setup_task(snake_case__							)

						lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase      =   fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]			,					task=snake_case__							)

			lowerCamelCase      =   model[0].eval()

			recursively_load_weights(snake_case__			,					snake_case__			,					not is_finetuned							)

			hf_wavavec.save_pretrained(snake_case__							)


if __name__ == "__main__":
					lowerCAmelCase				:     Union[str, Any]					=				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(
					    """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
					)
					parser.add_argument(
					    """--is_seq_class""",
					    action="""store_true""",
					    help="""Whether the model to convert is a fine-tuned sequence classification model or not""",
					)
					lowerCAmelCase				:     str					=				parser.parse_args()

					lowerCAmelCase				:     Any					=				not args.not_finetuned and not args.is_seq_class
					convert_wavaveca_checkpoint(
					    args.checkpoint_path,
					    args.pytorch_dump_folder_path,
					    args.config_path,
					    args.dict_path,
					    is_finetuned,
					    args.is_seq_class,
					)









"""simple docstring"""




def        a__					(							)		->   int:
			return 1



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else two_pence(x - 2							) + one_pence()



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else five_pence(x - 5							) + two_pence(snake_case__							)



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else ten_pence(x - 10							) + five_pence(snake_case__							)



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else twenty_pence(x - 20							) + ten_pence(snake_case__							)



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else fifty_pence(x - 50							) + twenty_pence(snake_case__							)



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else one_pound(x - 1_00							) + fifty_pence(snake_case__							)



def        a__					(							snake_case__							)		->   int:
			return 0 if x < 0 else two_pound(x - 2_00							) + one_pound(snake_case__							)



def        a__					(							snake_case__ = 2_00							)		->   int:
			return two_pound(snake_case__							)


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



