






'''simple docstring'''






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 							_SCREAMING_SNAKE_CASE	(					A	:							int	,		A	:							Dict	,		A	:							Any	)     ->			Tuple:







   """simple docstring"""
   # Initialise PyTorch model
   __snake_case					:   Dict  				=			FNetConfig.from_json_file(A	)
   print(F"""Building PyTorch model from configuration: {config}"""	)
   __snake_case					:   Optional[Any]  				=			FNetForPreTraining(A	)

   __snake_case					:   Any  				=			restore_checkpoint(A	,		A	)
   __snake_case					:   Optional[int]  				=			checkpoint_dict['target']

   # Embeddings
   # Position IDs
   __snake_case					:   Dict  				=			fnet_pretraining_model.state_dict()

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

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

      __snake_case					:   List[Any]  				=			torch.tensor(
          pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['intermediate']['kernel']	).T
      __snake_case					:   Any  				=			torch.tensor(
          pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['intermediate']['bias']	)

      __snake_case					:   Union[str, Any]  				=			torch.tensor(
          pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['output']['kernel']	).T
      __snake_case					:   Union[str, Any]  				=			torch.tensor(
          pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['output']['bias']	)

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

   # Pooler Layers
   __snake_case					:   Union[str, Any]  				=			torch.tensor(pretrained_model_params['encoder']['pooler']['kernel']	).T
   __snake_case					:   List[str]  				=			torch.tensor(pretrained_model_params['encoder']['pooler']['bias']	)

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

   # Seq Relationship Layers
   __snake_case					:   Optional[Any]  				=			torch.tensor(
       pretrained_model_params['classification']['output_kernel']	)
   __snake_case					:   Dict  				=			torch.tensor(
       pretrained_model_params['classification']['output_bias']	)

   # Load State Dict
   fnet_pretraining_model.load_state_dict(A	)

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


if __name__ == "__main__":
      __A     						= 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     						= parser.parse_args()
      convert_flax_checkpoint_to_pytorch(args.flax_checkpoint_path, args.fnet_config_file, args.save_path)







'''simple docstring'''






def 							_SCREAMING_SNAKE_CASE	(					)     ->			int:







   """simple docstring"""

   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 							_SCREAMING_SNAKE_CASE	(					)     ->			int:







   """simple docstring"""

   for a in range(3_00	):
      for b in range(4_00	):
         __snake_case					:   Optional[Any]  				=			10_00 - a - b
         if a < b < c and (a**2) + (b**2) == (c**2):
            return a * b * c

   return -1




def 							_SCREAMING_SNAKE_CASE	(					)     ->			None:







   """simple docstring"""
   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() = }''')