





from ... import PretrainedConfig


_A					:				Any				=			{
    """sijunhe/nezha-cn-base""": """https://huggingface.co/sijunhe/nezha-cn-base/resolve/main/config.json""",
}



class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    lowerCamelCase__    :		str				=	NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP
    lowerCamelCase__    :		Optional[Any]				=	"""nezha"""



    def __init__(       self   ,				A_=2_11_28   ,				A_=7_68   ,				A_=12   ,				A_=12   ,				A_=30_72   ,				A_="gelu"   ,				A_=0.1   ,				A_=0.1   ,				A_=5_12   ,				A_=64   ,				A_=2   ,				A_=0.02   ,				A_=1E-12   ,				A_=0.1   ,				A_=0   ,				A_=2   ,				A_=3   ,				A_=True   ,				**A_   ,				):





        '''simple docstring'''

        super().__init__(pad_token_id=A_   ,				bos_token_id=A_   ,				eos_token_id=A_   ,				**A_     )

        SCREAMING_SNAKE_CASE__											=			vocab_size
        SCREAMING_SNAKE_CASE__											=			hidden_size
        SCREAMING_SNAKE_CASE__											=			num_hidden_layers
        SCREAMING_SNAKE_CASE__											=			num_attention_heads
        SCREAMING_SNAKE_CASE__											=			hidden_act
        SCREAMING_SNAKE_CASE__											=			intermediate_size
        SCREAMING_SNAKE_CASE__											=			hidden_dropout_prob
        SCREAMING_SNAKE_CASE__											=			attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE__											=			max_position_embeddings
        SCREAMING_SNAKE_CASE__											=			max_relative_position
        SCREAMING_SNAKE_CASE__											=			type_vocab_size
        SCREAMING_SNAKE_CASE__											=			initializer_range
        SCREAMING_SNAKE_CASE__											=			layer_norm_eps
        SCREAMING_SNAKE_CASE__											=			classifier_dropout
        SCREAMING_SNAKE_CASE__											=			use_cache








"""simple docstring"""
class   SCREAMING_SNAKE_CASE	:





	"""simple docstring"""




	def __init__(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_=None  ,  lowerCAmelCase_=None				):
		A_		:    Dict						     = data
		A_		:    Dict						     = previous
		A_		:    int						     = next_node





	def __str__(self				):
		return f"""{self.data}"""





	def  lowerCamelCase(self				):
		return self.data





	def  lowerCamelCase(self				):
		return self.next





	def  lowerCamelCase(self				):
		return self.previous






class   SCREAMING_SNAKE_CASE	:





	"""simple docstring"""




	def __init__(self  ,  lowerCAmelCase_				):
		A_		:    Optional[Any]						     = head





	def __iter__(self				):
		return self





	def  lowerCamelCase(self				):
		if not self.current:
			raise StopIteration
		else:
			A_		:    str						     = self.current.get_data()
			A_		:    List[str]						     = self.current.get_next()
			return value






class   SCREAMING_SNAKE_CASE	:





	"""simple docstring"""




	def __init__(self				):
		A_		:    str						     = None  # First node in list
		A_		:    Tuple						     = None  # Last node in list





	def __str__(self				):
		A_		:    int						     = self.head
		A_		:    str						     = []
		while current is not None:
			nodes.append(current.get_data()				)
			A_		:    Any						     = current.get_next()
		return " ".join(str(lowerCAmelCase_				) for node in nodes				)





	def __contains__(self  ,  lowerCAmelCase_				):
		A_		:    Union[str, Any]						     = self.head
		while current:
			if current.get_data() == value:
				return True
			A_		:    Union[str, Any]						     = current.get_next()
		return False





	def __iter__(self				):
		return LinkedListIterator(self.head				)





	def  lowerCamelCase(self				):
		if self.head:
			return self.head.get_data()
		return None





	def  lowerCamelCase(self				):
		if self.tail:
			return self.tail.get_data()
		return None





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		if self.head is None:
			A_		:    str						     = node
			A_		:    Optional[int]						     = node
		else:
			self.insert_before_node(self.head  ,  lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		if self.head is None:
			self.set_head(lowerCAmelCase_				)
		else:
			self.insert_after_node(self.tail  ,  lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		A_		:    List[Any]						     = Node(lowerCAmelCase_				)
		if self.head is None:
			self.set_head(lowerCAmelCase_				)
		else:
			self.set_tail(lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    str						     = node
		A_		:    Union[str, Any]						     = node.previous

		if node.get_previous() is None:
			A_		:    Dict						     = node_to_insert
		else:
			A_		:    Optional[Any]						     = node_to_insert

		A_		:    Any						     = node_to_insert





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    Dict						     = node
		A_		:    Optional[Any]						     = node.next

		if node.get_next() is None:
			A_		:    Optional[int]						     = node_to_insert
		else:
			A_		:    List[Any]						     = node_to_insert

		A_		:    Optional[Any]						     = node_to_insert





	def  lowerCamelCase(self  ,  lowerCAmelCase_  ,  lowerCAmelCase_				):
		A_		:    str						     = 1
		A_		:    Tuple						     = Node(lowerCAmelCase_				)
		A_		:    Dict						     = self.head
		while node:
			if current_position == position:
				self.insert_before_node(lowerCAmelCase_  ,  lowerCAmelCase_				)
				return
			current_position += 1
			A_		:    List[str]						     = node.next
		self.insert_after_node(self.tail  ,  lowerCAmelCase_				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		A_		:    Dict						     = self.head
		while node:
			if node.get_data() == item:
				return node
			A_		:    Optional[int]						     = node.get_next()
		raise Exception("""Node not found"""				)





	def  lowerCamelCase(self  ,  lowerCAmelCase_				):
		if (node := self.get_node(lowerCAmelCase_				)) is not None:
			if node == self.head:
				A_		:    Tuple						     = self.head.get_next()

			if node == self.tail:
				A_		:    Dict						     = self.tail.get_previous()

			self.remove_node_pointers(lowerCAmelCase_				)





	@staticmethod
	def  lowerCamelCase(lowerCAmelCase_				):
		if node.get_next():
			A_		:    Any						     = node.previous

		if node.get_previous():
			A_		:    int						     = node.next

		A_		:    str						     = None
		A_		:    int						     = None





	def  lowerCamelCase(self				):
		return self.head is None






def       __UpperCamelCase						(		):
	pass


if __name__ == "__main__":
							import doctest

							doctest.testmod()

