





'''simple docstring'''






from __future__ import annotations

from collections.abc import Iterator
from typing import Any



class  lowerCamelCase__				:


	"""simple docstring"""





	def __init__(					self   ,     UpperCAmelCase__			)       ->				Tuple:
					_A :				Dict				=  data
					_A :				Union[str, Any]				=  None




	def __str__(					self			)       ->				Optional[int]:
					return F"""{self.data}"""



class  lowerCamelCase__				:


	"""simple docstring"""





	def __init__(					self			)       ->				List[str]:
					_A :				Any				=  None
					_A :				Dict				=  None




	def __iter__(					self			)       ->				List[str]:
					_A :				Optional[Any]				=  self.front
					while node:
									yield node.data
									_A :				List[Any]				=  node.next




	def __len__(					self			)       ->				Optional[Any]:
					return len(tuple(iter(self			)			)			)




	def __str__(					self			)       ->				Optional[int]:
					return " <- ".join(str(__UpperCamelCase			) for item in self			)




	def 				_lowerCamelCase				(					self			)       ->				Any:
					return len(self			) == 0




	def 				_lowerCamelCase				(					self   ,     UpperCAmelCase__			)       ->				Any:
					_A :				Optional[Any]				=  Node(__UpperCamelCase			)
					if self.is_empty():
									_A :				Dict				=  node
					else:
									assert isinstance(self.rear   ,     __UpperCamelCase			)
									_A :				Tuple				=  node
									_A :				Optional[Any]				=  node




	def 				_lowerCamelCase				(					self			)       ->				Optional[int]:





					if self.is_empty():
									raise IndexError('''dequeue from empty queue'''			)
					assert isinstance(self.front   ,     __UpperCamelCase			)
					_A :				List[str]				=  self.front
					_A :				List[Any]				=  self.front.next
					if self.front is None:
									_A :				int				=  None
					return node.data




	def 				_lowerCamelCase				(					self			)       ->				str:
					_A :				Optional[int]				=  None


if __name__ == "__main__":
	from doctest import testmod

	testmod()



def        _lowercase  (					a_					:       str       ,a_					:       List[str]					)					->						Optional[Any]:




					'''simple docstring'''







					sequence.append(a_					)

					__magic_name__				=     0
					while sequence[index] != target:
										index += 1

					sequence.pop()

					if index == len(a_					):
										return None

					return index


if __name__ == "__main__":
						A__							=				input("Enter numbers separated by comma:\n").strip()
						A__							=				[int(item) for item in user_input.split(",")]

						A__							=				input("Enter a single number to be found in the list:\n")
						A__							=				int(target_input)
						A__							=				sentinel_linear_search(sequence, target)
						if result is not None:
												print(f'''{target} found at positions: {result}''')
						else:
												print("Not found")




