code: 
  
  from urllib.error import HTTPError
  
  from bsa import BeautifulSoup
  from requests import exceptions, get
  
  _lowerCAmelCase     :			Union[str, Any]    ="""https://www.wellrx.com/prescriptions/{0}/{1}/?freshSearch=true"""
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  
  	try:
  		# Has user provided both inputs?
  		if not drug_name or not zip_code:
  			return None
  
  		UpperCAmelCase__:  Optional[Any]		       =   BASE_URL.format(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)
  		UpperCAmelCase__:  str		       =   get(SCREAMING_SNAKE_CASE			)
  
  		# Is the response ok?
  		response.raise_for_status()
  
  		# Scrape the data using bs4
  		UpperCAmelCase__:  int		       =   BeautifulSoup(response.text  ,"html.parser"			)
  
  		# This list will store the name and price.
  		UpperCAmelCase__:  Optional[Any]		       =   []
  
  		# Fetch all the grids that contains the items.
  		UpperCAmelCase__:  Tuple		       =   soup.find_all("div"  ,{"class": "grid-x pharmCard"}			)
  		if grid_list and len(SCREAMING_SNAKE_CASE			) > 0:
  			for grid in grid_list:
  				# Get the pharmacy price.
  				UpperCAmelCase__:  int		       =   grid.find("p"  ,{"class": "list-title"}			).text
  
  				# Get price of the drug.
  				UpperCAmelCase__:  Dict		       =   grid.find("span"  ,{"p", "price price-large"}			).text
  
  				pharmacy_price_list.append(
  				    {
  				        "pharmacy_name": pharmacy_name,
  				        "price": price,
  				    }			)
  
  		return pharmacy_price_list
  
  	except (HTTPError, exceptions.RequestException, ValueError):
  		return None
  
  
  if __name__ == "__main__":
  					# Enter a drug name and a zip code
  					_lowerCAmelCase     :			Optional[int]    =input("""Enter drug name: """).strip()
  					_lowerCAmelCase     :			List[Any]    =input("""Enter zip code: """).strip()
  
  					_lowerCAmelCase     :			list | None    =fetch_pharmacy_and_price_list(
  					    drug_name, zip_code
  					)
  
  					if pharmacy_price_list:
  										print(F"\nSearch results for {drug_name} at location {zip_code}:")
  										for pharmacy_price in pharmacy_price_list:
  															_lowerCAmelCase     :			Tuple    =pharmacy_price["""pharmacy_name"""]
  															_lowerCAmelCase     :			str    =pharmacy_price["""price"""]
  
  															print(F"Pharmacy: {name} Price: {price}")
  					else:
  										print(F"No results found for {drug_name}")
  
  
  
  
style_context: 
  
  _lowerCAmelCase     :			Optional[int]    ={
      """+""": lambda x, y: x + y,
      """-""": lambda x, y: x - y,
      """*""": lambda x, y: x * y,
      """/""": lambda x, y: x / y,
  }
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	return c.isdigit()
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  str		       =   []
  
  	# iterate over the string in reverse order
  	for c in expression.split()[::-1]:
  		# push operand to stack
  		if is_operand(SCREAMING_SNAKE_CASE			):
  			stack.append(int(SCREAMING_SNAKE_CASE			)			)
  
  		else:
  			# pop values from stack can calculate the result
  			# push the result onto the stack again
  			UpperCAmelCase__:  Any		       =   stack.pop()
  			UpperCAmelCase__:  int		       =   stack.pop()
  			stack.append(calc[c](SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)			)
  
  	return stack.pop()
  
  
  # Driver code
  if __name__ == "__main__":
  					_lowerCAmelCase     :			Optional[int]    ="""+ 9 * 2 6"""
  					print(evaluate(test_expression))
  
  					_lowerCAmelCase     :			Optional[Any]    ="""/ * 10 2 + 4 1 """
  					print(evaluate(test_expression))