


"""simple docstring"""
import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
			from tokenizers import Tokenizer
			from tokenizers.models import WordPiece



class      _UpperCAmelCase					(				unittest.TestCase							):






		'''simple docstring'''

		def 							SCREAMING_SNAKE_CASE    (self							,			a_   ):





			'''simple docstring'''

			__snake_case      :		str         =							list(tokenizer_class.max_model_input_sizes.keys()   )
			for model_name in sa_models[:1]:
				__snake_case      :		Union[str, Any]         =							tokenizer_class.from_pretrained(a_   )
				self.assertIsNotNone(a_   )
				self.assertIsInstance(a_							,			a_   )
				self.assertIsInstance(a_							,			a_   )

				for special_tok in tokenizer.all_special_tokens:
					self.assertIsInstance(a_							,			a_   )
					__snake_case      :		Optional[Any]         =							tokenizer.convert_tokens_to_ids(a_   )
					self.assertIsInstance(a_							,			a_   )



		def 							SCREAMING_SNAKE_CASE    (self							,			a_							,			a_ = None   ):





			'''simple docstring'''

			__snake_case      :		Any         =							pickle.dumps(a_   )
			self.assertIsNotNone(a_   )

			__snake_case      :		int         =							pickle.loads(a_   )

			# Ensure is_fast is correctly restored
			self.assertEqual(be_restored.is_fast							,			be_original.is_fast   )

			# Ensure encodings are potentially correctly restored
			if be_original.is_fast:
				self.assertIsNotNone(be_restored.encodings   )
			else:
				self.assertIsNone(be_restored.encodings   )

			# Ensure the keys are the same
			for original_v, restored_v in zip(be_original.values()							,			be_restored.values()   ):
				if equal_op:
					self.assertTrue(equal_op(a_							,			a_   )   )
				else:
					self.assertEqual(a_							,			a_   )



		@slow
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			self.check_tokenizer_from_pretrained(a_   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			self.assertEqual(TensorType('''tf'''   )							,			TensorType.TENSORFLOW   )
			self.assertEqual(TensorType('''pt'''   )							,			TensorType.PYTORCH   )
			self.assertEqual(TensorType('''np'''   )							,			TensorType.NUMPY   )



		@require_tokenizers
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			import numpy as np

			__snake_case      :		Optional[Any]         =							BertTokenizer.from_pretrained('''bert-base-cased'''   )
			__snake_case      :		Tuple         =							BertTokenizerFast.from_pretrained('''bert-base-cased'''   )

			# Python no tensor
			with self.subTest('''BatchEncoding (Python, return_tensors=None)'''   ):
				self.assert_dump_and_restore(tokenizer_p('''Small example to encode'''   )   )

			with self.subTest('''BatchEncoding (Python, return_tensors=NUMPY)'''   ):
				self.assert_dump_and_restore(
				    tokenizer_p('''Small example to encode'''							,			return_tensors=TensorType.NUMPY   )							,			np.array_equal   )

			with self.subTest('''BatchEncoding (Rust, return_tensors=None)'''   ):
				self.assert_dump_and_restore(tokenizer_r('''Small example to encode'''   )   )

			with self.subTest('''BatchEncoding (Rust, return_tensors=NUMPY)'''   ):
				self.assert_dump_and_restore(
				    tokenizer_r('''Small example to encode'''							,			return_tensors=TensorType.NUMPY   )							,			np.array_equal   )



		@require_tf
		@require_tokenizers
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			import tensorflow as tf

			def tf_array_equals(a_							,			a_   ):
				return tf.reduce_all(tf.equal(a_							,			a_   )   )

			__snake_case      :		int         =							BertTokenizer.from_pretrained('''bert-base-cased'''   )
			__snake_case      :		Any         =							BertTokenizerFast.from_pretrained('''bert-base-cased'''   )

			with self.subTest('''BatchEncoding (Python, return_tensors=TENSORFLOW)'''   ):
				self.assert_dump_and_restore(
				    tokenizer_p('''Small example to encode'''							,			return_tensors=TensorType.TENSORFLOW   )							,			a_   )

			with self.subTest('''BatchEncoding (Rust, return_tensors=TENSORFLOW)'''   ):
				self.assert_dump_and_restore(
				    tokenizer_r('''Small example to encode'''							,			return_tensors=TensorType.TENSORFLOW   )							,			a_   )



		@require_torch
		@require_tokenizers
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			import torch

			__snake_case      :		List[str]         =							BertTokenizer.from_pretrained('''bert-base-cased'''   )
			__snake_case      :		List[str]         =							BertTokenizerFast.from_pretrained('''bert-base-cased'''   )

			with self.subTest('''BatchEncoding (Python, return_tensors=PYTORCH)'''   ):
				self.assert_dump_and_restore(
				    tokenizer_p('''Small example to encode'''							,			return_tensors=TensorType.PYTORCH   )							,			torch.equal   )

			with self.subTest('''BatchEncoding (Rust, return_tensors=PYTORCH)'''   ):
				self.assert_dump_and_restore(
				    tokenizer_r('''Small example to encode'''							,			return_tensors=TensorType.PYTORCH   )							,			torch.equal   )



		@require_tokenizers
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Any         =							BertTokenizer.from_pretrained('''bert-base-cased'''   )
			__snake_case      :		Tuple         =							BertTokenizerFast.from_pretrained('''bert-base-cased'''   )

			with self.subTest('''Python Tokenizer'''   ):
				self.assertFalse(tokenizer_p('''Small example to_encode'''   ).is_fast   )

			with self.subTest('''Rust Tokenizer'''   ):
				self.assertTrue(tokenizer_r('''Small example to_encode'''   ).is_fast   )



		@require_tokenizers
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[str]         =							BertTokenizerFast.from_pretrained('''bert-base-cased'''   )
			__snake_case      :		Tuple         =							tokenizer_r(['''Test''', '''\xad''', '''test''']							,			is_split_into_words=a_   )

			self.assertEqual(encoded.word_to_tokens(0   )							,			TokenSpan(start=1							,			end=2   )   )
			self.assertEqual(encoded.word_to_tokens(1   )							,			a_   )
			self.assertEqual(encoded.word_to_tokens(2   )							,			TokenSpan(start=2							,			end=3   )   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Union[str, Any]         =							BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}   )
			__snake_case      :		Union[str, Any]         =							batch.convert_to_tensors(tensor_type='''np'''   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(2, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(2,)   )
			# test converting the converted
			with CaptureStderr() as cs:
				__snake_case      :		Union[str, Any]         =							batch.convert_to_tensors(tensor_type='''np'''   )
			self.assertFalse(len(cs.err   )							,			msg=f"""should have no warning, but got {cs.err}"""   )

			__snake_case      :		Optional[int]         =							BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}   )
			__snake_case      :		Dict         =							batch.convert_to_tensors(tensor_type='''np'''							,			prepend_batch_axis=a_   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(1, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(1,)   )



		@require_torch
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[Any]         =							BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}   )
			__snake_case      :		Union[str, Any]         =							batch.convert_to_tensors(tensor_type='''pt'''   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(2, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(2,)   )
			# test converting the converted
			with CaptureStderr() as cs:
				__snake_case      :		Any         =							batch.convert_to_tensors(tensor_type='''pt'''   )
			self.assertFalse(len(cs.err   )							,			msg=f"""should have no warning, but got {cs.err}"""   )

			__snake_case      :		List[Any]         =							BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}   )
			__snake_case      :		List[Any]         =							batch.convert_to_tensors(tensor_type='''pt'''							,			prepend_batch_axis=a_   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(1, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(1,)   )



		@require_tf
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Any         =							BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}   )
			__snake_case      :		Dict         =							batch.convert_to_tensors(tensor_type='''tf'''   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(2, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(2,)   )
			# test converting the converted
			with CaptureStderr() as cs:
				__snake_case      :		Optional[Any]         =							batch.convert_to_tensors(tensor_type='''tf'''   )
			self.assertFalse(len(cs.err   )							,			msg=f"""should have no warning, but got {cs.err}"""   )

			__snake_case      :		Union[str, Any]         =							BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}   )
			__snake_case      :		Union[str, Any]         =							batch.convert_to_tensors(tensor_type='''tf'''							,			prepend_batch_axis=a_   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(1, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(1,)   )



		@require_flax
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[Any]         =							BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}   )
			__snake_case      :		int         =							batch.convert_to_tensors(tensor_type='''jax'''   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(2, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(2,)   )
			# test converting the converted
			with CaptureStderr() as cs:
				__snake_case      :		Optional[Any]         =							batch.convert_to_tensors(tensor_type='''jax'''   )
			self.assertFalse(len(cs.err   )							,			msg=f"""should have no warning, but got {cs.err}"""   )

			__snake_case      :		List[str]         =							BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}   )
			__snake_case      :		Union[str, Any]         =							batch.convert_to_tensors(tensor_type='''jax'''							,			prepend_batch_axis=a_   )
			self.assertEqual(tensor_batch['''inputs'''].shape							,			(1, 3)   )
			self.assertEqual(tensor_batch['''labels'''].shape							,			(1,)   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Tuple         =							[{'''input_ids''': np.array([0, 1, 2]   )}, {'''input_ids''': np.array([0, 1, 2, 3]   )}]
			__snake_case      :		Union[str, Any]         =							BertTokenizer.from_pretrained('''bert-base-cased'''   )

			__snake_case      :		Dict         =							tokenizer.pad(a_							,			padding=a_   )
			self.assertTrue(isinstance(batch['''input_ids''']							,			np.ndarray   )   )
			self.assertEqual(batch['''input_ids'''].tolist()							,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]   )
			__snake_case      :		Union[str, Any]         =							tokenizer.pad(a_							,			padding=a_							,			return_tensors='''np'''   )
			self.assertTrue(isinstance(batch['''input_ids''']							,			np.ndarray   )   )
			self.assertEqual(batch['''input_ids'''].tolist()							,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]   )



		@require_torch
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			import torch

			__snake_case      :		Tuple         =							[{'''input_ids''': torch.tensor([0, 1, 2]   )}, {'''input_ids''': torch.tensor([0, 1, 2, 3]   )}]
			__snake_case      :		Dict         =							BertTokenizer.from_pretrained('''bert-base-cased'''   )

			__snake_case      :		Any         =							tokenizer.pad(a_							,			padding=a_   )
			self.assertTrue(isinstance(batch['''input_ids''']							,			torch.Tensor   )   )
			self.assertEqual(batch['''input_ids'''].tolist()							,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]   )
			__snake_case      :		int         =							tokenizer.pad(a_							,			padding=a_							,			return_tensors='''pt'''   )
			self.assertTrue(isinstance(batch['''input_ids''']							,			torch.Tensor   )   )
			self.assertEqual(batch['''input_ids'''].tolist()							,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]   )



		@require_tf
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			import tensorflow as tf

			__snake_case      :		Optional[Any]         =							[{'''input_ids''': tf.constant([0, 1, 2]   )}, {'''input_ids''': tf.constant([0, 1, 2, 3]   )}]
			__snake_case      :		Any         =							BertTokenizer.from_pretrained('''bert-base-cased'''   )

			__snake_case      :		Optional[Any]         =							tokenizer.pad(a_							,			padding=a_   )
			self.assertTrue(isinstance(batch['''input_ids''']							,			tf.Tensor   )   )
			self.assertEqual(batch['''input_ids'''].numpy().tolist()							,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]   )
			__snake_case      :		List[str]         =							tokenizer.pad(a_							,			padding=a_							,			return_tensors='''tf'''   )
			self.assertTrue(isinstance(batch['''input_ids''']							,			tf.Tensor   )   )
			self.assertEqual(batch['''input_ids'''].numpy().tolist()							,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]   )



		@require_tokenizers
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Tuple         =							Tokenizer(WordPiece(unk_token='''[UNK]'''   )   )
			PreTrainedTokenizerFast(tokenizer_object=a_   )



		@require_tokenizers
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Any         =							Tokenizer(WordPiece(unk_token='''[UNK]'''   )   )
			with tempfile.TemporaryDirectory() as tmpdirname:
				bert_tokenizer.save(os.path.join(a_							,			'''tokenizer.json'''   )   )
				PreTrainedTokenizerFast(tokenizer_file=os.path.join(a_							,			'''tokenizer.json'''   )   )











