
import argparse
import json
import logging
import os
import sys
from unittest.mock import patch

from transformers.testing_utils import TestCasePlus, get_gpu_count, slow


_lowercase											=    [
    os.path.join(os.path.dirname(__file__), dirname)
    for dirname in [
        """text-classification""",
        """language-modeling""",
        """summarization""",
        """token-classification""",
        """question-answering""",
    ]
]
sys.path.extend(SRC_DIRS)


if SRC_DIRS is not None:
 import run_clm_flax
 import run_flax_glue
 import run_flax_ner
 import run_mlm_flax
 import run_qa
 import run_summarization_flax
 import run_ta_mlm_flax


logging.basicConfig(level=logging.DEBUG)

_lowercase											=    logging.getLogger()
def 							SCREAMING_SNAKE_CASE_	(					)			->						Dict:
       SCREAMING_SNAKE_CASE_							:				str		=argparse.ArgumentParser()
       parser.add_argument('''-f'''				)
       SCREAMING_SNAKE_CASE_							:				int		=parser.parse_args()
       return args.f
def 							SCREAMING_SNAKE_CASE_	(					UpperCAmelCase_	:     str			,							UpperCAmelCase_	:     int="eval"				)			->						Union[str, Any]:
       SCREAMING_SNAKE_CASE_							:				List[str]		=os.path.join(UpperCAmelCase_			,							f'{split}_results.json'				)
       if os.path.exists(UpperCAmelCase_				):
              with open(UpperCAmelCase_			,							'''r'''				) as f:
                     return json.load(UpperCAmelCase_				)
       raise ValueError(f'can\'t find {path}'				)


_lowercase											=    logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)


