
"""simple docstring"""




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_nllb import NllbTokenizer
else:
					UpperCAmelCase__      :    Optional[Any]    							= None


UpperCAmelCase__      :    Union[str, Any]    							= logging.get_logger(__name__)


UpperCAmelCase__      :    str    							= {'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'}

UpperCAmelCase__      :    Dict    							= {
    'vocab_file': {
        'facebook/nllb-200-distilled-600M': (
            'https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/sentencepiece.bpe.model'
        ),
    },
    'tokenizer_file': {
        'facebook/nllb-200-distilled-600M': (
            'https://huggingface.co/facebook/nllb-200-distilled-600M/resolve/main/tokenizer.json'
        ),
    },
}

UpperCAmelCase__      :    List[Any]    							= {
    'facebook/nllb-large-en-ro': 1_0_2_4,
    'facebook/nllb-200-distilled-600M': 1_0_2_4,
}

# fmt: off
UpperCAmelCase__      :    Any    							= ['ace_Arab', 'ace_Latn', 'acm_Arab', 'acq_Arab', 'aeb_Arab', 'afr_Latn', 'ajp_Arab', 'aka_Latn', 'amh_Ethi', 'apc_Arab', 'arb_Arab', 'ars_Arab', 'ary_Arab', 'arz_Arab', 'asm_Beng', 'ast_Latn', 'awa_Deva', 'ayr_Latn', 'azb_Arab', 'azj_Latn', 'bak_Cyrl', 'bam_Latn', 'ban_Latn', 'bel_Cyrl', 'bem_Latn', 'ben_Beng', 'bho_Deva', 'bjn_Arab', 'bjn_Latn', 'bod_Tibt', 'bos_Latn', 'bug_Latn', 'bul_Cyrl', 'cat_Latn', 'ceb_Latn', 'ces_Latn', 'cjk_Latn', 'ckb_Arab', 'crh_Latn', 'cym_Latn', 'dan_Latn', 'deu_Latn', 'dik_Latn', 'dyu_Latn', 'dzo_Tibt', 'ell_Grek', 'eng_Latn', 'epo_Latn', 'est_Latn', 'eus_Latn', 'ewe_Latn', 'fao_Latn', 'pes_Arab', 'fij_Latn', 'fin_Latn', 'fon_Latn', 'fra_Latn', 'fur_Latn', 'fuv_Latn', 'gla_Latn', 'gle_Latn', 'glg_Latn', 'grn_Latn', 'guj_Gujr', 'hat_Latn', 'hau_Latn', 'heb_Hebr', 'hin_Deva', 'hne_Deva', 'hrv_Latn', 'hun_Latn', 'hye_Armn', 'ibo_Latn', 'ilo_Latn', 'ind_Latn', 'isl_Latn', 'ita_Latn', 'jav_Latn', 'jpn_Jpan', 'kab_Latn', 'kac_Latn', 'kam_Latn', 'kan_Knda', 'kas_Arab', 'kas_Deva', 'kat_Geor', 'knc_Arab', 'knc_Latn', 'kaz_Cyrl', 'kbp_Latn', 'kea_Latn', 'khm_Khmr', 'kik_Latn', 'kin_Latn', 'kir_Cyrl', 'kmb_Latn', 'kon_Latn', 'kor_Hang', 'kmr_Latn', 'lao_Laoo', 'lvs_Latn', 'lij_Latn', 'lim_Latn', 'lin_Latn', 'lit_Latn', 'lmo_Latn', 'ltg_Latn', 'ltz_Latn', 'lua_Latn', 'lug_Latn', 'luo_Latn', 'lus_Latn', 'mag_Deva', 'mai_Deva', 'mal_Mlym', 'mar_Deva', 'min_Latn', 'mkd_Cyrl', 'plt_Latn', 'mlt_Latn', 'mni_Beng', 'khk_Cyrl', 'mos_Latn', 'mri_Latn', 'zsm_Latn', 'mya_Mymr', 'nld_Latn', 'nno_Latn', 'nob_Latn', 'npi_Deva', 'nso_Latn', 'nus_Latn', 'nya_Latn', 'oci_Latn', 'gaz_Latn', 'ory_Orya', 'pag_Latn', 'pan_Guru', 'pap_Latn', 'pol_Latn', 'por_Latn', 'prs_Arab', 'pbt_Arab', 'quy_Latn', 'ron_Latn', 'run_Latn', 'rus_Cyrl', 'sag_Latn', 'san_Deva', 'sat_Beng', 'scn_Latn', 'shn_Mymr', 'sin_Sinh', 'slk_Latn', 'slv_Latn', 'smo_Latn', 'sna_Latn', 'snd_Arab', 'som_Latn', 'sot_Latn', 'spa_Latn', 'als_Latn', 'srd_Latn', 'srp_Cyrl', 'ssw_Latn', 'sun_Latn', 'swe_Latn', 'swh_Latn', 'szl_Latn', 'tam_Taml', 'tat_Cyrl', 'tel_Telu', 'tgk_Cyrl', 'tgl_Latn', 'tha_Thai', 'tir_Ethi', 'taq_Latn', 'taq_Tfng', 'tpi_Latn', 'tsn_Latn', 'tso_Latn', 'tuk_Latn', 'tum_Latn', 'tur_Latn', 'twi_Latn', 'tzm_Tfng', 'uig_Arab', 'ukr_Cyrl', 'umb_Latn', 'urd_Arab', 'uzn_Latn', 'vec_Latn', 'vie_Latn', 'war_Latn', 'wol_Latn', 'xho_Latn', 'ydd_Hebr', 'yor_Latn', 'yue_Hant', 'zho_Hans', 'zho_Hant', 'zul_Latn']