from __future__ import annotations

class   UpperCAmelCase    :






   def __init__(						self :							List[Any]    ,       UpperCamelCase_ :							int  )->      None:
     _lowercase:			Optional[Any]      =     data
     _lowercase:			Optional[int]      =     None

class   UpperCAmelCase    :






   def __init__(						self :							Optional[Any]  )->      Union[str, Any]:
     _lowercase:			List[str]      =     None






   def 			_a    (						self :							List[Any]    ,       UpperCamelCase_ :							int  )->      int:
     _lowercase:			Any      =     Node(UpperCamelCase_  )
     _lowercase:			List[Any]      =     self.head
     _lowercase:			List[str]      =     new_node
     return self.head.data






   def 			_a    (						self :							Tuple  )->      int | None:
     _lowercase:			List[str]      =     self.head
     _lowercase:			str      =     self.head
     if self.head:
       while fast_pointer and fast_pointer.next:
         _lowercase:			Optional[int]      =     fast_pointer.next.next
         _lowercase:			Tuple      =     slow_pointer.next
       return slow_pointer.data
     else:
       print('No element found.'  )
       return None


if __name__ == "__main__":
   UpperCAmelCase__    :							Union[str, Any]       		=     LinkedList()
   for _ in range(int(input().strip())):
      UpperCAmelCase__    :							List[Any]       		=     int(input().strip())
      link.push(data)
   print(link.middle_element())
