




from itertools import permutations



def   lowerCAmelCase						(						_lowerCAmelCase							:				int = 5		):




 """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
 UpperCAmelCase__								=  list(range(gon_side + 1  ,							0  ,							-1		)		)
 UpperCAmelCase__								=  list(range(gon_side + 2  ,							gon_side * 2 + 1		)		)

 for perm in permutations(small_numbers + big_numbers		):
  UpperCAmelCase__								=  generate_gon_ring(_lowerCAmelCase  ,							list(_lowerCAmelCase		)		)
  if is_magic_gon(_lowerCAmelCase		):
   return int("".join(str(_lowerCAmelCase		) for n in numbers		)		)

 UpperCAmelCase__								=  F'''Magic {gon_side}-gon ring is impossible'''
 raise ValueError(_lowerCAmelCase		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				list[int]		):




 """simple docstring"""







 UpperCAmelCase__								=  [0] * (gon_side * 3)
 UpperCAmelCase__								=  perm[0:3]
 perm.append(perm[1]		)

 UpperCAmelCase__								=  1 if gon_side < 5 else 2

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

 return result



def   lowerCAmelCase						(						_lowerCAmelCase							:				list[int]		):




 """simple docstring"""







 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

 UpperCAmelCase__								=  sum(numbers[:3]		)

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


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











from typing import TYPE_CHECKING

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


_lowerCAmelCase  :				str						=				{
    "configuration_esm": ["ESM_PRETRAINED_CONFIG_ARCHIVE_MAP", "EsmConfig"],
    "tokenization_esm": ["EsmTokenizer"],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase  :				Union[str, Any]						=				[
      "ESM_PRETRAINED_MODEL_ARCHIVE_LIST",
      "EsmForMaskedLM",
      "EsmForSequenceClassification",
      "EsmForTokenClassification",
      "EsmModel",
      "EsmPreTrainedModel",
  ]
  _lowerCAmelCase  :				Tuple						=				["EsmForProteinFolding", "EsmFoldPreTrainedModel"]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase  :				str						=				[
      "TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST",
      "TFEsmForMaskedLM",
      "TFEsmForSequenceClassification",
      "TFEsmForTokenClassification",
      "TFEsmModel",
      "TFEsmPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_esm import ESM_PRETRAINED_CONFIG_ARCHIVE_MAP, EsmConfig
  from .tokenization_esm import EsmTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_esm import (
        ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
        EsmForMaskedLM,
        EsmForSequenceClassification,
        EsmForTokenClassification,
        EsmModel,
        EsmPreTrainedModel,
    )
    from .modeling_esmfold import EsmFoldPreTrainedModel, EsmForProteinFolding

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_esm import (
        TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFEsmForMaskedLM,
        TFEsmForSequenceClassification,
        TFEsmForTokenClassification,
        TFEsmModel,
        TFEsmPreTrainedModel,
    )


else:
  import sys

  _lowerCAmelCase  :				List[Any]						=				_LazyModule(__name__, globals()["__file__"], _import_structure)





