'''simple docstring'''


from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

__lowerCAmelCase	:       List[str]						       =	TypeVar("KEY")
__lowerCAmelCase	:       str						       =	TypeVar("VAL")






@dataclass(frozen=_A       ,	slots=_A   )
class 						A   (   Generic[KEY, VAL]   ):
							a_        =      4_2
							a_        =      4_2






class 						A   (   _Item   ):





							def __init__(      self				:							List[str]	)							->	None:
								super().__init__(UpperCamelCase__     ,		UpperCamelCase__	)






							def __bool__(      self				:							Union[str, Any]	)							->	bool:
								return False

__lowerCAmelCase	:       str						       =	_DeletedItem()






class 						A   (   MutableMapping[KEY, VAL]   ):





							def __init__(      self				:							List[Any]     ,		__a				:							int = 8     ,		__a				:							float = 0.7_5	)							->	None:
								__UpperCAmelCase							=			initial_block_size
								__UpperCAmelCase							=			[None] * initial_block_size
								assert 0.0 < capacity_factor < 1.0
								__UpperCAmelCase							=			capacity_factor
								__UpperCAmelCase							=			0





							def       snake_case__						(      self				:							List[str]     ,		__a				:							KEY	)							->	int:
								return hash(UpperCamelCase__	) % len(self._buckets	)





							def       snake_case__						(      self				:							int     ,		__a				:							int	)							->	int:
								return (ind + 1) % len(self._buckets	)





							def       snake_case__						(      self				:							Union[str, Any]     ,		__a				:							int     ,		__a				:							KEY     ,		__a				:							VAL	)							->	bool:
								__UpperCAmelCase							=			self._buckets[ind]
								if not stored:
									__UpperCAmelCase							=			_Item(UpperCamelCase__     ,		UpperCamelCase__	)
									self._len += 1
									return True
								elif stored.key == key:
									__UpperCAmelCase							=			_Item(UpperCamelCase__     ,		UpperCamelCase__	)
									return True
								else:
									return False





							def       snake_case__						(      self				:							Union[str, Any]	)							->	bool:
								__UpperCAmelCase							=			len(self._buckets	) * self._capacity_factor
								return len(self	) >= int(UpperCamelCase__	)





							def       snake_case__						(      self				:							int	)							->	bool:






								if len(self._buckets	) <= self._initial_block_size:
									return False
								__UpperCAmelCase							=			len(self._buckets	) * self._capacity_factor / 2
								return len(self	) < limit





							def       snake_case__						(      self				:							int     ,		__a				:							int	)							->	None:
								__UpperCAmelCase							=			self._buckets
								__UpperCAmelCase							=			[None] * new_size
								__UpperCAmelCase							=			0
								for item in old_buckets:
									if item:
										self._add_item(item.key     ,		item.val	)





							def       snake_case__						(      self				:							Dict	)							->	None:
								self._resize(len(self._buckets	) * 2	)





							def       snake_case__						(      self				:							Union[str, Any]	)							->	None:
								self._resize(len(self._buckets	) // 2	)





							def       snake_case__						(      self				:							Dict     ,		__a				:							KEY	)							->	Iterator[int]:
								__UpperCAmelCase							=			self._get_bucket_index(UpperCamelCase__	)
								for _ in range(len(self._buckets	)	):
									yield ind
									__UpperCAmelCase							=			self._get_next_ind(UpperCamelCase__	)





							def       snake_case__						(      self				:							Any     ,		__a				:							KEY     ,		__a				:							VAL	)							->	None:






								for ind in self._iterate_buckets(UpperCamelCase__	):
									if self._try_set(UpperCamelCase__     ,		UpperCamelCase__     ,		UpperCamelCase__	):
										break





							def __setitem__(      self				:							str     ,		__a				:							KEY     ,		__a				:							VAL	)							->	None:






								if self._is_full():
									self._size_up()

								self._add_item(UpperCamelCase__     ,		UpperCamelCase__	)





							def __delitem__(      self				:							int     ,		__a				:							KEY	)							->	None:






								for ind in self._iterate_buckets(UpperCamelCase__	):
									__UpperCAmelCase							=			self._buckets[ind]
									if item is None:
										raise KeyError(UpperCamelCase__	)
									if item is _deleted:
										continue
									if item.key == key:
										__UpperCAmelCase							=			_deleted
										self._len -= 1
										break
								if self._is_sparse():
									self._size_down()





							def __getitem__(      self				:							Tuple     ,		__a				:							KEY	)							->	VAL:






								for ind in self._iterate_buckets(UpperCamelCase__	):
									__UpperCAmelCase							=			self._buckets[ind]
									if item is None:
										break
									if item is _deleted:
										continue
									if item.key == key:
										return item.val
								raise KeyError(UpperCamelCase__	)





							def __len__(      self				:							Optional[int]	)							->	int:
								return self._len





							def __iter__(      self				:							int	)							->	Iterator[KEY]:
								yield from (item.key for item in self._buckets if item)






							def __repr__(      self				:							str	)							->	str:
								__UpperCAmelCase							=			''' ,'''.join(
								    f"""{item.key}: {item.val}""" for item in self._buckets if item	)
								return f"""HashMap({val_string})"""






'''simple docstring'''


import requests
from bsa import BeautifulSoup





def       lowerCAmelCase					(		UpperCamelCase__				:   str = "AAPL"       ):


	"""simple docstring"""
	__UpperCAmelCase							=			f"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
	__UpperCAmelCase							=			BeautifulSoup(requests.get(UpperCamelCase__       ).text    ,					'''html.parser'''       )
	__UpperCAmelCase							=			'''My(6px) Pos(r) smartphone_Mt(6px)'''
	return soup.find('''div'''    ,					class_=class_       ).find('''span'''       ).text


if __name__ == "__main__":
					for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
										print(F"""Current {symbol:<4} stock price is {stock_price(symbol):>8}""")
