

def 					__lowercase      (     _A			)     ->						Dict:
      return [
          {
              0: [1, 2],
              1: [0, 2],
              2: [0, 1, 3, 5],
              3: [2, 4],
              4: [3],
              5: [2, 6, 8],
              6: [5, 7],
              7: [6, 8],
              8: [5, 7],
          },
          {
              0: [6],
              1: [9],
              2: [4, 5],
              3: [4],
              4: [2, 3],
              5: [2],
              6: [0, 7],
              7: [6],
              8: [],
              9: [1],
          },
          {
              0: [4],
              1: [6],
              2: [],
              3: [5, 6, 7],
              4: [0, 6],
              5: [3, 8, 9],
              6: [1, 3, 4, 7],
              7: [3, 6, 8, 9],
              8: [5, 7],
              9: [5, 7],
          },
          {
              0: [1, 3],
              1: [0, 2, 4],
              2: [1, 3, 4],
              3: [0, 2, 4],
              4: [1, 2, 3],
          },
      ][index]






def 					__lowercase      (     _A			)     ->						list[tuple[int, int]]:
      SCREAMING_SNAKE_CASE :      List[Any]       =   0
      SCREAMING_SNAKE_CASE :      Tuple       =   len(_A			)  # No of vertices in graph
      SCREAMING_SNAKE_CASE :      int       =   [0] * n
      SCREAMING_SNAKE_CASE :      Optional[Any]       =   [False] * n

      def dfs(_A						,    _A						,    _A						,    _A			):
            SCREAMING_SNAKE_CASE :      Optional[Any]       =   True
            SCREAMING_SNAKE_CASE :      List[str]       =   id_
            id_ += 1
            for to in graph[at]:
                  if to == parent:
                        pass
                  elif not visited[to]:
                        dfs(_A						,    _A						,    _A						,    id_			)
                        SCREAMING_SNAKE_CASE :      Tuple       =   min(low[at]						,    low[to]			)
                        if id_ <= low[to]:
                              bridges.append((at, to) if at < to else (to, at)			)
                  else:
                        # This edge is a back edge and cannot be a bridge
                        SCREAMING_SNAKE_CASE :      Tuple       =   min(low[at]						,    low[to]			)

      SCREAMING_SNAKE_CASE :      list[tuple[int, int]]       =   []
      for i in range(_A			):
            if not visited[i]:
                  dfs(_A						,    -1						,    _A						,    id_			)
      return bridges


if __name__ == "__main__":
  import doctest

  doctest.testmod()







from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__ :     Dict				    =    logging.get_logger(__name__)

UpperCAmelCase__ :     int				    =    {
    """abeja/gpt-neox-japanese-2.7b""": """https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/config.json""",
}







class        a__       (   UpperCAmelCase       ):







  """simple docstring"""




  UpperCAmelCase__      : Any			       ="""gpt_neox_japanese"""


  def __init__(			self    : Any				,				UpperCAmelCase__    : Any=3_2_0_0_0				,				UpperCAmelCase__    : Dict=2_5_6_0				,				UpperCAmelCase__    : List[str]=3_2				,				UpperCAmelCase__    : Optional[int]=3_2				,				UpperCAmelCase__    : List[str]=4				,				UpperCAmelCase__    : List[str]="gelu"				,				UpperCAmelCase__    : Optional[int]=1.00				,				UpperCAmelCase__    : List[Any]=1_0_0_0_0				,				UpperCAmelCase__    : Tuple=2_0_4_8				,				UpperCAmelCase__    : Optional[int]=0.02				,				UpperCAmelCase__    : Dict=1e-5				,				UpperCAmelCase__    : Dict=True				,				UpperCAmelCase__    : Tuple=3_1_9_9_6				,				UpperCAmelCase__    : Tuple=3_1_9_9_9				,				UpperCAmelCase__    : Dict=0.1				,				UpperCAmelCase__    : Union[str, Any]=0.0				,				**UpperCAmelCase__    : Optional[Any]				,				)					->Optional[Any]:
        """simple docstring"""







        super().__init__(bos_token_id=UpperCAmelCase__				,				eos_token_id=UpperCAmelCase__				,				**UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      List[str]       =   vocab_size
        SCREAMING_SNAKE_CASE :      List[str]       =   max_position_embeddings
        SCREAMING_SNAKE_CASE :      Tuple       =   hidden_size
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   num_hidden_layers
        SCREAMING_SNAKE_CASE :      Optional[int]       =   num_attention_heads
        SCREAMING_SNAKE_CASE :      Any       =   intermediate_multiple_size
        SCREAMING_SNAKE_CASE :      Tuple       =   hidden_act
        SCREAMING_SNAKE_CASE :      Any       =   rotary_pct
        SCREAMING_SNAKE_CASE :      Tuple       =   rotary_emb_base
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   initializer_range
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   layer_norm_eps
        SCREAMING_SNAKE_CASE :      str       =   use_cache
        SCREAMING_SNAKE_CASE :      Any       =   attention_dropout
        SCREAMING_SNAKE_CASE :      str       =   hidden_dropout




