


'''simple docstring'''





from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


UpperCAmelCase__     			=							logging.get_logger(__name__)

UpperCAmelCase__     			=							{
    """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json""",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}







class    lowerCamelCase__     ( __lowerCamelCase):
     SCREAMING_SNAKE_CASE__       =    '''mbart'''
     SCREAMING_SNAKE_CASE__       =    ['''past_key_values''']
     SCREAMING_SNAKE_CASE__       =    {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}





     def __init__(self	,  UpperCAmelCase=5_0_2_6_5	,  UpperCAmelCase=1_0_2_4	,  UpperCAmelCase=1_2	,  UpperCAmelCase=4_0_9_6	,  UpperCAmelCase=1_6	,  UpperCAmelCase=1_2	,  UpperCAmelCase=4_0_9_6	,  UpperCAmelCase=1_6	,  UpperCAmelCase=0.0	,  UpperCAmelCase=0.0	,  UpperCAmelCase=True	,  UpperCAmelCase=True	,  UpperCAmelCase="gelu"	,  UpperCAmelCase=1_0_2_4	,  UpperCAmelCase=0.1	,  UpperCAmelCase=0.0	,  UpperCAmelCase=0.0	,  UpperCAmelCase=0.02	,  UpperCAmelCase=0.0	,  UpperCAmelCase=False	,  UpperCAmelCase=1	,  UpperCAmelCase=0	,  UpperCAmelCase=2	,  UpperCAmelCase=2	,  **UpperCAmelCase	,  )  ->     Optional[Any]:
      _lowercase							   =vocab_size
      _lowercase							   =max_position_embeddings
      _lowercase							   =d_model
      _lowercase							   =encoder_ffn_dim
      _lowercase							   =encoder_layers
      _lowercase							   =encoder_attention_heads
      _lowercase							   =decoder_ffn_dim
      _lowercase							   =decoder_layers
      _lowercase							   =decoder_attention_heads
      _lowercase							   =dropout
      _lowercase							   =attention_dropout
      _lowercase							   =activation_dropout
      _lowercase							   =activation_function
      _lowercase							   =init_std
      _lowercase							   =encoder_layerdrop
      _lowercase							   =decoder_layerdrop
      _lowercase							   =classifier_dropout
      _lowercase							   =use_cache
      _lowercase							   =encoder_layers
      _lowercase							   =scale_embedding  # scale factor will be sqrt(d_model) if True
      super().__init__(
          pad_token_id=_lowerCAmelCase	,  bos_token_id=_lowerCAmelCase	,  eos_token_id=_lowerCAmelCase	,  is_encoder_decoder=_lowerCAmelCase	,  forced_eos_token_id=_lowerCAmelCase	,  **_lowerCAmelCase	,  )







