code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  lowercase__			=	9.8_0665
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     if not isinstance(snake_case	,     (int, float)   ):
        raise TypeError('''Invalid velocity. Should be a positive number.'''   )
  
     if not isinstance(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 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     check_args(snake_case	,     snake_case   )
     SCREAMING_SNAKE_CASE__			:				Tuple       						= angle_to_radians(2 * angle   )
     return round(init_velocity**2 * sin(snake_case   ) / g	,     2   )
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     check_args(snake_case	,     snake_case   )
     SCREAMING_SNAKE_CASE__			:				Tuple       						= angle_to_radians(snake_case   )
     return round(init_velocity**2 * sin(snake_case   ) ** 2 / (2 * g)	,     2   )
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     check_args(snake_case	,     snake_case   )
     SCREAMING_SNAKE_CASE__			:				List[Any]       						= angle_to_radians(snake_case   )
     return round(2 * init_velocity * sin(snake_case   ) / g	,     2   )
  
  
  def 				UpperCamelCase	(  ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				List[str]       						= 25, 20
     assert horizontal_distance(snake_case	,     snake_case   ) == 40.97
     assert max_height(snake_case	,     snake_case   ) == 3.73
     assert total_time(snake_case	,     snake_case   ) == 1.74
  
  
  if __name__ == "__main__":
         from doctest import testmod
  
         testmod()
  
         # Get input from user
         lowercase__			=	float(input('''Initial Velocity: ''').strip())
  
         # Get input from user
         lowercase__			=	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]")
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  from __future__ import annotations
  
  import sys
  
  
  
  
  
  
  class 						lowercase     :
  
  
  
  
  
  
        def __init__(self ,  a__ ,  a__					)       ->   List[str]:
           SCREAMING_SNAKE_CASE__			:				str       						= letter
           SCREAMING_SNAKE_CASE__			:				int       						= freq
           SCREAMING_SNAKE_CASE__			:				dict[str, str]       						= {}
  
  
  
  
  
  
        def __repr__(self					)       ->   str:
           return f"""{self.letter}:{self.freq}"""
  
  
  
  
  
  
  class 						lowercase     :
  
  
  
  
  
  
        def __init__(self ,  a__ ,  a__ ,  a__					)       ->   Union[str, Any]:
           SCREAMING_SNAKE_CASE__			:				int       						= freq
           SCREAMING_SNAKE_CASE__			:				Letter | TreeNode       						= left
           SCREAMING_SNAKE_CASE__			:				Letter | TreeNode       						= right
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				dict[str, int]       						= {}
     with open(snake_case   ) as f:
        while True:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= f.read(1   )
           if not c:
              break
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= chars[c] + 1 if c in chars else 1
     return sorted((Letter(snake_case	,     snake_case   ) for c, f in chars.items())	,     key=lambda snake_case   : x.freq   )
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				list[Letter | TreeNode]       						= letters  # type: ignore
     while len(snake_case   ) > 1:
        SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= response.pop(0   )
        SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= response.pop(0   )
        SCREAMING_SNAKE_CASE__			:				Dict       						= left.freq + right.freq
        SCREAMING_SNAKE_CASE__			:				Any       						= TreeNode(snake_case	,     snake_case	,     snake_case   )
        response.append(snake_case   )
        response.sort(key=lambda snake_case   : x.freq   )
     return response[0]
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     if isinstance(snake_case	,     snake_case   ):
        SCREAMING_SNAKE_CASE__			:				Optional[int]       						= bitstring
        return [root]
     SCREAMING_SNAKE_CASE__			:				TreeNode       						= root  # type: ignore
     SCREAMING_SNAKE_CASE__			:				int       						= []
     letters += traverse_tree(treenode.left	,     bitstring + '''0'''   )
     letters += traverse_tree(treenode.right	,     bitstring + '''1'''   )
     return letters
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				Optional[int]       						= parse_file(snake_case   )
     SCREAMING_SNAKE_CASE__			:				List[Any]       						= build_tree(snake_case   )
     SCREAMING_SNAKE_CASE__			:				List[str]       						= {
         k: v for letter in traverse_tree(snake_case	,     ''''''   ) for k, v in letter.bitstring.items()
     }
     print(f"""Huffman Coding  of {file_path}: """   )
     with open(snake_case   ) as f:
        while True:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= f.read(1   )
           if not c:
              break
           print(letters[c]	,     end=''' '''   )
     print()
  
  
  if __name__ == "__main__":
         # pass the file path to the huffman function
         huffman(sys.argv[1])
  
  