





from collections import deque



def  UpperCamelCase__     (   _A:    Dict				):




      '''simple docstring'''







      __lowerCamelCase				   =       len(__snake_case				)
      __lowerCamelCase				   =       deque()
      __lowerCamelCase				   =       [False for _ in range(__snake_case				)]
      __lowerCamelCase				   =       [-1 for _ in range(__snake_case				)]
      __lowerCamelCase				   =       index_of[:]

      def strong_connect(_A:    Any							,    _A:    str							,    _A:    Dict				):
            __lowerCamelCase				   =       index  # the number when this node is seen
            __lowerCamelCase				   =       index  # lowest rank node reachable from here
            index += 1
            stack.append(__snake_case				)
            __lowerCamelCase				   =       True

            for w in g[v]:
                  if index_of[w] == -1:
                        __lowerCamelCase				   =       strong_connect(__snake_case							,    __snake_case							,    __snake_case				)
                        __lowerCamelCase				   =       (
                            lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
                        )
                  elif on_stack[w]:
                        __lowerCamelCase				   =       (
                            lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
                        )

            if lowlink_of[v] == index_of[v]:
                  __lowerCamelCase				   =       []
                  __lowerCamelCase				   =       stack.pop()
                  __lowerCamelCase				   =       False
                  component.append(__snake_case				)
                  while w != v:
                        __lowerCamelCase				   =       stack.pop()
                        __lowerCamelCase				   =       False
                        component.append(__snake_case				)
                  components.append(__snake_case				)
            return index

      __lowerCamelCase				   =       []
      for v in range(__snake_case				):
            if index_of[v] == -1:
                  strong_connect(__snake_case							,    0							,    __snake_case				)

      return components



def  UpperCamelCase__     (   _A:    int							,    _A:    int				):




      '''simple docstring'''







      __lowerCamelCase				   =       [[] for _ in range(__snake_case				)]
      for u, v in edges:
            g[u].append(__snake_case				)
      return g


if __name__ == "__main__":
   # Test
   _a				:	Union[str, Any]           =       7
   _a				:	List[Any]           =       [0, 0, 1, 2, 3, 3, 4, 4, 6]
   _a				:	Union[str, Any]           =       [1, 3, 2, 0, 1, 4, 5, 6, 5]
   _a				:	Dict           =       [(u, v) for u, v in zip(source, target)]
   _a				:	Any           =       create_graph(n_vertices, edges)

   assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)











"""simple docstring"""






import warnings

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


__snake_case				:  Tuple =       logging.get_logger(__name__)

__snake_case				:  Tuple =       {
    'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/config.json',
    'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/config.json',
}



