





from collections.abc import Generator
from math import sin




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

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




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

    UpperCamelCase__							:				Optional[Any]          =      format(__UpperCAmelCase		,   '''08x'''      )[-8:]
    UpperCamelCase__							:				Tuple          =      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 		lowerCAmelCase_    (  __UpperCAmelCase:			bytes      )      ->	bytes:
    UpperCamelCase__							:				Dict          =      B''''''
    for char in message:
        bit_string += format(__UpperCAmelCase		,   '''08b'''      ).encode('''utf-8'''      )
    UpperCamelCase__							:				Optional[Any]          =      format(len(__UpperCAmelCase      )		,   '''064b'''      ).encode('''utf-8'''      )

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

    return bit_string




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

    for pos in range(0		,   len(__UpperCAmelCase      )		,   512      ):
        UpperCamelCase__							:				Any          =      bit_string[pos : pos + 512]
        UpperCamelCase__							:				List[str]          =      []
        for i in range(0		,   512		,   32      ):
            block_words.append(int(to_little_endian(block[i : i + 32]      )		,   2      )      )
        yield block_words




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

    UpperCamelCase__							:				int          =      format(__UpperCAmelCase		,   '''032b'''      )
    UpperCamelCase__							:				Union[str, Any]          =      ''''''
    for c in i_str:
        new_str += "1" if c == "0" else "0"
    return int(__UpperCAmelCase		,   2      )




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




def 		lowerCAmelCase_    (  __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 		lowerCAmelCase_    (  __UpperCAmelCase:			bytes      )      ->	bytes:
    UpperCamelCase__							:				Optional[Any]          =      preprocess(__UpperCAmelCase      )

    UpperCamelCase__							:				List[Any]          =      [int(2**32 * abs(sin(i + 1      )      )      ) for i in range(64      )]

    # Starting states
    UpperCamelCase__							:				Optional[int]          =      0x67_452_301
    UpperCamelCase__							:				List[Any]          =      0xEF_CDA_B89
    UpperCamelCase__							:				Dict          =      0x98_BAD_CFE
    UpperCamelCase__							:				int          =      0x10_325_476

    UpperCamelCase__							:				Dict          =      [
        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      ):
        UpperCamelCase__							:				List[Any]          =      aa
        UpperCamelCase__							:				List[Any]          =      ba
        UpperCamelCase__							:				Any          =      ca
        UpperCamelCase__							:				Union[str, Any]          =      da

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

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

    UpperCamelCase__							:				List[str]          =      reformat_hex(__UpperCAmelCase      ) + reformat_hex(__UpperCAmelCase      ) + reformat_hex(__UpperCAmelCase      ) + reformat_hex(__UpperCAmelCase      )
    return digest


if __name__ == "__main__":
  import doctest

  doctest.testmod()








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase_     							= {
    'configuration_convbert': ['CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ConvBertConfig', 'ConvBertOnnxConfig'],
    'tokenization_convbert': ['ConvBertTokenizer'],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_     							= ['ConvBertTokenizerFast']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_     							= [
      'CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'ConvBertForMaskedLM',
      'ConvBertForMultipleChoice',
      'ConvBertForQuestionAnswering',
      'ConvBertForSequenceClassification',
      'ConvBertForTokenClassification',
      'ConvBertLayer',
      'ConvBertModel',
      'ConvBertPreTrainedModel',
      'load_tf_weights_in_convbert',
  ]


try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_     							= [
      'TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFConvBertForMaskedLM',
      'TFConvBertForMultipleChoice',
      'TFConvBertForQuestionAnswering',
      'TFConvBertForSequenceClassification',
      'TFConvBertForTokenClassification',
      'TFConvBertLayer',
      'TFConvBertModel',
      'TFConvBertPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
  from .tokenization_convbert import ConvBertTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_convbert_fast import ConvBertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_convbert import (
        CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        ConvBertForMaskedLM,
        ConvBertForMultipleChoice,
        ConvBertForQuestionAnswering,
        ConvBertForSequenceClassification,
        ConvBertForTokenClassification,
        ConvBertLayer,
        ConvBertModel,
        ConvBertPreTrainedModel,
        load_tf_weights_in_convbert,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_convbert import (
        TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFConvBertForMaskedLM,
        TFConvBertForMultipleChoice,
        TFConvBertForQuestionAnswering,
        TFConvBertForSequenceClassification,
        TFConvBertForTokenClassification,
        TFConvBertLayer,
        TFConvBertModel,
        TFConvBertPreTrainedModel,
    )


else:
  import sys

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

