





from collections.abc import Generator
from math import sin

def   a_    ( lowerCAmelCase_      :			int	):
   if len(lowerCAmelCase_	) != 32:
      raise ValueError('Input must be of length 32'	)

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

def   a_    ( lowerCAmelCase_      :			Optional[int]	):
   if i < 0:
      raise ValueError('Input must be non-negative'	)

   __lowerCAmelCase								=	format(lowerCAmelCase_,	'08x'	)[-8:]
   __lowerCAmelCase								=	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   a_    ( lowerCAmelCase_      :			List[Any]	):
   __lowerCAmelCase								=	B''
   for char in message:
      bit_string += format(lowerCAmelCase_,	'08b'	).encode('utf-8'	)
   __lowerCAmelCase								=	format(len(lowerCAmelCase_	),	'064b'	).encode('utf-8'	)

   # Pad bit_string to a multiple of 512 chars
   bit_string += b"1"
   while len(lowerCAmelCase_	) % 512 != 448:
      bit_string += b"0"
   bit_string += to_little_endian(start_len[32:]	) + to_little_endian(start_len[:32]	)

   return bit_string

def   a_    ( lowerCAmelCase_      :			Optional[Any]	):
   if len(lowerCAmelCase_	) % 512 != 0:
      raise ValueError('Input must have length that\'s a multiple of 512'	)

   for pos in range(0,	len(lowerCAmelCase_	),	512	):
      __lowerCAmelCase								=	bit_string[pos : pos + 512]
      __lowerCAmelCase								=	[]
      for i in range(0,	512,	32	):
         block_words.append(int(to_little_endian(block[i : i + 32]	),	2	)	)
      yield block_words

def   a_    ( lowerCAmelCase_      :			int	):
   if i < 0:
      raise ValueError('Input must be non-negative'	)

   __lowerCAmelCase								=	format(lowerCAmelCase_,	'032b'	)
   __lowerCAmelCase								=	''
   for c in i_str:
      new_str += "1" if c == "0" else "0"
   return int(lowerCAmelCase_,	2	)

def   a_    ( lowerCAmelCase_      :			str,	lowerCAmelCase_      :			Tuple	):
   return (a + b) % 2**32

def   a_    ( lowerCAmelCase_      :			int,	lowerCAmelCase_      :			List[str]	):
   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   a_    ( lowerCAmelCase_      :			Tuple	):
   __lowerCAmelCase								=	preprocess(lowerCAmelCase_	)

   __lowerCAmelCase								=	[int(2**32 * abs(sin(i + 1	)	)	) for i in range(64	)]

   # Starting states
   __lowerCAmelCase								=	0X67452301
   __lowerCAmelCase								=	0Xefcdab89
   __lowerCAmelCase								=	0X98badcfe
   __lowerCAmelCase								=	0X10325476

   __lowerCAmelCase								=	[
       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(lowerCAmelCase_	):
      __lowerCAmelCase								=	aa
      __lowerCAmelCase								=	ba
      __lowerCAmelCase								=	ca
      __lowerCAmelCase								=	da

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

      # Add hashed chunk to running total
      __lowerCAmelCase								=	sum_aa(lowerCAmelCase_,	lowerCAmelCase_	)
      __lowerCAmelCase								=	sum_aa(lowerCAmelCase_,	lowerCAmelCase_	)
      __lowerCAmelCase								=	sum_aa(lowerCAmelCase_,	lowerCAmelCase_	)
      __lowerCAmelCase								=	sum_aa(lowerCAmelCase_,	lowerCAmelCase_	)

   __lowerCAmelCase								=	reformat_hex(lowerCAmelCase_	) + reformat_hex(lowerCAmelCase_	) + reformat_hex(lowerCAmelCase_	) + reformat_hex(lowerCAmelCase_	)
   return digest


if __name__ == "__main__":
     import doctest

     doctest.testmod()





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__lowerCAmelCase		       =							{
    '''configuration_canine''': ['''CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CanineConfig'''],
    '''tokenization_canine''': ['''CanineTokenizer'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowerCAmelCase		       =							[
     '''CANINE_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''CanineForMultipleChoice''',
     '''CanineForQuestionAnswering''',
     '''CanineForSequenceClassification''',
     '''CanineForTokenClassification''',
     '''CanineLayer''',
     '''CanineModel''',
     '''CaninePreTrainedModel''',
     '''load_tf_weights_in_canine''',
 ]


if TYPE_CHECKING:
 from .configuration_canine import CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP, CanineConfig
 from .tokenization_canine import CanineTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_canine import (
      CANINE_PRETRAINED_MODEL_ARCHIVE_LIST,
      CanineForMultipleChoice,
      CanineForQuestionAnswering,
      CanineForSequenceClassification,
      CanineForTokenClassification,
      CanineLayer,
      CanineModel,
      CaninePreTrainedModel,
      load_tf_weights_in_canine,
  )


else:
 import sys

 __lowerCAmelCase		       =							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


