





"""simple docstring"""






import argparse

import torch

from transformers import (
    EncodecConfig,
    EncodecFeatureExtractor,
    EncodecModel,
    logging,
)


# checkpoints downloaded from:
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th


logging.set_verbosity_info()
A			      =	logging.get_logger('''transformers.models.encodec''')

A			      =	{
    '''quantizer.vq.layers.*._codebook.inited''': '''quantizer.layers.*.codebook.inited''',
    '''quantizer.vq.layers.*._codebook.cluster_size''': '''quantizer.layers.*.codebook.cluster_size''',
    '''quantizer.vq.layers.*._codebook.embed''': '''quantizer.layers.*.codebook.embed''',
    '''quantizer.vq.layers.*._codebook.embed_avg''': '''quantizer.layers.*.codebook.embed_avg''',
}
A			      =	{
    '''encoder.model.0.conv.conv''': '''encoder.layers.0.conv''',
    '''encoder.model.1.block.1.conv.conv''': '''encoder.layers.1.block.1.conv''',
    '''encoder.model.1.block.3.conv.conv''': '''encoder.layers.1.block.3.conv''',
    '''encoder.model.1.shortcut.conv.conv''': '''encoder.layers.1.shortcut.conv''',
    '''encoder.model.3.conv.conv''': '''encoder.layers.3.conv''',
    '''encoder.model.4.block.1.conv.conv''': '''encoder.layers.4.block.1.conv''',
    '''encoder.model.4.block.3.conv.conv''': '''encoder.layers.4.block.3.conv''',
    '''encoder.model.4.shortcut.conv.conv''': '''encoder.layers.4.shortcut.conv''',
    '''encoder.model.6.conv.conv''': '''encoder.layers.6.conv''',
    '''encoder.model.7.block.1.conv.conv''': '''encoder.layers.7.block.1.conv''',
    '''encoder.model.7.block.3.conv.conv''': '''encoder.layers.7.block.3.conv''',
    '''encoder.model.7.shortcut.conv.conv''': '''encoder.layers.7.shortcut.conv''',
    '''encoder.model.9.conv.conv''': '''encoder.layers.9.conv''',
    '''encoder.model.10.block.1.conv.conv''': '''encoder.layers.10.block.1.conv''',
    '''encoder.model.10.block.3.conv.conv''': '''encoder.layers.10.block.3.conv''',
    '''encoder.model.10.shortcut.conv.conv''': '''encoder.layers.10.shortcut.conv''',
    '''encoder.model.12.conv.conv''': '''encoder.layers.12.conv''',
    '''encoder.model.13.lstm''': '''encoder.layers.13.lstm''',
    '''encoder.model.15.conv.conv''': '''encoder.layers.15.conv''',
}
A			      =	{
    '''encoder.model.0.conv.norm''': '''encoder.layers.0.norm''',
    '''encoder.model.1.block.1.conv.norm''': '''encoder.layers.1.block.1.norm''',
    '''encoder.model.1.block.3.conv.norm''': '''encoder.layers.1.block.3.norm''',
    '''encoder.model.1.shortcut.conv.norm''': '''encoder.layers.1.shortcut.norm''',
    '''encoder.model.3.conv.norm''': '''encoder.layers.3.norm''',
    '''encoder.model.4.block.1.conv.norm''': '''encoder.layers.4.block.1.norm''',
    '''encoder.model.4.block.3.conv.norm''': '''encoder.layers.4.block.3.norm''',
    '''encoder.model.4.shortcut.conv.norm''': '''encoder.layers.4.shortcut.norm''',
    '''encoder.model.6.conv.norm''': '''encoder.layers.6.norm''',
    '''encoder.model.7.block.1.conv.norm''': '''encoder.layers.7.block.1.norm''',
    '''encoder.model.7.block.3.conv.norm''': '''encoder.layers.7.block.3.norm''',
    '''encoder.model.7.shortcut.conv.norm''': '''encoder.layers.7.shortcut.norm''',
    '''encoder.model.9.conv.norm''': '''encoder.layers.9.norm''',
    '''encoder.model.10.block.1.conv.norm''': '''encoder.layers.10.block.1.norm''',
    '''encoder.model.10.block.3.conv.norm''': '''encoder.layers.10.block.3.norm''',
    '''encoder.model.10.shortcut.conv.norm''': '''encoder.layers.10.shortcut.norm''',
    '''encoder.model.12.conv.norm''': '''encoder.layers.12.norm''',
    '''encoder.model.15.conv.norm''': '''encoder.layers.15.norm''',
}
A			      =	{
    '''decoder.model.0.conv.conv''': '''decoder.layers.0.conv''',
    '''decoder.model.1.lstm''': '''decoder.layers.1.lstm''',
    '''decoder.model.3.convtr.convtr''': '''decoder.layers.3.conv''',
    '''decoder.model.4.block.1.conv.conv''': '''decoder.layers.4.block.1.conv''',
    '''decoder.model.4.block.3.conv.conv''': '''decoder.layers.4.block.3.conv''',
    '''decoder.model.4.shortcut.conv.conv''': '''decoder.layers.4.shortcut.conv''',
    '''decoder.model.6.convtr.convtr''': '''decoder.layers.6.conv''',
    '''decoder.model.7.block.1.conv.conv''': '''decoder.layers.7.block.1.conv''',
    '''decoder.model.7.block.3.conv.conv''': '''decoder.layers.7.block.3.conv''',
    '''decoder.model.7.shortcut.conv.conv''': '''decoder.layers.7.shortcut.conv''',
    '''decoder.model.9.convtr.convtr''': '''decoder.layers.9.conv''',
    '''decoder.model.10.block.1.conv.conv''': '''decoder.layers.10.block.1.conv''',
    '''decoder.model.10.block.3.conv.conv''': '''decoder.layers.10.block.3.conv''',
    '''decoder.model.10.shortcut.conv.conv''': '''decoder.layers.10.shortcut.conv''',
    '''decoder.model.12.convtr.convtr''': '''decoder.layers.12.conv''',
    '''decoder.model.13.block.1.conv.conv''': '''decoder.layers.13.block.1.conv''',
    '''decoder.model.13.block.3.conv.conv''': '''decoder.layers.13.block.3.conv''',
    '''decoder.model.13.shortcut.conv.conv''': '''decoder.layers.13.shortcut.conv''',
    '''decoder.model.15.conv.conv''': '''decoder.layers.15.conv''',
}
A			      =	{
    '''decoder.model.0.conv.norm''': '''decoder.layers.0.norm''',
    '''decoder.model.3.convtr.norm''': '''decoder.layers.3.norm''',
    '''decoder.model.4.block.1.conv.norm''': '''decoder.layers.4.block.1.norm''',
    '''decoder.model.4.block.3.conv.norm''': '''decoder.layers.4.block.3.norm''',
    '''decoder.model.4.shortcut.conv.norm''': '''decoder.layers.4.shortcut.norm''',
    '''decoder.model.6.convtr.norm''': '''decoder.layers.6.norm''',
    '''decoder.model.7.block.1.conv.norm''': '''decoder.layers.7.block.1.norm''',
    '''decoder.model.7.block.3.conv.norm''': '''decoder.layers.7.block.3.norm''',
    '''decoder.model.7.shortcut.conv.norm''': '''decoder.layers.7.shortcut.norm''',
    '''decoder.model.9.convtr.norm''': '''decoder.layers.9.norm''',
    '''decoder.model.10.block.1.conv.norm''': '''decoder.layers.10.block.1.norm''',
    '''decoder.model.10.block.3.conv.norm''': '''decoder.layers.10.block.3.norm''',
    '''decoder.model.10.shortcut.conv.norm''': '''decoder.layers.10.shortcut.norm''',
    '''decoder.model.12.convtr.norm''': '''decoder.layers.12.norm''',
    '''decoder.model.13.block.1.conv.norm''': '''decoder.layers.13.block.1.norm''',
    '''decoder.model.13.block.3.conv.norm''': '''decoder.layers.13.block.3.norm''',
    '''decoder.model.13.shortcut.conv.norm''': '''decoder.layers.13.shortcut.norm''',
    '''decoder.model.15.conv.norm''': '''decoder.layers.15.norm''',
}
A			      =	{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
}
A			      =	{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_ENCODER_48K,
    **MAPPING_DECODER,
    **MAPPING_DECODER_48K,
}
A			      =	[]
A			      =	[]