class      A__  (    __SCREAMING_SNAKE_CASE				):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE        =      'xlnet'
	SCREAMING_SNAKE_CASE        =      ['mems']
	SCREAMING_SNAKE_CASE        =      {
	    'n_token': 'vocab_size',  # Backward compatibility
	    'hidden_size': 'd_model',
	    'num_attention_heads': 'n_head',
	    'num_hidden_layers': 'n_layer',
	}

	def __init__(	self:						Tuple			,     _SCREAMING_SNAKE_CASE:						List[str]=3_2000			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=1024			,     _SCREAMING_SNAKE_CASE:						Dict=24			,     _SCREAMING_SNAKE_CASE:						Optional[int]=16			,     _SCREAMING_SNAKE_CASE:						List[str]=4096			,     _SCREAMING_SNAKE_CASE:						Tuple="gelu"			,     _SCREAMING_SNAKE_CASE:						int=True			,     _SCREAMING_SNAKE_CASE:						List[Any]="bi"			,     _SCREAMING_SNAKE_CASE:						Any=0.02			,     _SCREAMING_SNAKE_CASE:						List[str]=1e-12			,     _SCREAMING_SNAKE_CASE:						Any=0.1			,     _SCREAMING_SNAKE_CASE:						Any=512			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=None			,     _SCREAMING_SNAKE_CASE:						Any=True			,     _SCREAMING_SNAKE_CASE:						Any=False			,     _SCREAMING_SNAKE_CASE:						Tuple=False			,     _SCREAMING_SNAKE_CASE:						List[Any]=-1			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=False			,     _SCREAMING_SNAKE_CASE:						Optional[int]="last"			,     _SCREAMING_SNAKE_CASE:						Tuple=True			,     _SCREAMING_SNAKE_CASE:						Dict="tanh"			,     _SCREAMING_SNAKE_CASE:						int=0.1			,     _SCREAMING_SNAKE_CASE:						Tuple=5			,     _SCREAMING_SNAKE_CASE:						List[str]=5			,     _SCREAMING_SNAKE_CASE:						Optional[Any]=5			,     _SCREAMING_SNAKE_CASE:						Optional[int]=1			,     _SCREAMING_SNAKE_CASE:						Tuple=2			,     **_SCREAMING_SNAKE_CASE:						str			,     )							->			Optional[Any]:

				"""simple docstring"""

				__lowerCAmelCase :    Dict				=			vocab_size
				__lowerCAmelCase :    Optional[int]				=			d_model
				__lowerCAmelCase :    Union[str, Any]				=			n_layer
				__lowerCAmelCase :    List[Any]				=			n_head
				if d_model % n_head != 0:
							raise ValueError(F"""'d_model % n_head' ({d_model % n_head}) should be equal to 0""")
				if "d_head" in kwargs:
							if kwargs["d_head"] != d_model // n_head:
										raise ValueError(
										    F"""`d_head` ({kwargs['d_head']}) should be equal to `d_model // n_head` ({d_model // n_head})""")
				__lowerCAmelCase :    Optional[Any]				=			d_model // n_head
				__lowerCAmelCase :    Tuple				=			ff_activation
				__lowerCAmelCase :    Union[str, Any]				=			d_inner
				__lowerCAmelCase :    Any				=			untie_r
				__lowerCAmelCase :    int				=			attn_type

				__lowerCAmelCase :    Any				=			initializer_range
				__lowerCAmelCase :    List[Any]				=			layer_norm_eps

				__lowerCAmelCase :    int				=			dropout
				__lowerCAmelCase :    List[Any]				=			mem_len
				__lowerCAmelCase :    str				=			reuse_len
				__lowerCAmelCase :    Any				=			bi_data
				__lowerCAmelCase :    Optional[int]				=			clamp_len
				__lowerCAmelCase :    Union[str, Any]				=			same_length

				__lowerCAmelCase :    List[str]				=			summary_type
				__lowerCAmelCase :    Optional[int]				=			summary_use_proj
				__lowerCAmelCase :    Tuple				=			summary_activation
				__lowerCAmelCase :    Dict				=			summary_last_dropout
				__lowerCAmelCase :    str				=			start_n_top
				__lowerCAmelCase :    List[str]				=			end_n_top

				__lowerCAmelCase :    str				=			bos_token_id
				__lowerCAmelCase :    Optional[Any]				=			pad_token_id
				__lowerCAmelCase :    Optional[Any]				=			eos_token_id

				if "use_cache" in kwargs:
							warnings.warn(
							    "The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`"
							    " instead."			,     _SCREAMING_SNAKE_CASE			,     )
							__lowerCAmelCase :    Optional[int]				=			kwargs["use_cache"]

				__lowerCAmelCase :    Optional[int]				=			use_mems_eval
				__lowerCAmelCase :    Any				=			use_mems_train
				super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE			,     bos_token_id=_SCREAMING_SNAKE_CASE			,     eos_token_id=_SCREAMING_SNAKE_CASE			,     **_SCREAMING_SNAKE_CASE)

	@property
	def 				_SCREAMING_SNAKE_CASE  (	self:						Any)							->			int:

				"""simple docstring"""

				logger.info(F"""The model {self.model_type} is one of the few models that has no sequence length limit.""")
				return -1







	@max_position_embeddings.setter
	def 				_SCREAMING_SNAKE_CASE  (	self:						List[str]			,     _SCREAMING_SNAKE_CASE:						Optional[int])							->			Optional[int]:

				"""simple docstring"""

				raise NotImplementedError(
				    F"""The model {self.model_type} is one of the few models that has no sequence length limit.""")