





"""simple docstring"""





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 		lowerCAmelCase_	(  lowercase_   :							Optional[int] ,      lowercase_   :							Optional[int] ,      lowercase_   :							int ,      lowercase_   :							Tuple		):

 '''simple docstring'''






 __SCREAMING_SNAKE_CASE :			Optional[Any]												=       ElectraConfig.from_json_file(__UpperCamelCase		)
 print(F'''Building PyTorch model from configuration: {config}'''		)

 if discriminator_or_generator == "discriminator":
  __SCREAMING_SNAKE_CASE :			int												=       ElectraForPreTraining(__UpperCamelCase		)
 elif discriminator_or_generator == "generator":
  __SCREAMING_SNAKE_CASE :			int												=       ElectraForMaskedLM(__UpperCamelCase		)
 else:
  raise ValueError('''The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''''		)

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

 # Save pytorch-model
 print(F'''Save PyTorch model to {pytorch_dump_path}'''		)
 torch.save(model.state_dict() ,      __UpperCamelCase		)


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
    )



"""simple docstring"""


import itertools



def     _lowerCamelCase(__UpperCamelCase       )				-> List[str]:
	return (
	    int("""""".join(combination[0:2]       )       ) * int("""""".join(combination[2:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	) or (
	    int("""""".join(combination[0]       )       ) * int("""""".join(combination[1:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	)



def     _lowerCamelCase()				-> Dict:
	return sum(
	    {
	        int("""""".join(pandigital[5:9]       )       )
	        for pandigital in itertools.permutations("""123456789"""       )
	        if is_combination_valid(__UpperCamelCase       )
	    }       )


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