def      __A   (      a_    :Optional[Any] ,							a_    :Tuple ,							a_    :str ,							a_    :List[str] ,							a_    :int)		->		int:
				for attribute in key.split('''.'''):
								__a			:    List[Any]      							=	getattr(a_ ,							a_)

				if weight_type is not None:
								__a			:    List[str]      							=	getattr(a_ ,							a_).shape
				else:
								__a			:    Tuple      							=	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":
								__a			:    int      							=	value
				elif weight_type == "weight_g":
								__a			:    int      							=	value
				elif weight_type == "weight_v":
								__a			:    Any      							=	value
				elif weight_type == "bias":
								__a			:    Optional[int]      							=	value
				elif weight_type == "running_mean":
								__a			:    List[str]      							=	value
				elif weight_type == "running_var":
								__a			:    Optional[int]      							=	value
				elif weight_type == "num_batches_tracked":
								__a			:    Dict      							=	value
				elif weight_type == "weight_ih_l0":
								__a			:    Any      							=	value
				elif weight_type == "weight_hh_l0":
								__a			:    Union[str, Any]      							=	value
				elif weight_type == "bias_ih_l0":
								__a			:    Optional[int]      							=	value
				elif weight_type == "bias_hh_l0":
								__a			:    Any      							=	value
				elif weight_type == "weight_ih_l1":
								__a			:    Union[str, Any]      							=	value
				elif weight_type == "weight_hh_l1":
								__a			:    Dict      							=	value
				elif weight_type == "bias_ih_l1":
								__a			:    List[str]      							=	value
				elif weight_type == "bias_hh_l1":
								__a			:    Optional[int]      							=	value
				else:
								__a			:    Dict      							=	value

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

