






class 					__SCREAMING_SNAKE_CASE:
							def __init__(       self: int    ,		UpperCamelCase: Tuple  )						->						List[str]:
											snake_case__													=       val
											# Number of nodes in left subtree
											snake_case__													=       0
											snake_case__													=       None
											snake_case__													=       None
											snake_case__													=       None


							def lowerCAmelCase_	(       self: Tuple    ,		UpperCamelCase: int  )						->						Tuple:
											assert self.left_tree_size == other.left_tree_size, "Unequal Sizes of Blocks"

											if self.val < other.val:
															snake_case__													=       self.right
															snake_case__													=       None
															if self.right:
																			snake_case__													=       other
															snake_case__													=       other
															snake_case__													=       self.left_tree_size * 2 + 1
															return self
											else:
															snake_case__													=       other.right
															snake_case__													=       None
															if other.right:
																			snake_case__													=       self
															snake_case__													=       self
															snake_case__													=       other.left_tree_size * 2 + 1
															return other


class 					__SCREAMING_SNAKE_CASE:
							def __init__(       self: Tuple    ,		UpperCamelCase: Union[str, Any]=None    ,		UpperCamelCase: int=None    ,		UpperCamelCase: Union[str, Any]=0  )						->						Union[str, Any]:
											snake_case__													=       heap_size
											snake_case__													=       bottom_root
											snake_case__													=       min_node
							def lowerCAmelCase_	(       self: List[Any]    ,		UpperCamelCase: List[str]  )						->						List[Any]:






											if other.size == 0:
															return None
											if self.size == 0:
															snake_case__													=       other.size
															snake_case__													=       other.bottom_root
															snake_case__													=       other.min_node
															return None
											# Update size
											snake_case__													=       self.size + other.size

											# Update min.node
											if self.min_node.val > other.min_node.val:
															snake_case__													=       other.min_node
											# Merge

											# Order roots by left_subtree_size
											snake_case__													=       []
											snake_case__							,  snake_case__													=       self.bottom_root, other.bottom_root
											while i or j:
															if i and ((not j) or i.left_tree_size < j.left_tree_size):
																			combined_roots_list.append((i, True)  )
																			snake_case__													=       i.parent
															else:
																			combined_roots_list.append((j, False)  )
																			snake_case__													=       j.parent
															 # Insert links between them
											for i in range(len(lowercase_  ) - 1  ):
															if combined_roots_list[i][1] != combined_roots_list[i + 1][1]:
																			snake_case__													=       combined_roots_list[i + 1][0]
																			snake_case__													=       combined_roots_list[i][0]
															 # Consecutively merge roots with same left_tree_size
											snake_case__													=       combined_roots_list[0][0]
											while i.parent:
															if (
															    (i.left_tree_size == i.parent.left_tree_size) and (not i.parent.parent)
															) or (
															    i.left_tree_size == i.parent.left_tree_size
															    and i.left_tree_size != i.parent.parent.left_tree_size
															):
																			# Neighbouring Nodes
																			snake_case__													=       i.left
																			snake_case__													=       i.parent.parent

																			# Merging trees
																			snake_case__													=       i.merge_trees(i.parent  )

																			# Updating links
																			snake_case__													=       previous_node
																			snake_case__													=       next_node
																			if previous_node:
																							snake_case__													=       i
																			if next_node:
																							snake_case__													=       i
															else:
																			snake_case__													=       i.parent
															 # Updating self.bottom_root
											while i.left:
															snake_case__													=       i.left
											snake_case__													=       i

											# Update other
											snake_case__													=       self.size
											snake_case__													=       self.bottom_root
											snake_case__													=       self.min_node

											# Return the merged heap
											return self
							def lowerCAmelCase_	(       self: Dict    ,		UpperCamelCase: Tuple  )						->						Optional[Any]:






											if self.size == 0:
															snake_case__													=       Node(lowercase_  )
															snake_case__													=       1
															snake_case__													=       self.bottom_root
											else:
															# Create new node
															snake_case__													=       Node(lowercase_  )

															# Update size
															self.size += 1

															# update min_node
															if val < self.min_node.val:
																			snake_case__													=       new_node
															# Put new_node as a bottom_root in heap
															snake_case__													=       new_node
															snake_case__													=       self.bottom_root
															snake_case__													=       new_node

															# Consecutively merge roots with same left_tree_size
															while (
															    self.bottom_root.parent
															    and self.bottom_root.left_tree_size
															    == self.bottom_root.parent.left_tree_size
															):
																			# Next node
																			snake_case__													=       self.bottom_root.parent.parent

																			# Merge
																			snake_case__													=       self.bottom_root.merge_trees(self.bottom_root.parent  )

																			# Update Links
																			snake_case__													=       next_node
																			snake_case__													=       None
																			if next_node:
																							snake_case__													=       self.bottom_root
							def lowerCAmelCase_	(       self: List[Any]  )						->						str:
											return self.min_node.val
							def lowerCAmelCase_	(       self: List[Any]  )						->						Tuple:
											return self.size == 0
							def lowerCAmelCase_	(       self: Optional[Any]  )						->						List[str]:
											snake_case__													=       self.min_node.val

											# Last element in heap corner case
											if self.size == 1:
															# Update size
															snake_case__													=       0

															# Update bottom root
															snake_case__													=       None

															# Update min_node
															snake_case__													=       None

															return min_value
											# No right subtree corner case
											# The structure of the tree implies that this should be the bottom root
											# and there is at least one other root
											if self.min_node.right is None:
															# Update size
															self.size -= 1

															# Update bottom root
															snake_case__													=       self.bottom_root.parent
															snake_case__													=       None

															# Update min_node
															snake_case__													=       self.bottom_root
															snake_case__													=       self.bottom_root.parent
															while i:
																			if i.val < self.min_node.val:
																							snake_case__													=       i
																			snake_case__													=       i.parent
															return min_value
											# General case
											# Find the BinomialHeap of the right subtree of min_node
											snake_case__													=       self.min_node.right
											snake_case__													=       None
											snake_case__													=       bottom_of_new
											snake_case__													=       1

											# Size, min_node and bottom_root
											while bottom_of_new.left:
															snake_case__													=       size_of_new * 2 + 1
															snake_case__													=       bottom_of_new.left
															if bottom_of_new.val < min_of_new.val:
																			snake_case__													=       bottom_of_new
															 # Corner case of single root on top left path
											if (not self.min_node.left) and (not self.min_node.parent):
															snake_case__													=       size_of_new
															snake_case__													=       bottom_of_new
															snake_case__													=       min_of_new
															# print("Single root, multiple nodes case")
															return min_value
											# Remaining cases
											# Construct heap of right subtree
											snake_case__													=       BinomialHeap(
											    bottom_root=lowercase_    ,		min_node=lowercase_    ,		heap_size=lowercase_  )

											# Update size
											snake_case__													=       self.size - 1 - size_of_new

											# Neighbour nodes
											snake_case__													=       self.min_node.left
											snake_case__													=       self.min_node.parent

											# Initialize new bottom_root and min_node
											snake_case__													=       previous_node or next_node
											snake_case__													=       next_node

											# Update links of previous_node and search below for new min_node and
											# bottom_root
											if previous_node:
															snake_case__													=       next_node

															# Update bottom_root and search for min_node below
															snake_case__													=       previous_node
															snake_case__													=       previous_node
															while self.bottom_root.left:
																			snake_case__													=       self.bottom_root.left
																			if self.bottom_root.val < self.min_node.val:
																							snake_case__													=       self.bottom_root
											if next_node:
															snake_case__													=       previous_node

															# Search for new min_node above min_node
															snake_case__													=       next_node
															while i:
																			if i.val < self.min_node.val:
																							snake_case__													=       i
																			snake_case__													=       i.parent
															 # Merge heaps
											self.merge_heaps(lowercase_  )

											return min_value
							def lowerCAmelCase_	(       self: Dict  )						->						List[str]:
											snake_case__													=       self.bottom_root
											while top_root.parent:
															snake_case__													=       top_root.parent
											# preorder
											snake_case__													=       []
											self.__traversal(lowercase_    ,		lowercase_  )
											return heap_pre_order
							def lowerCAmelCase_	(       self: List[str]    ,		UpperCamelCase: List[Any]    ,		UpperCamelCase: Union[str, Any]    ,		UpperCamelCase: Dict=0  )						->						List[str]:






											if curr_node:
															preorder.append((curr_node.val, level)  )
															self.__traversal(curr_node.left    ,		lowercase_    ,		level + 1  )
															self.__traversal(curr_node.right    ,		lowercase_    ,		level + 1  )
											else:
															preorder.append(('#', level)  )


							def __str__(       self: Optional[int]  )						->						List[str]:






											if self.is_empty():
															return ""
											snake_case__													=       self.pre_order()

											return "\n".join(('-' * level + str(lowercase_  )) for value, level in preorder_heap  )


