output_description: If no arrangements satisfy the conditions, print `-1`. If such arrangements
  exist, print the lexicographically smallest such arrangement, in the following
  format:
  
      
      
      b_1 b_2 \ldots b_N
      
  
  Here, b_i represents the i-th card from the left.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 \ldots a_N
attempt: import sys
  
  input = lambda: sys.stdin.readline().rstrip()
  sys.setrecursionlimit(max(1000, 10**9))
  write = lambda x: sys.stdout.write(x + "\n")
  
  
  n = int(input())
  a = list(map(int, input().split()))
  if n == 2:
      ans = -1
  else:
      from collections import Counter
  
      c = Counter(a)
      from heapq import heappush as hp, heappop as hpp
  
      h = []
  
      for i in range(1, n + 1):
          hp(h, i)
      ans = [1]
      ban = a[0]
      done = [False] * (n + 1)
      done[1] = True
      c[a[0]] -= 1
      for i in range(n - 1):
          if len(c) == 2 and max(c.values()) == sum(c.values()) - 1:
              #             print(c, ans)
              hp(h, ans.pop())
              if c[a[0]] == n - 1:
                  v0 = a[0]
              else:
                  v0 = a[1]
              ans.append(v0)
              while h:
                  u = hpp(h)
                  if u != v0:
                      ans.append(u)
              break
          flg = False
          #         print(h, done)
          while h:
              num = hpp(h)
              #             print(num)
              if num == ban:
                  flg = True
              elif done[num]:
                  pass
              else:
                  #                 print("hoge")
                  break
          if flg:
              hp(h, ban)
          #         print(ban, num, h)
          ans.append(num)
          done[num] = True
          c[a[num - 1]] -= 1
          if c[a[i]] == 0:
              del c[a[i]]
          ban = a[num - 1]
  if ans == -1:
      print(ans)
  else:
      write(" ".join(map(str, ans)))
  
problem_description: Statement
  
  Niwango has N cards, numbered 1,2,\ldots,N. He will now arrange these cards in
  a row.
  
  Niwango wants to know if there is a way to arrange the cards while satisfying
  all the N conditions below. To help him, determine whether such a way exists.
  If the answer is yes, also find the lexicographically smallest such
  arrangement.
  
    * To the immediate right of Card 1 (if any) is NOT Card a_1.
    * To the immediate right of Card 2 (if any) is NOT Card a_2.
    * \vdots
    * To the immediate right of Card N (if any) is NOT Card a_N.
samples: [{"input": "4\n    2 3 4 1", "output": "1 3 2 4\n    \n\n  * The arrangement (1,2,3,4) is lexicographically smaller than (1,3,2,4), but is invalid, since it violates the condition \"to the immediate right of Card 1 is not Card 2.\"\n\n* * *"}, {"input": "2\n    2 1", "output": "-1\n    \n\n  * If no arrangements satisfy the conditions, print `-1`.\n\n* * *"}, {"input": "13\n    2 3 4 5 6 7 8 9 10 11 12 13 12", "output": "1 3 2 4 6 5 7 9 8 10 12 11 13"}]