


'''simple docstring'''



import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


A__						:   Union[str, Any]				=    get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
      from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

A__						:   str				=    256047
A__						:   int				=    256145





@require_sentencepiece
@require_tokenizers
class   UpperCAmelCase_    (_UpperCAmelCase   ,						unittest.TestCase    ):





    """simple docstring"""






    lowerCamelCase    :   List[Any]					=     NllbTokenizer
    lowerCamelCase    :   Optional[int]					=     NllbTokenizerFast
    lowerCamelCase    :   List[Any]					=     True
    lowerCamelCase    :   Dict					=     True
    lowerCamelCase    :   int					=     {}







    def  lowercase_							(				self      )							->	str:
         super().setUp()

         # We have a SentencePiece fixture for testing
         __lowerCamelCase  :      Union[str, Any]														=						NllbTokenizer(SCREAMING_SNAKE_CASE_     ,	keep_accents=SCREAMING_SNAKE_CASE_      )
         tokenizer.save_pretrained(self.tmpdirname      )







    def  lowercase_							(				self      )							->	Tuple:
         __lowerCamelCase  :      str														=						NllbTokenizer(SCREAMING_SNAKE_CASE_     ,	keep_accents=SCREAMING_SNAKE_CASE_      )

         __lowerCamelCase  :      str														=						tokenizer.tokenize('This is a test'      )
         self.assertListEqual(SCREAMING_SNAKE_CASE_     ,	['▁This', '▁is', '▁a', '▁t', 'est']      )

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_      )     ,	[value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]     ,	)

         __lowerCamelCase  :      Dict														=						tokenizer.tokenize('I was born in 92000, and this is falsé.'      )
         self.assertListEqual(
             SCREAMING_SNAKE_CASE_     ,	[
                 SPIECE_UNDERLINE + 'I',
                 SPIECE_UNDERLINE + 'was',
                 SPIECE_UNDERLINE + 'b',
                 'or',
                 'n',
                 SPIECE_UNDERLINE + 'in',
                 SPIECE_UNDERLINE + '',
                 '9',
                 '2',
                 '0',
                 '0',
                 '0',
                 ',',
                 SPIECE_UNDERLINE + 'and',
                 SPIECE_UNDERLINE + 'this',
                 SPIECE_UNDERLINE + 'is',
                 SPIECE_UNDERLINE + 'f',
                 'al',
                 's',
                 'é',
                 '.',
             ]     ,	)
         __lowerCamelCase  :      int														=						tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_      )
         self.assertListEqual(
             SCREAMING_SNAKE_CASE_     ,	[
                 value + tokenizer.fairseq_offset
                 for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
             ]     ,	)

         __lowerCamelCase  :      Any														=						tokenizer.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_      )
         self.assertListEqual(
             SCREAMING_SNAKE_CASE_     ,	[
                 SPIECE_UNDERLINE + 'I',
                 SPIECE_UNDERLINE + 'was',
                 SPIECE_UNDERLINE + 'b',
                 'or',
                 'n',
                 SPIECE_UNDERLINE + 'in',
                 SPIECE_UNDERLINE + '',
                 '<unk>',
                 '2',
                 '0',
                 '0',
                 '0',
                 ',',
                 SPIECE_UNDERLINE + 'and',
                 SPIECE_UNDERLINE + 'this',
                 SPIECE_UNDERLINE + 'is',
                 SPIECE_UNDERLINE + 'f',
                 'al',
                 's',
                 '<unk>',
                 '.',
             ]     ,	)







    def  lowercase_							(				self      )							->	Tuple:
         __lowerCamelCase  :      Union[str, Any]														=						(self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {})
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'      ):
                   __lowerCamelCase  :      Optional[Any]														=						self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      Tuple														=						self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )

                   __lowerCamelCase  :      Optional[int]														=						tempfile.mkdtemp()

                   __lowerCamelCase  :      Any														=						tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      Any														=						tokenizer_p.save_pretrained(SCREAMING_SNAKE_CASE_      )

                   # Checks it save with the same files + the tokenizer.json file for the fast one
                   self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files      )      )
                   __lowerCamelCase  :      List[str]														=						tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f      )
                   self.assertSequenceEqual(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

                   # Checks everything loads correctly in the same way
                   __lowerCamelCase  :      Tuple														=						tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      int														=						tokenizer_p.from_pretrained(SCREAMING_SNAKE_CASE_      )

                   # Check special tokens are set accordingly on Rust and Python
                   for key in tokenizer_pp.special_tokens_map:
                        self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )      )

                   shutil.rmtree(SCREAMING_SNAKE_CASE_      )

                   # Save tokenizer rust, legacy_format=True
                   __lowerCamelCase  :      Any														=						tempfile.mkdtemp()

                   __lowerCamelCase  :      int														=						tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_     ,	legacy_format=SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      Any														=						tokenizer_p.save_pretrained(SCREAMING_SNAKE_CASE_      )

                   # Checks it save with the same files
                   self.assertSequenceEqual(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

                   # Checks everything loads correctly in the same way
                   __lowerCamelCase  :      Optional[Any]														=						tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      Any														=						tokenizer_p.from_pretrained(SCREAMING_SNAKE_CASE_      )

                   # Check special tokens are set accordingly on Rust and Python
                   for key in tokenizer_pp.special_tokens_map:
                        self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )      )

                   shutil.rmtree(SCREAMING_SNAKE_CASE_      )

                   # Save tokenizer rust, legacy_format=False
                   __lowerCamelCase  :      Any														=						tempfile.mkdtemp()

                   __lowerCamelCase  :      int														=						tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_     ,	legacy_format=SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      Optional[int]														=						tokenizer_p.save_pretrained(SCREAMING_SNAKE_CASE_      )

                   # Checks it saved the tokenizer.json file
                   self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files      )      )

                   # Checks everything loads correctly in the same way
                   __lowerCamelCase  :      str														=						tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      Tuple														=						tokenizer_p.from_pretrained(SCREAMING_SNAKE_CASE_      )

                   # Check special tokens are set accordingly on Rust and Python
                   for key in tokenizer_pp.special_tokens_map:
                        self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )      )

                   shutil.rmtree(SCREAMING_SNAKE_CASE_      )







    @require_torch
    def  lowercase_							(				self      )							->	Optional[int]:
         if not self.test_seqaseq:
              return

         __lowerCamelCase  :      Optional[int]														=						self.get_tokenizers()
         for tokenizer in tokenizers:
              with self.subTest(f'{tokenizer.__class__.__name__}'      ):
                   # Longer text that will definitely require truncation.
                   __lowerCamelCase  :      Union[str, Any]														=						[
                       ' UN Chief Says There Is No Military Solution in Syria',
                       ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'
                       ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'
                       ' will only worsen the violence and misery for millions of people.',
                   ]
                   __lowerCamelCase  :      List[str]														=						[
                       'Şeful ONU declară că nu există o soluţie militară în Siria',
                       'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'
                       ' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'
                       ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
                   ]
                   try:
                        __lowerCamelCase  :      Optional[Any]														=						tokenizer.prepare_seqaseq_batch(
                            src_texts=SCREAMING_SNAKE_CASE_     ,	tgt_texts=SCREAMING_SNAKE_CASE_     ,	max_length=3     ,	max_target_length=10     ,	return_tensors='pt'     ,	src_lang='eng_Latn'     ,	tgt_lang='ron_Latn'     ,	)
                   except NotImplementedError:
                        return
                   self.assertEqual(batch.input_ids.shape[1]     ,	3      )
                   self.assertEqual(batch.labels.shape[1]     ,	10      )
                   # max_target_length will default to max_length if not specified
                   __lowerCamelCase  :      int														=						tokenizer.prepare_seqaseq_batch(
                       SCREAMING_SNAKE_CASE_     ,	tgt_texts=SCREAMING_SNAKE_CASE_     ,	max_length=3     ,	return_tensors='pt'      )
                   self.assertEqual(batch.input_ids.shape[1]     ,	3      )
                   self.assertEqual(batch.labels.shape[1]     ,	3      )

                   __lowerCamelCase  :      List[str]														=						tokenizer.prepare_seqaseq_batch(
                       src_texts=SCREAMING_SNAKE_CASE_     ,	max_length=3     ,	max_target_length=10     ,	return_tensors='pt'      )
                   self.assertEqual(batch_encoder_only.input_ids.shape[1]     ,	3      )
                   self.assertEqual(batch_encoder_only.attention_mask.shape[1]     ,	3      )
                   self.assertNotIn('decoder_input_ids'     ,	SCREAMING_SNAKE_CASE_      )







    @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.'      )
    def  lowercase_							(				self      )							->	Optional[Any]:
         pass







    def  lowercase_							(				self      )							->	Tuple:
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'      ):
                   __lowerCamelCase  :      Dict														=						[AddedToken('<special>'     ,	lstrip=SCREAMING_SNAKE_CASE_      )]

                   __lowerCamelCase  :      Dict														=						self.rust_tokenizer_class.from_pretrained(
                       SCREAMING_SNAKE_CASE_     ,	additional_special_tokens=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      List[Any]														=						tokenizer_r.encode('Hey this is a <special> token'      )

                   __lowerCamelCase  :      Union[str, Any]														=						tokenizer_r.encode('<special>'     ,	add_special_tokens=SCREAMING_SNAKE_CASE_      )[0]

                   self.assertTrue(special_token_id in r_output      )

                   if self.test_slow_tokenizer:
                        __lowerCamelCase  :      Optional[int]														=						self.rust_tokenizer_class.from_pretrained(
                            SCREAMING_SNAKE_CASE_     ,	additional_special_tokens=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_     ,	)
                        __lowerCamelCase  :      Dict														=						self.tokenizer_class.from_pretrained(
                            SCREAMING_SNAKE_CASE_     ,	additional_special_tokens=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )

                        __lowerCamelCase  :      str														=						tokenizer_p.encode('Hey this is a <special> token'      )

                        __lowerCamelCase  :      Union[str, Any]														=						tokenizer_cr.encode('Hey this is a <special> token'      )

                        self.assertEqual(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
                        self.assertEqual(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
                        self.assertTrue(special_token_id in p_output      )
                        self.assertTrue(special_token_id in cr_output      )







@require_torch
@require_sentencepiece
@require_tokenizers
class   UpperCAmelCase_    (unittest.TestCase    ):





    """simple docstring"""






    lowerCamelCase    :   Optional[int]					=     'facebook/nllb-200-distilled-600M'
    lowerCamelCase    :   List[str]					=     [
        ' UN Chief Says There Is No Military Solution in Syria',
        ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.',
    ]
    lowerCamelCase    :   List[str]					=     [
        'Şeful ONU declară că nu există o soluţie militară în Siria',
        'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'
        ' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'
        ' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
    ]
    lowerCamelCase    :   Tuple					=     [
        2_5_6_0_4_7,
        1_6_2_9_7,
        1_3_4_4_0_8,
        8_1_6_5,
        2_4_8_0_6_6,
        1_4_7_3_4,
        9_5_0,
        1_1_3_5,
        1_0_5_7_2_1,
        3_5_7_3,
        8_3,
        2_7_3_5_2,
        1_0_8,
        4_9_4_8_6,
        2,
    ]







    @classmethod
    def  lowercase_							(				cls      )							->	Union[str, Any]:
         __lowerCamelCase  :      NllbTokenizer														=						NllbTokenizer.from_pretrained(
             cls.checkpoint_name     ,	src_lang='eng_Latn'     ,	tgt_lang='ron_Latn'      )
         __lowerCamelCase  :      Dict														=						1
         return cls







    def  lowercase_							(				self      )							->	List[Any]:
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab']     ,	25_60_01      )
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn']     ,	25_60_02      )
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn']     ,	25_60_57      )







    def  lowercase_							(				self      )							->	Any:
         __lowerCamelCase  :      Optional[Any]														=						self.tokenizer.batch_encode_plus(self.src_text      ).input_ids[0]
         self.assertListEqual(self.expected_src_tokens     ,	SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	List[Any]:
         self.assertIn(SCREAMING_SNAKE_CASE_     ,	self.tokenizer.all_special_ids      )
         # fmt: off
         __lowerCamelCase  :      List[Any]														=						[RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47]
         # fmt: on

         __lowerCamelCase  :      Optional[int]														=						self.tokenizer.decode(SCREAMING_SNAKE_CASE_     ,	skip_special_tokens=SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Union[str, Any]														=						self.tokenizer.decode(generated_ids[1:]     ,	skip_special_tokens=SCREAMING_SNAKE_CASE_      )
         self.assertEqual(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
         self.assertNotIn(self.tokenizer.eos_token     ,	SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	int:
         __lowerCamelCase  :      Tuple														=						['this is gunna be a long sentence ' * 20]
         assert isinstance(src_text[0]     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      str														=						10
         __lowerCamelCase  :      List[Any]														=						self.tokenizer(SCREAMING_SNAKE_CASE_     ,	max_length=SCREAMING_SNAKE_CASE_     ,	truncation=SCREAMING_SNAKE_CASE_      ).input_ids[0]
         self.assertEqual(ids[-1]     ,	2      )
         self.assertEqual(ids[0]     ,	SCREAMING_SNAKE_CASE_      )
         self.assertEqual(len(SCREAMING_SNAKE_CASE_      )     ,	SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	Union[str, Any]:
         self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']      )     ,	[25_62_03, 3]      )







    def  lowercase_							(				self      )							->	str:
         __lowerCamelCase  :      Dict														=						tempfile.mkdtemp()
         __lowerCamelCase  :      List[Any]														=						self.tokenizer.fairseq_tokens_to_ids
         self.tokenizer.save_pretrained(SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Any														=						NllbTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_      )
         self.assertDictEqual(new_tok.fairseq_tokens_to_ids     ,	SCREAMING_SNAKE_CASE_      )







    @require_torch
    def  lowercase_							(				self      )							->	Any:
         __lowerCamelCase  :      Tuple														=						self.tokenizer(
             self.src_text     ,	text_target=self.tgt_text     ,	padding=SCREAMING_SNAKE_CASE_     ,	truncation=SCREAMING_SNAKE_CASE_     ,	max_length=len(self.expected_src_tokens      )     ,	return_tensors='pt'     ,	)
         __lowerCamelCase  :      Dict														=						shift_tokens_right(
             batch['labels']     ,	self.tokenizer.pad_token_id     ,	self.tokenizer.lang_code_to_id['ron_Latn']      )

         self.assertIsInstance(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

         self.assertEqual((2, 15)     ,	batch.input_ids.shape      )
         self.assertEqual((2, 15)     ,	batch.attention_mask.shape      )
         __lowerCamelCase  :      List[Any]														=						batch.input_ids.tolist()[0]
         self.assertListEqual(self.expected_src_tokens     ,	SCREAMING_SNAKE_CASE_      )
         self.assertEqual(SCREAMING_SNAKE_CASE_     ,	batch.decoder_input_ids[0, 0]      )  # EOS
         # Test that special tokens are reset
         self.assertEqual(self.tokenizer.prefix_tokens     ,	[EN_CODE]      )
         self.assertEqual(self.tokenizer.suffix_tokens     ,	[self.tokenizer.eos_token_id]      )







    def  lowercase_							(				self      )							->	Dict:
         __lowerCamelCase  :      int														=						self.tokenizer(self.src_text     ,	padding=SCREAMING_SNAKE_CASE_     ,	truncation=SCREAMING_SNAKE_CASE_     ,	max_length=3     ,	return_tensors='pt'      )
         __lowerCamelCase  :      Tuple														=						self.tokenizer(
             text_target=self.tgt_text     ,	padding=SCREAMING_SNAKE_CASE_     ,	truncation=SCREAMING_SNAKE_CASE_     ,	max_length=10     ,	return_tensors='pt'      )
         __lowerCamelCase  :      Optional[int]														=						targets['input_ids']
         __lowerCamelCase  :      List[Any]														=						shift_tokens_right(
             SCREAMING_SNAKE_CASE_     ,	self.tokenizer.pad_token_id     ,	decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]     ,	)

         self.assertEqual(batch.input_ids.shape[1]     ,	3      )
         self.assertEqual(batch.decoder_input_ids.shape[1]     ,	10      )







    @require_torch
    def  lowercase_							(				self      )							->	Optional[int]:
         __lowerCamelCase  :      Tuple														=						self.tokenizer._build_translation_inputs(
             'A test'     ,	return_tensors='pt'     ,	src_lang='eng_Latn'     ,	tgt_lang='fra_Latn'      )

         self.assertEqual(
             nested_simplify(SCREAMING_SNAKE_CASE_      )     ,	{
                 # A, test, EOS, en_XX
                 'input_ids': [[25_60_47, 70, 73_56, 2]],
                 'attention_mask': [[1, 1, 1, 1]],
                 # ar_AR
                 'forced_bos_token_id': 25_60_57,
             }     ,	)







    @require_torch
    def  lowercase_							(				self      )							->	List[Any]:
         __lowerCamelCase  :      List[Any]														=						True
         __lowerCamelCase  :      Any														=						self.tokenizer(
             'UN Chief says there is no military solution in Syria'     ,	src_lang='eng_Latn'     ,	tgt_lang='fra_Latn'      )
         self.assertEqual(
             inputs.input_ids     ,	[1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47]      )

         __lowerCamelCase  :      List[Any]														=						False
         __lowerCamelCase  :      Union[str, Any]														=						self.tokenizer(
             'UN Chief says there is no military solution in Syria'     ,	src_lang='eng_Latn'     ,	tgt_lang='fra_Latn'      )
         self.assertEqual(
             inputs.input_ids     ,	[25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2]      )










'''simple docstring'''



from collections.abc import Generator
from math import sin



def      UpperCAmelCase__   (      UpperCAmelCase_       :							bytes				)	->						bytes:
     if len(UpperCAmelCase_				) != 32:
          raise ValueError('Input must be of length 32'				)

     __lowerCamelCase  :      Dict														=						B''
     for i in [3, 2, 1, 0]:
          little_endian += string_aa[8 * i : 8 * i + 8]
     return little_endian



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int				)	->						bytes:
     if i < 0:
          raise ValueError('Input must be non-negative'				)

     __lowerCamelCase  :      Union[str, Any]														=						format(UpperCAmelCase_ ,       '08x'				)[-8:]
     __lowerCamelCase  :      str														=						B''
     for i in [3, 2, 1, 0]:
          little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('utf-8'				)
     return little_endian_hex



def      UpperCAmelCase__   (      UpperCAmelCase_       :							bytes				)	->						bytes:
     __lowerCamelCase  :      Optional[Any]														=						B''
     for char in message:
          bit_string += format(UpperCAmelCase_ ,       '08b'				).encode('utf-8'				)
     __lowerCamelCase  :      List[str]														=						format(len(UpperCAmelCase_				) ,       '064b'				).encode('utf-8'				)

     # Pad bit_string to a multiple of 512 chars
     bit_string += b"1"
     while len(UpperCAmelCase_				) % 5_12 != 4_48:
          bit_string += b"0"
     bit_string += to_little_endian(start_len[32:]				) + to_little_endian(start_len[:32]				)

     return bit_string



def      UpperCAmelCase__   (      UpperCAmelCase_       :							bytes				)	->						Generator[list[int], None, None]:
     if len(UpperCAmelCase_				) % 5_12 != 0:
          raise ValueError('Input must have length that\'s a multiple of 512'				)

     for pos in range(0 ,       len(UpperCAmelCase_				) ,       5_12				):
          __lowerCamelCase  :      Any														=						bit_string[pos : pos + 5_12]
          __lowerCamelCase  :      Optional[int]														=						[]
          for i in range(0 ,       5_12 ,       32				):
               block_words.append(int(to_little_endian(block[i : i + 32]				) ,       2				)				)
          yield block_words



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int				)	->						int:
     if i < 0:
          raise ValueError('Input must be non-negative'				)

     __lowerCamelCase  :      List[Any]														=						format(UpperCAmelCase_ ,       '032b'				)
     __lowerCamelCase  :      Optional[int]														=						''
     for c in i_str:
          new_str += "1" if c == "0" else "0"
     return int(UpperCAmelCase_ ,       2				)



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int ,       UpperCAmelCase_       :							int				)	->						int:
     return (a + b) % 2**32



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int ,       UpperCAmelCase_       :							int				)	->						int:
     if i < 0:
          raise ValueError('Input must be non-negative'				)
     if shift < 0:
          raise ValueError('Shift must be non-negative'				)
     return ((i << shift) ^ (i >> (32 - shift))) % 2**32



def      UpperCAmelCase__   (      UpperCAmelCase_       :							bytes				)	->						bytes:
     __lowerCamelCase  :      Optional[Any]														=						preprocess(UpperCAmelCase_				)

     __lowerCamelCase  :      Union[str, Any]														=						[int(2**32 * abs(sin(i + 1				)				)				) for i in range(64				)]

     # Starting states
     __lowerCamelCase  :      Dict														=						0x67_45_23_01
     __lowerCamelCase  :      Union[str, Any]														=						0xef_cd_ab_89
     __lowerCamelCase  :      Optional[Any]														=						0x98_ba_dc_fe
     __lowerCamelCase  :      Union[str, Any]														=						0x10_32_54_76

     __lowerCamelCase  :      List[str]														=						[
         7,
         12,
         17,
         22,
         7,
         12,
         17,
         22,
         7,
         12,
         17,
         22,
         7,
         12,
         17,
         22,
         5,
         9,
         14,
         20,
         5,
         9,
         14,
         20,
         5,
         9,
         14,
         20,
         5,
         9,
         14,
         20,
         4,
         11,
         16,
         23,
         4,
         11,
         16,
         23,
         4,
         11,
         16,
         23,
         4,
         11,
         16,
         23,
         6,
         10,
         15,
         21,
         6,
         10,
         15,
         21,
         6,
         10,
         15,
         21,
         6,
         10,
         15,
         21,
     ]

     # Process bit string in chunks, each with 16 32-char words
     for block_words in get_block_words(UpperCAmelCase_				):
          __lowerCamelCase  :      Dict														=						aa
          __lowerCamelCase  :      Tuple														=						ba
          __lowerCamelCase  :      List[Any]														=						ca
          __lowerCamelCase  :      Dict														=						da

          # Hash current chunk
          for i in range(64				):
               if i <= 15:
                    # f = (b & c) | (not_32(b) & d)     # Alternate definition for f
                    __lowerCamelCase  :      List[str]														=						d ^ (b & (c ^ d))
                    __lowerCamelCase  :      Optional[int]														=						i
               elif i <= 31:
                    # f = (d & b) | (not_32(d) & c)     # Alternate definition for f
                    __lowerCamelCase  :      Optional[int]														=						c ^ (d & (b ^ c))
                    __lowerCamelCase  :      Tuple														=						(5 * i + 1) % 16
               elif i <= 47:
                    __lowerCamelCase  :      str														=						b ^ c ^ d
                    __lowerCamelCase  :      Any														=						(3 * i + 5) % 16
               else:
                    __lowerCamelCase  :      Union[str, Any]														=						c ^ (b | not_aa(UpperCAmelCase_				))
                    __lowerCamelCase  :      int														=						(7 * i) % 16
               __lowerCamelCase  :      Optional[int]														=						(f + a + added_consts[i] + block_words[g]) % 2**32
               __lowerCamelCase  :      Optional[Any]														=						d
               __lowerCamelCase  :      Tuple														=						c
               __lowerCamelCase  :      Optional[int]														=						b
               __lowerCamelCase  :      List[str]														=						sum_aa(UpperCAmelCase_ ,       left_rotate_aa(UpperCAmelCase_ ,       shift_amounts[i]				)				)

          # Add hashed chunk to running total
          __lowerCamelCase  :      int														=						sum_aa(UpperCAmelCase_ ,       UpperCAmelCase_				)
          __lowerCamelCase  :      str														=						sum_aa(UpperCAmelCase_ ,       UpperCAmelCase_				)
          __lowerCamelCase  :      List[Any]														=						sum_aa(UpperCAmelCase_ ,       UpperCAmelCase_				)
          __lowerCamelCase  :      List[str]														=						sum_aa(UpperCAmelCase_ ,       UpperCAmelCase_				)

     __lowerCamelCase  :      Dict														=						reformat_hex(UpperCAmelCase_				) + reformat_hex(UpperCAmelCase_				) + reformat_hex(UpperCAmelCase_				) + reformat_hex(UpperCAmelCase_				)
     return digest


if __name__ == "__main__":
      import doctest

      doctest.testmod()