# Unit Tests
if __name__ == "__main__":
							import doctest

							doctest.testmod()












import os
import unittest

from transformers import ElectraTokenizerFast
from transformers.models.electra.tokenization_electra import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    ElectraTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class 					__SCREAMING_SNAKE_CASE(		a_      ,					unittest.TestCase		):
							_UpperCAmelCase	      =    ElectraTokenizer
							_UpperCAmelCase	      =    ElectraTokenizerFast
							_UpperCAmelCase	      =    True
							_UpperCAmelCase	      =    True
							_UpperCAmelCase	      =    filter_non_english
							def lowerCAmelCase_	(       self: Optional[int]  )						->						int:
											super().setUp()

											snake_case__													=       [
											    '[UNK]',
											    '[CLS]',
											    '[SEP]',
											    '[PAD]',
											    '[MASK]',
											    'want',
											    '##want',
											    '##ed',
											    'wa',
											    'un',
											    'runn',
											    '##ing',
											    ',',
											    'low',
											    'lowest',
											]
											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: str    ,		UpperCamelCase: List[str]  )						->						Union[str, Any]:
											snake_case__													=       'UNwant\u00E9d,running'
											snake_case__													=       'unwanted, running'
											return input_text, output_text
							def lowerCAmelCase_	(       self: List[str]  )						->						List[Any]:
											snake_case__													=       self.tokenizer_class(self.vocab_file  )

											snake_case__													=       tokenizer.tokenize('UNwant\u00E9d,running'  )
											self.assertListEqual(UpperCamelCase    ,		['un', '##want', '##ed', ',', 'runn', '##ing']  )
											self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase  )    ,		[9, 6, 7, 12, 10, 11]  )
							def lowerCAmelCase_	(       self: str  )						->						Tuple:
											if not self.test_rust_tokenizer:
															return

											snake_case__													=       self.get_tokenizer()
											snake_case__													=       self.get_rust_tokenizer()

											snake_case__													=       'UNwant\u00E9d,running'

											snake_case__													=       tokenizer.tokenize(UpperCamelCase  )
											snake_case__													=       rust_tokenizer.tokenize(UpperCamelCase  )
											self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )

											snake_case__													=       tokenizer.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )
											snake_case__													=       rust_tokenizer.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )
											self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )

											snake_case__													=       self.get_rust_tokenizer()
											snake_case__													=       tokenizer.encode(UpperCamelCase  )
											snake_case__													=       rust_tokenizer.encode(UpperCamelCase  )
											self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )

											# With lower casing
											snake_case__													=       self.get_tokenizer(do_lower_case=UpperCamelCase  )
											snake_case__													=       self.get_rust_tokenizer(do_lower_case=UpperCamelCase  )

											snake_case__													=       'UNwant\u00E9d,running'

											snake_case__													=       tokenizer.tokenize(UpperCamelCase  )
											snake_case__													=       rust_tokenizer.tokenize(UpperCamelCase  )
											self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )

											snake_case__													=       tokenizer.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )
											snake_case__													=       rust_tokenizer.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )
											self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )

											snake_case__													=       self.get_rust_tokenizer()
											snake_case__													=       tokenizer.encode(UpperCamelCase  )
											snake_case__													=       rust_tokenizer.encode(UpperCamelCase  )
											self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )
							def lowerCAmelCase_	(       self: Optional[int]  )						->						int:
											snake_case__													=       BasicTokenizer()

											self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'  )    ,		['ah', '\u535A', '\u63A8', 'zz']  )
							def lowerCAmelCase_	(       self: str  )						->						Optional[int]:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '  )    ,		['hello', '!', 'how', 'are', 'you', '?']  )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )    ,		['hello']  )
							def lowerCAmelCase_	(       self: str  )						->						Optional[Any]:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase    ,		strip_accents=UpperCamelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )    ,		['hällo', '!', 'how', 'are', 'you', '?']  )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )    ,		['h\u00E9llo']  )
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Tuple:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase    ,		strip_accents=UpperCamelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )    ,		['hallo', '!', 'how', 'are', 'you', '?']  )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )    ,		['hello']  )
							def lowerCAmelCase_	(       self: str  )						->						Optional[int]:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )    ,		['hallo', '!', 'how', 'are', 'you', '?']  )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )    ,		['hello']  )
							def lowerCAmelCase_	(       self: Any  )						->						int:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '  )    ,		['HeLLo', '!', 'how', 'Are', 'yoU', '?']  )
							def lowerCAmelCase_	(       self: str  )						->						List[str]:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase    ,		strip_accents=UpperCamelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )    ,		['HäLLo', '!', 'how', 'Are', 'yoU', '?']  )
							def lowerCAmelCase_	(       self: int  )						->						str:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase    ,		strip_accents=UpperCamelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )    ,		['HaLLo', '!', 'how', 'Are', 'yoU', '?']  )
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Tuple:
											snake_case__													=       BasicTokenizer(do_lower_case=UpperCamelCase    ,		never_split=['[UNK]']  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'  )    ,		['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']  )
							def lowerCAmelCase_	(       self: Any  )						->						Dict:
											snake_case__													=       ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

											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('unwanted running'  )    ,		['un', '##want', '##ed', 'runn', '##ing']  )

											self.assertListEqual(tokenizer.tokenize('unwantedX running'  )    ,		['[UNK]', 'runn', '##ing']  )
							def lowerCAmelCase_	(       self: Dict  )						->						str:
											self.assertTrue(_is_whitespace(' '  )  )
											self.assertTrue(_is_whitespace('\t'  )  )
											self.assertTrue(_is_whitespace('\r'  )  )
											self.assertTrue(_is_whitespace('\n'  )  )
											self.assertTrue(_is_whitespace('\u00A0'  )  )

											self.assertFalse(_is_whitespace('A'  )  )
											self.assertFalse(_is_whitespace('-'  )  )
							def lowerCAmelCase_	(       self: List[str]  )						->						Dict:
											self.assertTrue(_is_control('\u0005'  )  )

											self.assertFalse(_is_control('A'  )  )
											self.assertFalse(_is_control(' '  )  )
											self.assertFalse(_is_control('\t'  )  )
											self.assertFalse(_is_control('\r'  )  )
							def lowerCAmelCase_	(       self: List[str]  )						->						Tuple:
											self.assertTrue(_is_punctuation('-'  )  )
											self.assertTrue(_is_punctuation('$'  )  )
											self.assertTrue(_is_punctuation('`'  )  )
											self.assertTrue(_is_punctuation('.'  )  )

											self.assertFalse(_is_punctuation('A'  )  )
											self.assertFalse(_is_punctuation(' '  )  )
							def lowerCAmelCase_	(       self: str  )						->						Any:
											snake_case__													=       self.get_tokenizer()
											snake_case__													=       self.get_rust_tokenizer()

											# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
											self.assertListEqual([tokenizer.tokenize(UpperCamelCase  ) for t in ['Test', '\xad', 'test']]    ,		[['[UNK]'], [], ['[UNK]']]  )

											self.assertListEqual(
											    [rust_tokenizer.tokenize(UpperCamelCase  ) for t in ['Test', '\xad', 'test']]    ,		[['[UNK]'], [], ['[UNK]']]  )
							@slow
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Tuple:
											snake_case__													=       self.tokenizer_class.from_pretrained('google/electra-base-discriminator'  )

											snake_case__													=       tokenizer.encode('sequence builders'    ,		add_special_tokens=UpperCamelCase  )
											snake_case__													=       tokenizer.encode('multi-sequence build'    ,		add_special_tokens=UpperCamelCase  )

											snake_case__													=       tokenizer.build_inputs_with_special_tokens(UpperCamelCase  )
											snake_case__													=       tokenizer.build_inputs_with_special_tokens(UpperCamelCase    ,		UpperCamelCase  )

											assert encoded_sentence == [1_01] + text + [1_02]
											assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]
							def lowerCAmelCase_	(       self: List[str]  )						->						Dict:
											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''  ):
																			snake_case__													=       self.rust_tokenizer_class.from_pretrained(UpperCamelCase    ,		**UpperCamelCase  )

																			snake_case__													=       F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																			snake_case__													=       tokenizer_r.encode_plus(
																			    UpperCamelCase    ,		return_attention_mask=UpperCamelCase    ,		return_token_type_ids=UpperCamelCase    ,		return_offsets_mapping=UpperCamelCase    ,		add_special_tokens=UpperCamelCase    ,		)

																			snake_case__													=       tokenizer_r.do_lower_case if hasattr(UpperCamelCase    ,		'do_lower_case'  ) else False
																			snake_case__													=       (
																			    [
																			        ((0, 0), tokenizer_r.cls_token),
																			        ((0, 1), 'A'),
																			        ((1, 2), ','),
																			        ((3, 5), 'na'),
																			        ((5, 6), '##ï'),
																			        ((6, 8), '##ve'),
																			        ((9, 15), tokenizer_r.mask_token),
																			        ((16, 21), 'Allen'),
																			        ((21, 23), '##NL'),
																			        ((23, 24), '##P'),
																			        ((25, 33), 'sentence'),
																			        ((33, 34), '.'),
																			        ((0, 0), tokenizer_r.sep_token),
																			    ]
																			    if not do_lower_case
																			    else [
																			        ((0, 0), tokenizer_r.cls_token),
																			        ((0, 1), 'a'),
																			        ((1, 2), ','),
																			        ((3, 8), 'naive'),
																			        ((9, 15), tokenizer_r.mask_token),
																			        ((16, 21), 'allen'),
																			        ((21, 23), '##nl'),
																			        ((23, 24), '##p'),
																			        ((25, 33), 'sentence'),
																			        ((33, 34), '.'),
																			        ((0, 0), tokenizer_r.sep_token),
																			    ]
																			)

																			self.assertEqual(
																			    [e[1] for e in expected_results]    ,		tokenizer_r.convert_ids_to_tokens(tokens['input_ids']  )  )
																			self.assertEqual([e[0] for e in expected_results]    ,		tokens['offset_mapping']  )


							def lowerCAmelCase_	(       self: Tuple  )						->						Any:
											snake_case__													=       ['的', '人', '有']
											snake_case__													=       ''.join(UpperCamelCase  )
											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''  ):
																			snake_case__													=       True
																			snake_case__													=       self.tokenizer_class.from_pretrained(UpperCamelCase    ,		**UpperCamelCase  )
																			snake_case__													=       self.rust_tokenizer_class.from_pretrained(UpperCamelCase    ,		**UpperCamelCase  )

																			snake_case__													=       tokenizer_p.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )
																			snake_case__													=       tokenizer_r.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )

																			snake_case__													=       tokenizer_r.convert_ids_to_tokens(UpperCamelCase  )
																			snake_case__													=       tokenizer_p.convert_ids_to_tokens(UpperCamelCase  )

																			# it is expected that each Chinese character is not preceded by "##"
																			self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )
																			self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )

																			snake_case__													=       False
																			snake_case__													=       self.rust_tokenizer_class.from_pretrained(UpperCamelCase    ,		**UpperCamelCase  )
																			snake_case__													=       self.tokenizer_class.from_pretrained(UpperCamelCase    ,		**UpperCamelCase  )

																			snake_case__													=       tokenizer_r.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )
																			snake_case__													=       tokenizer_p.encode(UpperCamelCase    ,		add_special_tokens=UpperCamelCase  )

																			snake_case__													=       tokenizer_r.convert_ids_to_tokens(UpperCamelCase  )
																			snake_case__													=       tokenizer_p.convert_ids_to_tokens(UpperCamelCase  )

																			# it is expected that only the first Chinese character is not preceded by "##".
																			snake_case__													=       [
																			    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(UpperCamelCase  )
																			]
																			self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )
																			self.assertListEqual(UpperCamelCase    ,		UpperCamelCase  )




