


'''simple docstring'''
import sys

__SCREAMING_SNAKE_CASE					:				List[Any]									=		(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)







def       a_				(	UpperCamelCase_ ):
							A_			    =		1
							for digit in s:
														product *= int(UpperCamelCase_ )
							return product







def       a_				(	UpperCamelCase_ = N ):
							A_			    =		-sys.maxsize - 1
							A_			    =		n[:1_3]
							A_			    =		1_3
							while cur_index < len(UpperCamelCase_ ) - 1_3:
														if int(n[cur_index] ) >= int(substr[0] ):
																					A_			    =		substr[1:] + n[cur_index]
																					cur_index += 1
														else:
																					A_			    =		max(UpperCamelCase_						,  str_eval(UpperCamelCase_ ) )
																					A_			    =		n[cur_index : cur_index + 1_3]
																					cur_index += 1_3
							return largest_product


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









'''simple docstring'''
import argparse

import torch

from transformers import BlenderbotConfig, BlenderbotForConditionalGeneration
from transformers.utils import logging


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

__SCREAMING_SNAKE_CASE					:				Tuple									=		[
    ['''attention''', '''attn'''],
    ['''encoder_attention''', '''encoder_attn'''],
    ['''q_lin''', '''q_proj'''],
    ['''k_lin''', '''k_proj'''],
    ['''v_lin''', '''v_proj'''],
    ['''out_lin''', '''out_proj'''],
    ['''norm_embeddings''', '''layernorm_embedding'''],
    ['''position_embeddings''', '''embed_positions'''],
    ['''embeddings''', '''embed_tokens'''],
    ['''ffn.lin''', '''fc'''],
]







def       a_				(	UpperCamelCase_ ):
							if k == "embeddings.weight":
														return "shared.weight"

							for parlai_name, hf_name in PATTERNS:
														A_			    =		k.replace(UpperCamelCase_						,  UpperCamelCase_ )

							if k.startswith("encoder" ):
														A_			    =		k.replace(".attn"						,  ".self_attn" )
														A_			    =		k.replace("norm1"						,  "self_attn_layer_norm" )
														A_			    =		k.replace("norm2"						,  "final_layer_norm" )
							elif k.startswith("decoder" ):
														A_			    =		k.replace("norm1"						,  "self_attn_layer_norm" )
														A_			    =		k.replace("norm2"						,  "encoder_attn_layer_norm" )
														A_			    =		k.replace("norm3"						,  "final_layer_norm" )
							return k







def       a_				(	UpperCamelCase_ ):
							A_			    =		[
							    "model.encoder.layernorm_embedding.weight",
							    "model.encoder.layernorm_embedding.bias",
							    "model.decoder.layernorm_embedding.weight",
							    "model.decoder.layernorm_embedding.bias",
							]
							for k in keys:
														A_			    =		sd.pop(UpperCamelCase_ )
														A_			    =		k.replace("layernorm_embedding"						,  "layer_norm" )
														assert new_k not in sd
														A_			    =		v


__SCREAMING_SNAKE_CASE					:				Union[str, Any]									=		['''START''']







@torch.no_grad()
def       a_				(	UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ ):
							A_			    =		torch.load(UpperCamelCase_						,  map_location="cpu" )
							A_			    =		model["model"]
							A_			    =		BlenderbotConfig.from_json_file(UpperCamelCase_ )
							A_			    =		BlenderbotForConditionalGeneration(UpperCamelCase_ )
							A_			    =		m.model.state_dict().keys()
							A_			    =		[]
							A_			    =		{}
							for k, v in sd.items():
														if k in IGNORE_KEYS:
																					continue

														A_			    =		rename_state_dict_key(UpperCamelCase_ )
														if new_k not in valid_keys:
																					failures.append([k, new_k] )
														else:
																					A_			    =		v
							if cfg.normalize_before:  # Blenderbot-3B checkpoints. Rename layernorm_embedding -> layer_norm
														rename_layernorm_keys(UpperCamelCase_ )
							m.model.load_state_dict(UpperCamelCase_						,  strict=UpperCamelCase_ )
							m.half()
							m.save_pretrained(UpperCamelCase_ )


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE					:				Union[str, Any]									=		argparse.ArgumentParser()
							# Required parameters
							parser.add_argument('''--src_path''', type=str, help='''like blenderbot-model.bin''')
							parser.add_argument('''--save_dir''', default='''hf_blenderbot''', type=str, help='''Where to save converted model.''')
							parser.add_argument(
							    '''--hf_config_json''', default='''blenderbot-3b-config.json''', type=str, help='''Path to config to use'''
							)
							__SCREAMING_SNAKE_CASE					:				List[Any]									=		parser.parse_args()
							convert_parlai_checkpoint(args.src_path, args.save_dir, args.hf_config_json)





