
"""simple docstring"""







import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin







@custom_tokenizers
class 							__magic_name__     (		__UpperCAmelCase      ,		unittest.TestCase   ):

					'''simple docstring'''





					_SCREAMING_SNAKE_CASE       :					Any     							=   BertJapaneseTokenizer
					_SCREAMING_SNAKE_CASE       :					Optional[int]     							=   False
					_SCREAMING_SNAKE_CASE       :					int     							=   True





					def 							lowerCAmelCase      (				self   :							Any    ):
												super().setUp()

												__snake_case     			=       [
												    "[UNK]",
												    "[CLS]",
												    "[SEP]",
												    "こんにちは",
												    "こん",
												    "にちは",
												    "ばんは",
												    "##こん",
												    "##にちは",
												    "##ばんは",
												    "世界",
												    "##世界",
												    "、",
												    "##、",
												    "。",
												    "##。",
												]

												__snake_case     			=       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   :							Tuple							,						snake_case_   :							Dict    ):
												__snake_case     			=       "こんにちは、世界。 \nこんばんは、世界。"
												__snake_case     			=       "こんにちは 、 世界 。 こんばんは 、 世界 。"
												return input_text, output_text





					def 							lowerCAmelCase      (				self   :							List[str]							,						snake_case_   :							Optional[int]    ):
												__snake_case			,   __snake_case     			=       self.get_input_output_texts(UpperCAmelCase_    )
												__snake_case     			=       tokenizer.encode(UpperCAmelCase_							,						add_special_tokens=UpperCAmelCase_    )
												__snake_case     			=       tokenizer.decode(UpperCAmelCase_							,						clean_up_tokenization_spaces=UpperCAmelCase_    )
												return text, ids





					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												pass  # TODO add if relevant





					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												pass  # TODO add if relevant





					def 							lowerCAmelCase      (				self   :							List[Any]    ):
												pass  # TODO add if relevant





					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												__snake_case     			=       self.tokenizer_class(self.vocab_file    )

												__snake_case     			=       tokenizer.tokenize("こんにちは、世界。\nこんばんは、世界。"    )
												self.assertListEqual(UpperCAmelCase_							,						["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]    )
												self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase_    )							,						[3, 12, 10, 14, 4, 9, 12, 10, 14]    )





					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												__snake_case     			=       self.tokenizer_class(self.vocab_file							,						word_tokenizer_type="mecab"    )
												self.assertIsNotNone(UpperCAmelCase_    )

												__snake_case     			=       "こんにちは、世界。\nこんばんは、世界。"
												__snake_case     			=       tokenizer.tokenize(UpperCAmelCase_    )
												self.assertListEqual(UpperCAmelCase_							,						["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]    )
												self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase_    )							,						[3, 12, 10, 14, 4, 9, 12, 10, 14]    )

												__snake_case     			=       os.path.join(self.tmpdirname							,						"tokenizer.bin"    )
												with open(UpperCAmelCase_							,						"wb"    ) as handle:
																			pickle.dump(UpperCAmelCase_							,						UpperCAmelCase_    )

												with open(UpperCAmelCase_							,						"rb"    ) as handle:
																			__snake_case     			=       pickle.load(UpperCAmelCase_    )

												__snake_case     			=       tokenizer_new.tokenize(UpperCAmelCase_    )

												self.assertListEqual(UpperCAmelCase_							,						UpperCAmelCase_    )





					def 							lowerCAmelCase      (				self   :							Tuple    ):
												__snake_case     			=       MecabTokenizer(mecab_dic="ipadic"    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップルストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]							,						)





					def 							lowerCAmelCase      (				self   :							str    ):
												try:
																			__snake_case     			=       MecabTokenizer(mecab_dic="unidic_lite"    )
												except ModuleNotFoundError:
																			return

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]							,						)





					def 							lowerCAmelCase      (				self   :							str    ):
												try:
																			__snake_case     			=       MecabTokenizer(mecab_dic="unidic"    )
												except ModuleNotFoundError:
																			return

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]							,						)





					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												__snake_case     			=       MecabTokenizer(do_lower_case=UpperCAmelCase_							,						mecab_dic="ipadic"    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップルストア", "で", "iphone", "8", "が", "発売", "さ", "れ", "た", "。"]							,						)





					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												try:
																			__snake_case     			=       MecabTokenizer(
																			    do_lower_case=UpperCAmelCase_							,						normalize_text=UpperCAmelCase_							,						mecab_option="-d /usr/local/lib/mecab/dic/jumandic"    )
												except RuntimeError:
																			# if dict doesn't exist in the system, previous code raises this error.
																			return

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["ｱｯﾌﾟﾙストア", "で", "iPhone", "８", "が", "発売", "さ", "れた", "\u3000", "。"]							,						)





					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												__snake_case     			=       MecabTokenizer(normalize_text=UpperCAmelCase_							,						mecab_dic="ipadic"    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["ｱｯﾌﾟﾙストア", "で", "iPhone", "８", "が", "発売", "さ", "れ", "た", "　", "。"]							,						)





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							int    ):
												__snake_case     			=       self.tokenizer_class(self.vocab_file							,						word_tokenizer_type="sudachi"    )
												self.assertIsNotNone(UpperCAmelCase_    )

												__snake_case     			=       "こんにちは、世界。\nこんばんは、世界。"
												__snake_case     			=       tokenizer.tokenize(UpperCAmelCase_    )
												self.assertListEqual(UpperCAmelCase_							,						["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]    )
												self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase_    )							,						[3, 12, 10, 14, 4, 9, 12, 10, 14]    )

												__snake_case     			=       os.path.join(self.tmpdirname							,						"tokenizer.bin"    )
												with open(UpperCAmelCase_							,						"wb"    ) as handle:
																			pickle.dump(UpperCAmelCase_							,						UpperCAmelCase_    )

												with open(UpperCAmelCase_							,						"rb"    ) as handle:
																			__snake_case     			=       pickle.load(UpperCAmelCase_    )

												__snake_case     			=       tokenizer_new.tokenize(UpperCAmelCase_    )

												self.assertListEqual(UpperCAmelCase_							,						UpperCAmelCase_    )





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							Dict    ):
												__snake_case     			=       SudachiTokenizer(sudachi_dict_type="core"    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						[" ", "\t", "アップル", "ストア", "で", "iPhone", "8", " ", "が", " ", " ", "\n ", "発売", "さ", "れ", "た", " ", "。", " ", " "]							,						)





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							str    ):
												__snake_case     			=       SudachiTokenizer(sudachi_dict_type="core"							,						sudachi_split_mode="A"    )

												self.assertListEqual(tokenizer.tokenize("外国人参政権"    )							,						["外国", "人", "参政", "権"]    )





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							Any    ):
												__snake_case     			=       SudachiTokenizer(sudachi_dict_type="core"							,						sudachi_split_mode="B"    )

												self.assertListEqual(tokenizer.tokenize("外国人参政権"    )							,						["外国人", "参政権"]    )





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							int    ):
												__snake_case     			=       SudachiTokenizer(sudachi_dict_type="core"							,						sudachi_split_mode="C"    )

												self.assertListEqual(tokenizer.tokenize("外国人参政権"    )							,						["外国人参政権"]    )





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												__snake_case     			=       SudachiTokenizer(do_lower_case=UpperCAmelCase_							,						sudachi_dict_type="core"    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						[" ", "\t", "アップル", "ストア", "で", "iphone", "8", " ", "が", " ", " ", "\n ", "発売", "さ", "れ", "た", " ", "。", " ", " "]							,						)





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												__snake_case     			=       SudachiTokenizer(normalize_text=UpperCAmelCase_							,						sudachi_dict_type="core"    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						[" ", "\t", "ｱｯﾌﾟﾙ", "ストア", "で", "iPhone", "８", " ", "が", " ", " ", "\n ", "発売", "さ", "れ", "た", "\u3000", "。", " ", " "]							,						)





					@require_sudachi
					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												__snake_case     			=       SudachiTokenizer(trim_whitespace=UpperCAmelCase_							,						sudachi_dict_type="core"    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れ", "た", "。"]							,						)





					@require_jumanpp
					def 							lowerCAmelCase      (				self   :							Tuple    ):
												__snake_case     			=       self.tokenizer_class(self.vocab_file							,						word_tokenizer_type="jumanpp"    )
												self.assertIsNotNone(UpperCAmelCase_    )

												__snake_case     			=       "こんにちは、世界。\nこんばんは、世界。"
												__snake_case     			=       tokenizer.tokenize(UpperCAmelCase_    )
												self.assertListEqual(UpperCAmelCase_							,						["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]    )
												self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase_    )							,						[3, 12, 10, 14, 4, 9, 12, 10, 14]    )

												__snake_case     			=       os.path.join(self.tmpdirname							,						"tokenizer.bin"    )
												with open(UpperCAmelCase_							,						"wb"    ) as handle:
																			pickle.dump(UpperCAmelCase_							,						UpperCAmelCase_    )

												with open(UpperCAmelCase_							,						"rb"    ) as handle:
																			__snake_case     			=       pickle.load(UpperCAmelCase_    )

												__snake_case     			=       tokenizer_new.tokenize(UpperCAmelCase_    )

												self.assertListEqual(UpperCAmelCase_							,						UpperCAmelCase_    )





					@require_jumanpp
					def 							lowerCAmelCase      (				self   :							List[str]    ):
												__snake_case     			=       JumanppTokenizer()

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップル", "ストア", "で", "iPhone", "8", "\u3000", "が", "\u3000", "\u3000", "\u3000", "発売", "さ", "れた", "\u3000", "。"]							,						)





					@require_jumanpp
					def 							lowerCAmelCase      (				self   :							int    ):
												__snake_case     			=       JumanppTokenizer(do_lower_case=UpperCAmelCase_    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップル", "ストア", "で", "iphone", "8", "\u3000", "が", "\u3000", "\u3000", "\u3000", "発売", "さ", "れた", "\u3000", "。"]							,						)





					@require_jumanpp
					def 							lowerCAmelCase      (				self   :							int    ):
												__snake_case     			=       JumanppTokenizer(normalize_text=UpperCAmelCase_    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["ｱ", "ｯ", "ﾌ", "ﾟ", "ﾙ", "ストア", "で", "iPhone", "８", "\u3000", "が", "\u3000", "\u3000", "\u3000", "発売", "さ", "れた", "\u3000", "。"]							,						)





					@require_jumanpp
					def 							lowerCAmelCase      (				self   :							str    ):
												__snake_case     			=       JumanppTokenizer(trim_whitespace=UpperCAmelCase_    )

												self.assertListEqual(
												    tokenizer.tokenize(" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  "    )							,						["アップル", "ストア", "で", "iPhone", "8", "が", "発売", "さ", "れた", "。"]							,						)





					@require_jumanpp
					def 							lowerCAmelCase      (				self   :							Any    ):
												__snake_case     			=       JumanppTokenizer()

												self.assertListEqual(
												    tokenizer.tokenize("ありがとうございますm(_ _)ｍ見つけるのが大変です。"    )							,						["ありがとう", "ございます", "m(_ _)m", "見つける", "の", "が", "大変です", "。"]							,						)





					def 							lowerCAmelCase      (				self   :							str    ):
												__snake_case     			=       ["[UNK]", "[CLS]", "[SEP]", "こんにちは", "こん", "にちは", "ばんは", "##こん", "##にちは", "##ばんは"]

												__snake_case     			=       {}
												for i, token in enumerate(UpperCAmelCase_    ):
																			__snake_case     			=       i
												__snake_case     			=       WordpieceTokenizer(vocab=UpperCAmelCase_							,						unk_token="[UNK]"    )

												self.assertListEqual(tokenizer.tokenize(""    )							,						[]    )

												self.assertListEqual(tokenizer.tokenize("こんにちは"    )							,						["こんにちは"]    )

												self.assertListEqual(tokenizer.tokenize("こんばんは"    )							,						["こん", "##ばんは"]    )

												self.assertListEqual(tokenizer.tokenize("こんばんは こんばんにちは こんにちは"    )							,						["こん", "##ばんは", "[UNK]", "こんにちは"]    )





					def 							lowerCAmelCase      (				self   :							str    ):
												__snake_case     			=       BertJapaneseTokenizer.from_pretrained("nlp-waseda/roberta-base-japanese-with-auto-jumanpp"    )
												__snake_case     			=       tokenizer.subword_tokenizer

												__snake_case     			=       subword_tokenizer.tokenize("国境 の 長い トンネル を 抜ける と 雪国 であった 。"    )
												self.assertListEqual(UpperCAmelCase_							,						["▁国境", "▁の", "▁長い", "▁トンネル", "▁を", "▁抜ける", "▁と", "▁雪", "国", "▁であった", "▁。"]    )

												__snake_case     			=       subword_tokenizer.tokenize("こんばんは こんばん にち は こんにちは"    )
												self.assertListEqual(UpperCAmelCase_							,						["▁こん", "ばん", "は", "▁こん", "ばん", "▁に", "ち", "▁は", "▁こんにちは"]    )





					def 							lowerCAmelCase      (				self   :							Dict    ):
												__snake_case     			=       self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese"    )

												__snake_case     			=       tokenizer.encode("ありがとう。"							,						add_special_tokens=UpperCAmelCase_    )
												__snake_case     			=       tokenizer.encode("どういたしまして。"							,						add_special_tokens=UpperCAmelCase_    )

												__snake_case     			=       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_    )
												__snake_case     			=       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_							,						UpperCAmelCase_    )

												# 2 is for "[CLS]", 3 is for "[SEP]"
												assert encoded_sentence == [2] + text + [3]
												assert encoded_pair == [2] + text + [3] + text_a + [3]







