






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     lowerCamelCase__				(   __lowerCamelCase      :					List[Any]  ,		__lowerCamelCase      :					int  ,		__lowerCamelCase      :					Any		):
  # Initialise PyTorch model
  __UpperCAmelCase							:     Optional[Any]									=  FNetConfig.from_json_file(__lowerCamelCase		)
  print(f"""Building PyTorch model from configuration: {config}"""		)
  __UpperCAmelCase							:     Dict									=  FNetForPreTraining(__lowerCamelCase		)

  __UpperCAmelCase							:     Optional[Any]									=  restore_checkpoint(__lowerCamelCase  ,		__lowerCamelCase		)
  __UpperCAmelCase							:     str									=  checkpoint_dict["""target"""]

  # Embeddings
  # Position IDs
  __UpperCAmelCase							:     Tuple									=  fnet_pretraining_model.state_dict()

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

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

    __UpperCAmelCase							:     str									=  torch.tensor(
        pretrained_model_params["""encoder"""][f"""feed_forward_{layer}"""]["""intermediate"""]["""kernel"""]		).T
    __UpperCAmelCase							:     Tuple									=  torch.tensor(
        pretrained_model_params["""encoder"""][f"""feed_forward_{layer}"""]["""intermediate"""]["""bias"""]		)

    __UpperCAmelCase							:     Optional[Any]									=  torch.tensor(
        pretrained_model_params["""encoder"""][f"""feed_forward_{layer}"""]["""output"""]["""kernel"""]		).T
    __UpperCAmelCase							:     Dict									=  torch.tensor(
        pretrained_model_params["""encoder"""][f"""feed_forward_{layer}"""]["""output"""]["""bias"""]		)

    __UpperCAmelCase							:     Union[str, Any]									=  torch.tensor(
        pretrained_model_params["""encoder"""][f"""encoder_{layer}"""]["""output_layer_norm"""]["""scale"""]		)
    __UpperCAmelCase							:     Dict									=  torch.tensor(
        pretrained_model_params["""encoder"""][f"""encoder_{layer}"""]["""output_layer_norm"""]["""bias"""]		)

  # Pooler Layers
  __UpperCAmelCase							:     List[Any]									=  torch.tensor(pretrained_model_params["""encoder"""]["""pooler"""]["""kernel"""]		).T
  __UpperCAmelCase							:     Any									=  torch.tensor(pretrained_model_params["""encoder"""]["""pooler"""]["""bias"""]		)

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

  # Seq Relationship Layers
  __UpperCAmelCase							:     Tuple									=  torch.tensor(
      pretrained_model_params["""classification"""]["""output_kernel"""]		)
  __UpperCAmelCase							:     Dict									=  torch.tensor(
      pretrained_model_params["""classification"""]["""output_bias"""]		)

  # Load State Dict
  fnet_pretraining_model.load_state_dict(__lowerCamelCase		)

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


if __name__ == "__main__":
       a		:	int      					=			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		:	List[str]      					=			parser.parse_args()
       convert_flax_checkpoint_to_pytorch(args.flax_checkpoint_path, args.fnet_config_file, args.save_path)










def     lowerCamelCase__				(   ):

  for a in range(300		):
    for b in range(a + 1  ,		400		):
      for c in range(b + 1  ,		500		):
        if (a + b + c) == 1000 and (a**2) + (b**2) == (c**2):
          return a * b * c

  return -1






def     lowerCamelCase__				(   ):

  for a in range(300		):
    for b in range(400		):
      __UpperCAmelCase							:     Optional[Any]									=  1000 - a - b
      if a < b < c and (a**2) + (b**2) == (c**2):
        return a * b * c

  return -1






def     lowerCamelCase__				(   ):
  import timeit

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


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