class    lowerCamelCase__     ( __lowerCamelCase):





     @property
     def   __A      (self )  ->     Any:
      if self.task in ["default", "seq2seq-lm"]:
       _lowercase							   =OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ] )

       if self.use_past:
        _lowercase							   ={0: """batch"""}
        _lowercase							   ={0: """batch""", 1: """past_decoder_sequence + sequence"""}
       else:
        _lowercase							   ={0: """batch""", 1: """decoder_sequence"""}
        _lowercase							   ={0: """batch""", 1: """decoder_sequence"""}

       if self.use_past:
        self.fill_with_past_key_values_(_lowerCAmelCase	,  direction='''inputs''' )
      elif self.task == "causal-lm":
       # TODO: figure this case out.
       _lowercase							   =OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ] )
       if self.use_past:
        _lowercase							   =self.num_layers
        for i in range(_lowerCAmelCase ):
         _lowercase							   ={0: """batch""", 2: """past_sequence + sequence"""}
         _lowercase							   ={0: """batch""", 2: """past_sequence + sequence"""}
      else:
       _lowercase							   =OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
               ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
           ] )

      return common_inputs





     @property
     def   __A      (self )  ->     Dict:
      if self.task in ["default", "seq2seq-lm"]:
       _lowercase							   =super().outputs
      else:
       _lowercase							   =super(_lowerCAmelCase	,  self ).outputs
       if self.use_past:
        _lowercase							   =self.num_layers
        for i in range(_lowerCAmelCase ):
         _lowercase							   ={0: """batch""", 2: """past_sequence + sequence"""}
         _lowercase							   ={0: """batch""", 2: """past_sequence + sequence"""}
      return common_outputs





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase = -1	,  UpperCAmelCase = -1	,  UpperCAmelCase = False	,  UpperCAmelCase = None	,  )  ->     List[str]:
      _lowercase							   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase )

      # Generate decoder inputs
      _lowercase							   =seq_length if not self.use_past else 1
      _lowercase							   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase )
      _lowercase							   ={f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
      _lowercase							   =dict(**_lowerCAmelCase	,  **_lowerCAmelCase )

      if self.use_past:
       if not is_torch_available():
        raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.''' )
       else:
        import torch
       _lowercase							   =common_inputs["""input_ids"""].shape
       _lowercase							   =common_inputs["""decoder_input_ids"""].shape[1]
       _lowercase							   =self.num_attention_heads
       _lowercase							   =(
           batch,
           num_encoder_attention_heads,
           encoder_seq_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )
       _lowercase							   =decoder_seq_length + 3
       _lowercase							   =(
           batch,
           num_decoder_attention_heads,
           decoder_past_length,
           self._config.hidden_size // num_decoder_attention_heads,
       )

       _lowercase							   =torch.cat(
           [common_inputs['''decoder_attention_mask'''], torch.ones(_lowerCAmelCase	,  _lowerCAmelCase )]	,  dim=1 )

       _lowercase							   =[]
       # If the number of encoder and decoder layers are present in the model configuration, both are considered
       _lowercase							   =self.num_layers
       _lowercase							   =min(_lowerCAmelCase	,  _lowerCAmelCase )
       _lowercase							   =max(_lowerCAmelCase	,  _lowerCAmelCase ) - min_num_layers
       _lowercase							   ="""encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

       for _ in range(_lowerCAmelCase ):
        common_inputs["past_key_values"].append(
            (
                torch.zeros(_lowerCAmelCase ),
                torch.zeros(_lowerCAmelCase ),
                torch.zeros(_lowerCAmelCase ),
                torch.zeros(_lowerCAmelCase ),
            ) )
       # TODO: test this.
       _lowercase							   =encoder_shape if remaining_side_name == """encoder""" else decoder_shape
       for _ in range(_lowerCAmelCase	,  _lowerCAmelCase ):
        common_inputs["past_key_values"].append((torch.zeros(_lowerCAmelCase ), torch.zeros(_lowerCAmelCase )) )
      return common_inputs





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase = -1	,  UpperCAmelCase = -1	,  UpperCAmelCase = False	,  UpperCAmelCase = None	,  )  ->     Any:
      _lowercase							   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
          _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase )

      if self.use_past:
       if not is_torch_available():
        raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.''' )
       else:
        import torch
       _lowercase							   =common_inputs["""input_ids"""].shape
       # Not using the same length for past_key_values
       _lowercase							   =seqlen + 2
       _lowercase							   =self.num_layers
       _lowercase							   =self.num_attention_heads
       _lowercase							   =(
           batch,
           num_encoder_attention_heads,
           past_key_values_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )

       _lowercase							   =common_inputs["""attention_mask"""].dtype
       _lowercase							   =torch.cat(
           [common_inputs['''attention_mask'''], torch.ones(_lowerCAmelCase	,  _lowerCAmelCase	,  dtype=_lowerCAmelCase )]	,  dim=1 )
       _lowercase							   =[
           (torch.zeros(_lowerCAmelCase ), torch.zeros(_lowerCAmelCase )) for _ in range(_lowerCAmelCase )
       ]
      return common_inputs





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase = -1	,  UpperCAmelCase = -1	,  UpperCAmelCase = False	,  UpperCAmelCase = None	,  )  ->     Optional[Any]:
      # Copied from OnnxConfig.generate_dummy_inputs
      # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
      # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
      _lowercase							   =compute_effective_axis_dimension(
          _lowerCAmelCase	,  fixed_dimension=OnnxConfig.default_fixed_batch	,  num_token_to_add=0 )

      # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
      _lowercase							   =tokenizer.num_special_tokens_to_add(_lowerCAmelCase )
      _lowercase							   =compute_effective_axis_dimension(
          _lowerCAmelCase	,  fixed_dimension=OnnxConfig.default_fixed_sequence	,  num_token_to_add=_lowerCAmelCase )

      # Generate dummy inputs according to compute batch and sequence
      _lowercase							   =[""" """.join([tokenizer.unk_token] ) * seq_length] * batch_size
      _lowercase							   =dict(tokenizer(_lowerCAmelCase	,  return_tensors=_lowerCAmelCase ) )
      return common_inputs





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase = -1	,  UpperCAmelCase = -1	,  UpperCAmelCase = False	,  UpperCAmelCase = None	,  )  ->     Tuple:
      if self.task in ["default", "seq2seq-lm"]:
       _lowercase							   =self._generate_dummy_inputs_for_default_and_seqaseq_lm(
           _lowerCAmelCase	,  batch_size=_lowerCAmelCase	,  seq_length=_lowerCAmelCase	,  is_pair=_lowerCAmelCase	,  framework=_lowerCAmelCase )

      elif self.task == "causal-lm":
       _lowercase							   =self._generate_dummy_inputs_for_causal_lm(
           _lowerCAmelCase	,  batch_size=_lowerCAmelCase	,  seq_length=_lowerCAmelCase	,  is_pair=_lowerCAmelCase	,  framework=_lowerCAmelCase )
      else:
       _lowercase							   =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           _lowerCAmelCase	,  batch_size=_lowerCAmelCase	,  seq_length=_lowerCAmelCase	,  is_pair=_lowerCAmelCase	,  framework=_lowerCAmelCase )

      return common_inputs





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase )  ->     Optional[Any]:
      if self.task in ["default", "seq2seq-lm"]:
       _lowercase							   =super()._flatten_past_key_values_(_lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase )
      else:
       _lowercase							   =super(_lowerCAmelCase	,  self )._flatten_past_key_values_(
           _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase )





