
from itertools import permutations


def 					SCREAMING_SNAKE_CASE    (    a__ = 5						) ->						int:
				if gon_side < 3 or gon_side > 5:
								raise ValueError('''gon_side must be in the range [3, 5]'''						)

				# Since it's 16, we know 10 is on the outer ring
				# Put the big numbers at the end so that they are never the first number
				__a    							=					list(range(gon_side + 1		,					0		,					-1						)						)
				__a    							=					list(range(gon_side + 2		,					gon_side * 2 + 1						)						)

				for perm in permutations(small_numbers + big_numbers						):
								__a    							=					generate_gon_ring(a__		,					list(a__						)						)
								if is_magic_gon(a__						):
												return int(''''''.join(str(a__						) for n in numbers						)						)

				__a    							=					F"""Magic {gon_side}-gon ring is impossible"""
				raise ValueError(a__						)


def 					SCREAMING_SNAKE_CASE    (    a__		,					a__						) ->						list[int]:
				__a    							=					[0] * (gon_side * 3)
				__a    							=					perm[0:3]
				perm.append(perm[1]						)

				__a    							=					1 if gon_side < 5 else 2

				for i in range(1		,					len(a__						) // 3 + magic_number						):
								__a    							=					perm[2 * i + 1]
								__a    							=					result[3 * i - 1]
								__a    							=					perm[2 * i + 2]

				return result


def 					SCREAMING_SNAKE_CASE    (    a__						) ->						bool:
				if len(a__						) % 3 != 0:
								raise ValueError('''a gon ring should have a length that is a multiple of 3'''						)

				if min(numbers[::3]						) != numbers[0]:
								return False

				__a    							=					sum(numbers[:3]						)

				return all(sum(numbers[i : i + 3]						) == total for i in range(3		,					len(a__						)		,					3						)						)


if __name__ == "__main__":
					print(solution())

import argparse

import torch

from transformers import MraConfig, MraForMaskedLM


def 					__lowerCAmelCase    (    a__						) ->						Any:
				if "model" in orig_key:
								__a    							=					orig_key.replace('''model.'''		,					''''''						)
				if "norm1" in orig_key:
								__a    							=					orig_key.replace('''norm1'''		,					'''attention.output.LayerNorm'''						)
				if "norm2" in orig_key:
								__a    							=					orig_key.replace('''norm2'''		,					'''output.LayerNorm'''						)
				if "norm" in orig_key:
								__a    							=					orig_key.replace('''norm'''		,					'''LayerNorm'''						)
				if "transformer" in orig_key:
								__a    							=					orig_key.split('''.'''						)[0].split('''_'''						)[-1]
								__a    							=					orig_key.replace(F"""transformer_{layer_num}"""		,					F"""encoder.layer.{layer_num}"""						)
				if "mha.attn" in orig_key:
								__a    							=					orig_key.replace('''mha.attn'''		,					'''attention.self'''						)
				if "mha" in orig_key:
								__a    							=					orig_key.replace('''mha'''		,					'''attention'''						)
				if "W_q" in orig_key:
								__a    							=					orig_key.replace('''W_q'''		,					'''self.query'''						)
				if "W_k" in orig_key:
								__a    							=					orig_key.replace('''W_k'''		,					'''self.key'''						)
				if "W_v" in orig_key:
								__a    							=					orig_key.replace('''W_v'''		,					'''self.value'''						)
				if "ff.0" in orig_key:
								__a    							=					orig_key.replace('''ff.0'''		,					'''intermediate.dense'''						)
				if "ff.2" in orig_key:
								__a    							=					orig_key.replace('''ff.2'''		,					'''output.dense'''						)
				if "ff" in orig_key:
								__a    							=					orig_key.replace('''ff'''		,					'''output.dense'''						)
				if "mlm_class" in orig_key:
								__a    							=					orig_key.replace('''mlm.mlm_class'''		,					'''cls.predictions.decoder'''						)
				if "mlm" in orig_key:
								__a    							=					orig_key.replace('''mlm'''		,					'''cls.predictions.transform'''						)
				if "backbone.backbone.encoders" in orig_key:
								__a    							=					orig_key.replace('''backbone.backbone.encoders'''		,					'''encoder.layer'''						)
				if "cls" not in orig_key:
								__a    							=					'''mra.''' + orig_key

				return orig_key


def 					__lowerCAmelCase    (    a__		,					a__						) ->						Any:
				for key in orig_state_dict.copy().keys():
								__a    							=					orig_state_dict.pop(a__						)

								if ("pooler" in key) or ("sen_class" in key):
												continue
								else:
												__a    							=					val

				__a    							=					orig_state_dict['''cls.predictions.decoder.bias''']
				__a    							=					torch.arange(a__						).expand((1, -1)						) + 2

				return orig_state_dict


def 					__lowerCAmelCase    (    a__		,					a__		,					a__						) ->						List[Any]:
				__a    							=					torch.load(a__		,					map_location='''cpu'''						)['''model_state_dict''']
				__a    							=					MraConfig.from_json_file(a__						)
				__a    							=					MraForMaskedLM(a__						)

				__a    							=					convert_checkpoint_helper(config.max_position_embeddings		,					a__						)

				print(model.load_state_dict(a__						)						)
				model.eval()
				model.save_pretrained(a__						)

				print(F"""Checkpoint successfuly converted. Model saved at {pytorch_dump_path}"""						)


if __name__ == "__main__":
					A  :			Any     				=				argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--pytorch_model_path', default=None, type=str, required=True, help='Path to Mra pytorch checkpoint.'
					)
					parser.add_argument(
					    '--config_file',
					    default=None,
					    type=str,
					    required=True,
					    help='The json file for Mra model config.',
					)
					parser.add_argument(
					    '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
					)
					A  :			Tuple     				=				parser.parse_args()
					convert_mra_checkpoint(args.pytorch_model_path, args.config_file, args.pytorch_dump_path)