from math import isclose, sqrt
def    snake_case		(__lowercase   ,     __lowercase   ,     __lowercase		)			->			tuple[float, float, float]:

						'''simple docstring'''



						_snake_case		:	Tuple							=       point_y / 4 / point_x
						_snake_case		:	Any							=       2 * normal_gradient / (1 + normal_gradient * normal_gradient)
						_snake_case		:	int							=       (1 - normal_gradient * normal_gradient) / (
						    1 + normal_gradient * normal_gradient
						)
						_snake_case		:	Tuple							=       (sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

						# to find the next point, solve the simultaeneous equations:
						# y^2 + 4x^2 = 100
						# y - b = m * (x - a)
						# ==> A x^2 + B x + C = 0
						_snake_case		:	Union[str, Any]							=       outgoing_gradient**2 + 4
						_snake_case		:	int							=       2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
						_snake_case		:	Any							=       (point_y - outgoing_gradient * point_x) ** 2 - 100

						_snake_case		:	List[Any]							=       (
						    -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term		)
						) / (2 * quadratic_term)
						_snake_case		:	Dict							=       (
						    -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term		)
						) / (2 * quadratic_term)

						# two solutions, one of which is our input point
						_snake_case		:	Optional[int]							=       x_minus if isclose(UpperCamelCase__   ,     UpperCamelCase__		) else x_plus
						_snake_case		:	Any							=       point_y + outgoing_gradient * (next_x - point_x)

						return next_x, next_y, outgoing_gradient
def    snake_case		(__lowercase = 1.4   ,     __lowercase = -9.6		)			->			int:

						'''simple docstring'''



						_snake_case		:	int							=       0
						_snake_case		:	float							=       first_x_coord
						_snake_case		:	float							=       first_y_coord
						_snake_case		:	float							=       (10.1 - point_y) / (0.0 - point_x)

						while not (-0.01 <= point_x <= 0.01 and point_y > 0):
												_snake_case		:	str							=       next_point(UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__		)
												num_reflections += 1

						return num_reflections


if __name__ == "__main__":
				print(F'''{solution() = }''')






def 		lowerCAmelCase  (	UpperCamelCase__   :   list       ,			UpperCamelCase__   :   list       ,			UpperCamelCase__   :   int					)      ->    list:

						"""simple docstring"""





						__SCREAMING_SNAKE_CASE:				Tuple           =   len(UpperCamelCase__					)
						__SCREAMING_SNAKE_CASE:				Optional[int]           =   [[0] * n for i in range(UpperCamelCase__					)]
						for i in range(UpperCamelCase__					):
												__SCREAMING_SNAKE_CASE:				str           =   y_points[i]

						for i in range(2       ,			UpperCamelCase__					):
												for j in range(UpperCamelCase__       ,			UpperCamelCase__					):
																		__SCREAMING_SNAKE_CASE:				Optional[int]           =   (
																		    (xa - x_points[j - i + 1]) * q[j][i - 1]
																		    - (xa - x_points[j]) * q[j - 1][i - 1]
																		) / (x_points[j] - x_points[j - i + 1])

						return [q[n - 1][n - 1], q]


if __name__ == "__main__":
							import doctest

							doctest.testmod()



