



'''simple docstring'''







import hashlib
from typing import Union







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		if isinstance(lowerCamelCase__ ,		lowerCamelCase__     ):
				# Data already in bytes, returns as it as
				return hash_data
		elif isinstance(lowerCamelCase__ ,		lowerCamelCase__     ):
				# We keep the data as it as for it ot be later encoded to UTF-8
				# However replace `\\` with `/` for Windows compatibility
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      hash_data.replace('\\' ,		'/'     )
		elif isinstance(lowerCamelCase__ ,		lowerCamelCase__     ):
				SCREAMING_SNAKE_CASE_						:Any										=      str(lowerCamelCase__     )
		else:
				# If data is not of the required type, raise error
				raise InvalidKeyError(lowerCamelCase__     )

		return hash_data.encode('utf-8'     )




class 				__lowerCAmelCase(							a__      ):






			def __init__(   self  :							int      ,       SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      '''\nFAILURE TO GENERATE DATASET: Invalid key type detected'''
					SCREAMING_SNAKE_CASE_						:List[str]										=      f'\nFound Key {hash_data} of type {type(_lowerCamelCase	)}'
					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      '''\nKeys should be either str, int or bytes type'''
					super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'	)




class 				__lowerCAmelCase(							a__      ):






			def __init__(   self  :							Union[str, Any]      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       SCREAMING_SNAKE_CASE  :							List[Any]      ,       SCREAMING_SNAKE_CASE  :							Dict=""	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      key
					SCREAMING_SNAKE_CASE_						:List[Any]										=      duplicate_key_indices
					SCREAMING_SNAKE_CASE_						:Dict										=      fix_msg
					SCREAMING_SNAKE_CASE_						:List[str]										=      '''Found multiple examples generated with the same key'''
					if len(_lowerCamelCase	) <= 20:
							SCREAMING_SNAKE_CASE_						:int										=      f'\nThe examples at index {", ".join(_lowerCamelCase	)} have the key {key}'
					else:
							SCREAMING_SNAKE_CASE_						:int										=      f'\nThe examples at index {", ".join(duplicate_key_indices[:20]	)}... ({len(_lowerCamelCase	) - 20} more) have the key {key}'
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      '''\n''' + fix_msg if fix_msg else ''''''
					super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'	)




class 				__lowerCAmelCase:






			def __init__(   self  :							Optional[Any]      ,       SCREAMING_SNAKE_CASE  :							str	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      hashlib.mda(_as_bytes(_lowerCamelCase	)	)






			def 				_lowercase	(   self  :							Any      ,       SCREAMING_SNAKE_CASE  :							Union[str, int, bytes]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[Any]										=      self._split_mda.copy()
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      _as_bytes(_lowerCamelCase	)
					mda.update(_lowerCamelCase	)
					# Convert to integer with hexadecimal conversion
					return int(mda.hexdigest()      ,       16	)






'''simple docstring'''




from itertools import permutations




def     snake_case__     (			lowerCamelCase__					: int = 5      ) -> int:
					if gon_side < 3 or gon_side > 5:
										raise ValueError('''gon_side must be in the range [3, 5]'''      )

					# Since it's 16, we know 10 is on the outer ring
					# Put the big numbers at the end so that they are never the first number
					A_			:  int			=				list(range(gon_side + 1      ,		0      ,		-1      )      )
					A_			:  List[Any]			=				list(range(gon_side + 2      ,		gon_side * 2 + 1      )      )

					for perm in permutations(small_numbers + big_numbers      ):
										A_			:  Optional[int]			=				generate_gon_ring(lowerCamelCase__      ,		list(lowerCamelCase__      )      )
										if is_magic_gon(lowerCamelCase__      ):
															return int(''''''.join(str(lowerCamelCase__      ) for n in numbers      )      )

					A_			:  Optional[Any]			=				f'Magic {gon_side}-gon ring is impossible'
					raise ValueError(lowerCamelCase__      )




def     snake_case__     (			lowerCamelCase__					: int      ,		lowerCamelCase__					: list[int]      ) -> list[int]:
					A_			:  List[Any]			=				[0] * (gon_side * 3)
					A_			:  Optional[Any]			=				perm[0:3]
					perm.append(perm[1]      )

					A_			:  Optional[Any]			=				1 if gon_side < 5 else 2

					for i in range(1      ,		len(lowerCamelCase__      ) // 3 + magic_number      ):
										A_			:  List[str]			=				perm[2 * i + 1]
										A_			:  str			=				result[3 * i - 1]
										A_			:  Union[str, Any]			=				perm[2 * i + 2]

					return result




def     snake_case__     (			lowerCamelCase__					: list[int]      ) -> bool:
					if len(lowerCamelCase__      ) % 3 != 0:
										raise ValueError('''a gon ring should have a length that is a multiple of 3'''      )

					if min(numbers[::3]      ) != numbers[0]:
										return False

					A_			:  Union[str, Any]			=				sum(numbers[:3]      )

					return all(sum(numbers[i : i + 3]      ) == total for i in range(3      ,		len(lowerCamelCase__      )      ,		3      )      )


if __name__ == "__main__":
							print(solution())



