


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase_           =	{
    'configuration_openai': ['OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'OpenAIGPTConfig'],
    'tokenization_openai': ['OpenAIGPTTokenizer'],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase_           =	['OpenAIGPTTokenizerFast']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase_           =	[
           'OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'OpenAIGPTDoubleHeadsModel',
           'OpenAIGPTForSequenceClassification',
           'OpenAIGPTLMHeadModel',
           'OpenAIGPTModel',
           'OpenAIGPTPreTrainedModel',
           'load_tf_weights_in_openai_gpt',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase_           =	[
           'TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'TFOpenAIGPTDoubleHeadsModel',
           'TFOpenAIGPTForSequenceClassification',
           'TFOpenAIGPTLMHeadModel',
           'TFOpenAIGPTMainLayer',
           'TFOpenAIGPTModel',
           'TFOpenAIGPTPreTrainedModel',
       ]


if TYPE_CHECKING:
       from .configuration_openai import OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenAIGPTConfig
       from .tokenization_openai import OpenAIGPTTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_openai_fast import OpenAIGPTTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_openai import (
                  OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  OpenAIGPTDoubleHeadsModel,
                  OpenAIGPTForSequenceClassification,
                  OpenAIGPTLMHeadModel,
                  OpenAIGPTModel,
                  OpenAIGPTPreTrainedModel,
                  load_tf_weights_in_openai_gpt,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_openai import (
                  TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFOpenAIGPTDoubleHeadsModel,
                  TFOpenAIGPTForSequenceClassification,
                  TFOpenAIGPTLMHeadModel,
                  TFOpenAIGPTMainLayer,
                  TFOpenAIGPTModel,
                  TFOpenAIGPTPreTrainedModel,
              )

else:
       import sys

       lowercase_           =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





from __future__ import annotations


class        A_					:




      '''simple docstring'''


      def __init__(				self:       Union[str, Any]						,      a:       int				):
       __lowerCamelCase		:							List[Any]							=						data
       __lowerCamelCase		:							Optional[Any]							=						None



class        A_					:




      '''simple docstring'''


      def __init__(				self:       Dict				):
       __lowerCamelCase		:							Dict							=						None




      def      _snake_case	(				self:       Dict						,      a:       int				):
       __lowerCamelCase		:							List[Any]							=						Node(a				)
       __lowerCamelCase		:							Dict							=						self.head
       __lowerCamelCase		:							Optional[int]							=						new_node
       return self.head.data




      def      _snake_case	(				self:       Optional[Any]				):
       __lowerCamelCase		:							Union[str, Any]							=						self.head
       __lowerCamelCase		:							List[Any]							=						self.head
       if self.head:
        while fast_pointer and fast_pointer.next:
         __lowerCamelCase		:							Any							=						fast_pointer.next.next
         __lowerCamelCase		:							str							=						slow_pointer.next
        return slow_pointer.data
       else:
        print('No element found.'				)
        return None


if __name__ == "__main__":
       lowercase_           =	LinkedList()
       for _ in range(int(input().strip())):
              lowercase_           =	int(input().strip())
              link.push(data)
       print(link.middle_element())

