from __future__ import annotations

class 			lowerCamelCase_			:
      '''simple docstring'''

      def __init__( self		:       str		,      A		:       str ):
             _UpperCAmelCase  :						Union[str, Any]							   =					data
             _UpperCAmelCase  :						List[str]							   =					None

class 			lowerCamelCase_			:
      '''simple docstring'''

      def __init__( self		:       Optional[Any] ):
             _UpperCAmelCase  :						List[str]							   =					None




      def   _A			( self		:       List[Any]		,      A		:       Tuple ):
             _UpperCAmelCase  :						Tuple							   =					Node(__UpperCamelCase )
             _UpperCAmelCase  :						List[str]							   =					self.head
             _UpperCAmelCase  :						Dict							   =					new_node
             return self.head.data





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


if __name__ == "__main__":
  __SCREAMING_SNAKE_CASE :  str  =						LinkedList()
  for _ in range(int(input().strip())):
    __SCREAMING_SNAKE_CASE :  Optional[int]  =						int(input().strip())
    link.push(data)
  print(link.middle_element())


'''simple docstring'''




from typing import TYPE_CHECKING

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


__SCREAMING_SNAKE_CASE :  Union[str, Any]  =						{
    """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
    """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __SCREAMING_SNAKE_CASE :  Optional[int]  =						[
      """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """GPTSanJapaneseForConditionalGeneration""",
      """GPTSanJapaneseModel""",
      """GPTSanJapanesePreTrainedModel""",
  ]
  __SCREAMING_SNAKE_CASE :  Union[str, Any]  =						[
      """GPTSanJapaneseTokenizer""",
  ]


if TYPE_CHECKING:
  from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
  from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_gptsan_japanese import (
        GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
        GPTSanJapaneseForConditionalGeneration,
        GPTSanJapaneseModel,
        GPTSanJapanesePreTrainedModel,
    )
    from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
  import sys

  __SCREAMING_SNAKE_CASE :  Union[str, Any]  =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

