



"""simple docstring"""





import os
import unittest

from transformers import FunnelTokenizer, FunnelTokenizerFast
from transformers.models.funnel.tokenization_funnel import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class 			lowercase__			(      A,					unittest.TestCase    ):
							'''simple docstring'''







							_UpperCAmelCase      				=					FunnelTokenizer
							_UpperCAmelCase      				=					FunnelTokenizerFast
							_UpperCAmelCase      				=					True
							_UpperCAmelCase      				=					True






							def        lowerCamelCase_   (  self						)			->							int:
									super().setUp()

									_UpperCAmelCase							 =		[
									    '<unk>',
									    '<cls>',
									    '<sep>',
									    'want',
									    '##want',
									    '##ed',
									    'wa',
									    'un',
									    'runn',
									    '##ing',
									    ',',
									    'low',
									    'lowest',
									]
									_UpperCAmelCase							 =		os.path.join(self.tmpdirname	,       VOCAB_FILES_NAMES['vocab_file']						)
									with open(self.vocab_file	,       'w'	,       encoding='utf-8'						) as vocab_writer:
											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]						)						)






							def        lowerCamelCase_   (  self	,       **snake_case						)			->							Any:
									return FunnelTokenizer.from_pretrained(self.tmpdirname	,       **snake_case						)






							def        lowerCamelCase_   (  self	,       **snake_case						)			->							Union[str, Any]:
									return FunnelTokenizerFast.from_pretrained(self.tmpdirname	,       **snake_case						)






							def        lowerCamelCase_   (  self	,       snake_case						)			->							int:
									_UpperCAmelCase							 =		'UNwant\u00E9d,running'
									_UpperCAmelCase							 =		'unwanted, running'
									return input_text, output_text






							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									_UpperCAmelCase							 =		self.tokenizer_class(self.vocab_file						)

									_UpperCAmelCase							 =		tokenizer.tokenize('UNwant\u00E9d,running'						)
									self.assertListEqual(snake_case	,       ['un', '##want', '##ed', ',', 'runn', '##ing']						)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case						)	,       [7, 4, 5, 10, 8, 9]						)






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									_UpperCAmelCase							 =		self.get_tokenizers(do_lower_case=snake_case						)
									for tokenizer in tokenizers:
											_UpperCAmelCase							 =		tokenizer('UNwant\u00E9d,running'						)
											_UpperCAmelCase							 =		len(inputs['input_ids']						) - 1
											self.assertListEqual(inputs['token_type_ids']	,       [2] + [0] * sentence_len						)

											_UpperCAmelCase							 =		tokenizer('UNwant\u00E9d,running'	,       'UNwant\u00E9d,running'						)
											self.assertListEqual(inputs['token_type_ids']	,       [2] + [0] * sentence_len + [1] * sentence_len						)







"""simple docstring"""





from itertools import permutations




def 	UpperCAmelCase     (		A	:						tuple       ):

		'''simple docstring'''


		if num[3] % 2 != 0:
				return False

		if (num[2] + num[3] + num[4]) % 3 != 0:
				return False

		if num[5] % 5 != 0:
				return False

		_UpperCAmelCase							 =		[7, 11, 13, 17]
		for i, test in enumerate(A       ):
				if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
						return False
		return True




def 	UpperCAmelCase     (		A	:						int = 10       ):

		'''simple docstring'''


		return sum(
		    int(''.join(map(A     ,				A       )       )       )
		    for num in permutations(range(A       )       )
		    if is_substring_divisible(A       )       )


if __name__ == "__main__":
					print(F'''{solution() = }''')


