from itertools import permutations




def    __SCREAMING_SNAKE_CASE				(					lowercase_ = 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
    __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(lowercase_   ,       list(lowercase_ ) )
        if is_magic_gon(lowercase_ ):
            return int(''''''.join(str(lowercase_ ) for n in numbers ) )

    __UpperCamelCase											=  F"Magic {gon_side}-gon ring is impossible"
    raise ValueError(lowercase_ )




def    __SCREAMING_SNAKE_CASE				(					lowercase_   ,       lowercase_ )    ->		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(lowercase_ ) // 3 + magic_number ):
        __UpperCamelCase											=  perm[2 * i + 1]
        __UpperCamelCase											=  result[3 * i - 1]
        __UpperCamelCase											=  perm[2 * i + 2]

    return result




def    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		bool:

    """simple docstring"""


    if len(lowercase_ ) % 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(lowercase_ )   ,       3 ) )


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












def    __SCREAMING_SNAKE_CASE				(					lowercase_ )    ->		list:

    """simple docstring"""


    __UpperCamelCase											=  len(lowercase_ )

    # Set the gap value to be decreased by a factor of 1.3
    # after each iteration
    __UpperCamelCase											=  1.3

    # Continue sorting until the gap is 1
    while gap > 1:
        # Decrease the gap value
        __UpperCamelCase											=  int(gap / shrink )

        # Sort the elements using insertion sort
        for i in range(lowercase_   ,       len(lowercase_ ) ):
            __UpperCamelCase											=  collection[i]
            __UpperCamelCase											=  i
            while j >= gap and collection[j - gap] > temp:
                __UpperCamelCase											=  collection[j - gap]
                j -= gap
            __UpperCamelCase											=  temp

    return collection


if __name__ == "__main__":
 import doctest

 doctest.testmod()






