




from itertools import permutations




def 							_UpperCAmelCase     (UpperCamelCase_       :       Union[str, Any] = 5				):
				'''simple docstring'''






				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			:			int        =					list(range(gon_side + 1					,			0					,			-1				)				)
				_lowerCAmelCase			:			Tuple        =					list(range(gon_side + 2					,			gon_side * 2 + 1				)				)

				for perm in permutations(small_numbers + big_numbers				):
								_lowerCAmelCase			:			Union[str, Any]        =					generate_gon_ring(UpperCamelCase_					,			list(UpperCamelCase_				)				)
								if is_magic_gon(UpperCamelCase_				):
												return int("""""".join(str(UpperCamelCase_				) for n in numbers				)				)

				_lowerCAmelCase			:			List[Any]        =					F"Magic {gon_side}-gon ring is impossible"
				raise ValueError(UpperCamelCase_				)




def 							_UpperCAmelCase     (UpperCamelCase_       :       Optional[int]					,			UpperCamelCase_       :       Any				):
				'''simple docstring'''
				_lowerCAmelCase			:			Dict        =					[0] * (gon_side * 3)
				_lowerCAmelCase			:			List[Any]        =					perm[0:3]
				perm.append(perm[1]				)

				_lowerCAmelCase			:			List[str]        =					1 if gon_side < 5 else 2

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

				return result




def 							_UpperCAmelCase     (UpperCamelCase_       :       Optional[int]				):
				'''simple docstring'''






				if len(UpperCamelCase_				) % 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			:			List[str]        =					sum(numbers[:3]				)

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


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









import re


def      lowerCamelCase__	(   lowercase ):

  """simple docstring"""






  def docstring_decorator(lowercase ):
    SCREAMING_SNAKE_CASE				:					List[Any]		  =			fn.__doc__
    SCREAMING_SNAKE_CASE				:					Tuple		  =			func_doc.split("\n" )
    SCREAMING_SNAKE_CASE				:					Tuple		  =			0
    while i < len(lowercase ) and re.search(R"^\s*Examples?:\s*$"  ,   lines[i] ) is None:
      i += 1
    if i < len(lowercase ):
      SCREAMING_SNAKE_CASE				:					int		  =			example_docstring
      SCREAMING_SNAKE_CASE				:					Tuple		  =			"\n".join(lowercase )
    else:
      raise ValueError(
          F'''The function {fn} should have an empty \'Examples:\' in its docstring as placeholder, '''
          F'''current docstring is:\n{func_doc}''' )
    SCREAMING_SNAKE_CASE				:					int		  =			func_doc
    return fn

  return docstring_decorator






