

"""simple docstring"""




from __future__ import annotations

from queue import Queue
def    __SCREAMING_SNAKE_CASE						(						lowercase__			,							lowercase__      ):
					"""simple docstring"""
					a ^= b
					b ^= a
					a ^= b
					return a, b
def    __SCREAMING_SNAKE_CASE						(						lowercase__			,							lowercase__      ):
					"""simple docstring"""
					A			=					1
					while (1 << j) < max_node:
										for i in range(1			,							max_node + 1      ):
															A			=					parent[j - 1][parent[j - 1][i]]
										j += 1
					return parent
def    __SCREAMING_SNAKE_CASE						(						lowercase__			,							lowercase__			,							lowercase__			,							lowercase__      ):
					"""simple docstring"""
					# u must be deeper in the tree than v
					if level[u] < level[v]:
										A			,    A			=					swap(UpperCamelCase__			,							UpperCamelCase__      )
					# making depth of u same as depth of v
					for i in range(18			,							-1			,							-1      ):
										if level[u] - (1 << i) >= level[v]:
															A			=					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]]:
															A			,    A			=					parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
					return parent[0][u]
def    __SCREAMING_SNAKE_CASE						(						lowercase__			,							lowercase__			,							lowercase__			,							lowercase__			,							lowercase__ = 1			,							):
					"""simple docstring"""
					A			=					0
					A			=					Queue(maxsize=UpperCamelCase__      )
					q.put(UpperCamelCase__      )
					while q.qsize() != 0:
										A			=					q.get()
										for v in graph[u]:
															if level[v] == -1:
																				A			=					level[u] + 1
																				q.put(UpperCamelCase__      )
																				A			=					u
					return level, parent
def    __SCREAMING_SNAKE_CASE						(						):
					"""simple docstring"""
					A			=					13
					# initializing with 0
					A			=					[[0 for _ in range(max_node + 10      )] for _ in range(20      )]
					# initializing with -1 which means every node is unvisited
					A			=					[-1 for _ in range(max_node + 10      )]
					A			=					{
					    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: [],
					}
					A			,    A			=					breadth_first_search(UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__			,							1      )
					A			=					create_sparse(UpperCamelCase__			,							UpperCamelCase__      )
					print("LCA of node 1 and 3 is: "			,							lowest_common_ancestor(1			,							3			,							UpperCamelCase__			,							UpperCamelCase__      )      )
					print("LCA of node 5 and 6 is: "			,							lowest_common_ancestor(5			,							6			,							UpperCamelCase__			,							UpperCamelCase__      )      )
					print("LCA of node 7 and 11 is: "			,							lowest_common_ancestor(7			,							11			,							UpperCamelCase__			,							UpperCamelCase__      )      )
					print("LCA of node 6 and 7 is: "			,							lowest_common_ancestor(6			,							7			,							UpperCamelCase__			,							UpperCamelCase__      )      )
					print("LCA of node 4 and 12 is: "			,							lowest_common_ancestor(4			,							12			,							UpperCamelCase__			,							UpperCamelCase__      )      )
					print("LCA of node 8 and 8 is: "			,							lowest_common_ancestor(8			,							8			,							UpperCamelCase__			,							UpperCamelCase__      )      )


if __name__ == "__main__":
	main()












from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


_lowerCamelCase       =	{
    'configuration_gptsan_japanese': ['GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTSanJapaneseConfig'],
    'tokenization_gptsan_japanese': ['GPTSanJapaneseTokenizer'],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase       =	[
	    'GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'GPTSanJapaneseForConditionalGeneration',
	    'GPTSanJapaneseModel',
	    'GPTSanJapanesePreTrainedModel',
	]
	_lowerCamelCase       =	[
	    'GPTSanJapaneseTokenizer',
	]


if TYPE_CHECKING:
	from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
	from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gptsan_japanese import (
		    GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTSanJapaneseForConditionalGeneration,
		    GPTSanJapaneseModel,
		    GPTSanJapanesePreTrainedModel,
		)
		from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
	import sys

	_lowerCamelCase       =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)