


from itertools import permutations



def       lowerCAmelCase			(		lowerCAmelCase_ = 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
				lowerCAmelCase_			:   Any     					=					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_			:   Optional[int]     					=					generate_gon_ring(lowerCAmelCase_			, list(lowerCAmelCase_			)			)
								if is_magic_gon(lowerCAmelCase_			):
												return int(''''''.join(str(lowerCAmelCase_			) for n in numbers			)			)

				lowerCAmelCase_			:   Any     					=					f"""Magic {gon_side}-gon ring is impossible"""
				raise ValueError(lowerCAmelCase_			)



def       lowerCAmelCase			(		lowerCAmelCase_			, lowerCAmelCase_			)->			list[int]:
				lowerCAmelCase_			:   Dict     					=					[0] * (gon_side * 3)
				lowerCAmelCase_			:   List[str]     					=					perm[0:3]
				perm.append(perm[1]			)

				lowerCAmelCase_			:   Tuple     					=					1 if gon_side < 5 else 2

				for i in range(1			, len(lowerCAmelCase_			) // 3 + magic_number			):
								lowerCAmelCase_			:   Optional[int]     					=					perm[2 * i + 1]
								lowerCAmelCase_			:   List[str]     					=					result[3 * i - 1]
								lowerCAmelCase_			:   int     					=					perm[2 * i + 2]

				return result



def       lowerCAmelCase			(		lowerCAmelCase_			)->			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

				lowerCAmelCase_			:   Optional[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())


"""simple docstring"""
from typing import TYPE_CHECKING

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


A									=						{
    """configuration_imagegpt""": ["""IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ImageGPTConfig""", """ImageGPTOnnxConfig"""]
}

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 A									=						["""ImageGPTFeatureExtractor"""]
 A									=						["""ImageGPTImageProcessor"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 A									=						[
     """IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """ImageGPTForCausalImageModeling""",
     """ImageGPTForImageClassification""",
     """ImageGPTModel""",
     """ImageGPTPreTrainedModel""",
     """load_tf_weights_in_imagegpt""",
 ]


if TYPE_CHECKING:
 from .configuration_imagegpt import IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ImageGPTConfig, ImageGPTOnnxConfig

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_imagegpt import ImageGPTFeatureExtractor
  from .image_processing_imagegpt import ImageGPTImageProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_imagegpt import (
      IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      ImageGPTForCausalImageModeling,
      ImageGPTForImageClassification,
      ImageGPTModel,
      ImageGPTPreTrainedModel,
      load_tf_weights_in_imagegpt,
  )

else:
 import sys

 A									=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
