




"""simple docstring"""

import math
import sys

class     lowercase :







				def __init__(							self				:   str    ):



					"""simple docstring"""

					A_					:			Optional[Any]						=						0
					A_					:			Optional[Any]						=						[]
					A_					:			Dict						=						{}  # To store the pos of node in array







				def    a_					(							self				:   List[str]    ):



					"""simple docstring"""

					return self.cur_size == 0







				def    a_					(							self				:   str ,       _lowerCamelCase				:   List[str]    ):



					"""simple docstring"""

					A_					:			Any						=						self.left(_UpperCAmelCase    )
					A_					:			int						=						self.right(_UpperCAmelCase    )
					if lc < self.cur_size and self.array(_UpperCAmelCase    )[0] < self.array(_UpperCAmelCase    )[0]:
						A_					:			List[str]						=						lc
					else:
						A_					:			Optional[int]						=						idx
					if rc < self.cur_size and self.array(_UpperCAmelCase    )[0] < self.array(_UpperCAmelCase    )[0]:
						A_					:			List[Any]						=						rc
					if smallest != idx:
						self.swap(_UpperCAmelCase ,       _UpperCAmelCase    )
						self.min_heapify(_UpperCAmelCase    )







				def    a_					(							self				:   Dict ,       _lowerCamelCase				:   Dict    ):



					"""simple docstring"""

					A_					:			Optional[Any]						=						self.cur_size
					self.cur_size += 1
					self.array.append((sys.maxsize, tup[1])    )
					self.decrease_key((sys.maxsize, tup[1]) ,       tup[0]    )







				def    a_					(							self				:   List[str]    ):



					"""simple docstring"""

					A_					:			Optional[Any]						=						self.array[0][1]
					A_					:			List[str]						=						self.array[self.cur_size - 1]
					self.cur_size -= 1
					self.min_heapify(1    )
					del self.pos[min_node]
					return min_node







				def    a_					(							self				:   List[str] ,       _lowerCamelCase				:   Optional[Any]    ):



					"""simple docstring"""

					return 2 * i + 1







				def    a_					(							self				:   int ,       _lowerCamelCase				:   Tuple    ):



					"""simple docstring"""

					return 2 * i + 2







				def    a_					(							self				:   int ,       _lowerCamelCase				:   Union[str, Any]    ):



					"""simple docstring"""

					return math.floor(i / 2    )







				def    a_					(							self				:   Tuple ,       _lowerCamelCase				:   List[Any] ,       _lowerCamelCase				:   Tuple    ):



					"""simple docstring"""

					A_					:			List[Any]						=						j
					A_					:			List[Any]						=						i
					A_					:			int						=						self.array[i]
					A_					:			Union[str, Any]						=						self.array[j]
					A_					:			Tuple						=						temp







				def    a_					(							self				:   Optional[int] ,       _lowerCamelCase				:   Any ,       _lowerCamelCase				:   str    ):



					"""simple docstring"""

					A_					:			str						=						self.pos[tup[1]]
					# assuming the new_d is atmost old_d
					A_					:			Any						=						(new_d, tup[1])
					while idx > 0 and self.array[self.par(_UpperCAmelCase    )][0] > self.array[idx][0]:
						self.swap(_UpperCAmelCase ,       self.par(_UpperCAmelCase    )    )
						A_					:			List[Any]						=						self.par(_UpperCAmelCase    )

