class    lowercase_    :



							class    lowercase_    :
														_lowerCamelCase						=		'_prev', '_data', '_next'



														def __init__(						self      ,				lowercase_      ,				lowercase_      ,				lowercase_				):
																				_snake_case						:     List[str]				=    link_p
																				_snake_case						:     Tuple				=    element
																				_snake_case						:     Union[str, Any]				=    link_n



														def        UpperCamelCase       (						self				):
																				return (
																				    f""" Prev -> {self._prev is not None}, Next -> {self._next is not None}"""
																				)




							def __init__(						self				):
													_snake_case						:     List[Any]				=    self._Node(lowercase_      ,				lowercase_      ,				lowercase_				)
													_snake_case						:     List[Any]				=    self._Node(lowercase_      ,				lowercase_      ,				lowercase_				)
													_snake_case						:     Dict				=    self._trailer
													_snake_case						:     Any				=    self._header
													_snake_case						:     Optional[Any]				=    0



							def __len__(						self				):
													return self._size



							def        UpperCamelCase       (						self				):
													return self.__len__() == 0



							def        UpperCamelCase       (						self      ,				lowercase_      ,				lowercase_      ,				lowercase_				):
													# Create new_node by setting it's prev.link -> header
													# setting it's next.link -> trailer
													_snake_case						:     List[str]				=    self._Node(lowercase_      ,				lowercase_      ,				lowercase_				)
													_snake_case						:     str				=    new_node
													_snake_case						:     Any				=    new_node
													self._size += 1
													return self



							def        UpperCamelCase       (						self      ,				lowercase_				):
													_snake_case						:     Dict				=    node._prev
													_snake_case						:     Any				=    node._next

													_snake_case						:     Tuple				=    successor
													_snake_case						:     int				=    predecessor
													self._size -= 1
													_snake_case						:     List[Any]				=    node._data
													_snake_case						:     Optional[int]				=    None
													del node
													return temp




class    lowercase_    (     _DoublyLinkedBase		):



							def        UpperCamelCase       (						self				):
													if self.is_empty():
																			raise Exception("List is empty"				)
													return self._header._next._data



							def        UpperCamelCase       (						self				):
													if self.is_empty():
																			raise Exception("List is empty"				)
													return self._trailer._prev._data



							def        UpperCamelCase       (						self      ,				lowercase_				):
													return self._insert(self._header      ,				lowercase_      ,				self._header._next				)



							def        UpperCamelCase       (						self      ,				lowercase_				):
													return self._insert(self._trailer._prev      ,				lowercase_      ,				self._trailer				)



							def        UpperCamelCase       (						self				):
													if self.is_empty():
																			raise IndexError("remove_first from empty list"				)
													return self._delete(self._header._next				)



							def        UpperCamelCase       (						self				):
													if self.is_empty():
																			raise IndexError("remove_first from empty list"				)
													return self._delete(self._trailer._prev				)


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


SCREAMING_SNAKE_CASE						:int      =			{"""configuration_yoso""": ["""YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP""", """YosoConfig"""]}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE						:List[Any]      =			[
     """YOSO_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """YosoForMaskedLM""",
     """YosoForMultipleChoice""",
     """YosoForQuestionAnswering""",
     """YosoForSequenceClassification""",
     """YosoForTokenClassification""",
     """YosoLayer""",
     """YosoModel""",
     """YosoPreTrainedModel""",
 ]


if TYPE_CHECKING:
 from .configuration_yoso import YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP, YosoConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_yoso import (
      YOSO_PRETRAINED_MODEL_ARCHIVE_LIST,
      YosoForMaskedLM,
      YosoForMultipleChoice,
      YosoForQuestionAnswering,
      YosoForSequenceClassification,
      YosoForTokenClassification,
      YosoLayer,
      YosoModel,
      YosoPreTrainedModel,
  )


else:
 import sys

 SCREAMING_SNAKE_CASE						:str      =			_LazyModule(__name__, globals()["""__file__"""], _import_structure)
