code: 
  def 		UpperCamelCase    (					_UpperCAmelCase     :      Optional[int]   , _UpperCAmelCase     :      Dict     )      -> int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						_lowercase					:  Any    			=      len(_UpperCAmelCase     )
  						# Create a stack and push index of fist element to it
  						_lowercase					:  str    			=      []
  						st.append(0     )
  
  						# Span value of first element is always 1
  						_lowercase					:  List[Any]    			=      1
  
  						# Calculate span values for rest of the elements
  						for i in range(1   , _UpperCAmelCase     ):
  												# Pop elements from stack while stack is not
  												# empty and top of stack is smaller than price[i]
  												while len(_UpperCAmelCase     ) > 0 and price[st[0]] <= price[i]:
  																		st.pop()
  
  												# If stack becomes empty, then price[i] is greater
  												# than all elements on left of it, i.e. price[0],
  												# price[1], ..price[i-1]. Else the price[i]  is
  												# greater than elements after top of stack
  												_lowercase					:  Optional[Any]    			=      i + 1 if len(_UpperCAmelCase     ) <= 0 else (i - st[0])
  
  												# Push this element to stack
  												st.append(_UpperCAmelCase     )
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      Dict   , _UpperCAmelCase     :      int     )      -> str:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						for i in range(0   , _UpperCAmelCase     ):
  												print(arr[i]   , end=" "     )
  
  
  # Driver program to test above function
  UpperCamelCase_	:    Union[str, Any]  					=       [10, 4, 5, 90, 120, 80]
  UpperCamelCase_	:    int  					=       [0 for i in range(len(price) + 1)]
  
  # Fill the span values in array S[]
  calculation_span(price, S)
  
  
  print_array(S, len(price))
  
  
  
  
  
style_context: 
  import math
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      int     )      -> list:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						if n <= 0:
  												raise ValueError("Only positive integers have prime factors"     )
  						_lowercase					:  Optional[int]    			=      []
  						while n % 2 == 0:
  												pf.append(2     )
  												_lowercase					:  Tuple    			=      int(n / 2     )
  						for i in range(3   , int(math.sqrt(_UpperCAmelCase     )     ) + 1   , 2     ):
  												while n % i == 0:
  																		pf.append(_UpperCAmelCase     )
  																		_lowercase					:  Optional[int]    			=      int(n / i     )
  						if n > 2:
  												pf.append(_UpperCAmelCase     )
  						return pf
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      int     )      -> int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						if n <= 0:
  												raise ValueError("Only positive numbers are accepted"     )
  						_lowercase					:  str    			=      1
  						_lowercase					:  Tuple    			=      1
  						while n % 2 == 0:
  												temp += 1
  												_lowercase					:  List[Any]    			=      int(n / 2     )
  						div *= temp
  						for i in range(3   , int(math.sqrt(_UpperCAmelCase     )     ) + 1   , 2     ):
  												_lowercase					:  Optional[Any]    			=      1
  												while n % i == 0:
  																		temp += 1
  																		_lowercase					:  Optional[Any]    			=      int(n / i     )
  												div *= temp
  						if n > 1:
  												div *= 2
  						return div
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      int     )      -> int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						if n <= 0:
  												raise ValueError("Only positive numbers are accepted"     )
  						_lowercase					:  int    			=      1
  						_lowercase					:  List[str]    			=      1
  						while n % 2 == 0:
  												temp += 1
  												_lowercase					:  str    			=      int(n / 2     )
  						if temp > 1:
  												s *= (2**temp - 1) / (2 - 1)
  						for i in range(3   , int(math.sqrt(_UpperCAmelCase     )     ) + 1   , 2     ):
  												_lowercase					:  int    			=      1
  												while n % i == 0:
  																		temp += 1
  																		_lowercase					:  List[Any]    			=      int(n / i     )
  												if temp > 1:
  																		s *= (i**temp - 1) / (i - 1)
  						return int(_UpperCAmelCase     )
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      int     )      -> int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						_lowercase					:  int    			=      n
  						for x in set(prime_factors(_UpperCAmelCase     )     ):
  												s *= (x - 1) / x
  						return int(_UpperCAmelCase     )
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()
  
  
  
  
  