




from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
lowerCamelCase_	 =		9.80665
def 				SCREAMING_SNAKE_CASE_				(							__A       :				Dict ,  __A       :				List[str]						)				->				None:

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

   if not isinstance(__A ,  (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 				SCREAMING_SNAKE_CASE_				(							__A       :				int ,  __A       :				Dict						)				->				float:
   check_args(__A ,  __A						)
   _SCREAMING_SNAKE_CASE =   angle_to_radians(2 * angle						)
   return round(init_velocity**2 * sin(__A						) / g ,  2						)
def 				SCREAMING_SNAKE_CASE_				(							__A       :				Any ,  __A       :				List[str]						)				->				float:
   check_args(__A ,  __A						)
   _SCREAMING_SNAKE_CASE =   angle_to_radians(__A						)
   return round(init_velocity**2 * sin(__A						) ** 2 / (2 * g) ,  2						)
def 				SCREAMING_SNAKE_CASE_				(							__A       :				str ,  __A       :				Optional[Any]						)				->				float:
   check_args(__A ,  __A						)
   _SCREAMING_SNAKE_CASE =   angle_to_radians(__A						)
   return round(2 * init_velocity * sin(__A						) / g ,  2						)
def 				SCREAMING_SNAKE_CASE_				(							)				->				None:
   _SCREAMING_SNAKE_CASE =   25, 20
   assert horizontal_distance(__A ,  __A						) == 4_0.9_7
   assert max_height(__A ,  __A						) == 3.7_3
   assert total_time(__A ,  __A						) == 1.7_4


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

 testmod()

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

 # Get input from user
 lowerCamelCase_	 =		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'''



lowerCamelCase_	 =		[[0, 1, 1], [0, 0, 1], [1, 0, 0]]







class 	lowercase_					:


   """simple docstring"""

   def __init__(					self      :			List[Any]						,   __lowerCamelCase      :			str					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   name
      _SCREAMING_SNAKE_CASE =   []
      _SCREAMING_SNAKE_CASE =   []



   def 							lowerCAmelCase_    (					self      :			int						,   __lowerCamelCase      :			Union[str, Any]					):

      """simple docstring"""
      self.inbound.append(__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			int						,   __lowerCamelCase      :			Any					):

      """simple docstring"""
      self.outbound.append(__lowerCamelCase					)



   def __repr__(					self      :			List[str]					):

      """simple docstring"""
      return F"""<node={self.name} inbound={self.inbound} outbound={self.outbound}>"""


def 				SCREAMING_SNAKE_CASE_				(							__A       :				Tuple ,  __A       :				List[Any]=3 ,  __A       :				Optional[int]=0.8_5						)				->				Optional[Any]:
   _SCREAMING_SNAKE_CASE =   {}
   for node in nodes:
      _SCREAMING_SNAKE_CASE =   1

   _SCREAMING_SNAKE_CASE =   {}
   for node in nodes:
      _SCREAMING_SNAKE_CASE =   len(node.outbound						)

   for i in range(__A						):
      print(f"""======= Iteration {i + 1} ======="""						)
      for _, node in enumerate(__A						):
         _SCREAMING_SNAKE_CASE =   (1 - d) + d * sum(
             ranks[ib] / outbounds[ib] for ib in node.inbound						)
      print(__A						)
def 				SCREAMING_SNAKE_CASE_				(							)				->				List[str]:
   _SCREAMING_SNAKE_CASE =   list(input("Enter Names of the Nodes: "						).split()						)

   _SCREAMING_SNAKE_CASE =   [Node(__A						) for name in names]

   for ri, row in enumerate(__A						):
      for ci, col in enumerate(__A						):
         if col == 1:
            nodes[ci].add_inbound(names[ri]						)
            nodes[ri].add_outbound(names[ci]						)

   print("======= Nodes ======="						)
   for node in nodes:
      print(__A						)

   page_rank(__A						)


if __name__ == "__main__":
 main()

