"""simple docstring"""




import json
import os
import unittest

from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class       a_      (     __UpperCamelCase ,		unittest.TestCase			):
					UpperCamelCase_ :	Optional[Any]			=    MgpstrTokenizer
					UpperCamelCase_ :	Union[str, Any]			=    False
					UpperCamelCase_ :	Dict			=    {}
					UpperCamelCase_ :	int			=    False




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							super().setUp()

							# fmt: off
							lowerCAmelCase__        =   ["""[GO]""", """[s]""", """0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9""", """a""", """b""", """c""", """d""", """e""", """f""", """g""", """h""", """i""", """j""", """k""", """l""", """m""", """n""", """o""", """p""", """q""", """r""", """s""", """t""", """u""", """v""", """w""", """x""", """y""", """z"""]
							# fmt: on
							lowerCAmelCase__        =   dict(zip(snake_case__  ,						range(len(snake_case__     )     )     )     )

							lowerCAmelCase__        =   os.path.join(self.tmpdirname  ,						VOCAB_FILES_NAMES["""vocab_file"""]     )
							with open(self.vocab_file  ,						"""w"""  ,						encoding="""utf-8"""     ) as fp:
									fp.write(json.dumps(snake_case__     ) + """\n"""     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple  ,						**snake_case__						:     Dict     ):
							return MgpstrTokenizer.from_pretrained(self.tmpdirname  ,						**snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]  ,						snake_case__						:     Any     ):
							lowerCAmelCase__        =   """tester"""
							lowerCAmelCase__        =   """tester"""
							return input_text, output_text




					@unittest.skip("""MGP-STR always lower cases letters."""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							pass




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							lowerCAmelCase__        =   self.get_tokenizers(do_lower_case=snake_case__     )
							for tokenizer in tokenizers:
									with self.subTest(F"""{tokenizer.__class__.__name__}"""     ):
											lowerCAmelCase__        =   """[SPECIAL_TOKEN]"""

											tokenizer.add_special_tokens({"""cls_token""": special_token}     )
											lowerCAmelCase__        =   tokenizer.encode([special_token]  ,						add_special_tokens=snake_case__     )
											self.assertEqual(len(snake_case__     )  ,						1     )

											lowerCAmelCase__        =   tokenizer.decode(snake_case__  ,						skip_special_tokens=snake_case__     )
											self.assertTrue(special_token not in decoded     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							lowerCAmelCase__        =   self.get_tokenizers()
							for tokenizer in tokenizers:
									with self.subTest(F"""{tokenizer.__class__.__name__}"""     ):
											lowerCAmelCase__   ,					lowerCAmelCase__        =   self.get_input_output_texts(snake_case__     )

											lowerCAmelCase__        =   tokenizer.tokenize(snake_case__     )
											lowerCAmelCase__        =   tokenizer.convert_tokens_to_ids(snake_case__     )
											lowerCAmelCase__        =   tokenizer.encode(snake_case__  ,						add_special_tokens=snake_case__     )
											self.assertListEqual(snake_case__  ,						snake_case__     )

											lowerCAmelCase__        =   tokenizer.convert_ids_to_tokens(snake_case__     )
											self.assertNotEqual(len(snake_case__     )  ,						0     )
											lowerCAmelCase__        =   tokenizer.decode(snake_case__     )
											self.assertIsInstance(snake_case__  ,						snake_case__     )

											self.assertEqual(text_a.replace(""" """  ,						""""""     )  ,						snake_case__     )




					@unittest.skip("""MGP-STR tokenizer only handles one sequence."""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]     ):
							pass




					@unittest.skip("""inputs cannot be pretokenized in MgpstrTokenizer"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							pass





"""simple docstring"""




import os
from math import logaa







def 							_UpperCAmelCase		(       lowerCamelCase__ = "base_exp.txt"     ):





		"""simple docstring"""




		lowerCAmelCase__        =   0
		lowerCAmelCase__        =   0
		for i, line in enumerate(open(os.path.join(os.path.dirname(lowerCamelCase__     )			,  lowerCamelCase__     )     )     ):
				lowerCAmelCase__   ,					lowerCAmelCase__        =   list(map(lowerCamelCase__			,  line.split(""","""     )     )     )
				if x * logaa(lowerCamelCase__     ) > largest:
						lowerCAmelCase__        =   x * logaa(lowerCamelCase__     )
						lowerCAmelCase__        =   i + 1
		return result


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




