


from itertools import permutations



def 			_a      (    __UpperCamelCase = 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
     a_     :  Dict				      =     list(range(gon_side + 1	,	0	,	-1			)			)
     a_     :  Optional[Any]				      =     list(range(gon_side + 2	,	gon_side * 2 + 1			)			)

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

     a_     :  Optional[int]				      =     F'''Magic {gon_side}-gon ring is impossible'''
     raise ValueError(__UpperCamelCase			)



def 			_a      (    __UpperCamelCase	,	__UpperCamelCase			):
     a_     :  List[str]				      =     [0] * (gon_side * 3)
     a_     :  Dict				      =     perm[0:3]
     perm.append(perm[1]			)

     a_     :  Tuple				      =     1 if gon_side < 5 else 2

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

     return result



def 			_a      (    __UpperCamelCase			):

     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

     a_     :  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())





from typing import TYPE_CHECKING

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


_UpperCAmelCase   :					int    =			{"configuration_levit": ["LEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "LevitConfig", "LevitOnnxConfig"]}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase   :					Optional[Any]    =			["LevitFeatureExtractor"]
					_UpperCAmelCase   :					Optional[int]    =			["LevitImageProcessor"]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase   :					Optional[int]    =			[
					    "LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "LevitForImageClassification",
					    "LevitForImageClassificationWithTeacher",
					    "LevitModel",
					    "LevitPreTrainedModel",
					]


if TYPE_CHECKING:
					from .configuration_levit import LEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, LevitConfig, LevitOnnxConfig

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_levit import LevitFeatureExtractor
										from .image_processing_levit import LevitImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_levit import (
										    LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    LevitForImageClassification,
										    LevitForImageClassificationWithTeacher,
										    LevitModel,
										    LevitPreTrainedModel,
										)
else:
					import sys

					_UpperCAmelCase   :					Optional[Any]    =			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
