code: 
  
  from __future__ import annotations
  
  from queue import Queue
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int					)				->							tuple[int, int]:
  	a ^= b
  	b ^= a
  	a ^= b
  	return a, b
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      list[list[int]]					)				->							list[list[int]]:
  	__A   : Optional[int]								= 1
  	while (1 << j) < max_node:
  		for i in range(1 ,max_node + 1					):
  			__A   : str								= parent[j - 1][parent[j - 1][i]]
  		j += 1
  	return parent
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      list[int] ,a__						:      list[list[int]]					)				->							int:
  	# u must be deeper in the tree than v
  	if level[u] < level[v]:
  		__A						,							__A   : Tuple								= 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]:
  			__A   : Tuple								= 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   : Union[str, Any]								= parent[i][u], parent[i][v]
      # returning longest common ancestor of u,v
  	return parent[0][u]
  def        __SCREAMING_SNAKE_CASE    (      a__						:      list[int] ,a__						:      list[list[int]] ,a__						:      int ,a__						:      dict[int, list[int]] ,a__						:      int = 1 ,)				->							tuple[list[int], list[list[int]]]:
  	__A   : Tuple								= 0
  	__A   : Queue[int]								= Queue(maxsize=a__					)
  	q.put(a__					)
  	while q.qsize() != 0:
  		__A   : Any								= q.get()
  		for v in graph[u]:
  			if level[v] == -1:
  				__A   : Optional[int]								= level[u] + 1
  				q.put(a__					)
  				__A   : Optional[Any]								= u
  	return level, parent
  def        __SCREAMING_SNAKE_CASE    (      )				->							None:
  	__A   : Any								= 13
  	# initializing with 0
  	__A   : Dict								= [[0 for _ in range(max_node + 10					)] for _ in range(20					)]
  	# initializing with -1 which means every node is unvisited
  	__A   : Tuple								= [-1 for _ in range(max_node + 10					)]
  	__A   : dict[int, list[int]]								= {
  	    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   : Tuple								= breadth_first_search(a__ ,a__ ,a__ ,a__ ,1					)
  	__A   : Optional[int]								= 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: 
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfigWithPast
  from ...utils import logging
  
  
  UpperCAmelCase_       :				int		   =      logging.get_logger(__name__)
  
  UpperCAmelCase_       :				Any		   =      {
      '''uclanlp/plbart-base''': '''https://huggingface.co/uclanlp/plbart-base/resolve/main/config.json''',
      # See all PLBART models at https://huggingface.co/models?filter=plbart
  }
  
  
  
  
  
  
  class     lowerCamelCase_			(  _lowercase  ):
  	_lowercase		:      str    				=							'''plbart'''
  	_lowercase		:      str    				=							['''past_key_values''']
  	_lowercase		:      Any    				=							{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
  
  
  
  
  	def __init__(    self	:    List[Any]				,			__A	:    str=5_0005				,			__A	:    Union[str, Any]=1024				,			__A	:    int=6				,			__A	:    Dict=3072				,			__A	:    Union[str, Any]=12				,			__A	:    Tuple=6				,			__A	:    Tuple=3072				,			__A	:    Optional[int]=12				,			__A	:    int=0.0				,			__A	:    List[Any]=0.0				,			__A	:    Union[str, Any]=True				,			__A	:    Any=True				,			__A	:    Optional[int]="gelu"				,			__A	:    Optional[int]=768				,			__A	:    Any=0.1				,			__A	:    Union[str, Any]=0.1				,			__A	:    Union[str, Any]=0.0				,			__A	:    int=0.0_2				,			__A	:    Union[str, Any]=0.0				,			__A	:    Tuple=True				,			__A	:    List[str]=1				,			__A	:    str=0				,			__A	:    List[Any]=2				,			__A	:    Any=2				,			**__A	:    Union[str, Any]				,			):
  		__A   : List[Any]								= vocab_size
  		__A   : str								= max_position_embeddings
  		__A   : Union[str, Any]								= d_model
  		__A   : List[str]								= encoder_ffn_dim
  		__A   : Optional[Any]								= encoder_layers
  		__A   : Tuple								= encoder_attention_heads
  		__A   : List[Any]								= decoder_ffn_dim
  		__A   : Optional[int]								= decoder_layers
  		__A   : Any								= decoder_attention_heads
  		__A   : Optional[int]								= dropout
  		__A   : Any								= attention_dropout
  		__A   : Tuple								= activation_dropout
  		__A   : List[Any]								= activation_function
  		__A   : Tuple								= init_std
  		__A   : List[Any]								= encoder_layerdrop
  		__A   : str								= decoder_layerdrop
  		__A   : Union[str, Any]								= classifier_dropout
  		__A   : Optional[Any]								= use_cache
  		__A   : List[str]								= encoder_layers
  		__A   : Optional[int]								= scale_embedding  # scale factor will be sqrt(d_model) if True
  		super().__init__(
  		    pad_token_id=__A				,			bos_token_id=__A				,			eos_token_id=__A				,			is_encoder_decoder=__A				,			forced_eos_token_id=__A				,			**__A				,			)
  
  
  
  
  
  
  class     lowerCamelCase_			(  _lowercase  ):
  
  
  
  
  	@property
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		return OrderedDict(
  		    [
  		        ("""input_ids""", {0: """batch""", 1: """sequence"""}),
  		        ("""attention_mask""", {0: """batch""", 1: """sequence"""}),
  		    ]       )
  
  
  
  
  	@property
  	def 					lowerCAmelCase_					(    self	:    Tuple       ):
  		if self.use_past:
  			return OrderedDict(
  			    [
  			        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			        ("""past_keys""", {0: """batch""", 2: """sequence"""}),
  			        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			    ]       )
  		else:
  			return OrderedDict(
  			    [
  			        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			    ]       )
  
  
  
  
  
  