





'''simple docstring'''






from collections.abc import Generator
from math import sin


def 					_a   (__SCREAMING_SNAKE_CASE   ):


		"""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 					_a   (__SCREAMING_SNAKE_CASE   ):


		"""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 					_a   (__SCREAMING_SNAKE_CASE   ):


		"""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 					_a   (__SCREAMING_SNAKE_CASE   ):


		"""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 					_a   (__SCREAMING_SNAKE_CASE   ):


		"""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 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


		"""simple docstring"""

		return (a + b) % 2**32


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


		"""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 					_a   (__SCREAMING_SNAKE_CASE   ):


		"""simple docstring"""

		_UpperCamelCase       			=preprocess(__SCREAMING_SNAKE_CASE   )

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

		# Starting states
		_UpperCamelCase       			=0X6745_2301
		_UpperCamelCase       			=0Xefcd_ab89
		_UpperCamelCase       			=0X98ba_dcfe
		_UpperCamelCase       			=0X1032_5476

		_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()













'''simple docstring'''






import argparse
import datetime


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _UpperCamelCase       			={
      '''0''': '''Sunday''',
      '''1''': '''Monday''',
      '''2''': '''Tuesday''',
      '''3''': '''Wednesday''',
      '''4''': '''Thursday''',
      '''5''': '''Friday''',
      '''6''': '''Saturday''',
  }

  _UpperCamelCase       			={0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

  # Validate
  if not 0 < len(__SCREAMING_SNAKE_CASE   ) < 11:
    raise ValueError('''Must be 10 characters long'''   )

  # Get month
  _UpperCamelCase       			=int(date_input[0] + date_input[1]   )
  # Validate
  if not 0 < m < 13:
    raise ValueError('''Month must be between 1 - 12'''   )

  _UpperCamelCase       			=date_input[2]
  # Validate
  if sep_a not in ["-", "/"]:
    raise ValueError('''Date separator must be \'-\' or \'/\''''   )

  # Get day
  _UpperCamelCase       			=int(date_input[3] + date_input[4]   )
  # Validate
  if not 0 < d < 32:
    raise ValueError('''Date must be between 1 - 31'''   )

  # Get second separator
  _UpperCamelCase       			=date_input[5]
  # Validate
  if sep_a not in ["-", "/"]:
    raise ValueError('''Date separator must be \'-\' or \'/\''''   )

  # Get year
  _UpperCamelCase       			=int(date_input[6] + date_input[7] + date_input[8] + date_input[9]   )
  # Arbitrary year range
  if not 45 < y < 8500:
    raise ValueError(
        '''Year out of range. There has to be some sort of limit...right?'''   )

  # Get datetime obj for validation
  _UpperCamelCase       			=datetime.date(int(__SCREAMING_SNAKE_CASE   )  ,      int(__SCREAMING_SNAKE_CASE   )  ,      int(__SCREAMING_SNAKE_CASE   )   )

  # Start math
  if m <= 2:
    _UpperCamelCase       			=y - 1
    _UpperCamelCase       			=m + 12
  # maths var
  _UpperCamelCase       			=int(str(__SCREAMING_SNAKE_CASE   )[:2]   )
  _UpperCamelCase       			=int(str(__SCREAMING_SNAKE_CASE   )[2:]   )
  _UpperCamelCase       			=int(2.6 * m - 5.3_9   )
  _UpperCamelCase       			=int(c / 4   )
  _UpperCamelCase       			=int(k / 4   )
  _UpperCamelCase       			=int(d + k   )
  _UpperCamelCase       			=int(t + u + v + x   )
  _UpperCamelCase       			=int(z - (2 * c)   )
  _UpperCamelCase       			=round(w % 7   )
  # End math

  # Validate math
  if f != convert_datetime_days[dt_ck.weekday()]:
    raise AssertionError('''The date was evaluated incorrectly. Contact developer.'''   )

  # Response
  _UpperCamelCase       			=f'''Your date {date_input}, is a {days[str(__SCREAMING_SNAKE_CASE   )]}!'''
  return response


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      __lowerCamelCase						: List[Any]		=   argparse.ArgumentParser(
          description=(
              'Find out what day of the week nearly any date is or was. Enter '
              'date as a string in the mm-dd-yyyy or mm/dd/yyyy format'
          )
      )
      parser.add_argument(
          'date_input', type=str, help='Date as a string (mm-dd-yyyy or mm/dd/yyyy)'
      )
      __lowerCamelCase						: Union[str, Any]		=   parser.parse_args()
      zeller(args.date_input)