class     lowercase :







				def __init__(							self				:   List[Any] ,       _lowerCamelCase				:   Dict    ):



					"""simple docstring"""

					A_					:			Union[str, Any]						=						{}  # To store graph: u -> (v,w)
					A_					:			Tuple						=						num  # Number of nodes in graph
					# To store the distance from source vertex
					A_					:			int						=						[0] * self.num_nodes
					A_					:			Optional[int]						=						[-1] * self.num_nodes  # To store the path







				def    a_					(							self				:   Tuple ,       _lowerCamelCase				:   Union[str, Any] ,       _lowerCamelCase				:   int ,       _lowerCamelCase				:   Any    ):



					"""simple docstring"""

					if u in self.adjList:
						self.adjList[u].append((v, w)    )
					else:
						A_					:			List[str]						=						[(v, w)]

					# Assuming undirected graph
					if v in self.adjList:
						self.adjList[v].append((u, w)    )
					else:
						A_					:			Union[str, Any]						=						[(u, w)]







				def    a_					(							self				:   Optional[Any]    ):



					"""simple docstring"""

					for u in self.adjList:
						print(_UpperCAmelCase ,       '''->''' ,       ''' -> '''.join(str(F"""{v}({w})"""    ) for v, w in self.adjList[u]    )    )







				def    a_					(							self				:   List[str] ,       _lowerCamelCase				:   List[str]    ):



					"""simple docstring"""

					A_					:			Dict						=						[-1] * self.num_nodes
					# src is the source node
					A_					:			Optional[int]						=						0
					A_					:			List[str]						=						PriorityQueue()
					q.insert((0, src)    )  # (dist from src, node)
					for u in self.adjList:
						if u != src:
							A_					:			Optional[Any]						=						sys.maxsize  # Infinity
							A_					:			List[str]						=						-1

					while not q.is_empty():
						A_					:			Optional[Any]						=						q.extract_min()  # Returns node with the min dist from source
						# Update the distance of all the neighbours of u and
						# if their prev dist was INFINITY then push them in Q
						for v, w in self.adjList[u]:
							A_					:			Any						=						self.dist[u] + w
							if self.dist[v] > new_dist:
								if self.dist[v] == sys.maxsize:
									q.insert((new_dist, v)    )
								else:
									q.decrease_key((self.dist[v], v) ,       _UpperCAmelCase    )
								A_					:			Any						=						new_dist
								A_					:			Tuple						=						u

        # Show the shortest distances from src
					self.show_distances(_UpperCAmelCase    )







				def    a_					(							self				:   Optional[int] ,       _lowerCamelCase				:   Optional[int]    ):



					"""simple docstring"""

					print(F"""Distance from node: {src}"""    )
					for u in range(self.num_nodes    ):
						print(F"""Node {u} has distance: {self.dist[u]}"""    )







				def    a_					(							self				:   List[Any] ,       _lowerCamelCase				:   Any ,       _lowerCamelCase				:   str    ):



					"""simple docstring"""

					A_					:			Dict						=						[]
					A_					:			Optional[int]						=						0
					A_					:			List[Any]						=						dest
					# Backtracking from dest to src
					while self.par[temp] != -1:
						path.append(_UpperCAmelCase    )
						if temp != src:
							for v, w in self.adjList[temp]:
								if v == self.par[temp]:
									cost += w
									break
						A_					:			str						=						self.par[temp]
					path.append(_UpperCAmelCase    )
					path.reverse()

					print(F"""----Path to reach {dest} from {src}----"""    )
					for u in path:
						print(F"""{u}""" ,       end=''' '''    )
						if u != dest:
							print('''-> ''' ,       end=''''''    )

					print('''\nTotal cost of path: ''' ,       _UpperCAmelCase    )


if __name__ == "__main__":
							_lowerCamelCase					:     int				       =    Graph(9)
							graph.add_edge(0, 1, 4)
							graph.add_edge(0, 7, 8)
							graph.add_edge(1, 2, 8)
							graph.add_edge(1, 7, 11)
							graph.add_edge(2, 3, 7)
							graph.add_edge(2, 8, 2)
							graph.add_edge(2, 5, 4)
							graph.add_edge(3, 4, 9)
							graph.add_edge(3, 5, 14)
							graph.add_edge(4, 5, 10)
							graph.add_edge(5, 6, 2)
							graph.add_edge(6, 7, 1)
							graph.add_edge(6, 8, 6)
							graph.add_edge(7, 8, 7)
							graph.show_graph()
							graph.dijkstra(0)
							graph.show_path(0, 4)

