
import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()


def     UpperCamelCase      (					__lowerCamelCase  :				Tuple       ,      __lowerCamelCase  :				Tuple       ,      __lowerCamelCase  :				str       ,      __lowerCamelCase  :				str					):
       # Initialise PyTorch model
       snake_case :     Union[str, Any]           =   ElectraConfig.from_json_file(__lowerCamelCase					)
       print(f"""Building PyTorch model from configuration: {config}"""					)

       if discriminator_or_generator == "discriminator":
              snake_case :     Union[str, Any]           =   ElectraForPreTraining(__lowerCamelCase					)
       elif discriminator_or_generator == "generator":
              snake_case :     Optional[Any]           =   ElectraForMaskedLM(__lowerCamelCase					)
       else:
              raise ValueError("The discriminator_or_generator argument should be either 'discriminator' or 'generator'"					)

       # Load weights from tf checkpoint
       load_tf_weights_in_electra(
           __lowerCamelCase       ,      __lowerCamelCase       ,      __lowerCamelCase       ,      discriminator_or_generator=__lowerCamelCase					)

       # Save pytorch-model
       print(f"""Save PyTorch model to {pytorch_dump_path}"""					)
       torch.save(model.state_dict()       ,      __lowerCamelCase					)


if __name__ == "__main__":
   __lowerCamelCase							= argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
   )
   parser.add_argument(
       """--config_file""",
       default=None,
       type=str,
       required=True,
       help="""The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.""",
   )
   parser.add_argument(
       """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
   )
   parser.add_argument(
       """--discriminator_or_generator""",
       default=None,
       type=str,
       required=True,
       help=(
           """Whether to export the generator or the discriminator. Should be a string, either 'discriminator' or """
           """'generator'."""
       ),
   )
   __lowerCamelCase							= parser.parse_args()
   convert_tf_checkpoint_to_pytorch(
       args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
   )







import math
from itertools import permutations


def     UpperCamelCase      (					__lowerCamelCase  :				int					):

       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5       ,      int(math.sqrt(__lowerCamelCase					) + 1					)       ,      6					):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True


def     UpperCamelCase      (					__lowerCamelCase  :				int       ,      __lowerCamelCase  :				list					):
       snake_case       ,      snake_case :     List[str]           =   0, len(__lowerCamelCase					) - 1
       while left <= right:
              snake_case :     int           =   (left + right) // 2
              if prime_list[middle] == target:
                     return True
              elif prime_list[middle] < target:
                     snake_case :     Dict           =   middle + 1
              else:
                     snake_case :     Optional[int]           =   middle - 1

       return False


def     UpperCamelCase      (					):
       snake_case :     List[Any]           =   [n for n in range(1001       ,      10000       ,      2					) if is_prime(__lowerCamelCase					)]
       snake_case :     Dict           =   []

       for number in prime_list:
              snake_case :     Dict           =   []

              for prime_member in permutations(list(str(__lowerCamelCase					)					)					):
                     snake_case :     Dict           =   int("".join(__lowerCamelCase					)					)

                     if prime % 2 == 0:
                            continue

                     if search(__lowerCamelCase       ,      __lowerCamelCase					):
                            tmp_numbers.append(__lowerCamelCase					)

              tmp_numbers.sort()
              if len(__lowerCamelCase					) >= 3:
                     candidates.append(__lowerCamelCase					)

       snake_case :     Union[str, Any]           =   []
       for candidate in candidates:
              snake_case :     Dict           =   len(__lowerCamelCase					)
              snake_case :     Any           =   False

              for i in range(__lowerCamelCase					):
                     for j in range(i + 1       ,      __lowerCamelCase					):
                            for k in range(j + 1       ,      __lowerCamelCase					):
                                   if (
                                       abs(candidate[i] - candidate[j]					)
                                       == abs(candidate[j] - candidate[k]					)
                                       and len({candidate[i], candidate[j], candidate[k]}					) == 3
                                   ):
                                          passed.append(
                                              sorted([candidate[i], candidate[j], candidate[k]]					)					)
                                          snake_case :     Optional[Any]           =   True

                                   if found:
                                          break
                            if found:
                                   break
                     if found:
                            break

       snake_case :     Tuple           =   set()
       for seq in passed:
              answer.add("".join([str(__lowerCamelCase					) for i in seq]					)					)

       return max(int(__lowerCamelCase					) for x in answer					)


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





