
"""simple docstring"""






def 		_snake_case			(      lowercase__						:    int = 1_0_0_0						)    ->							int:


			'''simple docstring'''





			lowerCAmelCase_       :Tuple     	=    0
			for i in range(lowercase__						):
						if i % 3 == 0 or i % 5 == 0:
									result += i
			return result


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








"""simple docstring"""






import json
import os
import unittest

from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import (
    VOCAB_FILES_NAMES,
    GPTNeoXJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class      _SCREAMING_SNAKE_CASE   (     A__      ,					unittest.TestCase				):
			UpperCAmelCase_    :List[str]												=		GPTNeoXJapaneseTokenizer
			UpperCAmelCase_    :List[str]												=		False
			UpperCAmelCase_    :int												=		{"do_clean_text": False, "add_prefix_space": False}






			def 					__lowerCAmelCase					(   self			)     ->	Optional[Any]:
						super().setUp()

						lowerCAmelCase_       :int     	=    [
						    """こん""",
						    """こんに""",
						    """にちは""",
						    """ばんは""",
						    """世界,㔺界""",
						    """、""",
						    """。""",
						    """<BR>""",
						    """<SP>""",
						    """<TAB>""",
						    """<URL>""",
						    """<EMAIL>""",
						    """<TEL>""",
						    """<DATE>""",
						    """<PRICE>""",
						    """<BLOCK>""",
						    """<KIGOU>""",
						    """<U2000U2BFF>""",
						    """<|emoji1|>""",
						    """<unk>""",
						    """<|startoftext|>""",
						    """<|endoftext|>""",
						]
						lowerCAmelCase_       :str     	=    {"""emoji""": {"""\ud83d\ude00""": """<|emoji1|>"""}, """emoji_inv""": {"""<|emoji1|>""": """\ud83d\ude00"""}}  # 😀
						lowerCAmelCase_       :Dict     	=    {"""unk_token""": """<unk>"""}

						lowerCAmelCase_       :Union[str, Any]     	=    os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["""vocab_file"""]			)
						lowerCAmelCase_       :Union[str, Any]     	=    os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["""emoji_file"""]			)
						with open(self.vocab_file			,  """w"""			,  encoding="""utf-8"""			) as vocab_writer:
									vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]			)			)
						with open(self.emoji_file			,  """w"""			) as emoji_writer:
									emoji_writer.write(json.dumps(__A			)			)






			def 					__lowerCAmelCase					(   self			,  **__A			)     ->	str:
						kwargs.update(self.special_tokens_map			)
						return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname			,  **__A			)






			def 					__lowerCAmelCase					(   self			,  __A			)     ->	List[Any]:
						lowerCAmelCase_       :Optional[Any]     	=    """こんにちは、世界。 \nこんばんは、㔺界。😀"""
						lowerCAmelCase_       :List[Any]     	=    """こんにちは、世界。 \nこんばんは、世界。😀"""
						return input_text, output_text






			def 					__lowerCAmelCase					(   self			,  __A			)     ->	Optional[Any]:
						lowerCAmelCase_	,			lowerCAmelCase_       :Optional[int]     	=    self.get_input_output_texts(__A			)
						lowerCAmelCase_       :List[Any]     	=    tokenizer.encode(__A			,  add_special_tokens=__A			)
						lowerCAmelCase_       :Optional[Any]     	=    tokenizer.decode(__A			,  clean_up_tokenization_spaces=__A			)
						return text, ids






			def 					__lowerCAmelCase					(   self			)     ->	str:
						pass  # TODO add if relevant






			def 					__lowerCAmelCase					(   self			)     ->	Any:
						pass  # TODO add if relevant






			def 					__lowerCAmelCase					(   self			)     ->	Optional[int]:
						pass  # TODO add if relevant






			def 					__lowerCAmelCase					(   self			)     ->	Optional[Any]:
						lowerCAmelCase_       :int     	=    self.get_tokenizer()

						# Testing tokenization
						lowerCAmelCase_       :List[str]     	=    """こんにちは、世界。　こんばんは、㔺界。"""
						lowerCAmelCase_       :int     	=    ["""こん""", """にちは""", """、""", """世界""", """。""", """<SP>""", """こん""", """ばんは""", """、""", """㔺界""", """。"""]
						lowerCAmelCase_       :List[Any]     	=    tokenizer.tokenize(__A			)
						self.assertListEqual(__A			,  __A			)

						# Testing conversion to ids without special tokens
						lowerCAmelCase_       :List[str]     	=    [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
						lowerCAmelCase_       :Dict     	=    tokenizer.convert_tokens_to_ids(__A			)
						self.assertListEqual(__A			,  __A			)

						# Testing conversion to ids with special tokens
						lowerCAmelCase_       :Tuple     	=    tokens + [tokenizer.unk_token]
						lowerCAmelCase_       :str     	=    [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
						lowerCAmelCase_       :Any     	=    tokenizer.convert_tokens_to_ids(__A			)
						self.assertListEqual(__A			,  __A			)






			@slow
			def 					__lowerCAmelCase					(   self			)     ->	Any:
						lowerCAmelCase_       :str     	=    self.tokenizer_class.from_pretrained("""abeja/gpt-neox-japanese-2.7b"""			)

						lowerCAmelCase_       :Union[str, Any]     	=    tokenizer.encode("""ありがとう。"""			,  add_special_tokens=__A			)
						lowerCAmelCase_       :Dict     	=    tokenizer.encode("""どういたしまして。"""			,  add_special_tokens=__A			)

						lowerCAmelCase_       :Union[str, Any]     	=    tokenizer.build_inputs_with_special_tokens(__A			)
						lowerCAmelCase_       :Optional[int]     	=    tokenizer.build_inputs_with_special_tokens(__A			,  __A			)

						assert encoded_sentence == ids_a
						assert encoded_pair == ids_a + ids_a






			def 					__lowerCAmelCase					(   self			)     ->	Dict:
						# Intentionally convert some words to accommodate character fluctuations unique to Japanese
						pass






			def 					__lowerCAmelCase					(   self			)     ->	List[str]:
						# tokenizer has no padding token
						pass






