



def        lowercase_							(A : Union[str, Any]      ):
       snake_case__							:	Optional[Any]   	=	1
       snake_case__							:	Tuple   	=	2
       while i * i <= n:
              snake_case__							:	Optional[int]   	=	0
              while n % i == 0:
                     n //= i
                     multiplicity += 1
              n_divisors *= multiplicity + 1
              i += 1
       if n > 1:
              n_divisors *= 2
       return n_divisors
def        lowercase_							():
       snake_case__							:	str   	=	1
       snake_case__							:	Any   	=	1

       while True:
              i += 1
              t_num += i

              if count_divisors(lowercase__      ) > 5_0_0:
                     break

       return t_num


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












"""simple docstring"""






def      _snake_case			(				lowercase__							,    lowercase__		):
				# "extended trapezoidal rule"
				# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
				_lowerCamelCase     :			List[Any]    =    (boundary[1] - boundary[0]) / steps
				_lowerCamelCase     :			Tuple    =    boundary[0]
				_lowerCamelCase     :			Dict    =    boundary[1]
				_lowerCamelCase     :			List[Any]    =    make_points(lowercase__							,    lowercase__							,    lowercase__		)
				_lowerCamelCase     :			List[Any]    =    0.0
				y += (h / 2.0) * f(lowercase__		)
				for i in x_i:
								# print(i)
								y += h * f(lowercase__		)
				y += (h / 2.0) * f(lowercase__		)
				return y







def      _snake_case			(				lowercase__							,    lowercase__							,    lowercase__		):
				_lowerCamelCase     :			str    =    a + h
				while x < (b - h):
								yield x
								_lowerCamelCase     :			int    =    x + h







def      _snake_case			(				lowercase__		):  # enter your function here
				_lowerCamelCase     :			Optional[Any]    =    (x - 0) * (x - 0)
				return y







def      _snake_case			(				):
				_lowerCamelCase     :			int    =    0.0  # Lower bound of integration
				_lowerCamelCase     :			Optional[int]    =    1.0  # Upper bound of integration
				_lowerCamelCase     :			List[str]    =    1_0.0  # define number of steps or resolution
				_lowerCamelCase     :			List[Any]    =    [a, b]  # define boundary of integration
				_lowerCamelCase     :			Optional[Any]    =    method_a(lowercase__							,    lowercase__		)
				print(f'''y = {y}'''		)


if __name__ == "__main__":
			main()