code: 
  from __future__ import annotations
  
  from queue import Queue
  
  
  def       a			(   a		,	a  )    ->tuple[int, int]:
  
  
  
  
  			'''simple docstring'''
  
  
  			a ^= b
  			b ^= a
  			a ^= b
  			return a, b
  
  
  def       a			(   a		,	a  )    ->list[list[int]]:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE    	=   1
  			while (1 << j) < max_node:
  						for i in range(1		,	max_node + 1  ):
  									SCREAMING_SNAKE_CASE    	=   parent[j - 1][parent[j - 1][i]]
  						j += 1
  			return parent
  
  
  def       a			(   a		,	a		,	a		,	a  )    ->int:
  
  
  
  
  			'''simple docstring'''
  
  
  			if level[u] < level[v]:
  						SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   swap(a		,	a  )
  			# making depth of u same as depth of v
  			for i in range(18		,	-1		,	-1  ):
  						if level[u] - (1 << i) >= level[v]:
  									SCREAMING_SNAKE_CASE    	=   parent[i][u]
      # at the same depth if u==v that mean lca is found
  			if u == v:
  						return u
  			# moving both nodes upwards till lca in found
  			for i in range(18		,	-1		,	-1  ):
  						if parent[i][u] not in [0, parent[i][v]]:
  									SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   parent[i][u], parent[i][v]
      # returning longest common ancestor of u,v
  			return parent[0][u]
  
  
  def       a			(   a		,	a		,	a		,	a		,	a = 1		,	)    ->tuple[list[int], list[list[int]]]:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE    	=   0
  			SCREAMING_SNAKE_CASE    	=   Queue(maxsize=a  )
  			q.put(a  )
  			while q.qsize() != 0:
  						SCREAMING_SNAKE_CASE    	=   q.get()
  						for v in graph[u]:
  									if level[v] == -1:
  												SCREAMING_SNAKE_CASE    	=   level[u] + 1
  												q.put(a  )
  												SCREAMING_SNAKE_CASE    	=   u
  			return level, parent
  
  
  def       a			(   )    ->None:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE    	=   13
  			# initializing with 0
  			SCREAMING_SNAKE_CASE    	=   [[0 for _ in range(max_node + 10  )] for _ in range(20  )]
  			# initializing with -1 which means every node is unvisited
  			SCREAMING_SNAKE_CASE    	=   [-1 for _ in range(max_node + 10  )]
  			SCREAMING_SNAKE_CASE    	=   {
  			    1: [2, 3, 4],
  			    2: [5],
  			    3: [6, 7],
  			    4: [8],
  			    5: [9, 10],
  			    6: [11],
  			    7: [],
  			    8: [12, 13],
  			    9: [],
  			    10: [],
  			    11: [],
  			    12: [],
  			    13: [],
  			}
  			SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   breadth_first_search(a		,	a		,	a		,	a		,	1  )
  			SCREAMING_SNAKE_CASE    	=   create_sparse(a		,	a  )
  			print('''LCA of node 1 and 3 is: '''		,	lowest_common_ancestor(1		,	3		,	a		,	a  )  )
  			print('''LCA of node 5 and 6 is: '''		,	lowest_common_ancestor(5		,	6		,	a		,	a  )  )
  			print('''LCA of node 7 and 11 is: '''		,	lowest_common_ancestor(7		,	11		,	a		,	a  )  )
  			print('''LCA of node 6 and 7 is: '''		,	lowest_common_ancestor(6		,	7		,	a		,	a  )  )
  			print('''LCA of node 4 and 12 is: '''		,	lowest_common_ancestor(4		,	12		,	a		,	a  )  )
  			print('''LCA of node 8 and 8 is: '''		,	lowest_common_ancestor(8		,	8		,	a		,	a  )  )
  
  
  if __name__ == "__main__":
  							main()