from collections import deque
def        UpperCAmelCase_      (							__snake_case		)  ->    Any:







 """simple docstring"""


 return input(__snake_case		).strip().split(''' '''		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    dict[int, list[int]]:







 """simple docstring"""


 _lowercase							   ={}
 for i in range(__snake_case		):
  _lowercase							   =[]

 for e in range(__snake_case		):
  _lowercase   ,					_lowercase							   =(int(__snake_case		) for i in _input(F"Edge {e + 1}: <node1> <node2> "		))
  graph[x].append(__snake_case		)
 return graph
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    dict[int, list[int]]:







 """simple docstring"""


 _lowercase							   ={}
 for i in range(__snake_case		):
  _lowercase							   =[]

 for e in range(__snake_case		):
  _lowercase   ,					_lowercase							   =(int(__snake_case		) for i in _input(F"Edge {e + 1}: <node1> <node2> "		))
  graph[x].append(__snake_case		)
  graph[y].append(__snake_case		)
 return graph
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    dict[int, list[tuple[int, int]]]:







 """simple docstring"""


 _lowercase							   ={}
 for i in range(__snake_case		):
  _lowercase							   =[]

 for e in range(__snake_case		):
  _lowercase   ,					_lowercase   ,					_lowercase							   =(int(__snake_case		) for i in _input(F"Edge {e + 1}: <node1> <node2> <weight> "		))
  graph[x].append((y, w)		)
  graph[y].append((x, w)		)
 return graph


if __name__ == "__main__":
  UpperCAmelCase__			,UpperCAmelCase__     			=							(int(i) for i in _input('''Number of nodes and edges: '''))

  UpperCAmelCase__     			=							int(
      _input(
          '''Press 1 or 2 or 3 \n'''
          '''1. Unweighted directed \n'''
          '''2. Unweighted undirected \n'''
          '''3. Weighted undirected \n'''
      )[0]
  )

  UpperCAmelCase__     			=							{
      1: initialize_unweighted_directed_graph,
      2: initialize_unweighted_undirected_graph,
      3: initialize_weighted_undirected_graph,
  }[graph_choice](n, m)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    Tuple:







 """simple docstring"""


 _lowercase   ,					_lowercase							   ={s}, [s]
 print(__snake_case		)
 while _s:
  _lowercase							   =0
  for i in g[_s[-1]]:
   if i not in vis:
    _s.append(__snake_case		)
    vis.add(__snake_case		)
    _lowercase							   =1
    print(__snake_case		)
    break
  if not flag:
   _s.pop()
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    int:







 """simple docstring"""


 _lowercase   ,					_lowercase							   ={s}, deque([s]		)
 print(__snake_case		)
 while q:
  _lowercase							   =q.popleft()
  for v in g[u]:
   if v not in vis:
    vis.add(__snake_case		)
    q.append(__snake_case		)
    print(__snake_case		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    Optional[int]:







 """simple docstring"""


 _lowercase   ,					_lowercase   ,					_lowercase							   ={s: 0}, set(), {s: 0}
 while True:
  if len(__snake_case		) == len(__snake_case		) - 1:
   break
  _lowercase							   =100000
  for i in dist:
   if i not in known and dist[i] < mini:
    _lowercase							   =dist[i]
    _lowercase							   =i
  known.add(__snake_case		)
  for v in g[u]:
   if v[0] not in known and dist[u] + v[1] < dist.get(v[0]  ,		100000		):
    _lowercase							   =dist[u] + v[1]
    _lowercase							   =u
 for i in dist:
  if i != s:
   print(dist[i]		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case=None  ,		__snake_case=None		)  ->    Tuple:







 """simple docstring"""


 if q is None:
  _lowercase							   =[1]
 if ind is None:
  _lowercase							   =[0] * (len(__snake_case		) + 1)  # SInce oth Index is ignored
  for u in g:
   for v in g[u]:
    ind[v] += 1
  _lowercase							   =deque()
  for i in g:
   if ind[i] == 0:
    q.append(__snake_case		)
 if len(__snake_case		) == 0:
  return
 _lowercase							   =q.popleft()
 print(__snake_case		)
 for w in g[v]:
  ind[w] -= 1
  if ind[w] == 0:
   q.append(__snake_case		)
 topo(__snake_case  ,		__snake_case  ,		__snake_case		)
def        UpperCAmelCase_      (							)  ->    Tuple:







 """simple docstring"""


 _lowercase							   =input().strip()
 _lowercase							   =[]
 for _ in range(__snake_case		):
  a.append(map(__snake_case  ,		input().strip().split()		)		)
 return a, n
def        UpperCAmelCase_      (							__snake_case		)  ->    Any:







 """simple docstring"""


 ((_lowercase)   ,					(_lowercase))							   =a_and_n
 _lowercase							   =list(__snake_case		)
 _lowercase							   =[[0] * n for i in range(__snake_case		)]
 for k in range(__snake_case		):
  for i in range(__snake_case		):
   for j in range(__snake_case		):
    if dist[i][j] > dist[i][k] + dist[k][j]:
     _lowercase							   =dist[i][k] + dist[k][j]
     _lowercase							   =k
 print(__snake_case		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    Optional[Any]:







 """simple docstring"""


 _lowercase   ,					_lowercase   ,					_lowercase							   ={s: 0}, set(), {s: 0}
 while True:
  if len(__snake_case		) == len(__snake_case		) - 1:
   break
  _lowercase							   =100000
  for i in dist:
   if i not in known and dist[i] < mini:
    _lowercase							   =dist[i]
    _lowercase							   =i
  known.add(__snake_case		)
  for v in g[u]:
   if v[0] not in known and v[1] < dist.get(v[0]  ,		100000		):
    _lowercase							   =v[1]
    _lowercase							   =u
 return dist
def        UpperCAmelCase_      (							)  ->    Dict:







 """simple docstring"""


 _lowercase   ,					_lowercase							   =map(__snake_case  ,		input().split(''' '''		)		)
 _lowercase							   =[]
 for _ in range(__snake_case		):
  edges.append(map(__snake_case  ,		input().split(''' '''		)		)		)
 return edges, n
def        UpperCAmelCase_      (							__snake_case		)  ->    str:







 """simple docstring"""


 ((_lowercase)   ,					(_lowercase))							   =e_and_n
 e.sort(reverse=__snake_case  ,		key=lambda __snake_case		: x[2]		)
 _lowercase							   =[{i} for i in range(1  ,		n + 1		)]
 while True:
  if len(__snake_case		) == 1:
   break
  print(__snake_case		)
  _lowercase							   =e.pop()
  for i in range(len(__snake_case		)		):
   if x[0] in s[i]:
    break
  for j in range(len(__snake_case		)		):
   if x[1] in s[j]:
    if i == j:
     break
    s[j].update(s[i]		)
    s.pop(__snake_case		)
    break



def        UpperCAmelCase_      (							__snake_case		)  ->    Tuple:







 """simple docstring"""


 _lowercase							   =[]
 for node in graph:
  if not graph[node]:
   isolated.append(__snake_case		)
 return isolated

