"""simple docstring"""






from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
UpperCamelCase     					=     9.80665

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:Union[str, Any]		,			_SCREAMING_SNAKE_CASE	:int  )				-> None:

						# Ensure valid instance
						if not isinstance(_SCREAMING_SNAKE_CASE		,			(int, float)  ):
												raise TypeError("Invalid velocity. Should be a positive number."  )

						if not isinstance(_SCREAMING_SNAKE_CASE		,			(int, float)  ):
												raise TypeError("Invalid angle. Range is 1-90 degrees."  )

						# Ensure valid angle
						if angle > 90 or angle < 1:
												raise ValueError("Invalid angle. Range is 1-90 degrees."  )

						# Ensure valid velocity
						if init_velocity < 0:
												raise ValueError("Invalid velocity. Should be a positive number."  )

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:Tuple		,			_SCREAMING_SNAKE_CASE	:int  )				-> float:
						check_args(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  )
						a_							:			List[str]     		=					angle_to_radians(2 * angle  )
						return round(init_velocity**2 * sin(_SCREAMING_SNAKE_CASE  ) / g		,			2  )

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:str		,			_SCREAMING_SNAKE_CASE	:List[Any]  )				-> float:
						check_args(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  )
						a_							:			int     		=					angle_to_radians(_SCREAMING_SNAKE_CASE  )
						return round(init_velocity**2 * sin(_SCREAMING_SNAKE_CASE  ) ** 2 / (2 * g)		,			2  )

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:List[str]		,			_SCREAMING_SNAKE_CASE	:List[Any]  )				-> float:
						check_args(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  )
						a_							:			Dict     		=					angle_to_radians(_SCREAMING_SNAKE_CASE  )
						return round(2 * init_velocity * sin(_SCREAMING_SNAKE_CASE  ) / g		,			2  )

def  lowerCAmelCase_      ()				-> None:
						a_							:			Any     		=					25, 20
						assert horizontal_distance(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  ) == 40.97
						assert max_height(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  ) == 3.73
						assert total_time(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  ) == 1.74


if __name__ == "__main__":
		from doctest import testmod

		testmod()

		# Get input from user
		UpperCamelCase     					=     float(input('Initial Velocity: ').strip())

		# Get input from user
		UpperCamelCase     					=     float(input('angle: ').strip())

		# Print results
		print()
		print('Results: ')
		print(F'Horizontal Distance: {horizontal_distance(init_vel, angle)!s} [m]')
		print(F'Maximum Height: {max_height(init_vel, angle)!s} [m]')
		print(F'Total Time: {total_time(init_vel, angle)!s} [s]')





"""simple docstring"""






import numpy as np

UpperCamelCase     					=     [
    ['a', 'b', 'c', 'd', 'e'],
    ['f', 'g', 'h', 'i', 'k'],
    ['l', 'm', 'n', 'o', 'p'],
    ['q', 'r', 's', 't', 'u'],
    ['v', 'w', 'x', 'y', 'z'],
]
class   UpperCAmelCase__				:


	"""simple docstring"""







	def __init__(			self )    ->	None:
							a_							:			List[Any]     		=					np.array(_SCREAMING_SNAKE_CASE )







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE )    ->	np.ndarray:
							a_		,					a_							:			List[str]     		=					np.where(letter == self.SQUARE )
							a_							:			Union[str, Any]     		=					np.concatenate([indexa + 1, indexa + 1] )
							return indexes







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )    ->	str:
							return self.SQUARE[indexa - 1, indexa - 1]







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE )    ->	str:
							a_							:			List[str]     		=					message.lower()
							a_							:			Union[str, Any]     		=					message.replace("j"       ,     "i" )

							a_							:			Tuple     		=					""
							for letter_index in range(len(_SCREAMING_SNAKE_CASE ) ):
													if message[letter_index] != " ":
																			a_							:			Dict     		=					self.letter_to_numbers(message[letter_index] )
																			a_							:			str     		=					encoded_message + str(numbers[0] ) + str(numbers[1] )
													elif message[letter_index] == " ":
																			a_							:			Any     		=					encoded_message + " "

							return encoded_message







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE )    ->	str:
							a_							:			Dict     		=					message.replace(" "       ,     "  " )
							a_							:			str     		=					""
							for numbers_index in range(int(len(_SCREAMING_SNAKE_CASE ) / 2 ) ):
													if message[numbers_index * 2] != " ":
																			a_							:			str     		=					message[numbers_index * 2]
																			a_							:			str     		=					message[numbers_index * 2 + 1]

																			a_							:			Optional[Any]     		=					self.numbers_to_letter(int(_SCREAMING_SNAKE_CASE )       ,     int(_SCREAMING_SNAKE_CASE ) )
																			a_							:			Optional[Any]     		=					decoded_message + letter
													elif message[numbers_index * 2] == " ":
																			a_							:			str     		=					decoded_message + " "

							return decoded_message