style_context: 
  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 						lowerCamelCase			(					__lowerCamelCase   ,		unittest.TestCase				):
  	UpperCamelCase_     :				List[str]								=  GPTNeoXJapaneseTokenizer
  	UpperCamelCase_     :				List[Any]								=  False
  	UpperCamelCase_     :				int								=  {'do_clean_text': False, 'add_prefix_space': False}
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[int] )		->			Union[str, Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				super().setUp()
  
  				SCREAMING_SNAKE_CASE    	=   [
  				    '''こん''',
  				    '''こんに''',
  				    '''にちは''',
  				    '''ばんは''',
  				    '''世界,㔺界''',
  				    '''、''',
  				    '''。''',
  				    '''<BR>''',
  				    '''<SP>''',
  				    '''<TAB>''',
  				    '''<URL>''',
  				    '''<EMAIL>''',
  				    '''<TEL>''',
  				    '''<DATE>''',
  				    '''<PRICE>''',
  				    '''<BLOCK>''',
  				    '''<KIGOU>''',
  				    '''<U2000U2BFF>''',
  				    '''<|emoji1|>''',
  				    '''<unk>''',
  				    '''<|startoftext|>''',
  				    '''<|endoftext|>''',
  				]
  				SCREAMING_SNAKE_CASE    	=   {'''emoji''': {'''\ud83d\ude00''': '''<|emoji1|>'''}, '''emoji_inv''': {'''<|emoji1|>''': '''\ud83d\ude00'''}}  # 😀
  				SCREAMING_SNAKE_CASE    	=   {'''unk_token''': '''<unk>'''}
  
  				SCREAMING_SNAKE_CASE    	=   os.path.join(self.tmpdirname      ,    VOCAB_FILES_NAMES['''vocab_file'''] )
  				SCREAMING_SNAKE_CASE    	=   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(lowercase ) )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Dict      ,    **lowercase			:Optional[int] )		->			int:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				kwargs.update(self.special_tokens_map )
  				return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname      ,    **lowercase )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Dict      ,    lowercase			:Union[str, Any] )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   '''こんにちは、世界。 \nこんばんは、㔺界。😀'''
  				SCREAMING_SNAKE_CASE    	=   '''こんにちは、世界。 \nこんばんは、世界。😀'''
  				return input_text, output_text
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[int]      ,    lowercase			:Union[str, Any] )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self.get_input_output_texts(lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.encode(lowercase      ,    add_special_tokens=lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.decode(lowercase      ,    clean_up_tokenization_spaces=lowercase )
  				return text, ids
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Dict )		->			int:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass  # TODO add if relevant
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:List[str] )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass  # TODO add if relevant
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[Any] )		->			Union[str, Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass  # TODO add if relevant
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[Any] )		->			Dict:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   self.get_tokenizer()
  
  				# Testing tokenization
  				SCREAMING_SNAKE_CASE    	=   '''こんにちは、世界。　こんばんは、㔺界。'''
  				SCREAMING_SNAKE_CASE    	=   ['''こん''', '''にちは''', '''、''', '''世界''', '''。''', '''<SP>''', '''こん''', '''ばんは''', '''、''', '''㔺界''', '''。''']
  				SCREAMING_SNAKE_CASE    	=   tokenizer.tokenize(lowercase )
  				self.assertListEqual(lowercase      ,    lowercase )
  
  				# Testing conversion to ids without special tokens
  				SCREAMING_SNAKE_CASE    	=   [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
  				SCREAMING_SNAKE_CASE    	=   tokenizer.convert_tokens_to_ids(lowercase )
  				self.assertListEqual(lowercase      ,    lowercase )
  
  				# Testing conversion to ids with special tokens
  				SCREAMING_SNAKE_CASE    	=   tokens + [tokenizer.unk_token]
  				SCREAMING_SNAKE_CASE    	=   [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 1_9]
  				SCREAMING_SNAKE_CASE    	=   tokenizer.convert_tokens_to_ids(lowercase )
  				self.assertListEqual(lowercase      ,    lowercase )
  
  
  
  
  
  
  
  	@slow
  	def    snake_case__    (    self			:str )		->			Union[str, Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   self.tokenizer_class.from_pretrained('''abeja/gpt-neox-japanese-2.7b''' )
  
  				SCREAMING_SNAKE_CASE    	=   tokenizer.encode('''ありがとう。'''      ,    add_special_tokens=lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.encode('''どういたしまして。'''      ,    add_special_tokens=lowercase )
  
  				SCREAMING_SNAKE_CASE    	=   tokenizer.build_inputs_with_special_tokens(lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.build_inputs_with_special_tokens(lowercase      ,    lowercase )
  
  				assert encoded_sentence == ids_a
  				assert encoded_pair == ids_a + ids_a
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:List[Any] )		->			Dict:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Any )		->			str:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass