





from collections import deque


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Any):



  '''simple docstring'''






  return input(__snake_case).strip().split(''' ''')


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		List[str]  ,				__lowercase:		Optional[Any]):



  '''simple docstring'''






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

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


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Optional[Any]  ,				__lowercase:		int):



  '''simple docstring'''






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

  for e in range(__snake_case):
    __lowerCAmelCase						,    __lowerCAmelCase								=					(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        __SCREAMING_SNAKE_CASE	(				__lowercase:		List[Any]  ,				__lowercase:		Optional[Any]):



  '''simple docstring'''






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

  for e in range(__snake_case):
    __lowerCAmelCase						,    __lowerCAmelCase						,    __lowerCAmelCase								=					(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__":
      __lowercase    ,							__lowercase				    =      (int(i) for i in _input("""Number of nodes and edges: """))

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

      __lowercase				    =      {
          1: initialize_unweighted_directed_graph,
          2: initialize_unweighted_undirected_graph,
          3: initialize_weighted_undirected_graph,
      }[graph_choice](n, m)


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Dict  ,				__lowercase:		Any):



  '''simple docstring'''






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


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Optional[int]  ,				__lowercase:		Optional[int]):



  '''simple docstring'''






  __lowerCAmelCase						,    __lowerCAmelCase								=					{s}, deque([s])
  print(__snake_case)
  while q:
    __lowerCAmelCase								=					q.popleft()
    for v in g[u]:
      if v not in vis:
        vis.add(__snake_case)
        q.append(__snake_case)
        print(__snake_case)


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		str  ,				__lowercase:		Optional[Any]):



  '''simple docstring'''






  __lowerCAmelCase						,    __lowerCAmelCase						,    __lowerCAmelCase								=					{s: 0}, set(), {s: 0}
  while True:
    if len(__snake_case) == len(__snake_case) - 1:
      break
    __lowerCAmelCase								=					10_00_00
    for i in dist:
      if i not in known and dist[i] < mini:
        __lowerCAmelCase								=					dist[i]
        __lowerCAmelCase								=					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]  ,				10_00_00):
        __lowerCAmelCase								=					dist[u] + v[1]
        __lowerCAmelCase								=					u
  for i in dist:
    if i != s:
      print(dist[i])


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Optional[int]  ,				__lowercase:		List[Any]=None  ,				__lowercase:		Optional[int]=None):



  '''simple docstring'''






  if q is None:
    __lowerCAmelCase								=					[1]
  if ind is None:
    __lowerCAmelCase								=					[0] * (len(__snake_case) + 1)  # SInce oth Index is ignored
    for u in g:
      for v in g[u]:
        ind[v] += 1
    __lowerCAmelCase								=					deque()
    for i in g:
      if ind[i] == 0:
        q.append(__snake_case)
  if len(__snake_case) == 0:
    return
  __lowerCAmelCase								=					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        __SCREAMING_SNAKE_CASE	(				):



  '''simple docstring'''






  __lowerCAmelCase								=					input().strip()
  __lowerCAmelCase								=					[]
  for _ in range(__snake_case):
    a.append(map(__snake_case  ,				input().strip().split()))
  return a, n


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Tuple):



  '''simple docstring'''






  ((__lowerCAmelCase)						,    (__lowerCAmelCase))								=					a_and_n
  __lowerCAmelCase								=					list(__snake_case)
  __lowerCAmelCase								=					[[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]:
          __lowerCAmelCase								=					dist[i][k] + dist[k][j]
          __lowerCAmelCase								=					k
  print(__snake_case)


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Optional[Any]  ,				__lowercase:		List[str]):



  '''simple docstring'''






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


def        __SCREAMING_SNAKE_CASE	(				):



  '''simple docstring'''






  __lowerCAmelCase						,    __lowerCAmelCase								=					map(__snake_case  ,				input().split(''' '''))
  __lowerCAmelCase								=					[]
  for _ in range(__snake_case):
    edges.append(map(__snake_case  ,				input().split(''' ''')))
  return edges, n


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Tuple):



  '''simple docstring'''






  ((__lowerCAmelCase)						,    (__lowerCAmelCase))								=					e_and_n
  e.sort(reverse=__snake_case  ,				key=lambda __lowercase: x[2])
  __lowerCAmelCase								=					[{i} for i in range(1  ,				n + 1)]
  while True:
    if len(__snake_case) == 1:
      break
    print(__snake_case)
    __lowerCAmelCase								=					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        __SCREAMING_SNAKE_CASE	(				__lowercase:		Optional[Any]):



  '''simple docstring'''






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




from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCAmelCase__        =				logging.get_logger(__name__)

UpperCAmelCase__        =				{
    '''google/rembert''': '''https://huggingface.co/google/rembert/resolve/main/config.json''',
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}







class  lowerCamelCase__  (			lowerCAmelCase):
     SCREAMING_SNAKE_CASE__      =     '''rembert'''





     def __init__(self						,	UpperCAmelCase=2_5_0_3_0_0						,	UpperCAmelCase=1_1_5_2						,	UpperCAmelCase=3_2						,	UpperCAmelCase=1_8						,	UpperCAmelCase=2_5_6						,	UpperCAmelCase=1_6_6_4						,	UpperCAmelCase=4_6_0_8						,	UpperCAmelCase="gelu"						,	UpperCAmelCase=0.0						,	UpperCAmelCase=0.0						,	UpperCAmelCase=0.1						,	UpperCAmelCase=5_1_2						,	UpperCAmelCase=2						,	UpperCAmelCase=0.02						,	UpperCAmelCase=1e-12						,	UpperCAmelCase=True						,	UpperCAmelCase=0						,	UpperCAmelCase=3_1_2						,	UpperCAmelCase=3_1_3						,	**UpperCAmelCase						,	)	->  Tuple:
      super().__init__(pad_token_id=UpperCAmelCase						,	bos_token_id=UpperCAmelCase						,	eos_token_id=UpperCAmelCase						,	**UpperCAmelCase			)

      _lowercase				 =vocab_size
      _lowercase				 =input_embedding_size
      _lowercase				 =output_embedding_size
      _lowercase				 =max_position_embeddings
      _lowercase				 =hidden_size
      _lowercase				 =num_hidden_layers
      _lowercase				 =num_attention_heads
      _lowercase				 =intermediate_size
      _lowercase				 =hidden_act
      _lowercase				 =hidden_dropout_prob
      _lowercase				 =attention_probs_dropout_prob
      _lowercase				 =classifier_dropout_prob
      _lowercase				 =initializer_range
      _lowercase				 =type_vocab_size
      _lowercase				 =layer_norm_eps
      _lowercase				 =use_cache
      _lowercase				 =False







class  lowerCamelCase__  (			lowerCAmelCase):





     @property
     def 	__A   (self			)	->  Mapping[str, Mapping[int, str]]:
      if self.task == "multiple-choice":
       _lowercase				 ={0: '''batch''', 1: '''choice''', 2: '''sequence'''}
      else:
       _lowercase				 ={0: '''batch''', 1: '''sequence'''}
      return OrderedDict(
          [
              ('''input_ids''', dynamic_axis),
              ('''attention_mask''', dynamic_axis),
              ('''token_type_ids''', dynamic_axis),
          ]			)





     @property
     def 	__A   (self			)	->  float:
      return 1e-4

