






"""simple docstring"""





from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
UpperCamelCase					=     TypeVar("""T""", bound="""Enum""")







@unique
class 						_a  (		lowercase_       ):





   '''simple docstring'''






   UpperCamelCase__     	=							80
   UpperCamelCase__     	=							70
   UpperCamelCase__     	=							60
   UpperCamelCase__     	=							50
   UpperCamelCase__     	=							40
   UpperCamelCase__     	=							30
   UpperCamelCase__     	=							20
   UpperCamelCase__     	=							10







@unique
class 						_a  (		lowercase_       ):





   '''simple docstring'''






   UpperCamelCase__     	=							24
   UpperCamelCase__     	=							21
   UpperCamelCase__     	=							18
   UpperCamelCase__     	=							15
   UpperCamelCase__     	=							12
   UpperCamelCase__     	=							9
   UpperCamelCase__     	=							6
   UpperCamelCase__     	=							3
   UpperCamelCase__     	=							2
   UpperCamelCase__     	=							1
   UpperCamelCase__     	=							-1
   UpperCamelCase__     	=							-2
   UpperCamelCase__     	=							-3
   UpperCamelCase__     	=							-6
   UpperCamelCase__     	=							-9
   UpperCamelCase__     	=							-12
   UpperCamelCase__     	=							-15
   UpperCamelCase__     	=							-18
   UpperCamelCase__     	=							-21
   UpperCamelCase__     	=							-24





   @classmethod
   def __lowercase							(       cls)			->   dict:




          '''simple docstring'''




          return {unit.name: unit.value for unit in cls if unit.value > 0}





   @classmethod
   def __lowercase							(       cls)			->   dict:




          '''simple docstring'''




          return {unit.name: unit.value for unit in cls if unit.value < 0}







def 							A(    snake_case_						):
       """simple docstring"""





       lowercase__:							Union[str, Any]         =     SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
       for name_prefix, value_prefix in prefixes.items():
              lowercase__:							str         =     value / (10**value_prefix)
              if numerical_part > 1:
                     return F"""{numerical_part!s} {name_prefix}"""
       return str(snake_case_						)






def 							A(    snake_case_						):
       """simple docstring"""





       for prefix in BinaryUnit:
              lowercase__:							Tuple         =     value / (2**prefix.value)
              if numerical_part > 1:
                     return F"""{numerical_part!s} {prefix.name}"""
       return str(snake_case_						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()












from itertools import permutations



def    UpperCAmelCase							(  _snake_case = 5				):
							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
							lowerCAmelCase =		list(range(gon_side + 1    ,			0    ,			-1				)				)
							lowerCAmelCase =		list(range(gon_side + 2    ,			gon_side * 2 + 1				)				)

							for perm in permutations(small_numbers + big_numbers				):
														lowerCAmelCase =		generate_gon_ring(_snake_case    ,			list(_snake_case				)				)
														if is_magic_gon(_snake_case				):
																					return int(''''''.join(str(_snake_case				) for n in numbers				)				)

							lowerCAmelCase =		F"""Magic {gon_side}-gon ring is impossible"""
							raise ValueError(_snake_case				)



def    UpperCAmelCase							(  _snake_case    ,			_snake_case				):
							lowerCAmelCase =		[0] * (gon_side * 3)
							lowerCAmelCase =		perm[0:3]
							perm.append(perm[1]				)

							lowerCAmelCase =		1 if gon_side < 5 else 2

							for i in range(1    ,			len(_snake_case				) // 3 + magic_number				):
														lowerCAmelCase =		perm[2 * i + 1]
														lowerCAmelCase =		result[3 * i - 1]
														lowerCAmelCase =		perm[2 * i + 2]

							return result



def    UpperCAmelCase							(  _snake_case				):
							if len(_snake_case				) % 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

							lowerCAmelCase =		sum(numbers[:3]				)

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


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