class 	lowerCAmelCase_						(a__  ):


				"""simple docstring"""



				__UpperCamelCase      :						Tuple					       =   VOCAB_FILES_NAMES
				__UpperCamelCase      :						Tuple					       =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__UpperCamelCase      :						Any					       =   PRETRAINED_VOCAB_FILES_MAP
				__UpperCamelCase      :						str					       =   ['''input_ids''', '''attention_mask''']
				__UpperCamelCase      :						Tuple					       =   NllbTokenizer

				__UpperCamelCase      :						List[int]					       =   []
				__UpperCamelCase      :						List[int]					       =   []



				def __init__(self   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__="<s>"   ,       SCREAMING_SNAKE_CASE__="</s>"   ,       SCREAMING_SNAKE_CASE__="</s>"   ,       SCREAMING_SNAKE_CASE__="<s>"   ,       SCREAMING_SNAKE_CASE__="<unk>"   ,       SCREAMING_SNAKE_CASE__="<pad>"   ,       SCREAMING_SNAKE_CASE__="<mask>"   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__=False   ,       **SCREAMING_SNAKE_CASE__   ,       )					->		Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[str]           =   AddedToken(SCREAMING_SNAKE_CASE__   ,       lstrip=SCREAMING_SNAKE_CASE__   ,       rstrip=SCREAMING_SNAKE_CASE__    ) if isinstance(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    ) else mask_token
											SCREAMING_SNAKE_CASE__						:       int           =   legacy_behaviour
											super().__init__(
											    vocab_file=SCREAMING_SNAKE_CASE__   ,       tokenizer_file=SCREAMING_SNAKE_CASE__   ,       bos_token=SCREAMING_SNAKE_CASE__   ,       eos_token=SCREAMING_SNAKE_CASE__   ,       sep_token=SCREAMING_SNAKE_CASE__   ,       cls_token=SCREAMING_SNAKE_CASE__   ,       unk_token=SCREAMING_SNAKE_CASE__   ,       pad_token=SCREAMING_SNAKE_CASE__   ,       mask_token=SCREAMING_SNAKE_CASE__   ,       src_lang=SCREAMING_SNAKE_CASE__   ,       tgt_lang=SCREAMING_SNAKE_CASE__   ,       additional_special_tokens=SCREAMING_SNAKE_CASE__   ,       legacy_behaviour=SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__   ,       )

											SCREAMING_SNAKE_CASE__						:       str           =   vocab_file
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   False if not self.vocab_file else True

											SCREAMING_SNAKE_CASE__						:       List[str]           =   FAIRSEQ_LANGUAGE_CODES.copy()

											if additional_special_tokens is not None:
																		# Only add those special tokens if they are not already there.
																		_additional_special_tokens.extend(
																		    [t for t in additional_special_tokens if t not in _additional_special_tokens]    )

											self.add_special_tokens({"""additional_special_tokens""": _additional_special_tokens}    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   {
											    lang_code: self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__    ) for lang_code in FAIRSEQ_LANGUAGE_CODES
											}

											SCREAMING_SNAKE_CASE__						:       Any           =   src_lang if src_lang is not None else """eng_Latn"""
											SCREAMING_SNAKE_CASE__						:       Dict           =   self.convert_tokens_to_ids(self._src_lang    )
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   tgt_lang
											self.set_src_lang_special_tokens(self._src_lang    )



				@property
				def 	__magic_name__    (self    )					->		str:



											"""simple docstring"""




											return self._src_lang



				@src_lang.setter
				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		None:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Any           =   new_src_lang
											self.set_src_lang_special_tokens(self._src_lang    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None    )					->		List[int]:



											"""simple docstring"""




											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 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None    )					->		List[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   [self.sep_token_id]
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   [self.cls_token_id]

											if token_ids_a is None:
																		return len(cls + token_ids_a + sep    ) * [0]
											return len(cls + token_ids_a + sep + sep + token_ids_a + sep    ) * [0]



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__    )					->		Union[str, Any]:



											"""simple docstring"""




											if src_lang is None or tgt_lang is None:
																		raise ValueError("""Translation requires a `src_lang` and a `tgt_lang` for this model"""    )
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   src_lang
											SCREAMING_SNAKE_CASE__						:       Dict           =   self(SCREAMING_SNAKE_CASE__   ,       add_special_tokens=SCREAMING_SNAKE_CASE__   ,       return_tensors=SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       List[str]           =   self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       List[str]           =   tgt_lang_id
											return inputs



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = "eng_Latn"   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = "fra_Latn"   ,       **SCREAMING_SNAKE_CASE__   ,       )					->		BatchEncoding:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Tuple           =   src_lang
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   tgt_lang
											return super().prepare_seqaseq_batch(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											return self.set_src_lang_special_tokens(self.src_lang    )



				def 	__magic_name__    (self    )					->		int:



											"""simple docstring"""




											return self.set_tgt_lang_special_tokens(self.tgt_lang    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		None:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__    )

											if self.legacy_behaviour:
																		SCREAMING_SNAKE_CASE__						:       Any           =   []
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   [self.eos_token_id, self.cur_lang_code]
											else:
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   [self.cur_lang_code]
																		SCREAMING_SNAKE_CASE__						:       List[str]           =   [self.eos_token_id]

											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   self.convert_ids_to_tokens(self.prefix_tokens    )
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.convert_ids_to_tokens(self.suffix_tokens    )

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   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 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		None:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       str           =   self.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__    )
											if self.legacy_behaviour:
																		SCREAMING_SNAKE_CASE__						:       str           =   []
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   [self.eos_token_id, self.cur_lang_code]
											else:
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   [self.cur_lang_code]
																		SCREAMING_SNAKE_CASE__						:       int           =   [self.eos_token_id]

											SCREAMING_SNAKE_CASE__						:       str           =   self.convert_ids_to_tokens(self.prefix_tokens    )
											SCREAMING_SNAKE_CASE__						:       Tuple           =   self.convert_ids_to_tokens(self.suffix_tokens    )

											SCREAMING_SNAKE_CASE__						:       List[str]           =   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 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None    )					->		Tuple[str]:



											"""simple docstring"""




											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(SCREAMING_SNAKE_CASE__    ):
																		logger.error(F'''Vocabulary path ({save_directory}) should be a directory.'''    )
																		return
											SCREAMING_SNAKE_CASE__						:       Any           =   os.path.join(
											    SCREAMING_SNAKE_CASE__   ,       (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]    )

											if os.path.abspath(self.vocab_file    ) != os.path.abspath(SCREAMING_SNAKE_CASE__    ):
																		copyfile(self.vocab_file   ,       SCREAMING_SNAKE_CASE__    )

											return (out_vocab_file,)








