code: 
  
  """simple docstring"""
  class 			lowerCamelCase  :
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    class 			lowerCamelCase  :
  
  
      '''simple docstring'''
  
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE							=     "_prev", "_data", "_next"
  
  
  
      def __init__(self       ,					_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase  ):
  
  
            """simple docstring"""
  
            UpperCAmelCase__ :       List[str]						=						link_p
            UpperCAmelCase__ :       str						=						element
            UpperCAmelCase__ :       int						=						link_n
  
  
  
  
      def    _a			(self  ):
  
  
            """simple docstring"""
  
            return (
                F""" Prev -> {self._prev is not None}, Next -> {self._next is not None}"""
            )
  
  
  
  
    def __init__(self  ):
  
  
          """simple docstring"""
  
          UpperCAmelCase__ :       Union[str, Any]						=						self._Node(SCREAMING_SNAKE_CASE_       ,					SCREAMING_SNAKE_CASE_       ,					SCREAMING_SNAKE_CASE_  )
          UpperCAmelCase__ :       Optional[Any]						=						self._Node(SCREAMING_SNAKE_CASE_       ,					SCREAMING_SNAKE_CASE_       ,					SCREAMING_SNAKE_CASE_  )
          UpperCAmelCase__ :       Any						=						self._trailer
          UpperCAmelCase__ :       Union[str, Any]						=						self._header
          UpperCAmelCase__ :       List[Any]						=						0
  
  
  
    def __len__(self  ):
  
  
          """simple docstring"""
  
          return self._size
  
  
  
    def    _a			(self  ):
  
  
          """simple docstring"""
  
          return self.__len__() == 0
  
  
  
    def    _a			(self       ,					_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          UpperCAmelCase__ :       str						=						self._Node(SCREAMING_SNAKE_CASE_       ,					SCREAMING_SNAKE_CASE_       ,					SCREAMING_SNAKE_CASE_  )
          UpperCAmelCase__ :       int						=						new_node
          UpperCAmelCase__ :       str						=						new_node
          self._size += 1
          return self
  
  
  
  
    def    _a			(self       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          UpperCAmelCase__ :       Optional[Any]						=						node._prev
          UpperCAmelCase__ :       List[Any]						=						node._next
  
          UpperCAmelCase__ :       List[str]						=						successor
          UpperCAmelCase__ :       Any						=						predecessor
          self._size -= 1
          UpperCAmelCase__ :       Dict						=						node._data
          UpperCAmelCase__ :       str						=						None
          del node
          return temp
  
  
  
  
  class 			lowerCamelCase  (					_DoublyLinkedBase      ):
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    def    _a			(self  ):
  
  
          """simple docstring"""
  
          if self.is_empty():
                raise Exception("""List is empty"""  )
          return self._header._next._data
  
  
  
    def    _a			(self  ):
  
  
          """simple docstring"""
  
          if self.is_empty():
                raise Exception("""List is empty"""  )
          return self._trailer._prev._data
  
  
  
    def    _a			(self       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          return self._insert(self._header       ,					SCREAMING_SNAKE_CASE_       ,					self._header._next  )
  
  
  
    def    _a			(self       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          return self._insert(self._trailer._prev       ,					SCREAMING_SNAKE_CASE_       ,					self._trailer  )
  
  
  
    def    _a			(self  ):
  
  
          """simple docstring"""
  
          if self.is_empty():
                raise IndexError("""remove_first from empty list"""  )
          return self._delete(self._header._next  )
  
  
  
  
    def    _a			(self  ):
  
  
          """simple docstring"""
  
          if self.is_empty():
                raise IndexError("""remove_first from empty list"""  )
          return self._delete(self._trailer._prev  )
  
  
style_context: 
  
  """simple docstring"""
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_keras_nlp_available,
      is_tensorflow_text_available,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  _A						=     {
      """configuration_gpt2""": ["""GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPT2Config""", """GPT2OnnxConfig"""],
      """tokenization_gpt2""": ["""GPT2Tokenizer"""],
  }
  
  try:
      if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      _A						=     ["""GPT2TokenizerFast"""]
  
  try:
      if not is_torch_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      _A						=     [
          """GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """GPT2DoubleHeadsModel""",
          """GPT2ForQuestionAnswering""",
          """GPT2ForSequenceClassification""",
          """GPT2ForTokenClassification""",
          """GPT2LMHeadModel""",
          """GPT2Model""",
          """GPT2PreTrainedModel""",
          """load_tf_weights_in_gpt2""",
      ]
  
  try:
      if not is_tf_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      _A						=     [
          """TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TFGPT2DoubleHeadsModel""",
          """TFGPT2ForSequenceClassification""",
          """TFGPT2LMHeadModel""",
          """TFGPT2MainLayer""",
          """TFGPT2Model""",
          """TFGPT2PreTrainedModel""",
      ]
  
  try:
      if not is_keras_nlp_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      _A						=     ["""TFGPT2Tokenizer"""]
  
  try:
      if not is_flax_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      _A						=     ["""FlaxGPT2LMHeadModel""", """FlaxGPT2Model""", """FlaxGPT2PreTrainedModel"""]
  
  if TYPE_CHECKING:
      from .configuration_gpta import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTaConfig, GPTaOnnxConfig
      from .tokenization_gpta import GPTaTokenizer
  
      try:
          if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .tokenization_gpta_fast import GPTaTokenizerFast
  
      try:
          if not is_torch_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_gpta import (
              GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
              GPTaDoubleHeadsModel,
              GPTaForQuestionAnswering,
              GPTaForSequenceClassification,
              GPTaForTokenClassification,
              GPTaLMHeadModel,
              GPTaModel,
              GPTaPreTrainedModel,
              load_tf_weights_in_gpta,
          )
  
      try:
          if not is_tf_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_tf_gpta import (
              TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFGPTaDoubleHeadsModel,
              TFGPTaForSequenceClassification,
              TFGPTaLMHeadModel,
              TFGPTaMainLayer,
              TFGPTaModel,
              TFGPTaPreTrainedModel,
          )
  
      try:
          if not is_keras_nlp_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .tokenization_gpta_tf import TFGPTaTokenizer
  
      try:
          if not is_flax_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel, FlaxGPTaPreTrainedModel
  
  else:
      import sys
  
      _A						=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  