

from itertools import permutations
def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase = 5				)					-> int:



    '''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				:			Union[str, Any]    			=      list(range(gon_side + 1,      0,      -1				)				)
    lowerCAmelCase				:			str    			=      list(range(gon_side + 2,      gon_side * 2 + 1				)				)

    for perm in permutations(small_numbers + big_numbers				):
        lowerCAmelCase				:			Optional[Any]    			=      generate_gon_ring(_UpperCAmelCase,      list(_UpperCAmelCase				)				)
        if is_magic_gon(_UpperCAmelCase				):
            return int(''.join(str(_UpperCAmelCase				) for n in numbers				)				)

    lowerCAmelCase				:			List[str]    			=      f"Magic {gon_side}-gon ring is impossible"
    raise ValueError(_UpperCAmelCase				)
def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> list[int]:



    '''simple docstring'''






    lowerCAmelCase				:			List[str]    			=      [0] * (gon_side * 3)
    lowerCAmelCase				:			Optional[int]    			=      perm[0:3]
    perm.append(perm[1]				)

    lowerCAmelCase				:			Tuple    			=      1 if gon_side < 5 else 2

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

    return result
def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> bool:



    '''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())








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A   :     List[Any]      =			{'''configuration_umt5''': ['''UMT5Config''', '''UMT5OnnxConfig''']}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A   :     Tuple      =			[
     '''UMT5EncoderModel''',
     '''UMT5ForConditionalGeneration''',
     '''UMT5ForQuestionAnswering''',
     '''UMT5Model''',
     '''UMT5PreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_umta import UMTaConfig, UMTaOnnxConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_umta import (
      UMTaEncoderModel,
      UMTaForConditionalGeneration,
      UMTaForQuestionAnswering,
      UMTaModel,
      UMTaPreTrainedModel,
  )
else:
 import sys

 __A   :     Any      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