@custom_tokenizers
class 							__magic_name__     (		__UpperCAmelCase      ,		unittest.TestCase   ):

					'''simple docstring'''





					_SCREAMING_SNAKE_CASE       :					Union[str, Any]     							=   BertJapaneseTokenizer
					_SCREAMING_SNAKE_CASE       :					Optional[int]     							=   False





					def 							lowerCAmelCase      (				self   :							List[str]    ):
												super().setUp()

												__snake_case     			=       ["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

												__snake_case     			=       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   :							Union[str, Any]							,						**snake_case_   :							Optional[Any]    ):
												return BertJapaneseTokenizer.from_pretrained(self.tmpdirname							,						subword_tokenizer_type="character"							,						**UpperCAmelCase_    )





					def 							lowerCAmelCase      (				self   :							Any							,						snake_case_   :							List[str]    ):
												__snake_case     			=       "こんにちは、世界。 \nこんばんは、世界。"
												__snake_case     			=       "こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"
												return input_text, output_text





					def 							lowerCAmelCase      (				self   :							str    ):
												pass  # TODO add if relevant





					def 							lowerCAmelCase      (				self   :							Tuple    ):
												pass  # TODO add if relevant





					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												pass  # TODO add if relevant





					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												__snake_case     			=       self.tokenizer_class(self.vocab_file							,						subword_tokenizer_type="character"    )

												__snake_case     			=       tokenizer.tokenize("こんにちは、世界。 \nこんばんは、世界。"    )
												self.assertListEqual(
												    UpperCAmelCase_							,						["こ", "ん", "に", "ち", "は", "、", "世", "界", "。", "こ", "ん", "ば", "ん", "は", "、", "世", "界", "。"]    )
												self.assertListEqual(
												    tokenizer.convert_tokens_to_ids(UpperCAmelCase_    )							,						[3, 4, 5, 6, 7, 11, 9, 10, 12, 3, 4, 8, 4, 7, 11, 9, 10, 12]    )





					def 							lowerCAmelCase      (				self   :							Dict    ):
												__snake_case     			=       ["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

												__snake_case     			=       {}
												for i, token in enumerate(UpperCAmelCase_    ):
																			__snake_case     			=       i
												__snake_case     			=       CharacterTokenizer(vocab=UpperCAmelCase_							,						unk_token="[UNK]"    )

												self.assertListEqual(tokenizer.tokenize(""    )							,						[]    )

												self.assertListEqual(tokenizer.tokenize("こんにちは"    )							,						["こ", "ん", "に", "ち", "は"]    )

												self.assertListEqual(tokenizer.tokenize("こんにちほ"    )							,						["こ", "ん", "に", "ち", "[UNK]"]    )





					def 							lowerCAmelCase      (				self   :							Optional[Any]    ):
												__snake_case     			=       self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese-char"    )

												__snake_case     			=       tokenizer.encode("ありがとう。"							,						add_special_tokens=UpperCAmelCase_    )
												__snake_case     			=       tokenizer.encode("どういたしまして。"							,						add_special_tokens=UpperCAmelCase_    )

												__snake_case     			=       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_    )
												__snake_case     			=       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_							,						UpperCAmelCase_    )

												# 2 is for "[CLS]", 3 is for "[SEP]"
												assert encoded_sentence == [2] + text + [3]
												assert encoded_pair == [2] + text + [3] + text_a + [3]







