






from collections.abc import Generator
from math import sin
def       snake_case_		(     lowerCAmelCase_       :						bytes      ):
							if len(lowerCAmelCase_      ) != 32:
														raise ValueError("""Input must be of length 32"""      )

							__lowercase      :							Union[str, Any]				=     b""""""
							for i in [3, 2, 1, 0]:
														little_endian += string_aa[8 * i : 8 * i + 8]
							return little_endian
def       snake_case_		(     lowerCAmelCase_       :						int      ):
							if i < 0:
														raise ValueError("""Input must be non-negative"""      )

							__lowercase      :							List[str]				=     format(lowerCAmelCase_       ,       """08x"""      )[-8:]
							__lowercase      :							Optional[int]				=     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_		(     lowerCAmelCase_       :						bytes      ):
							__lowercase      :							Any				=     b""""""
							for char in message:
														bit_string += format(lowerCAmelCase_       ,       """08b"""      ).encode("""utf-8"""      )
							__lowercase      :							int				=     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       snake_case_		(     lowerCAmelCase_       :						bytes      ):
							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      ):
														__lowercase      :							List[str]				=     bit_string[pos : pos + 512]
														__lowercase      :							Dict				=     []
														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_		(     lowerCAmelCase_       :						int      ):
							if i < 0:
														raise ValueError("""Input must be non-negative"""      )

							__lowercase      :							Any				=     format(lowerCAmelCase_       ,       """032b"""      )
							__lowercase      :							Optional[Any]				=     """"""
							for c in i_str:
														new_str += "1" if c == "0" else "0"
							return int(lowerCAmelCase_       ,       2      )
def       snake_case_		(     lowerCAmelCase_       :						int       ,       lowerCAmelCase_       :						int      ):
							return (a + b) % 2**32