def      __A   (      a_    :Dict ,							a_    :Union[str, Any])		->		Dict:
				for key in ignore_keys:
								if key.endswith('''.*'''):
												if name.startswith(key[:-1]):
																return True
								elif ".*." in key:
												__a							,    __a			:    Optional[Any]      							=	key.split('''.*.''')
												if prefix in name and suffix in name:
																return True
								elif key in name:
												return True
				return False

def      __A   (      a_    :Any ,							a_    :str ,							a_    :Optional[Any])		->		Union[str, Any]:
				__a			:    Optional[Any]      							=	[]

				if model_name == "encodec_24khz" or "encodec_32khz":
								__a			:    str      							=	MAPPING_24K
				elif model_name == "encodec_48khz":
								__a			:    List[Any]      							=	MAPPING_48K
				else:
								raise ValueError(F"""Unsupported model: {model_name}""")

				for name, value in orig_dict.items():
								if should_ignore(a_ ,							a_):
												logger.info(F"""{name} was ignored""")
												continue

								__a			:    Optional[Any]      							=	False
								for key, mapped_key in MAPPING.items():
												if "*" in key:
																__a							,    __a			:    Dict      							=	key.split('''.*.''')
																if prefix in name and suffix in name:
																				__a			:    Dict      							=	suffix

												if key in name:
																# HACK otherwise .embed gets initialized with .embed_avg too
																if key.endswith('''embed''') and name.endswith('''embed_avg'''):
																				continue

																__a			:    Optional[int]      							=	True
																if "*" in mapped_key:
																				__a			:    List[Any]      							=	name.split(a_)[0].split('''.''')[-2]
																				__a			:    Union[str, Any]      							=	mapped_key.replace('''*''' ,							a_)
																if "weight_g" in name:
																				__a			:    Tuple      							=	'''weight_g'''
																elif "weight_v" in name:
																				__a			:    Optional[Any]      							=	'''weight_v'''
																elif "weight_ih_l0" in name:
																				__a			:    Union[str, Any]      							=	'''weight_ih_l0'''
																elif "weight_hh_l0" in name:
																				__a			:    Tuple      							=	'''weight_hh_l0'''
																elif "bias_ih_l0" in name:
																				__a			:    List[str]      							=	'''bias_ih_l0'''
																elif "bias_hh_l0" in name:
																				__a			:    str      							=	'''bias_hh_l0'''
																elif "weight_ih_l1" in name:
																				__a			:    int      							=	'''weight_ih_l1'''
																elif "weight_hh_l1" in name:
																				__a			:    Optional[int]      							=	'''weight_hh_l1'''
																elif "bias_ih_l1" in name:
																				__a			:    Tuple      							=	'''bias_ih_l1'''
																elif "bias_hh_l1" in name:
																				__a			:    List[str]      							=	'''bias_hh_l1'''
																elif "bias" in name:
																				__a			:    Optional[int]      							=	'''bias'''
																elif "weight" in name:
																				__a			:    str      							=	'''weight'''
																elif "running_mean" in name:
																				__a			:    int      							=	'''running_mean'''
																elif "running_var" in name:
																				__a			:    Optional[Any]      							=	'''running_var'''
																elif "num_batches_tracked" in name:
																				__a			:    List[Any]      							=	'''num_batches_tracked'''
																else:
																				__a			:    Tuple      							=	None
																set_recursively(a_ ,							a_ ,							a_ ,							a_ ,							a_)
												continue
								if not is_used:
												unused_weights.append(a_)

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

