




import argparse

import torch
from flax.training.checkpoints import restore_checkpoint

from transformers import FNetConfig, FNetForPreTraining
from transformers.utils import logging


logging.set_verbosity_info()
def  snake_case_					(		SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )      ->			Dict:
							# Initialise PyTorch model
							lowercase__  :	List[str]        =							FNetConfig.from_json_file(SCREAMING_SNAKE_CASE_    )
							print(F"""Building PyTorch model from configuration: {config}"""    )
							lowercase__  :	str        =							FNetForPreTraining(SCREAMING_SNAKE_CASE_    )

							lowercase__  :	Optional[int]        =							restore_checkpoint(SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )
							lowercase__  :	Union[str, Any]        =							checkpoint_dict["target"]

							# Embeddings
							# Position IDs
							lowercase__  :	Union[str, Any]        =							fnet_pretraining_model.state_dict()

							lowercase__  :	Optional[int]        =							state_dict["fnet.embeddings.position_ids"]
							lowercase__  :	List[str]        =							{"fnet.embeddings.position_ids": position_ids}
							# Embedding Layers
							lowercase__  :	List[Any]        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["word"]["embedding"]    )
							lowercase__  :	List[Any]        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["position"]["embedding"][0]    )
							lowercase__  :	Tuple        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["type"]["embedding"]    )
							lowercase__  :	Tuple        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["hidden_mapping_in"]["kernel"]    ).T
							lowercase__  :	Optional[int]        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["hidden_mapping_in"]["bias"]    )
							lowercase__  :	Dict        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["layer_norm"]["scale"]    )
							lowercase__  :	Optional[Any]        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["layer_norm"]["bias"]    )

							# Encoder Layers
							for layer in range(config.num_hidden_layers    ):
														lowercase__  :	Tuple        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""encoder_{layer}"""]["mixing_layer_norm"]["scale"]    )
														lowercase__  :	Any        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""encoder_{layer}"""]["mixing_layer_norm"]["bias"]    )

														lowercase__  :	Optional[int]        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""feed_forward_{layer}"""]["intermediate"]["kernel"]    ).T
														lowercase__  :	Optional[int]        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""feed_forward_{layer}"""]["intermediate"]["bias"]    )

														lowercase__  :	str        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""feed_forward_{layer}"""]["output"]["kernel"]    ).T
														lowercase__  :	Optional[Any]        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""feed_forward_{layer}"""]["output"]["bias"]    )

														lowercase__  :	str        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""encoder_{layer}"""]["output_layer_norm"]["scale"]    )
														lowercase__  :	str        =							torch.tensor(
														    pretrained_model_params["encoder"][F"""encoder_{layer}"""]["output_layer_norm"]["bias"]    )

							# Pooler Layers
							lowercase__  :	Tuple        =							torch.tensor(pretrained_model_params["encoder"]["pooler"]["kernel"]    ).T
							lowercase__  :	int        =							torch.tensor(pretrained_model_params["encoder"]["pooler"]["bias"]    )

							# Masked LM Layers
							lowercase__  :	str        =							torch.tensor(
							    pretrained_model_params["predictions_dense"]["kernel"]    ).T
							lowercase__  :	Union[str, Any]        =							torch.tensor(
							    pretrained_model_params["predictions_dense"]["bias"]    )
							lowercase__  :	List[Any]        =							torch.tensor(
							    pretrained_model_params["predictions_layer_norm"]["scale"]    )
							lowercase__  :	Union[str, Any]        =							torch.tensor(
							    pretrained_model_params["predictions_layer_norm"]["bias"]    )
							lowercase__  :	Optional[Any]        =							torch.tensor(
							    pretrained_model_params["encoder"]["embedder"]["word"]["embedding"]    )
							lowercase__  :	List[Any]        =							torch.tensor(
							    pretrained_model_params["predictions_output"]["output_bias"]    )
							lowercase__  :	int        =							torch.tensor(pretrained_model_params["predictions_output"]["output_bias"]    )

							# Seq Relationship Layers
							lowercase__  :	int        =							torch.tensor(
							    pretrained_model_params["classification"]["output_kernel"]    )
							lowercase__  :	str        =							torch.tensor(
							    pretrained_model_params["classification"]["output_bias"]    )

							# Load State Dict
							fnet_pretraining_model.load_state_dict(SCREAMING_SNAKE_CASE_    )

							# Save PreTrained
							print(F"""Saving pretrained model to {save_path}"""    )
							fnet_pretraining_model.save_pretrained(SCREAMING_SNAKE_CASE_    )


if __name__ == "__main__":
						__a  :		List[str]		     =   argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--flax_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
						)
						parser.add_argument(
						    '''--fnet_config_file''',
						    default=None,
						    type=str,
						    required=True,
						    help=(
						        '''The config json file corresponding to the pre-trained FNet model. \n'''
						        '''This specifies the model architecture.'''
						    ),
						)
						parser.add_argument('''--save_path''', default=None, type=str, required=True, help='''Path to the output model.''')
						__a  :		str		     =   parser.parse_args()
						convert_flax_checkpoint_to_pytorch(args.flax_checkpoint_path, args.fnet_config_file, args.save_path)





def  snake_case_					(		)      ->			int:

							for a in range(3_00    ):
														for b in range(a + 1    ,4_00    ):
																					for c in range(b + 1    ,5_00    ):
																												if (a + b + c) == 10_00 and (a**2) + (b**2) == (c**2):
																																			return a * b * c

							return -1
def  snake_case_					(		)      ->			int:

							for a in range(3_00    ):
														for b in range(4_00    ):
																					lowercase__  :	Dict        =							10_00 - a - b
																					if a < b < c and (a**2) + (b**2) == (c**2):
																												return a * b * c

							return -1
def  snake_case_					(		)      ->			None:
							import timeit

							print(
							    timeit.timeit("solution()"    ,setup="from __main__ import solution"    ,number=10_00    )    )
							print(
							    timeit.timeit(
							        "solution_fast()"    ,setup="from __main__ import solution_fast"    ,number=10_00    )    )


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