@custom_tokenizers
class 							__magic_name__     (		unittest.TestCase   ):

					'''simple docstring'''





					def 							lowerCAmelCase      (				self   :							Union[str, Any]    ):
												__snake_case     			=       "cl-tohoku/bert-base-japanese"
												__snake_case     			=       AutoTokenizer.from_pretrained(UpperCAmelCase_    )
												self.assertIsInstance(UpperCAmelCase_							,						UpperCAmelCase_    )







class 							__magic_name__     (		unittest.TestCase   ):

					'''simple docstring'''





					def 							lowerCAmelCase      (				self   :							Optional[int]    ):
												__snake_case     			=       "cl-tohoku/bert-base-japanese"
												with self.assertLogs("transformers"							,						level="WARNING"    ) as cm:
																			BertTokenizer.from_pretrained(UpperCAmelCase_    )
																			self.assertTrue(
																			    cm.records[0].message.startswith(
																			        "The tokenizer class you load from this checkpoint is not the same type as the class this function"
																			        " is called from."    )    )
												__snake_case     			=       "bert-base-cased"
												with self.assertLogs("transformers"							,						level="WARNING"    ) as cm:
																			BertJapaneseTokenizer.from_pretrained(UpperCAmelCase_    )
																			self.assertTrue(
																			    cm.records[0].message.startswith(
																			        "The tokenizer class you load from this checkpoint is not the same type as the class this function"
																			        " is called from."    )    )


"""simple docstring"""







from __future__ import annotations

from typing import Any
def   __UpperCamelCase   (					SCREAMING_SNAKE_CASE )  ->     int:







							"""simple docstring"""


							if not postfix_notation:
														return 0

							__snake_case     			=       {"+", "-", "*", "/"}
							__snake_case     			=       []

							for token in postfix_notation:
														if token in operations:
																					__snake_case			,   __snake_case     			=       stack.pop(), stack.pop()
																					if token == "+":
																												stack.append(a + b )
																					elif token == "-":
																												stack.append(a - b )
																					elif token == "*":
																												stack.append(a * b )
																					else:
																												if a * b < 0 and a % b != 0:
																																			stack.append(a // b + 1 )
																												else:
																																			stack.append(a // b )
														else:
																					stack.append(int(SCREAMING_SNAKE_CASE ) )

							return stack.pop()


if __name__ == "__main__":
		import doctest

		doctest.testmod()