def       snake_case_		(     lowerCAmelCase_       :						int       ,       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       snake_case_		(     lowerCAmelCase_       :						bytes      ):
							__lowercase      :							List[str]				=     preprocess(lowerCAmelCase_      )

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

							# Starting states
							__lowercase      :							int				=     0x6745_2301
							__lowercase      :							Dict				=     0xefcd_ab89
							__lowercase      :							str				=     0x98ba_dcfe
							__lowercase      :							Dict				=     0x1032_5476

							__lowercase      :							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(lowerCAmelCase_      ):
														__lowercase      :							Union[str, Any]				=     aa
														__lowercase      :							int				=     ba
														__lowercase      :							Optional[Any]				=     ca
														__lowercase      :							Optional[Any]				=     da

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

														# Add hashed chunk to running total
														__lowercase      :							List[str]				=     sum_aa(lowerCAmelCase_       ,       lowerCAmelCase_      )
														__lowercase      :							Any				=     sum_aa(lowerCAmelCase_       ,       lowerCAmelCase_      )
														__lowercase      :							Union[str, Any]				=     sum_aa(lowerCAmelCase_       ,       lowerCAmelCase_      )
														__lowercase      :							List[Any]				=     sum_aa(lowerCAmelCase_       ,       lowerCAmelCase_      )

							__lowercase      :							Dict				=     reformat_hex(lowerCAmelCase_      ) + reformat_hex(lowerCAmelCase_      ) + reformat_hex(lowerCAmelCase_      ) + reformat_hex(lowerCAmelCase_      )
							return digest


if __name__ == "__main__":
	import doctest

	doctest.testmod()







import logging
import os
import threading
import time


try:
	import warnings
except ImportError:
	lowerCamelCase : Any						   =       None

try:
	import msvcrt
except ImportError:
	lowerCamelCase : str						   =       None

try:
	import fcntl
except ImportError:
	lowerCamelCase : Optional[Any]						   =       None


# Backward compatibility
# ------------------------------------------------
try:
	TimeoutError
except NameError:
	lowerCamelCase : Union[str, Any]						   =       OSError


# Data
# ------------------------------------------------
lowerCamelCase : Tuple						   =       [
    '''Timeout''',
    '''BaseFileLock''',
    '''WindowsFileLock''',
    '''UnixFileLock''',
    '''SoftFileLock''',
    '''FileLock''',
]

lowerCamelCase : Tuple						   =       '''3.0.12'''


lowerCamelCase : Any						   =       None
def       snake_case_		(     ):
							global _logger
							__lowercase      :							List[str]				=     _logger or logging.getLogger(__name__      )
							return _logger

class 		lowerCAmelCase     ( __a			):

					'''simple docstring'''

					def __init__(  self				:	Any		,     __a				:	Any							)			->  List[Any]:


												"""simple docstring"""

												__lowercase      :							List[str]				=     lock_file
												return None



					def __str__(  self				:	str							)			->  Any:


												"""simple docstring"""

												__lowercase      :							Any				=     F"The file lock '{self.lock_file}' could not be acquired."
												return temp







class 		lowerCAmelCase     :

					'''simple docstring'''

					def __init__(  self				:	List[Any]		,     __a				:	Optional[int]							)			->  int:


												"""simple docstring"""

												__lowercase      :							Optional[Any]				=     lock
												return None



					def __enter__(  self				:	Dict							)			->  Dict:


												"""simple docstring"""

												return self.lock



					def __exit__(  self				:	Optional[int]		,     __a				:	Dict		,     __a				:	Any		,     __a				:	Tuple							)			->  Optional[Any]:


												"""simple docstring"""

												self.lock.release()
												return None







class 		lowerCAmelCase     :

					'''simple docstring'''

					def __init__(  self				:	Tuple		,     __a				:	Any		,     __a				:	Dict=-1		,     __a				:	Optional[Any]=None							)			->  Any:


												"""simple docstring"""

												__lowercase      :							Optional[int]				=     max_filename_length if max_filename_length is not None else 255
												# Hash the filename if it's too long
												__lowercase      :							Dict				=     self.hash_filename_if_too_long(__a		,     __a							)
												# The path to the lock file.
												__lowercase      :							Optional[Any]				=     lock_file

												# The file descriptor for the *_lock_file* as it is returned by the
												# os.open() function.
												# This file lock is only NOT None, if the object currently holds the
												# lock.
												__lowercase      :							int				=     None

												# The default timeout value.
												__lowercase      :							Optional[int]				=     timeout

												# We use this lock primarily for the lock counter.
												__lowercase      :							Optional[Any]				=     threading.Lock()

												# The lock counter is used for implementing the nested locking
												# mechanism. Whenever the lock is acquired, the counter is increased and
												# the lock is only released, when this value is 0 again.
												__lowercase      :							Union[str, Any]				=     0
												return None



					@property
					def       lowerCAmelCase				(  self				:	Optional[Any]							)			->  Optional[int]:


												"""simple docstring"""

												return self._lock_file



					@property
					def       lowerCAmelCase				(  self				:	Optional[int]							)			->  Optional[Any]:


												"""simple docstring"""

												return self._timeout



					@timeout.setter
					def       lowerCAmelCase				(  self				:	Tuple		,     __a				:	Tuple							)			->  Dict:


												"""simple docstring"""

												__lowercase      :							Tuple				=     float(__a							)
												return None



					def       lowerCAmelCase				(  self				:	Dict							)			->  Tuple:


												"""simple docstring"""

												raise NotImplementedError()



					def       lowerCAmelCase				(  self				:	Dict							)			->  Any:


												"""simple docstring"""

												raise NotImplementedError()



					@property
					def       lowerCAmelCase				(  self				:	Dict							)			->  List[Any]:


												"""simple docstring"""

												return self._lock_file_fd is not None



					def       lowerCAmelCase				(  self				:	Any		,     __a				:	Optional[Any]=None		,     __a				:	Union[str, Any]=0.05							)			->  List[str]:


												"""simple docstring"""

												if timeout is None:
																			__lowercase      :							Union[str, Any]				=     self.timeout

												# Increment the number right at the beginning.
												# We can still undo it, if something fails.
												with self._thread_lock:
																			self._lock_counter += 1

												__lowercase      :							int				=     id(self							)
												__lowercase      :							Optional[Any]				=     self._lock_file
												__lowercase      :							List[str]				=     time.time()
												try:
																			while True:
																										with self._thread_lock:
																																	if not self.is_locked:
																																								logger().debug(F"Attempting to acquire lock {lock_id} on {lock_filename}"							)
																																								self._acquire()

																										if self.is_locked:
																																	logger().debug(F"Lock {lock_id} acquired on {lock_filename}"							)
																																	break
																										elif timeout >= 0 and time.time() - start_time > timeout:
																																	logger().debug(F"Timeout on acquiring lock {lock_id} on {lock_filename}"							)
																																	raise Timeout(self._lock_file							)
																										else:
																																	logger().debug(
																																	    F"Lock {lock_id} not acquired on {lock_filename}, waiting {poll_intervall} seconds ..."							)
																																	time.sleep(__a							)
												except:  # noqa
																			# Something did go wrong, so decrement the counter.
																			with self._thread_lock:
																										__lowercase      :							Optional[int]				=     max(0		,     self._lock_counter - 1							)

																			raise
												return _Acquire_ReturnProxy(lock=self							)



					def       lowerCAmelCase				(  self				:	Union[str, Any]		,     __a				:	Optional[Any]=False							)			->  Optional[Any]:


												"""simple docstring"""

												with self._thread_lock:
																			if self.is_locked:
																										self._lock_counter -= 1

																										if self._lock_counter == 0 or force:
																																	__lowercase      :							Optional[Any]				=     id(self							)
																																	__lowercase      :							str				=     self._lock_file

																																	logger().debug(F"Attempting to release lock {lock_id} on {lock_filename}"							)
																																	self._release()
																																	__lowercase      :							List[str]				=     0
																																	logger().debug(F"Lock {lock_id} released on {lock_filename}"							)

												return None



					def __enter__(  self				:	Any							)			->  Optional[Any]:


												"""simple docstring"""

												self.acquire()
												return self



					def __exit__(  self				:	List[str]		,     __a				:	str		,     __a				:	int		,     __a				:	List[Any]							)			->  Tuple:


												"""simple docstring"""

												self.release()
												return None



					def __del__(  self				:	Optional[int]							)			->  Optional[int]:


												"""simple docstring"""

												self.release(force=__a							)
												return None



					def       lowerCAmelCase				(  self				:	Tuple		,     __a				:	str		,     __a				:	int							)			->  str:


												"""simple docstring"""

												__lowercase      :							List[Any]				=     os.path.basename(__a							)
												if len(__a							) > max_length and max_length > 0:
																			__lowercase      :							int				=     os.path.dirname(__a							)
																			__lowercase      :							List[str]				=     str(hash(__a							)							)
																			__lowercase      :							Optional[Any]				=     filename[: max_length - len(__a							) - 8] + """...""" + hashed_filename + """.lock"""
																			return os.path.join(__a		,     __a							)
												else:
																			return path







class 		lowerCAmelCase     ( __a			):

					'''simple docstring'''

					def __init__(  self				:	Union[str, Any]		,     __a				:	List[Any]		,     __a				:	Optional[int]=-1		,     __a				:	Tuple=None							)			->  List[Any]:


												"""simple docstring"""

												from .file_utils import relative_to_absolute_path

												super().__init__(__a		,     timeout=__a		,     max_filename_length=__a							)
												__lowercase      :							Tuple				=     """\\\\?\\""" + relative_to_absolute_path(self.lock_file							)



					def       lowerCAmelCase				(  self				:	Dict							)			->  Union[str, Any]:


												"""simple docstring"""

												__lowercase      :							List[str]				=     os.O_RDWR | os.O_CREAT | os.O_TRUNC

												try:
																			__lowercase      :							Tuple				=     os.open(self._lock_file		,     __a							)
												except OSError:
																			pass
												else:
																			try:
																										msvcrt.locking(__a		,     msvcrt.LK_NBLCK		,     1							)
																			except OSError:
																										os.close(__a							)
																			else:
																										__lowercase      :							Union[str, Any]				=     fd
												return None



					def       lowerCAmelCase				(  self				:	Any							)			->  List[Any]:


												"""simple docstring"""

												__lowercase      :							Optional[Any]				=     self._lock_file_fd
												__lowercase      :							int				=     None
												msvcrt.locking(__a		,     msvcrt.LK_UNLCK		,     1							)
												os.close(__a							)

												try:
																			os.remove(self._lock_file							)
												# Probably another instance of the application
												# that acquired the file lock.
												except OSError:
																			pass
												return None







class 		lowerCAmelCase     ( __a			):

					'''simple docstring'''

					def __init__(  self				:	List[str]		,     __a				:	Optional[Any]		,     __a				:	str=-1		,     __a				:	List[str]=None							)			->  Any:


												"""simple docstring"""

												__lowercase      :							Dict				=     os.statvfs(os.path.dirname(__a							)							).f_namemax
												super().__init__(__a		,     timeout=__a		,     max_filename_length=__a							)



					def       lowerCAmelCase				(  self				:	Optional[Any]							)			->  Dict:


												"""simple docstring"""

												__lowercase      :							List[Any]				=     os.O_RDWR | os.O_CREAT | os.O_TRUNC
												__lowercase      :							List[str]				=     os.open(self._lock_file		,     __a							)

												try:
																			fcntl.flock(__a		,     fcntl.LOCK_EX | fcntl.LOCK_NB							)
												except OSError:
																			os.close(__a							)
												else:
																			__lowercase      :							str				=     fd
												return None



					def       lowerCAmelCase				(  self				:	List[Any]							)			->  Optional[int]:


												"""simple docstring"""

												__lowercase      :							Any				=     self._lock_file_fd
												__lowercase      :							List[str]				=     None
												fcntl.flock(__a		,     fcntl.LOCK_UN							)
												os.close(__a							)
												return None







class 		lowerCAmelCase     ( __a			):

					'''simple docstring'''

					def       lowerCAmelCase				(  self				:	List[str]							)			->  Union[str, Any]:


												"""simple docstring"""

												__lowercase      :							Tuple				=     os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC
												try:
																			__lowercase      :							Union[str, Any]				=     os.open(self._lock_file		,     __a							)
												except OSError:
																			pass
												else:
																			__lowercase      :							Optional[int]				=     fd
												return None



					def       lowerCAmelCase				(  self				:	List[str]							)			->  Tuple:


												"""simple docstring"""

												os.close(self._lock_file_fd							)
												__lowercase      :							int				=     None

												try:
																			os.remove(self._lock_file							)
												# The file is already deleted and that's what we want.
												except OSError:
																			pass
												return None







lowerCamelCase : Optional[Any]						   =       None

if msvcrt:
	lowerCamelCase : List[Any]						   =       WindowsFileLock
elif fcntl:
	lowerCamelCase : List[Any]						   =       UnixFileLock
else:
	lowerCamelCase : Union[str, Any]						   =       SoftFileLock

	if warnings is not None:
		warnings.warn('''only soft file lock is available''')