



'''simple docstring'''






from typing import TYPE_CHECKING

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


A_				:					Optional[Any]							=      {"""configuration_cvt""": ["""CVT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CvtConfig"""]}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_				:					List[str]							=      [
       """CVT_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """CvtForImageClassification""",
       """CvtModel""",
       """CvtPreTrainedModel""",
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_				:					str							=      [
       """TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TFCvtForImageClassification""",
       """TFCvtModel""",
       """TFCvtPreTrainedModel""",
   ]

if TYPE_CHECKING:
   from .configuration_cvt import CVT_PRETRAINED_CONFIG_ARCHIVE_MAP, CvtConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_cvt import (
          CVT_PRETRAINED_MODEL_ARCHIVE_LIST,
          CvtForImageClassification,
          CvtModel,
          CvtPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_cvt import (
          TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFCvtForImageClassification,
          TFCvtModel,
          TFCvtPreTrainedModel,
      )


else:
   import sys

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





"""simple docstring"""




from itertools import permutations

def     UpperCamelCase_    (						SCREAMING_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
					SCREAMING_SNAKE_CASE           =      list(range(gon_side + 1,	0,	-1     )     )
					SCREAMING_SNAKE_CASE           =      list(range(gon_side + 2,	gon_side * 2 + 1     )     )

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

					SCREAMING_SNAKE_CASE           =      f'''Magic {gon_side}-gon ring is impossible'''
					raise ValueError(SCREAMING_SNAKE_CASE_     )

def     UpperCamelCase_    (						SCREAMING_SNAKE_CASE_,	SCREAMING_SNAKE_CASE_     ):
					SCREAMING_SNAKE_CASE           =      [0] * (gon_side * 3)
					SCREAMING_SNAKE_CASE           =      perm[0:3]
					perm.append(perm[1]     )

					SCREAMING_SNAKE_CASE           =      1 if gon_side < 5 else 2

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

					return result

def     UpperCamelCase_    (						SCREAMING_SNAKE_CASE_     ):
					if len(SCREAMING_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

					SCREAMING_SNAKE_CASE           =      sum(numbers[:3]     )

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


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