code: 
  
  
  
  import os
  from shutil import copyfile
  from typing import List, Optional, Tuple
  
  from tokenizers import processors
  
  from ...tokenization_utils import AddedToken, BatchEncoding
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import is_sentencepiece_available, logging
  
  
  if is_sentencepiece_available():
  	from .tokenization_mbartaa import MBartaaTokenizer
  else:
  	__A       					=		None
  
  
  __A       					=		logging.get_logger(__name__)
  
  __A       					=		{'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}
  
  __A       					=		{
      '''vocab_file''': {
          '''facebook/mbart-large-50-one-to-many-mmt''': (
              '''https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model'''
          ),
      },
      '''tokenizer_file''': {
          '''facebook/mbart-large-50-one-to-many-mmt''': (
              '''https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/tokenizer.json'''
          ),
      },
  }
  
  __A       					=		{
      '''facebook/mbart-large-50-one-to-many-mmt''': 1024,
  }
  
  # fmt: off
  __A       					=		['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN''', '''af_ZA''', '''az_AZ''', '''bn_IN''', '''fa_IR''', '''he_IL''', '''hr_HR''', '''id_ID''', '''ka_GE''', '''km_KH''', '''mk_MK''', '''ml_IN''', '''mn_MN''', '''mr_IN''', '''pl_PL''', '''ps_AF''', '''pt_XX''', '''sv_SE''', '''sw_KE''', '''ta_IN''', '''te_IN''', '''th_TH''', '''tl_XX''', '''uk_UA''', '''ur_PK''', '''xh_ZA''', '''gl_ES''', '''sl_SI''']
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Optional[Any]	     =							VOCAB_FILES_NAMES
  	a__   :      Optional[Any]	     =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  	a__   :      str	     =							PRETRAINED_VOCAB_FILES_MAP
  	a__   :      List[Any]	     =							["input_ids", "attention_mask"]
  	a__   :      Dict	     =							MBartaaTokenizer
  
  	a__   :      List[int]	     =							[]
  	a__   :      List[int]	     =							[]
  
  
  
  
  	def __init__(			self			:		List[Any]		,						__UpperCAmelCase			:		Any=None		,						__UpperCAmelCase			:		List[Any]=None		,						__UpperCAmelCase			:		Optional[Any]=None		,						__UpperCAmelCase			:		Any=None		,						__UpperCAmelCase			:		Dict="</s>"		,						__UpperCAmelCase			:		Dict="</s>"		,						__UpperCAmelCase			:		str="<s>"		,						__UpperCAmelCase			:		Optional[Any]="<unk>"		,						__UpperCAmelCase			:		Any="<pad>"		,						__UpperCAmelCase			:		List[str]="<mask>"		,						**__UpperCAmelCase			:		List[Any]		,						)    ->				Union[str, Any]:
  							# Mask token behave like a normal word, i.e. include the space before it
  							UpperCAmelCase_=     AddedToken(__UpperCAmelCase		,						lstrip=__UpperCAmelCase		,						rstrip=__UpperCAmelCase  ) if isinstance(__UpperCAmelCase		,						__UpperCAmelCase  ) else mask_token
  
  							UpperCAmelCase_=     kwargs.get("""additional_special_tokens"""		,						[]  )
  							kwargs["additional_special_tokens"] += [
  							    code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
  							]
  
  							super().__init__(
  							    __UpperCAmelCase		,						src_lang=__UpperCAmelCase		,						tgt_lang=__UpperCAmelCase		,						tokenizer_file=__UpperCAmelCase		,						eos_token=__UpperCAmelCase		,						sep_token=__UpperCAmelCase		,						cls_token=__UpperCAmelCase		,						unk_token=__UpperCAmelCase		,						pad_token=__UpperCAmelCase		,						mask_token=__UpperCAmelCase		,						**__UpperCAmelCase		,						)
  
  							UpperCAmelCase_=     vocab_file
  							UpperCAmelCase_=     False if not self.vocab_file else True
  
  							UpperCAmelCase_=     {
  							    lang_code: self.convert_tokens_to_ids(__UpperCAmelCase  ) for lang_code in FAIRSEQ_LANGUAGE_CODES
  							}
  
  							UpperCAmelCase_=     src_lang if src_lang is not None else """en_XX"""
  							UpperCAmelCase_=     tgt_lang
  							UpperCAmelCase_=     self.lang_code_to_id[self._src_lang]
  							self.set_src_lang_special_tokens(self._src_lang  )
  
  
  
  
  	@property
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				str:
  							return self._src_lang
  
  
  
  
  	@src_lang.setter
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]		,						__UpperCAmelCase			:		str  )    ->				None:
  							UpperCAmelCase_=     new_src_lang
  							self.set_src_lang_special_tokens(self._src_lang  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]		,						__UpperCAmelCase			:		List[int]		,						__UpperCAmelCase			:		Optional[List[int]] = None  )    ->				List[int]:
  							if token_ids_a is None:
  													return self.prefix_tokens + token_ids_a + self.suffix_tokens
  							# We don't expect to process pairs, but leave the pair logic for API consistency
  							return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		str = "en_XX"		,						__UpperCAmelCase			:		Optional[List[str]] = None		,						__UpperCAmelCase			:		str = "ro_RO"		,						**__UpperCAmelCase			:		str		,						)    ->				BatchEncoding:
  							UpperCAmelCase_=     src_lang
  							UpperCAmelCase_=     tgt_lang
  							return super().prepare_seqaseq_batch(__UpperCAmelCase		,						__UpperCAmelCase		,						**__UpperCAmelCase  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]  )    ->				List[str]:
  							return self.set_src_lang_special_tokens(self.src_lang  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				Union[str, Any]:
  							return self.set_tgt_lang_special_tokens(self.tgt_lang  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		str		,						__UpperCAmelCase			:		str  )    ->				None:
  							UpperCAmelCase_=     self.convert_tokens_to_ids(__UpperCAmelCase  )
  							UpperCAmelCase_=     [self.cur_lang_code_id]
  							UpperCAmelCase_=     [self.eos_token_id]
  
  							UpperCAmelCase_=     self.convert_ids_to_tokens(self.prefix_tokens  )
  							UpperCAmelCase_=     self.convert_ids_to_tokens(self.suffix_tokens  )
  
  							UpperCAmelCase_=     processors.TemplateProcessing(
  							    single=prefix_tokens_str + ["""$A"""] + suffix_tokens_str		,						pair=prefix_tokens_str + ["""$A""", """$B"""] + suffix_tokens_str		,						special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str		,						self.prefix_tokens + self.suffix_tokens  )  )		,						)
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]		,						__UpperCAmelCase			:		str  )    ->				None:
  							UpperCAmelCase_=     self.convert_tokens_to_ids(__UpperCAmelCase  )
  							UpperCAmelCase_=     [self.cur_lang_code_id]
  							UpperCAmelCase_=     [self.eos_token_id]
  
  							UpperCAmelCase_=     self.convert_ids_to_tokens(self.prefix_tokens  )
  							UpperCAmelCase_=     self.convert_ids_to_tokens(self.suffix_tokens  )
  
  							UpperCAmelCase_=     processors.TemplateProcessing(
  							    single=prefix_tokens_str + ["""$A"""] + suffix_tokens_str		,						pair=prefix_tokens_str + ["""$A""", """$B"""] + suffix_tokens_str		,						special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str		,						self.prefix_tokens + self.suffix_tokens  )  )		,						)
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]		,						__UpperCAmelCase			:		Union[str, Any]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Optional[str]		,						__UpperCAmelCase			:		Optional[str]		,						**__UpperCAmelCase			:		Tuple  )    ->				Tuple:
  							if src_lang is None or tgt_lang is None:
  													raise ValueError("""Translation requires a `src_lang` and a `tgt_lang` for this model"""  )
  							UpperCAmelCase_=     src_lang
  							UpperCAmelCase_=     self(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase		,						return_tensors=__UpperCAmelCase		,						**__UpperCAmelCase  )
  							UpperCAmelCase_=     self.convert_tokens_to_ids(__UpperCAmelCase  )
  							UpperCAmelCase_=     tgt_lang_id
  							return inputs
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Optional[str] = None  )    ->				Tuple[str]:
  							if not self.can_save_slow_tokenizer:
  													raise ValueError(
  													    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
  													    """tokenizer."""  )
  
  							if not os.path.isdir(__UpperCAmelCase  ):
  													logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""  )
  													return
  							UpperCAmelCase_=     os.path.join(
  							    __UpperCAmelCase		,						(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]  )
  
  							if os.path.abspath(self.vocab_file  ) != os.path.abspath(__UpperCAmelCase  ):
  													copyfile(self.vocab_file		,						__UpperCAmelCase  )
  
  							return (out_vocab_file,)
  
  
  
  
  
style_context: 
  
  
  
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  __A       					=		9.8_0_6_6_5
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				None:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						if not isinstance(lowerCAmelCase_    ,(int, float)       ):
  												raise TypeError("""Invalid velocity. Should be a positive number."""       )
  
  						if not isinstance(lowerCAmelCase_    ,(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  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(2 * angle       )
  						return round(init_velocity**2 * sin(lowerCAmelCase_       ) / g    ,2       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(lowerCAmelCase_       )
  						return round(init_velocity**2 * sin(lowerCAmelCase_       ) ** 2 / (2 * g)    ,2       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(lowerCAmelCase_       )
  						return round(2 * init_velocity * sin(lowerCAmelCase_       ) / g    ,2       )
  
  
  
  def  __a  (					)   ->				None:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCAmelCase_,     UpperCAmelCase_=     25, 20
  						assert horizontal_distance(lowerCAmelCase_    ,lowerCAmelCase_       ) == 40.97
  						assert max_height(lowerCAmelCase_    ,lowerCAmelCase_       ) == 3.73
  						assert total_time(lowerCAmelCase_    ,lowerCAmelCase_       ) == 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]')
  
  
  
  
  