
'''simple docstring'''

from collections.abc import Generator
from math import sin


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 if len(lowerCamelCase_			) != 3_2:
  raise ValueError("Input must be of length 32"			)

 lowerCAmelCase__     :   Optional[Any]     		=	B""
 for i in [3, 2, 1, 0]:
  little_endian += string_aa[8 * i : 8 * i + 8]
 return little_endian


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 if i < 0:
  raise ValueError("Input must be non-negative"			)

 lowerCAmelCase__     :   List[str]     		=	format(lowerCamelCase_      ,			"08x"			)[-8:]
 lowerCAmelCase__     :   Dict     		=	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_ (  lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Optional[Any]     		=	B""
 for char in message:
  bit_string += format(lowerCamelCase_      ,			"08b"			).encode("utf-8"			)
 lowerCAmelCase__     :   List[Any]     		=	format(len(lowerCamelCase_			)      ,			"064b"			).encode("utf-8"			)

 # Pad bit_string to a multiple of 512 chars
 bit_string += b"1"
 while len(lowerCamelCase_			) % 5_1_2 != 4_4_8:
  bit_string += b"0"
 bit_string += to_little_endian(start_len[3_2:]			) + to_little_endian(start_len[:3_2]			)

 return bit_string


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 if len(lowerCamelCase_			) % 5_1_2 != 0:
  raise ValueError("Input must have length that\'s a multiple of 512"			)

 for pos in range(0      ,			len(lowerCamelCase_			)      ,			5_1_2			):
  lowerCAmelCase__     :   Dict     		=	bit_string[pos : pos + 5_1_2]
  lowerCAmelCase__     :   Optional[int]     		=	[]
  for i in range(0      ,			5_1_2      ,			3_2			):
   block_words.append(int(to_little_endian(block[i : i + 3_2]			)      ,			2			)			)
  yield block_words


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 if i < 0:
  raise ValueError("Input must be non-negative"			)

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


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 return (a + b) % 2**3_2


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 if i < 0:
  raise ValueError("Input must be non-negative"			)
 if shift < 0:
  raise ValueError("Shift must be non-negative"			)
 return ((i << shift) ^ (i >> (3_2 - shift))) % 2**3_2


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Tuple     		=	preprocess(lowerCamelCase_			)

 lowerCAmelCase__     :   str     		=	[int(2**3_2 * abs(sin(i + 1			)			)			) for i in range(6_4			)]

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

 lowerCAmelCase__     :   int     		=	[
     7,
     1_2,
     1_7,
     2_2,
     7,
     1_2,
     1_7,
     2_2,
     7,
     1_2,
     1_7,
     2_2,
     7,
     1_2,
     1_7,
     2_2,
     5,
     9,
     1_4,
     2_0,
     5,
     9,
     1_4,
     2_0,
     5,
     9,
     1_4,
     2_0,
     5,
     9,
     1_4,
     2_0,
     4,
     1_1,
     1_6,
     2_3,
     4,
     1_1,
     1_6,
     2_3,
     4,
     1_1,
     1_6,
     2_3,
     4,
     1_1,
     1_6,
     2_3,
     6,
     1_0,
     1_5,
     2_1,
     6,
     1_0,
     1_5,
     2_1,
     6,
     1_0,
     1_5,
     2_1,
     6,
     1_0,
     1_5,
     2_1,
 ]

 # Process bit string in chunks, each with 16 32-char words
 for block_words in get_block_words(lowerCamelCase_			):
  lowerCAmelCase__     :   Dict     		=	aa
  lowerCAmelCase__     :   str     		=	ba
  lowerCAmelCase__     :   int     		=	ca
  lowerCAmelCase__     :   Tuple     		=	da

  # Hash current chunk
  for i in range(6_4			):
   if i <= 1_5:
    # f = (b & c) | (not_32(b) & d)     # Alternate definition for f
    lowerCAmelCase__     :   Union[str, Any]     		=	d ^ (b & (c ^ d))
    lowerCAmelCase__     :   Dict     		=	i
   elif i <= 3_1:
    # f = (d & b) | (not_32(d) & c)     # Alternate definition for f
    lowerCAmelCase__     :   List[Any]     		=	c ^ (d & (b ^ c))
    lowerCAmelCase__     :   int     		=	(5 * i + 1) % 1_6
   elif i <= 4_7:
    lowerCAmelCase__     :   List[Any]     		=	b ^ c ^ d
    lowerCAmelCase__     :   Optional[int]     		=	(3 * i + 5) % 1_6
   else:
    lowerCAmelCase__     :   Tuple     		=	c ^ (b | not_aa(lowerCamelCase_			))
    lowerCAmelCase__     :   Union[str, Any]     		=	(7 * i) % 1_6
   lowerCAmelCase__     :   Optional[Any]     		=	(f + a + added_consts[i] + block_words[g]) % 2**3_2
   lowerCAmelCase__     :   List[str]     		=	d
   lowerCAmelCase__     :   List[str]     		=	c
   lowerCAmelCase__     :   Any     		=	b
   lowerCAmelCase__     :   Optional[int]     		=	sum_aa(lowerCamelCase_      ,			left_rotate_aa(lowerCamelCase_      ,			shift_amounts[i]			)			)

  # Add hashed chunk to running total
  lowerCAmelCase__     :   Tuple     		=	sum_aa(lowerCamelCase_      ,			lowerCamelCase_			)
  lowerCAmelCase__     :   int     		=	sum_aa(lowerCamelCase_      ,			lowerCamelCase_			)
  lowerCAmelCase__     :   Dict     		=	sum_aa(lowerCamelCase_      ,			lowerCamelCase_			)
  lowerCAmelCase__     :   Dict     		=	sum_aa(lowerCamelCase_      ,			lowerCamelCase_			)

 lowerCAmelCase__     :   Union[str, Any]     		=	reformat_hex(lowerCamelCase_			) + reformat_hex(lowerCamelCase_			) + reformat_hex(lowerCamelCase_			) + reformat_hex(lowerCamelCase_			)
 return digest


if __name__ == "__main__":
     import doctest

     doctest.testmod()











'''simple docstring'''


from collections.abc import Generator
from math import sin
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) != 32:
														raise ValueError('''Input must be of length 32''' )

							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian += string_aa[8 * i : 8 * i + 8]
							return little_endian
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


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

							_a      	=							format(UpperCamelCase					,		'''08x''' )[-8:]
							_a      	=							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 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							B''''''
							for char in message:
														bit_string += format(UpperCamelCase					,		'''08b''' ).encode('''utf-8''' )
							_a      	=							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 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							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 ):
														_a      	=							bit_string[pos : pos + 512]
														_a      	=							[]
														for i in range(0					,		512					,		32 ):
																					block_words.append(int(to_little_endian(block[i : i + 32] )					,		2 ) )
														yield block_words
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


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

							_a      	=							format(UpperCamelCase					,		'''032b''' )
							_a      	=							''''''
							for c in i_str:
														new_str += "1" if c == "0" else "0"
							return int(UpperCamelCase					,		2 )
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							return (a + b) % 2**32
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							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 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							preprocess(UpperCamelCase )

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

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

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

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

														# Add hashed chunk to running total
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )

							_a      	=							reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase )
							return digest


if __name__ == "__main__":
				import doctest

				doctest.testmod()

