

"""simple docstring"""



from itertools import permutations





def 			_snake_case  (     UpperCAmelCase_	:       List[str] = 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
     A__				      =	list(range(gon_side + 1       , 0       , -1      )      )
     A__				      =	list(range(gon_side + 2       , gon_side * 2 + 1      )      )

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

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





def 			_snake_case  (     UpperCAmelCase_	:       List[Any]       , UpperCAmelCase_	:       Dict      ):
     A__				      =	[0] * (gon_side * 3)
     A__				      =	perm[0:3]
     perm.append(perm[1]      )

     A__				      =	1 if gon_side < 5 else 2

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

     return result





def 			_snake_case  (     UpperCAmelCase_	:       List[Any]      ):





     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

     A__				      =	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   UpperCamelCase(   lowercase_     ,   lowercase_				)      ->							Union[str, Any]:





  '''simple docstring'''





  if len(str(lowercase_				)				) == 1 or len(str(lowercase_				)				) == 1:
    return a * b

  snake_case_					= max(len(str(lowercase_				)				)     ,   len(str(lowercase_				)				)				)
  snake_case_					= ma // 2

  snake_case_		,							snake_case_					= divmod(lowercase_     ,   10**ma				)
  snake_case_		,							snake_case_					= divmod(lowercase_     ,   10**ma				)

  snake_case_					= karatsuba(lowercase_     ,   lowercase_				)
  snake_case_					= karatsuba((aa + aa)     ,   (ba + ba)				)
  snake_case_					= karatsuba(lowercase_     ,   lowercase_				)

  return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)



def   UpperCamelCase(   )      ->							Dict:





  '''simple docstring'''





  print(karatsuba(15463     ,   23489				)				)


if __name__ == "__main__":
    main()