




from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TFRoFormerForCausalLM,
      TFRoFormerForMaskedLM,
      TFRoFormerForMultipleChoice,
      TFRoFormerForQuestionAnswering,
      TFRoFormerForSequenceClassification,
      TFRoFormerForTokenClassification,
      TFRoFormerModel,
  )
  from transformers.models.roformer.modeling_tf_roformer import (
      TFRoFormerSelfAttention,
      TFRoFormerSinusoidalPositionalEmbedding,
  )







class 						lowercase							:

     def __init__(  self		,     _a		,     _a=13		,     _a=7		,     _a=True		,     _a=True		,     _a=True		,     _a=True		,     _a=99		,     _a=32		,     _a=2		,     _a=4		,     _a=37		,     _a="gelu"		,     _a=0.1		,     _a=0.1		,     _a=512		,     _a=16		,     _a=2		,     _a=0.02		,     _a=3		,     _a=4		,     _a=None		,     )						->							Optional[int]:
           _A							:     Tuple			=						parent
           _A							:     str			=						13
           _A							:     int			=						7
           _A							:     Dict			=						True
           _A							:     Optional[int]			=						True
           _A							:     str			=						True
           _A							:     Any			=						True
           _A							:     str			=						99
           _A							:     int			=						32
           _A							:     Any			=						2
           _A							:     Union[str, Any]			=						4
           _A							:     List[str]			=						37
           _A							:     Tuple			=						"""gelu"""
           _A							:     Optional[Any]			=						0.1
           _A							:     List[str]			=						0.1
           _A							:     Any			=						512
           _A							:     Union[str, Any]			=						16
           _A							:     Optional[Any]			=						2
           _A							:     Union[str, Any]			=						0.02
           _A							:     str			=						3
           _A							:     Optional[Any]			=						4
           _A							:     Tuple			=						None

     def 					a__	(  self				)						->							Optional[int]:
           _A							:     Any			=						ids_tensor([self.batch_size, self.seq_length]		,     self.vocab_size				)

           _A							:     Union[str, Any]			=						None
           if self.use_input_mask:
                 _A							:     Dict			=						random_attention_mask([self.batch_size, self.seq_length]				)

           _A							:     List[Any]			=						None
           if self.use_token_type_ids:
                 _A							:     Optional[int]			=						ids_tensor([self.batch_size, self.seq_length]		,     self.type_vocab_size				)

           _A							:     Union[str, Any]			=						None
           _A							:     List[str]			=						None
           _A							:     Any			=						None
           if self.use_labels:
                 _A							:     Optional[Any]			=						ids_tensor([self.batch_size]		,     self.type_sequence_label_size				)
                 _A							:     List[str]			=						ids_tensor([self.batch_size, self.seq_length]		,     self.num_labels				)
                 _A							:     Tuple			=						ids_tensor([self.batch_size]		,     self.num_choices				)

           _A							:     Union[str, Any]			=						RoFormerConfig(
               vocab_size=self.vocab_size		,     hidden_size=self.hidden_size		,     num_hidden_layers=self.num_hidden_layers		,     num_attention_heads=self.num_attention_heads		,     intermediate_size=self.intermediate_size		,     hidden_act=self.hidden_act		,     hidden_dropout_prob=self.hidden_dropout_prob		,     attention_probs_dropout_prob=self.attention_probs_dropout_prob		,     max_position_embeddings=self.max_position_embeddings		,     type_vocab_size=self.type_vocab_size		,     initializer_range=self.initializer_range		,     return_dict=_a		,     )

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							str:
           _A							:     List[Any]			=						TFRoFormerModel(config=_a				)
           _A							:     Dict			=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

           _A							:     Optional[Any]			=						[input_ids, input_mask]
           _A							:     Optional[int]			=						model(_a				)

           _A							:     Tuple			=						model(_a				)

           self.parent.assertEqual(result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)				)

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							Dict:
           _A							:     List[str]			=						True
           _A							:     List[str]			=						TFRoFormerForCausalLM(config=_a				)
           _A							:     Optional[Any]			=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }
           _A							:     int			=						model(_a				)["""logits"""]
           self.parent.assertListEqual(
               list(prediction_scores.numpy().shape				)		,     [self.batch_size, self.seq_length, self.vocab_size]				)

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							Any:
           _A							:     Optional[int]			=						TFRoFormerForMaskedLM(config=_a				)
           _A							:     Optional[int]			=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }
           _A							:     Dict			=						model(_a				)
           self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.vocab_size)				)

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							Optional[Any]:
           _A							:     str			=						self.num_labels
           _A							:     Tuple			=						TFRoFormerForSequenceClassification(config=_a				)
           _A							:     Dict			=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }

           _A							:     List[Any]			=						model(_a				)
           self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_labels)				)

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							List[Any]:
           _A							:     int			=						self.num_choices
           _A							:     Dict			=						TFRoFormerForMultipleChoice(config=_a				)
           _A							:     str			=						tf.tile(tf.expand_dims(_a		,     1				)		,     (1, self.num_choices, 1)				)
           _A							:     List[str]			=						tf.tile(tf.expand_dims(_a		,     1				)		,     (1, self.num_choices, 1)				)
           _A							:     Dict			=						tf.tile(tf.expand_dims(_a		,     1				)		,     (1, self.num_choices, 1)				)
           _A							:     List[str]			=						{
               """input_ids""": multiple_choice_inputs_ids,
               """attention_mask""": multiple_choice_input_mask,
               """token_type_ids""": multiple_choice_token_type_ids,
           }
           _A							:     int			=						model(_a				)
           self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_choices)				)

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							Union[str, Any]:
           _A							:     List[str]			=						self.num_labels
           _A							:     Union[str, Any]			=						TFRoFormerForTokenClassification(config=_a				)
           _A							:     Any			=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }
           _A							:     List[Any]			=						model(_a				)
           self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.num_labels)				)

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							List[str]:
           _A							:     List[Any]			=						TFRoFormerForQuestionAnswering(config=_a				)
           _A							:     Optional[int]			=						{
               """input_ids""": input_ids,
               """attention_mask""": input_mask,
               """token_type_ids""": token_type_ids,
           }

           _A							:     Union[str, Any]			=						model(_a				)
           self.parent.assertEqual(result.start_logits.shape		,     (self.batch_size, self.seq_length)				)
           self.parent.assertEqual(result.end_logits.shape		,     (self.batch_size, self.seq_length)				)



     def 					a__	(  self				)						->							List[str]:
           _A							:     Any			=						self.prepare_config_and_inputs()
           (
               (
               _A     
           )			,   (
               _A     
           )			,   (
               _A     
           )			,   (
               _A     
           )			,   (
               _A     
           )			,   (
               _A     
           )			,   (
               _A     
           )			,        
           )							:     Tuple			=						config_and_inputs
           _A							:     List[Any]			=						{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
           return config, inputs_dict







@require_tf
class 						lowercase							(   __a,__a,unittest.TestCase		):
     _a							 =						(
         (
             TFRoFormerModel,
             TFRoFormerForCausalLM,
             TFRoFormerForMaskedLM,
             TFRoFormerForQuestionAnswering,
             TFRoFormerForSequenceClassification,
             TFRoFormerForTokenClassification,
             TFRoFormerForMultipleChoice,
         )
         if is_tf_available()
         else ()
     )
     _a							 =						(
         {
             """feature-extraction""": TFRoFormerModel,
             """fill-mask""": TFRoFormerForMaskedLM,
             """question-answering""": TFRoFormerForQuestionAnswering,
             """text-classification""": TFRoFormerForSequenceClassification,
             """text-generation""": TFRoFormerForCausalLM,
             """token-classification""": TFRoFormerForTokenClassification,
             """zero-shot""": TFRoFormerForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )

     _a							 =						False
     _a							 =						False

     def 					a__	(  self		,     _a		,     _a		,     _a		,     _a		,     _a				)						->							str:

           if pipeline_test_casse_name == "TextGenerationPipelineTests":
                 return True

           return False

     def 					a__	(  self				)						->							str:
           _A							:     Any			=						TFRoFormerModelTester(self				)
           _A							:     Optional[int]			=						ConfigTester(self		,     config_class=_a		,     hidden_size=37				)

     def 					a__	(  self				)						->							List[Any]:
           self.config_tester.run_common_tests()

     def 					a__	(  self				)						->							List[str]:
           _A							:     str			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*_a				)

     def 					a__	(  self				)						->							Tuple:
           _A							:     str			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*_a				)

     def 					a__	(  self				)						->							Optional[Any]:
           _A							:     List[Any]			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_lm_head(*_a				)

     def 					a__	(  self				)						->							List[str]:
           _A							:     List[Any]			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_multiple_choice(*_a				)

     def 					a__	(  self				)						->							Dict:
           _A							:     List[Any]			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*_a				)

     def 					a__	(  self				)						->							int:
           _A							:     Optional[Any]			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*_a				)

     def 					a__	(  self				)						->							Union[str, Any]:
           _A							:     Dict			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*_a				)



     @slow
     def 					a__	(  self				)						->							Dict:
           _A							:     List[Any]			=						TFRoFormerModel.from_pretrained("""junnyu/roformer_chinese_base"""				)
           self.assertIsNotNone(_a				)







