


'''simple docstring'''




import math

def       __UpperCamelCase     (     _A     :					int					)     ->   int:




	"""simple docstring"""





	if 1 < number < 4:
		# 2 and 3 are primes
		return True
	elif number < 2 or number % 2 == 0 or number % 3 == 0:
		# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
		return False

	# All primes number are in format of 6k +/- 1
	for i in range(5       , int(math.sqrt(_lowerCAmelCase					) + 1					)       , 6					):
		if number % i == 0 or number % (i + 2) == 0:
			return False
	return True

def       __UpperCamelCase     (     _A     :					int = 10_00       , _A     :					int = 10_00					)     ->   Tuple:




	"""simple docstring"""





	lowerCAmelCase       :     Optional[int]   				=			[0, 0, 0]  # length, a, b
	for a in range((a_limit * -1) + 1       , _lowerCAmelCase					):
		for b in range(2       , _lowerCAmelCase					):
			if is_prime(_lowerCAmelCase					):
				lowerCAmelCase       :     str   				=			0
				lowerCAmelCase       :     Dict   				=			0
				while is_prime((n**2) + (a * n) + b					):
					count += 1
					n += 1
				if count > longest[0]:
					lowerCAmelCase       :     Optional[int]   				=			[count, a, b]
	lowerCAmelCase       :     Dict   				=			longest[1] * longest[2]
	return ans


if __name__ == "__main__":
				print(solution(1000, 1000))

"""simple docstring"""


def 						UpperCamelCase				(	_lowerCAmelCase   :							Dict				, _lowerCAmelCase   :							Tuple						):
    __a			      =						len(_lowerCAmelCase						)
    # Create a stack and push index of fist element to it
    __a			      =						[]
    st.append(0						)

    # Span value of first element is always 1
    __a			      =						1

    # Calculate span values for rest of the elements
    for i in range(1				, _lowerCAmelCase						):
        # Pop elements from stack while stack is not
        # empty and top of stack is smaller than price[i]
        while len(_lowerCAmelCase						) > 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
        __a			      =						i + 1 if len(_lowerCAmelCase						) <= 0 else (i - st[0])

        # Push this element to stack
        st.append(_lowerCAmelCase						)

def 						UpperCamelCase				(	_lowerCAmelCase   :							Dict				, _lowerCAmelCase   :							Optional[Any]						):
    for i in range(0				, _lowerCAmelCase						):
        print(arr[i]				, end=""" """						)


# Driver program to test above function
__A       			=      [10, 4, 5, 90, 1_20, 80]
__A       			=      [0 for i in range(len(price) + 1)]

# Fill the span values in array S[]
calculation_span(price, S)






print_array(S, len(price))
