code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  import argparse
  
  import torch
  
  from transformers import (
      WavaVecaFeatureExtractor,
      WavLMConfig,
      WavLMForAudioFrameClassification,
      WavLMForSequenceClassification,
      WavLMForXVector,
      logging,
  )
  
  
  logging.set_verbosity_info()
  A_			  =    logging.get_logger(__name__)
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A    ,       A			):
     UpperCamelCase_     =WavLMForSequenceClassification.from_pretrained(A    ,       config=A			)
     UpperCamelCase_     =downstream_dict["projector.weight"]
     UpperCamelCase_     =downstream_dict["projector.bias"]
     UpperCamelCase_     =downstream_dict["model.post_net.linear.weight"]
     UpperCamelCase_     =downstream_dict["model.post_net.linear.bias"]
     return model
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A    ,       A			):
     UpperCamelCase_     =WavLMForAudioFrameClassification.from_pretrained(A    ,       config=A			)
     UpperCamelCase_     =downstream_dict["model.linear.weight"]
     UpperCamelCase_     =downstream_dict["model.linear.bias"]
     return model
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A    ,       A			):
     UpperCamelCase_     =WavLMForXVector.from_pretrained(A    ,       config=A			)
     UpperCamelCase_     =downstream_dict["connector.weight"]
     UpperCamelCase_     =downstream_dict["connector.bias"]
     for i, kernel_size in enumerate(hf_config.tdnn_kernel			):
        UpperCamelCase_     =downstream_dict[
            f"""model.framelevel_feature_extractor.module.{i}.kernel.weight"""
        ]
        UpperCamelCase_     =downstream_dict[f"""model.framelevel_feature_extractor.module.{i}.kernel.bias"""]
  
     UpperCamelCase_     =downstream_dict["model.utterancelevel_feature_extractor.linear1.weight"]
     UpperCamelCase_     =downstream_dict["model.utterancelevel_feature_extractor.linear1.bias"]
     UpperCamelCase_     =downstream_dict["model.utterancelevel_feature_extractor.linear2.weight"]
     UpperCamelCase_     =downstream_dict["model.utterancelevel_feature_extractor.linear2.bias"]
     UpperCamelCase_     =downstream_dict["objective.W"]
     return model
  
  
  
  
  @torch.no_grad()
  def 						_UpperCamelCase			(  A    ,       A    ,       A    ,       A			):
     UpperCamelCase_     =torch.load(A    ,       map_location="cpu"			)
  
     UpperCamelCase_     =checkpoint["Downstream"]
  
     UpperCamelCase_     =WavLMConfig.from_pretrained(A			)
     UpperCamelCase_     =WavaVecaFeatureExtractor.from_pretrained(
         A    ,       return_attention_mask=A    ,       do_normalize=A			)
  
     UpperCamelCase_     =hf_config.architectures[0]
     if arch.endswith("ForSequenceClassification"			):
        UpperCamelCase_     =convert_classification(A    ,       A    ,       A			)
     elif arch.endswith("ForAudioFrameClassification"			):
        UpperCamelCase_     =convert_diarization(A    ,       A    ,       A			)
     elif arch.endswith("ForXVector"			):
        UpperCamelCase_     =convert_xvector(A    ,       A    ,       A			)
     else:
        raise NotImplementedError(f"""S3PRL weights conversion is not supported for {arch}"""			)
  
     if hf_config.use_weighted_layer_sum:
        UpperCamelCase_     =checkpoint["Featurizer"]["weights"]
  
     hf_feature_extractor.save_pretrained(A			)
     hf_model.save_pretrained(A			)
  
  
  if __name__ == "__main__":
      A_			  =    argparse.ArgumentParser()
      parser.add_argument(
          "--base_model_name", default=None, type=str, help="Name of the huggingface pretrained base model."
      )
      parser.add_argument("--config_path", default=None, type=str, help="Path to the huggingface classifier config.")
      parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to the s3prl checkpoint.")
      parser.add_argument("--model_dump_path", default=None, type=str, help="Path to the final converted model.")
      A_			  =    parser.parse_args()
      convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  A_			  =    9.80665
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
  
     # 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 						_UpperCamelCase			(  A    ,       A			):
     check_args(A    ,       A			)
     UpperCamelCase_     =angle_to_radians(2 * angle			)
     return round(init_velocity**2 * sin(A			) / g    ,       2			)
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     check_args(A    ,       A			)
     UpperCamelCase_     =angle_to_radians(A			)
     return round(init_velocity**2 * sin(A			) ** 2 / (2 * g)    ,       2			)
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     check_args(A    ,       A			)
     UpperCamelCase_     =angle_to_radians(A			)
     return round(2 * init_velocity * sin(A			) / g    ,       2			)
  
  
  
  
  def 						_UpperCamelCase			(  ):
     UpperCamelCase_    ,							UpperCamelCase_     =25, 20
     assert horizontal_distance(A    ,       A			) == 40.97
     assert max_height(A    ,       A			) == 3.73
     assert total_time(A    ,       A			) == 1.74
  
  
  if __name__ == "__main__":
      from doctest import testmod
  
      testmod()
  
      # Get input from user
      A_			  =    float(input("Initial Velocity: ").strip())
  
      # Get input from user
      A_			  =    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]''')
  