



from itertools import permutations
def   UpperCAmelCase							(		A__ = 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
	_snake_case					:							Dict					     =   list(range(gon_side + 1				,  0				,  -1     )     )
	_snake_case					:							Optional[Any]					     =   list(range(gon_side + 2				,  gon_side * 2 + 1     )     )

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

	_snake_case					:							List[str]					     =   f'''Magic {gon_side}-gon ring is impossible'''
	raise ValueError(a_     )
def   UpperCAmelCase							(		A__				,  A__     )							->					list[int]:
	_snake_case					:							List[str]					     =   [0] * (gon_side * 3)
	_snake_case					:							Any					     =   perm[0:3]
	perm.append(perm[1]     )

	_snake_case					:							Union[str, Any]					     =   1 if gon_side < 5 else 2

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

	return result
def   UpperCAmelCase							(		A__     )							->					bool:
	if len(a_     ) % 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

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

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


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







"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


SCREAMING_SNAKE_CASE_  					= {'configuration_detr': ['DETR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DetrConfig', 'DetrOnnxConfig']}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE_  					= ['DetrFeatureExtractor']
  SCREAMING_SNAKE_CASE_  					= ['DetrImageProcessor']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE_  					= [
      'DETR_PRETRAINED_MODEL_ARCHIVE_LIST',
      'DetrForObjectDetection',
      'DetrForSegmentation',
      'DetrModel',
      'DetrPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_detr import DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, DetrConfig, DetrOnnxConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_detr import DetrFeatureExtractor
    from .image_processing_detr import DetrImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_detr import (
        DETR_PRETRAINED_MODEL_ARCHIVE_LIST,
        DetrForObjectDetection,
        DetrForSegmentation,
        DetrModel,
        DetrPreTrainedModel,
    )

else:
  import sys

  SCREAMING_SNAKE_CASE_  					= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

