"""simple docstring"""







from itertools import permutations




def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				int = 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
     __A					:					Optional[int]								=		list(range(gon_side + 1  ,       0  ,       -1						)						)
     __A					:					Dict								=		list(range(gon_side + 2  ,       gon_side * 2 + 1						)						)

     for perm in permutations(small_numbers + big_numbers						):
          __A					:					Any								=		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						)						)

     __A					:					str								=		F'Magic {gon_side}-gon ring is impossible'
     raise ValueError(_SCREAMING_SNAKE_CASE						)




def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				int  ,       _SCREAMING_SNAKE_CASE				:				list[int]						)    ->     list[int]:







     '''simple docstring'''


     __A					:					Dict								=		[0] * (gon_side * 3)
     __A					:					List[str]								=		perm[0:3]
     perm.append(perm[1]						)

     __A					:					str								=		1 if gon_side < 5 else 2

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

     return result




def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				list[int]						)    ->     bool:







     '''simple docstring'''


     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

     __A					:					str								=		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())




"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase      : Dict       ={'''configuration_sew_d''': ['''SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SEWDConfig''']}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase      : List[str]       =[
           '''SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''SEWDForCTC''',
           '''SEWDForSequenceClassification''',
           '''SEWDModel''',
           '''SEWDPreTrainedModel''',
       ]

if TYPE_CHECKING:
       from .configuration_sew_d import SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWDConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_sew_d import (
                  SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST,
                  SEWDForCTC,
                  SEWDForSequenceClassification,
                  SEWDModel,
                  SEWDPreTrainedModel,
              )


else:
       import sys

       lowerCamelCase      : str       =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



