


'''simple docstring'''


class        lowercase__    :





							'''simple docstring'''


							def __init__(       self       ,   __snake_case       ,   __snake_case=None       ,   __snake_case=None    ):
											_SCREAMING_SNAKE_CASE					:			Any							= data
											_SCREAMING_SNAKE_CASE					:			str							= previous
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= next_node






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






							def UpperCAmelCase_      (       self    ):
											return self.data






							def UpperCAmelCase_      (       self    ):
											return self.next






							def UpperCAmelCase_      (       self    ):
											return self.previous





class        lowercase__    :





							'''simple docstring'''


							def __init__(       self       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			List[Any]							= head






							def __iter__(       self    ):
											return self






							def UpperCAmelCase_      (       self    ):
											if not self.current:
															raise StopIteration
											else:
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.current.get_data()
															_SCREAMING_SNAKE_CASE					:			Dict							= self.current.get_next()
															return value





class        lowercase__    :





							'''simple docstring'''


							def __init__(       self    ):
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= None  # First node in list
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= None  # Last node in list






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






							def __contains__(       self       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			List[Any]							= self.head
											while current:
															if current.get_data() == value:
																			return True
															_SCREAMING_SNAKE_CASE					:			Dict							= current.get_next()
											return False






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






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






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






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											if self.head is None:
															_SCREAMING_SNAKE_CASE					:			str							= node
															_SCREAMING_SNAKE_CASE					:			Dict							= node
											else:
															self.insert_before_node(self.head       ,   __snake_case    )






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											if self.head is None:
															self.set_head(__snake_case    )
											else:
															self.insert_after_node(self.tail       ,   __snake_case    )






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			int							= Node(__snake_case    )
											if self.head is None:
															self.set_head(__snake_case    )
											else:
															self.set_tail(__snake_case    )






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			List[Any]							= node
											_SCREAMING_SNAKE_CASE					:			str							= node.previous

											if node.get_previous() is None:
															_SCREAMING_SNAKE_CASE					:			Any							= node_to_insert
											else:
															_SCREAMING_SNAKE_CASE					:			int							= node_to_insert

											_SCREAMING_SNAKE_CASE					:			Optional[int]							= node_to_insert






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= node
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= node.next

											if node.get_next() is None:
															_SCREAMING_SNAKE_CASE					:			str							= node_to_insert
											else:
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= node_to_insert

											_SCREAMING_SNAKE_CASE					:			Any							= node_to_insert






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Tuple							= 1
											_SCREAMING_SNAKE_CASE					:			Any							= Node(__snake_case    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= self.head
											while node:
															if current_position == position:
																			self.insert_before_node(__snake_case       ,   __snake_case    )
																			return
															current_position += 1
															_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= node.next
											self.insert_after_node(self.tail       ,   __snake_case    )






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			str							= self.head
											while node:
															if node.get_data() == item:
																			return node
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= node.get_next()
											raise Exception("""Node not found"""    )






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											if (node := self.get_node(__snake_case    )) is not None:
															if node == self.head:
																			_SCREAMING_SNAKE_CASE					:			Tuple							= self.head.get_next()

															if node == self.tail:
																			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.tail.get_previous()

															self.remove_node_pointers(__snake_case    )






							@staticmethod
							def UpperCAmelCase_      (       __snake_case    ):
											if node.get_next():
															_SCREAMING_SNAKE_CASE					:			Dict							= node.previous

											if node.get_previous():
															_SCREAMING_SNAKE_CASE					:			List[str]							= node.next

											_SCREAMING_SNAKE_CASE					:			Dict							= None
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= None






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







def      snake_case_  (    ):







				"""simple docstring"""







if __name__ == "__main__":
				import doctest

				doctest.testmod()








'''simple docstring'''


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


UpperCAmelCase_						:  str				  =						logging.get_logger(__name__)

UpperCAmelCase_						:  Optional[int]				  =						{
    'SCUT-DLVCLab/lilt-roberta-en-base': (
        'https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base/resolve/main/config.json'
    ),
}





class        lowercase__    (		_snake_case   ):





							'''simple docstring'''


							A_				: List[str]       =    """lilt"""






							def __init__(       self       ,   __snake_case=3_0522       ,   __snake_case=768       ,   __snake_case=12       ,   __snake_case=12       ,   __snake_case=3072       ,   __snake_case="gelu"       ,   __snake_case=0.1       ,   __snake_case=0.1       ,   __snake_case=512       ,   __snake_case=2       ,   __snake_case=0.02       ,   __snake_case=1e-12       ,   __snake_case=0       ,   __snake_case="absolute"       ,   __snake_case=None       ,   __snake_case=4       ,   __snake_case=1024       ,   **__snake_case       ,   ):
											super().__init__(pad_token_id=__snake_case       ,   **__snake_case    )

											_SCREAMING_SNAKE_CASE					:			str							= vocab_size
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= hidden_size
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= num_hidden_layers
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= num_attention_heads
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= hidden_act
											_SCREAMING_SNAKE_CASE					:			Dict							= intermediate_size
											_SCREAMING_SNAKE_CASE					:			Tuple							= hidden_dropout_prob
											_SCREAMING_SNAKE_CASE					:			List[str]							= attention_probs_dropout_prob
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= max_position_embeddings
											_SCREAMING_SNAKE_CASE					:			Dict							= type_vocab_size
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= initializer_range
											_SCREAMING_SNAKE_CASE					:			Tuple							= layer_norm_eps
											_SCREAMING_SNAKE_CASE					:			str							= position_embedding_type
											_SCREAMING_SNAKE_CASE					:			List[str]							= classifier_dropout
											_SCREAMING_SNAKE_CASE					:			int							= channel_shrink_ratio
											_SCREAMING_SNAKE_CASE					:			str							= max_ad_position_embeddings