@torch.no_grad()
def      __A   (      a_    :int ,							a_    :List[Any] ,							a_    :Optional[Any] ,							a_    :Any=None ,							a_    :int=None ,							)		->		List[Any]:
				if config_path is not None:
								__a			:    Any      							=	EncodecConfig.from_pretrained(a_)
				else:
								__a			:    Dict      							=	EncodecConfig()

				if model_name == "encodec_24khz":
								pass  # config is already correct
				elif model_name == "encodec_32khz":
								__a			:    int      							=	[8, 5, 4, 4]
								__a			:    List[Any]      							=	[2.2]
								__a			:    List[Any]      							=	64
								__a			:    Tuple      							=	3_20_00
								__a			:    str      							=	20_48
								__a			:    Optional[int]      							=	False
								__a			:    List[Any]      							=	False
								__a			:    str      							=	False
				elif model_name == "encodec_48khz":
								__a			:    List[str]      							=	[8, 5, 4, 2]
								__a			:    Dict      							=	[3.0, 6.0, 1_2.0, 2_4.0]
								__a			:    Optional[int]      							=	4_80_00
								__a			:    List[Any]      							=	2
								__a			:    Optional[int]      							=	False
								__a			:    Dict      							=	'''time_group_norm'''
								__a			:    Optional[int]      							=	True
								__a			:    Any      							=	1.0
								__a			:    Optional[int]      							=	0.0_1
				else:
								raise ValueError(F"""Unknown model name: {model_name}""")

				__a			:    Optional[Any]      							=	EncodecModel(a_)

				__a			:    Dict      							=	EncodecFeatureExtractor(
				    feature_size=config.audio_channels ,							sampling_rate=config.sampling_rate ,							chunk_length_s=config.chunk_length_s ,							overlap=config.overlap ,							)
				feature_extractor.save_pretrained(a_)

				__a			:    int      							=	torch.load(a_)
				if "best_state" in original_checkpoint:
								# we might have a training state saved, in which case discard the yaml results and just retain the weights
								__a			:    List[str]      							=	original_checkpoint['''best_state''']
				recursively_load_weights(a_ ,							a_ ,							a_)
				model.save_pretrained(a_)

				if repo_id:
								print('''Pushing to the hub...''')
								feature_extractor.push_to_hub(a_)
								model.push_to_hub(a_)


if __name__ == "__main__":
		A			      =	argparse.ArgumentParser()
		parser.add_argument(
		    '''--model''',
		    default='''encodec_24khz''',
		    type=str,
		    help='''The model to convert. Should be one of \'encodec_24khz\', \'encodec_32khz\', \'encodec_48khz\'.''',
		)
		parser.add_argument('''--checkpoint_path''', required=True, default=None, type=str, help='''Path to original checkpoint''')
		parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', required=True, default=None, type=str, help='''Path to the output PyTorch model.'''
		)
		parser.add_argument(
		    '''--push_to_hub''', default=None, type=str, help='''Where to upload the converted model on the 🤗 hub.'''
		)

		A			      =	parser.parse_args()
		convert_checkpoint(
		    args.model,
		    args.checkpoint_path,
		    args.pytorch_dump_folder_path,
		    args.config_path,
		    args.push_to_hub,
		)

def  __lowerCamelCase					( _lowercase = 50000000			)       ->      int:
     UpperCamelCase						    =					set()
     UpperCamelCase						    =					int((limit - 24) ** (1 / 2)			)

     UpperCamelCase						    =					set(range(3						,     prime_square_limit + 1						,     2			)			)
     primes.add(2			)
     for p in range(3						,     prime_square_limit + 1						,     2			):
          if p not in primes:
               continue
          primes.difference_update(set(range(p * p						,     prime_square_limit + 1						,     _lowercase			)			)			)

     for primea in primes:
          UpperCamelCase						    =					primea * primea
          for primea in primes:
               UpperCamelCase						    =					primea * primea * primea
               if square + cube >= limit - 16:
                    break
               for primea in primes:
                    UpperCamelCase						    =					primea * primea * primea * primea
                    UpperCamelCase						    =					square + cube + tetr
                    if total >= limit:
                         break
                    ret.add(_lowercase			)

     return len(_lowercase			)


if __name__ == "__main__":
 print(F"{solution() = }")