@require_tf
class 						lowercase							(   unittest.TestCase		):

     @slow
     def 					a__	(  self				)						->							List[Any]:
           _A							:     str			=						TFRoFormerForMaskedLM.from_pretrained("""junnyu/roformer_chinese_base"""				)
           _A							:     Any			=						tf.constant([[0, 1, 2, 3, 4, 5]]				)
           _A							:     str			=						model(_a				)[0]

           # TODO Replace vocab size
           _A							:     Union[str, Any]			=						5_0000

           _A							:     Any			=						[1, 6, vocab_size]
           self.assertEqual(output.shape		,     _a				)

           print(output[:, :3, :3]				)

           # TODO Replace values below with what was printed above.
           _A							:     List[str]			=						tf.constant(
               [
                   [
                       [-0.12053341, -1.0264901, 0.29221946],
                       [-1.5133783, 0.197433, 0.15190607],
                       [-5.0135403, -3.900256, -0.84038764],
                   ]
               ]				)
           tf.debugging.assert_near(output[:, :3, :3]		,     _a		,     atol=1e-4				)







@require_tf
class 						lowercase							(   unittest.TestCase		):
     _a							 =						1e-4

     def 					a__	(  self				)						->							Dict:
           _A							:     Optional[Any]			=						tf.constant([[4, 10]]				)
           _A							:     Any			=						TFRoFormerSinusoidalPositionalEmbedding(num_positions=6		,     embedding_dim=6				)

           _A							:     Union[str, Any]			=						emba(input_ids.shape				)
           _A							:     Union[str, Any]			=						tf.constant(
               [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]				)

           tf.debugging.assert_near(_a		,     _a		,     atol=self.tolerance				)



     def 					a__	(  self				)						->							Optional[Any]:
           _A							:     int			=						tf.constant(
               [
                   [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
                   [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
                   [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
               ]				)
           _A							:     Optional[int]			=						TFRoFormerSinusoidalPositionalEmbedding(num_positions=512		,     embedding_dim=512				)
           emba([2, 16, 512]				)
           _A							:     int			=						emba.weight[:3, :5]

           tf.debugging.assert_near(_a		,     _a		,     atol=self.tolerance				)







@require_tf
class 						lowercase							(   unittest.TestCase		):
     _a							 =						1e-4

     def 					a__	(  self				)						->							Tuple:
           _A							:     List[Any]			=						tf.reshape(tf.range(2 * 12 * 16 * 64		,     dtype=tf.floataa				)		,     shape=(2, 12, 16, 64)				) / 100

           _A							:     Tuple			=						-tf.reshape(tf.range(2 * 12 * 16 * 64		,     dtype=tf.floataa				)		,     shape=(2, 12, 16, 64)				) / 100

           _A							:     Union[str, Any]			=						TFRoFormerSinusoidalPositionalEmbedding(num_positions=32		,     embedding_dim=64				)
           _A							:     Union[str, Any]			=						embed_positions([2, 16, 768]				)[None, None, :, :]

           _A			,   _A							:     str			=						TFRoFormerSelfAttention.apply_rotary_position_embeddings(
               _a		,     _a		,     _a				)

           _A							:     Any			=						tf.constant(
               [
                   [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
                   [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
                   [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
                   [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
                   [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
                   [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
               ]				)
           _A							:     Dict			=						tf.constant(
               [
                   [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
                   [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
                   [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
                   [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
                   [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
                   [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
               ]				)

           tf.debugging.assert_near(query_layer[0, 0, :6, :8]		,     _a		,     atol=self.tolerance				)
           tf.debugging.assert_near(key_layer[0, 0, :6, :8]		,     _a		,     atol=self.tolerance				)







'''simple docstring'''







import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


A     =logging.getLogger(__name__)





def 						snake_case_							(_a	:							Dict    ,   _a	:							Union[str, Any]     ):
    return (preds == labels).mean()


@dataclass
class 			_a  :
       __a				:     str   				=					field(
           metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""} )
       __a				:     Optional[str]   				=					field(
           default=__a							,							metadata={"""help""": """Pretrained config name or path if not the same as model_name"""} )
       __a				:     Optional[str]   				=					field(
           default=__a							,							metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""} )
       __a				:     Optional[str]   				=					field(
           default=__a							,							metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}							,							)






@dataclass
class 			_a  :
       __a				:     str   				=					field(metadata={"""help""": """The name of the task to train on: """ + """, """.join(processors.keys() )} )
       __a				:     str   				=					field(metadata={"""help""": """Should contain the data files for the task."""} )
       __a				:     int   				=					field(
           default=128							,							metadata={
               """help""": (
                   """The maximum total input sequence length after tokenization. Sequences longer """
                   """than this will be truncated, sequences shorter will be padded."""
               )
           }							,							)
       __a				:     bool   				=					field(
           default=__a							,							metadata={"""help""": """Overwrite the cached training and evaluation sets"""} )






def 						snake_case_							():
    # See all possible arguments in src/transformers/training_args.py
    # or by passing the --help flag to this script.
    # We now keep distinct sets of args, for a cleaner separation of concerns.

    UpperCAmelCase			       =		HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)     )
    UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase			       =		parser.parse_args_into_dataclasses()

    if (
        os.path.exists(training_args.output_dir     )
        and os.listdir(training_args.output_dir     )
        and training_args.do_train
        and not training_args.overwrite_output_dir
    ):
        raise ValueError(
            F"Output directory ({training_args.output_dir}) already exists and is not empty. Use"
            ''' --overwrite_output_dir to overcome.'''     )

    # Setup logging
    logging.basicConfig(
        format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s'''    ,   datefmt='''%m/%d/%Y %H:%M:%S'''    ,   level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN    ,   )
    logger.warning(
        '''Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s'''    ,   training_args.local_rank    ,   training_args.device    ,   training_args.n_gpu    ,   bool(training_args.local_rank != -1     )    ,   training_args.fpaa    ,   )
    # Set the verbosity to info of the Transformers logger (on main process only):
    if is_main_process(training_args.local_rank     ):
        transformers.utils.logging.set_verbosity_info()
        transformers.utils.logging.enable_default_handler()
        transformers.utils.logging.enable_explicit_format()
    logger.info('''Training/evaluation parameters %s'''    ,   _a     )

    # Set seed
    set_seed(training_args.seed     )

    try:
        UpperCAmelCase			       =		processors[data_args.task_name]()
        UpperCAmelCase			       =		processor.get_labels()
        UpperCAmelCase			       =		len(_a     )
    except KeyError:
        raise ValueError('''Task not found: %s''' % (data_args.task_name)     )

    # Load pretrained model and tokenizer
    #
    # Distributed training:
    # The .from_pretrained methods guarantee that only one local process can concurrently
    # download model & vocab.

    UpperCAmelCase			       =		AutoConfig.from_pretrained(
        model_args.config_name if model_args.config_name else model_args.model_name_or_path    ,   num_labels=_a    ,   finetuning_task=data_args.task_name    ,   cache_dir=model_args.cache_dir    ,   )
    UpperCAmelCase			       =		AutoTokenizer.from_pretrained(
        model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path    ,   cache_dir=model_args.cache_dir    ,   )
    UpperCAmelCase			       =		AutoModelForMultipleChoice.from_pretrained(
        model_args.model_name_or_path    ,   from_tf=bool('''.ckpt''' in model_args.model_name_or_path     )    ,   config=_a    ,   cache_dir=model_args.cache_dir    ,   )

    # Get datasets
    UpperCAmelCase			       =		(
        MultipleChoiceDataset(
            data_dir=data_args.data_dir    ,   tokenizer=_a    ,   task=data_args.task_name    ,   max_seq_length=data_args.max_seq_length    ,   overwrite_cache=data_args.overwrite_cache    ,   mode=Split.train    ,   )
        if training_args.do_train
        else None
    )
    UpperCAmelCase			       =		(
        MultipleChoiceDataset(
            data_dir=data_args.data_dir    ,   tokenizer=_a    ,   task=data_args.task_name    ,   max_seq_length=data_args.max_seq_length    ,   overwrite_cache=data_args.overwrite_cache    ,   mode=Split.dev    ,   )
        if training_args.do_eval
        else None
    )

    def compute_metrics(_a	:							EvalPrediction     ) -> Dict:
        UpperCAmelCase			       =		np.argmax(p.predictions    ,   axis=1     )
        return {"acc": simple_accuracy(_a    ,   p.label_ids     )}

    # Data collator
    UpperCAmelCase			       =		DataCollatorWithPadding(_a    ,   pad_to_multiple_of=8     ) if training_args.fpaa else None

    # Initialize our Trainer
    UpperCAmelCase			       =		Trainer(
        model=_a    ,   args=_a    ,   train_dataset=_a    ,   eval_dataset=_a    ,   compute_metrics=_a    ,   data_collator=_a    ,   )

    # Training
    if training_args.do_train:
        trainer.train(
            model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path     ) else None     )
        trainer.save_model()
        # For convenience, we also re-save the tokenizer to the same directory,
        # so that you can share your model easily on huggingface.co/models =)
        if trainer.is_world_master():
            tokenizer.save_pretrained(training_args.output_dir     )

    # Evaluation
    UpperCAmelCase			       =		{}
    if training_args.do_eval:
        logger.info('''*** Evaluate ***'''     )

        UpperCAmelCase			       =		trainer.evaluate()

        UpperCAmelCase			       =		os.path.join(training_args.output_dir    ,   '''eval_results.txt'''     )
        if trainer.is_world_master():
            with open(_a    ,   '''w'''     ) as writer:
                logger.info('''***** Eval results *****'''     )
                for key, value in result.items():
                    logger.info('''  %s = %s'''    ,   _a    ,   _a     )
                    writer.write('''%s = %s\n''' % (key, value)     )

                results.update(_a     )

    return results





def 						snake_case_							(_a	:							Optional[int]     ):
    # For xla_spawn (TPUs)
    main()


if __name__ == "__main__":
   main()