from math import isclose, sqrt


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ):
  A_      :				List[str]		     =					point_y / 4 / point_x
  A_      :				Union[str, Any]		     =					2 * normal_gradient / (1 + normal_gradient * normal_gradient)
  A_      :				int		     =					(1 - normal_gradient * normal_gradient) / (
      1 + normal_gradient * normal_gradient
  )
  A_      :				List[str]		     =					(sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

  # to find the next point, solve the simultaeneous equations:
  # y^2 + 4x^2 = 100
  # y - b = m * (x - a)
  # ==> A x^2 + B x + C = 0
  A_      :				List[str]		     =					outgoing_gradient**2 + 4
  A_      :				List[str]		     =					2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
  A_      :				Any		     =					(point_y - outgoing_gradient * point_x) ** 2 - 100

  A_      :				str		     =					(
      -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term       )
  ) / (2 * quadratic_term)
  A_      :				Any		     =					(
      -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term       )
  ) / (2 * quadratic_term)

  # two solutions, one of which is our input point
  A_      :				int		     =					x_minus if isclose(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ) else x_plus
  A_      :				Any		     =					point_y + outgoing_gradient * (next_x - point_x)

  return next_x, next_y, outgoing_gradient


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE = 1.4 ,			SCREAMING_SNAKE_CASE = -9.6       ):
  A_      :				int		     =					0
  A_      :				float		     =					first_x_coord
  A_      :				float		     =					first_y_coord
  A_      :				float		     =					(1_0.1 - point_y) / (0.0 - point_x)

  while not (-0.0_1 <= point_x <= 0.0_1 and point_y > 0):
    A_     ,       A_     ,       A_      :				List[str]		     =					next_point(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       )
    num_reflections += 1

  return num_reflections


if __name__ == "__main__":
     print(F'''{solution() = }''')