class 			lowercase_		(      A       ):


       def 	_snake_case				(    self				)						->    List[Any]:
              SCREAMING_SNAKE_CASE_							:				str		=self.get_auto_remove_tmp_dir()
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=F'\n            run_glue.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --eval_steps=2\n            --warmup_steps=2\n            --seed=42\n            --max_seq_length=128\n            '.split()

              with patch.object(__A						,       '''argv'''						,       __A				):
                     run_flax_glue.main()
                     SCREAMING_SNAKE_CASE_							:				List[Any]		=get_results(__A				)
                     self.assertGreaterEqual(result['''eval_accuracy''']						,       0.75				)


       @slow
       def 	_snake_case				(    self				)						->    List[str]:
              SCREAMING_SNAKE_CASE_							:				Optional[Any]		=self.get_auto_remove_tmp_dir()
              SCREAMING_SNAKE_CASE_							:				List[Any]		=F'\n            run_clm_flax.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --do_train\n            --do_eval\n            --block_size 128\n            --per_device_train_batch_size 4\n            --per_device_eval_batch_size 4\n            --num_train_epochs 2\n            --logging_steps 2 --eval_steps 2\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            '.split()

              with patch.object(__A						,       '''argv'''						,       __A				):
                     run_clm_flax.main()
                     SCREAMING_SNAKE_CASE_							:				Tuple		=get_results(__A				)
                     self.assertLess(result['''eval_perplexity''']						,       100				)


       @slow
       def 	_snake_case				(    self				)						->    Optional[Any]:
              SCREAMING_SNAKE_CASE_							:				Dict		=self.get_auto_remove_tmp_dir()
              SCREAMING_SNAKE_CASE_							:				str		=F'\n            run_summarization.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --test_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --num_train_epochs=3\n            --warmup_steps=8\n            --do_train\n            --do_eval\n            --do_predict\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --predict_with_generate\n        '.split()

              with patch.object(__A						,       '''argv'''						,       __A				):
                     run_summarization_flax.main()
                     SCREAMING_SNAKE_CASE_							:				str		=get_results(__A						,       split='''test'''				)
                     self.assertGreaterEqual(result['''test_rouge1''']						,       10				)
                     self.assertGreaterEqual(result['''test_rouge2''']						,       2				)
                     self.assertGreaterEqual(result['''test_rougeL''']						,       7				)
                     self.assertGreaterEqual(result['''test_rougeLsum''']						,       7				)


       @slow
       def 	_snake_case				(    self				)						->    Tuple:
              SCREAMING_SNAKE_CASE_							:				List[Any]		=self.get_auto_remove_tmp_dir()
              SCREAMING_SNAKE_CASE_							:				Any		=F'\n            run_mlm.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --max_seq_length 128\n            --per_device_train_batch_size 4\n            --per_device_eval_batch_size 4\n            --logging_steps 2 --eval_steps 2\n            --do_train\n            --do_eval\n            --num_train_epochs=1\n        '.split()

              with patch.object(__A						,       '''argv'''						,       __A				):
                     run_mlm_flax.main()
                     SCREAMING_SNAKE_CASE_							:				List[str]		=get_results(__A				)
                     self.assertLess(result['''eval_perplexity''']						,       42				)


       @slow
       def 	_snake_case				(    self				)						->    str:
              SCREAMING_SNAKE_CASE_							:				Tuple		=self.get_auto_remove_tmp_dir()
              SCREAMING_SNAKE_CASE_							:				Optional[Any]		=F'\n            run_t5_mlm_flax.py\n            --model_name_or_path t5-small\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --do_train\n            --do_eval\n            --max_seq_length 128\n            --per_device_train_batch_size 4\n            --per_device_eval_batch_size 4\n            --num_train_epochs 2\n            --logging_steps 2 --eval_steps 2\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            '.split()

              with patch.object(__A						,       '''argv'''						,       __A				):
                     run_ta_mlm_flax.main()
                     SCREAMING_SNAKE_CASE_							:				List[str]		=get_results(__A				)
                     self.assertGreaterEqual(result['''eval_accuracy''']						,       0.42				)


       @slow
       def 	_snake_case				(    self				)						->    Optional[Any]:
              # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
              SCREAMING_SNAKE_CASE_							:				List[Any]		=7 if get_gpu_count() > 1 else 2

              SCREAMING_SNAKE_CASE_							:				Optional[int]		=self.get_auto_remove_tmp_dir()
              SCREAMING_SNAKE_CASE_							:				int		=F'\n            run_flax_ner.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --do_train\n            --do_eval\n            --warmup_steps=2\n            --learning_rate=2e-4\n            --logging_steps 2 --eval_steps 2\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n        '.split()

              with patch.object(__A						,       '''argv'''						,       __A				):
                     run_flax_ner.main()
                     SCREAMING_SNAKE_CASE_							:				str		=get_results(__A				)
                     self.assertGreaterEqual(result['''eval_accuracy''']						,       0.75				)
                     self.assertGreaterEqual(result['''eval_f1''']						,       0.3				)





       @slow
       def 	_snake_case				(    self				)						->    List[Any]:
              SCREAMING_SNAKE_CASE_							:				List[str]		=self.get_auto_remove_tmp_dir()
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=F'\n            run_qa.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --num_train_epochs=3\n            --warmup_steps=2\n            --do_train\n            --do_eval\n            --logging_steps 2 --eval_steps 2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n        '.split()

              with patch.object(__A						,       '''argv'''						,       __A				):
                     run_qa.main()
                     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=get_results(__A				)
                     self.assertGreaterEqual(result['''eval_f1''']						,       30				)
                     self.assertGreaterEqual(result['''eval_exact''']						,       30				)


def 							SCREAMING_SNAKE_CASE_	(					UpperCAmelCase_	:     int = 1_0_0_0				)			->						int:
       SCREAMING_SNAKE_CASE_							:				int		=2**power
       SCREAMING_SNAKE_CASE_							:				Tuple		=0
       while n:
              SCREAMING_SNAKE_CASE_	,     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=r + n % 1_0, n // 1_0
       return r


if __name__ == "__main__":
 print(solution(int(str(input()).strip())))
