

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 				__a							(       __A			,							__A			,							__A						):
    # Initialise PyTorch model
    SCREAMING_SNAKE_CASE__         =    FNetConfig.from_json_file(__A						)
    print(f"Building PyTorch model from configuration: {config}"						)
    SCREAMING_SNAKE_CASE__         =    FNetForPreTraining(__A						)

    SCREAMING_SNAKE_CASE__         =    restore_checkpoint(__A			,							__A						)
    SCREAMING_SNAKE_CASE__         =    checkpoint_dict["target"]

    # Embeddings
    # Position IDs
    SCREAMING_SNAKE_CASE__         =    fnet_pretraining_model.state_dict()

    SCREAMING_SNAKE_CASE__         =    state_dict["fnet.embeddings.position_ids"]
    SCREAMING_SNAKE_CASE__         =    {"fnet.embeddings.position_ids": position_ids}
    # Embedding Layers
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["word"]["embedding"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["position"]["embedding"][0]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["type"]["embedding"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["hidden_mapping_in"]["kernel"]						).T
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["hidden_mapping_in"]["bias"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["layer_norm"]["scale"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["layer_norm"]["bias"]						)

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

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

        SCREAMING_SNAKE_CASE__         =    torch.tensor(
            pretrained_model_params["encoder"][f"feed_forward_{layer}"]["output"]["kernel"]						).T
        SCREAMING_SNAKE_CASE__         =    torch.tensor(
            pretrained_model_params["encoder"][f"feed_forward_{layer}"]["output"]["bias"]						)

        SCREAMING_SNAKE_CASE__         =    torch.tensor(
            pretrained_model_params["encoder"][f"encoder_{layer}"]["output_layer_norm"]["scale"]						)
        SCREAMING_SNAKE_CASE__         =    torch.tensor(
            pretrained_model_params["encoder"][f"encoder_{layer}"]["output_layer_norm"]["bias"]						)

    # Pooler Layers
    SCREAMING_SNAKE_CASE__         =    torch.tensor(pretrained_model_params["encoder"]["pooler"]["kernel"]						).T
    SCREAMING_SNAKE_CASE__         =    torch.tensor(pretrained_model_params["encoder"]["pooler"]["bias"]						)

    # Masked LM Layers
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["predictions_dense"]["kernel"]						).T
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["predictions_dense"]["bias"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["predictions_layer_norm"]["scale"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["predictions_layer_norm"]["bias"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["encoder"]["embedder"]["word"]["embedding"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["predictions_output"]["output_bias"]						)
    SCREAMING_SNAKE_CASE__         =    torch.tensor(pretrained_model_params["predictions_output"]["output_bias"]						)

    # Seq Relationship Layers
    SCREAMING_SNAKE_CASE__         =    torch.tensor(
        pretrained_model_params["classification"]["output_kernel"]						)
    SCREAMING_SNAKE_CASE__         =    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)





A__										=      10**8





def 				__a							(       __A						):
    if n % 10 == 0:
        return False
    SCREAMING_SNAKE_CASE__         =    str(__A						)
    return s == s[::-1]





def 				__a							(       ):
    SCREAMING_SNAKE_CASE__         =    set()
    SCREAMING_SNAKE_CASE__         =    1
    SCREAMING_SNAKE_CASE__         =    5
    while sum_squares < LIMIT:
        SCREAMING_SNAKE_CASE__         =    first_square + 1
        while sum_squares < LIMIT:
            if is_palindrome(__A						):
                answer.add(__A						)
            last_square += 1
            sum_squares += last_square**2
        first_square += 1
        SCREAMING_SNAKE_CASE__         =    first_square**2 + (first_square + 1) ** 2

    return sum(__A						)


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


