



"""simple docstring"""
from __future__ import annotations
class 							lowerCamelCase    :






					'''simple docstring'''





					def __init__(			self:				List[Any]		,	snake_case:				int		)  ->      None:
											snake_case_					:str		=     data
											snake_case_					:Tuple		=     None

class 							lowerCamelCase    :






					'''simple docstring'''





					def __init__(			self:				Tuple		)  ->      Any:
											snake_case_					:Optional[Any]		=     None






					def   lowerCAmelCase_							(			self:				Optional[Any]		,	snake_case:				int		)  ->      int:
											snake_case_					:Any		=     Node(snake_case		)
											snake_case_					:int		=     self.head
											snake_case_					:Tuple		=     new_node
											return self.head.data






					def   lowerCAmelCase_							(			self:				int		)  ->      int | None:
											snake_case_					:int		=     self.head
											snake_case_					:Optional[Any]		=     self.head
											if self.head:
																	while fast_pointer and fast_pointer.next:
																							snake_case_					:str		=     fast_pointer.next.next
																							snake_case_					:Optional[int]		=     slow_pointer.next
																	return slow_pointer.data
											else:
																	print("""No element found."""		)
																	return None


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





from typing import TYPE_CHECKING

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


UpperCAmelCase__  =			{
    "configuration_align": [
        "ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "AlignConfig",
        "AlignTextConfig",
        "AlignVisionConfig",
    ],
    "processing_align": ["AlignProcessor"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__  =			[
							    "ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "AlignModel",
							    "AlignPreTrainedModel",
							    "AlignTextModel",
							    "AlignVisionModel",
							]

if TYPE_CHECKING:
							from .configuration_align import (
							    ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    AlignConfig,
							    AlignTextConfig,
							    AlignVisionConfig,
							)
							from .processing_align import AlignProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_align import (
														    ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST,
														    AlignModel,
														    AlignPreTrainedModel,
														    AlignTextModel,
														    AlignVisionModel,
														)

else:
							import sys

							UpperCAmelCase__  =			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
