






from collections.abc import Generator
from math import sin







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     bytes:
     if len(__lowerCAmelCase      ) != 32:
          raise ValueError("Input must be of length 32"      )

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







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     bytes:
     if i < 0:
          raise ValueError("Input must be non-negative"      )

     UpperCamelCase__      :       int	    =  format(__lowerCAmelCase ,   "08x"      )[-8:]
     UpperCamelCase__      :       Union[str, Any]	    =  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 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     bytes:
     UpperCamelCase__      :       Optional[Any]	    =  B""
     for char in message:
          bit_string += format(__lowerCAmelCase ,   "08b"      ).encode("utf-8"      )
     UpperCamelCase__      :       Any	    =  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 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Generator[list[int], None, None]:
     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      ):
          UpperCamelCase__      :       Tuple	    =  bit_string[pos : pos + 512]
          UpperCamelCase__      :       Tuple	    =  []
          for i in range(0 ,   512 ,   32      ):
               block_words.append(int(to_little_endian(block[i : i + 32]      ) ,   2      )      )
          yield block_words







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     int:
     if i < 0:
          raise ValueError("Input must be non-negative"      )

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







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







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase      )			->     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 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     bytes:
     UpperCamelCase__      :       int	    =  preprocess(__lowerCAmelCase      )

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

     # Starting states
     UpperCamelCase__      :       Any	    =  0x6745_2301
     UpperCamelCase__      :       Optional[int]	    =  0xEFCD_AB89
     UpperCamelCase__      :       Union[str, Any]	    =  0x98BA_DCFE
     UpperCamelCase__      :       Any	    =  0x1032_5476

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

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

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

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


if __name__ == "__main__":
 import doctest

 doctest.testmod()







from __future__ import annotations







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase      )			->     list[int]:
     UpperCamelCase__      :       Optional[Any]	    =  0
     UpperCamelCase__      :       Any	    =  len(__lowerCAmelCase      ) - 1

     while i < j:
          if nums[i] + nums[j] == target:
               return [i, j]
          elif nums[i] + nums[j] < target:
               UpperCamelCase__      :       Optional[int]	    =  i + 1
          else:
               UpperCamelCase__      :       Dict	    =  j - 1

     return []


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F"""{two_pointer([2, 7, 11, 15], 9) = }""")