


from collections.abc import Generator
from math import sin






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		bytes	):





   """simple docstring"""




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

   UpperCamelCase         =					b""
   for i in [3, 2, 1, 0]:
      little_endian += string_aa[8 * i : 8 * i + 8]
   return little_endian






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int	):





   """simple docstring"""




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

   UpperCamelCase         =					format(SCREAMING_SNAKE_CASE_       ,  """08x"""	)[-8:]
   UpperCamelCase         =					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 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		bytes	):





   """simple docstring"""




   UpperCamelCase         =					b""
   for char in message:
      bit_string += format(SCREAMING_SNAKE_CASE_       ,  """08b"""	).encode("""utf-8"""	)
   UpperCamelCase         =					format(len(SCREAMING_SNAKE_CASE_	)       ,  """064b"""	).encode("""utf-8"""	)

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

   return bit_string






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		bytes	):





   """simple docstring"""




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

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






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int	):





   """simple docstring"""




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

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






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int       ,  SCREAMING_SNAKE_CASE_   :		int	):





   """simple docstring"""




   return (a + b) % 2**32






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int       ,  SCREAMING_SNAKE_CASE_   :		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 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		bytes	):





   """simple docstring"""




   UpperCamelCase         =					preprocess(SCREAMING_SNAKE_CASE_	)

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

   # Starting states
   UpperCamelCase         =					0x67_45_23_01
   UpperCamelCase         =					0xef_cd_ab_89
   UpperCamelCase         =					0x98_ba_dc_fe
   UpperCamelCase         =					0x10_32_54_76

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

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

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

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


if __name__ == "__main__":
   import doctest

   doctest.testmod()








def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			UpperCamelCase         =					int(SCREAMING_SNAKE_CASE_	)
			if decimal in (0, 1):  # Exit cases for the recursion
						return str(SCREAMING_SNAKE_CASE_	)
			UpperCamelCase  ,  UpperCamelCase         =					divmod(SCREAMING_SNAKE_CASE_       ,  2	)
			return binary_recursive(SCREAMING_SNAKE_CASE_	) + str(SCREAMING_SNAKE_CASE_	)






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		str	):





			"""simple docstring"""




			UpperCamelCase         =					str(SCREAMING_SNAKE_CASE_	).strip()
			if not number:
						raise ValueError("""No input value was provided"""	)
			UpperCamelCase         =					"""-""" if number.startswith("""-"""	) else """"""
			UpperCamelCase         =					number.lstrip("""-"""	)
			if not number.isnumeric():
						raise ValueError("""Input value is not an integer"""	)
			return f'{negative}0b{binary_recursive(int(SCREAMING_SNAKE_CASE_	)	)}'


if __name__ == "__main__":
			from doctest import testmod

			testmod()