# OUTPUT
# 0 -> 1(4) -> 7(8)
# 1 -> 0(4) -> 2(8) -> 7(11)
# 7 -> 0(8) -> 1(11) -> 6(1) -> 8(7)
# 2 -> 1(8) -> 3(7) -> 8(2) -> 5(4)
# 3 -> 2(7) -> 4(9) -> 5(14)
# 8 -> 2(2) -> 6(6) -> 7(7)
# 5 -> 2(4) -> 3(14) -> 4(10) -> 6(2)
# 4 -> 3(9) -> 5(10)
# 6 -> 5(2) -> 7(1) -> 8(6)
# Distance from node: 0
# Node 0 has distance: 0
# Node 1 has distance: 4
# Node 2 has distance: 12
# Node 3 has distance: 19
# Node 4 has distance: 21
# Node 5 has distance: 11
# Node 6 has distance: 9
# Node 7 has distance: 8
# Node 8 has distance: 14
# ----Path to reach 4 from 0----
# 0 -> 7 -> 6 -> 5 -> 4
# Total cost of path:  21











"""simple docstring"""

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     lowercase (      __UpperCAmelCase       ,		unittest.TestCase):
				__lowerCAmelCase      :      Any					    =				ElectraTokenizer
				__lowerCAmelCase      :      Optional[int]					    =				ElectraTokenizerFast
				__lowerCAmelCase      :      Any					    =				True
				__lowerCAmelCase      :      Tuple					    =				True
				__lowerCAmelCase      :      Optional[Any]					    =				filter_non_english







				def    a_					(							self				:   List[Any]    ):



					"""simple docstring"""

					super().setUp()

					A_					:			int						=						[
					    '''[UNK]''',
					    '''[CLS]''',
					    '''[SEP]''',
					    '''[PAD]''',
					    '''[MASK]''',
					    '''want''',
					    '''##want''',
					    '''##ed''',
					    '''wa''',
					    '''un''',
					    '''runn''',
					    '''##ing''',
					    ''',''',
					    '''low''',
					    '''lowest''',
					]
					A_					:			str						=						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    a_					(							self				:   Any ,       _lowerCamelCase				:   List[str]    ):



					"""simple docstring"""

					A_					:			List[str]						=						'''UNwant\u00E9d,running'''
					A_					:			Optional[int]						=						'''unwanted, running'''
					return input_text, output_text







				def    a_					(							self				:   List[Any]    ):



					"""simple docstring"""

					A_					:			Tuple						=						self.tokenizer_class(self.vocab_file    )

					A_					:			Dict						=						tokenizer.tokenize('''UNwant\u00E9d,running'''    )
					self.assertListEqual(_lowerCamelCase ,       ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']    )
					self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCamelCase    ) ,       [9, 6, 7, 12, 10, 11]    )







				def    a_					(							self				:   str    ):



					"""simple docstring"""

					if not self.test_rust_tokenizer:
						return

					A_					:			Any						=						self.get_tokenizer()
					A_					:			Optional[Any]						=						self.get_rust_tokenizer()

					A_					:			Union[str, Any]						=						'''UNwant\u00E9d,running'''

					A_					:			Optional[int]						=						tokenizer.tokenize(_lowerCamelCase    )
					A_					:			int						=						rust_tokenizer.tokenize(_lowerCamelCase    )
					self.assertListEqual(_lowerCamelCase ,       _lowerCamelCase    )

					A_					:			Optional[int]						=						tokenizer.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )
					A_					:			Union[str, Any]						=						rust_tokenizer.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )
					self.assertListEqual(_lowerCamelCase ,       _lowerCamelCase    )

					A_					:			Any						=						self.get_rust_tokenizer()
					A_					:			Optional[int]						=						tokenizer.encode(_lowerCamelCase    )
					A_					:			List[Any]						=						rust_tokenizer.encode(_lowerCamelCase    )
					self.assertListEqual(_lowerCamelCase ,       _lowerCamelCase    )

					# With lower casing
					A_					:			List[str]						=						self.get_tokenizer(do_lower_case=_lowerCamelCase    )
					A_					:			Any						=						self.get_rust_tokenizer(do_lower_case=_lowerCamelCase    )

					A_					:			List[Any]						=						'''UNwant\u00E9d,running'''

					A_					:			List[str]						=						tokenizer.tokenize(_lowerCamelCase    )
					A_					:			List[str]						=						rust_tokenizer.tokenize(_lowerCamelCase    )
					self.assertListEqual(_lowerCamelCase ,       _lowerCamelCase    )

					A_					:			Optional[Any]						=						tokenizer.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )
					A_					:			Union[str, Any]						=						rust_tokenizer.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )
					self.assertListEqual(_lowerCamelCase ,       _lowerCamelCase    )

					A_					:			List[Any]						=						self.get_rust_tokenizer()
					A_					:			List[Any]						=						tokenizer.encode(_lowerCamelCase    )
					A_					:			Dict						=						rust_tokenizer.encode(_lowerCamelCase    )
					self.assertListEqual(_lowerCamelCase ,       _lowerCamelCase    )







				def    a_					(							self				:   str    ):



					"""simple docstring"""

					A_					:			Union[str, Any]						=						BasicTokenizer()

					self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''    ) ,       ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']    )







				def    a_					(							self				:   List[str]    ):



					"""simple docstring"""

					A_					:			List[str]						=						BasicTokenizer(do_lower_case=_lowerCamelCase    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''    ) ,       ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    ) ,       ['''hello''']    )







				def    a_					(							self				:   Optional[Any]    ):



					"""simple docstring"""

					A_					:			List[Any]						=						BasicTokenizer(do_lower_case=_lowerCamelCase ,       strip_accents=_lowerCamelCase    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    ) ,       ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    ) ,       ['''h\u00E9llo''']    )







				def    a_					(							self				:   Optional[int]    ):



					"""simple docstring"""

					A_					:			Optional[int]						=						BasicTokenizer(do_lower_case=_lowerCamelCase ,       strip_accents=_lowerCamelCase    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    ) ,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    ) ,       ['''hello''']    )







				def    a_					(							self				:   Dict    ):



					"""simple docstring"""

					A_					:			Optional[int]						=						BasicTokenizer(do_lower_case=_lowerCamelCase    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    ) ,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    ) ,       ['''hello''']    )







				def    a_					(							self				:   Any    ):



					"""simple docstring"""

					A_					:			Optional[Any]						=						BasicTokenizer(do_lower_case=_lowerCamelCase    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''    ) ,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']    )







				def    a_					(							self				:   str    ):



					"""simple docstring"""

					A_					:			Tuple						=						BasicTokenizer(do_lower_case=_lowerCamelCase ,       strip_accents=_lowerCamelCase    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    ) ,       ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']    )







				def    a_					(							self				:   Optional[int]    ):



					"""simple docstring"""

					A_					:			Optional[Any]						=						BasicTokenizer(do_lower_case=_lowerCamelCase ,       strip_accents=_lowerCamelCase    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    ) ,       ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']    )







				def    a_					(							self				:   int    ):



					"""simple docstring"""

					A_					:			int						=						BasicTokenizer(do_lower_case=_lowerCamelCase ,       never_split=['''[UNK]''']    )

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''    ) ,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']    )







				def    a_					(							self				:   Optional[Any]    ):



					"""simple docstring"""

					A_					:			str						=						['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

					A_					:			Any						=						{}
					for i, token in enumerate(_lowerCamelCase    ):
						A_					:			int						=						i
					A_					:			str						=						WordpieceTokenizer(vocab=_lowerCamelCase ,       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    a_					(							self				:   Optional[int]    ):



					"""simple docstring"""

					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    a_					(							self				:   Any    ):



					"""simple docstring"""

					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    a_					(							self				:   Optional[int]    ):



					"""simple docstring"""

					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    a_					(							self				:   Dict    ):



					"""simple docstring"""

					A_					:			Optional[int]						=						self.get_tokenizer()
					A_					:			int						=						self.get_rust_tokenizer()

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

					self.assertListEqual(
					    [rust_tokenizer.tokenize(_lowerCamelCase    ) for t in ['''Test''', '''\xad''', '''test''']] ,       [['''[UNK]'''], [], ['''[UNK]''']]    )







				@slow
				def    a_					(							self				:   Union[str, Any]    ):



					"""simple docstring"""

					A_					:			List[Any]						=						self.tokenizer_class.from_pretrained('''google/electra-base-discriminator'''    )

					A_					:			Tuple						=						tokenizer.encode('''sequence builders''' ,       add_special_tokens=_lowerCamelCase    )
					A_					:			List[Any]						=						tokenizer.encode('''multi-sequence build''' ,       add_special_tokens=_lowerCamelCase    )

					A_					:			List[Any]						=						tokenizer.build_inputs_with_special_tokens(_lowerCamelCase    )
					A_					:			Any						=						tokenizer.build_inputs_with_special_tokens(_lowerCamelCase ,       _lowerCamelCase    )

					assert encoded_sentence == [1_01] + text + [1_02]
					assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]







				def    a_					(							self				:   str    ):



					"""simple docstring"""

					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""    ):
							A_					:			Optional[Any]						=						self.rust_tokenizer_class.from_pretrained(_lowerCamelCase ,       **_lowerCamelCase    )

							A_					:			Optional[int]						=						F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
							A_					:			Optional[int]						=						tokenizer_r.encode_plus(
							    _lowerCamelCase ,       return_attention_mask=_lowerCamelCase ,       return_token_type_ids=_lowerCamelCase ,       return_offsets_mapping=_lowerCamelCase ,       add_special_tokens=_lowerCamelCase ,       )

							A_					:			Union[str, Any]						=						tokenizer_r.do_lower_case if hasattr(_lowerCamelCase ,       '''do_lower_case'''    ) else False
							A_					:			List[Any]						=						(
							    [
							        ((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    a_					(							self				:   Optional[Any]    ):



					"""simple docstring"""

					A_					:			str						=						['''的''', '''人''', '''有''']
					A_					:			Optional[int]						=						''''''.join(_lowerCamelCase    )
					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""    ):
							A_					:			List[Any]						=						True
							A_					:			Any						=						self.tokenizer_class.from_pretrained(_lowerCamelCase ,       **_lowerCamelCase    )
							A_					:			str						=						self.rust_tokenizer_class.from_pretrained(_lowerCamelCase ,       **_lowerCamelCase    )

							A_					:			List[Any]						=						tokenizer_p.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )
							A_					:			Any						=						tokenizer_r.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )

							A_					:			Union[str, Any]						=						tokenizer_r.convert_ids_to_tokens(_lowerCamelCase    )
							A_					:			List[Any]						=						tokenizer_p.convert_ids_to_tokens(_lowerCamelCase    )

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

							A_					:			List[Any]						=						False
							A_					:			Any						=						self.rust_tokenizer_class.from_pretrained(_lowerCamelCase ,       **_lowerCamelCase    )
							A_					:			Union[str, Any]						=						self.tokenizer_class.from_pretrained(_lowerCamelCase ,       **_lowerCamelCase    )

							A_					:			Optional[Any]						=						tokenizer_r.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )
							A_					:			int						=						tokenizer_p.encode(_lowerCamelCase ,       add_special_tokens=_lowerCamelCase    )

							A_					:			str						=						tokenizer_r.convert_ids_to_tokens(_lowerCamelCase    )
							A_					:			List[Any]						=						tokenizer_p.convert_ids_to_tokens(_lowerCamelCase    )

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





