output_description: Print the next word that appears after S in the dictionary, or `-1` if it
  doesn't exist.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      S
attempt: # encoding:utf-8
  
  import fractions
  
  
  def check(l):
      l = list(map(int, l.split()))
      print(len(l), len([x for x in l if x % 2 == 0]), len([x for x in l if x % 2 == 1]))
      if max(l) >= 30001:
          print("max >= 30001")
          return False
  
      if len(set(l)) != len(l):
          print("not unique")
          return False
  
      tmp = l[0]
  
      for i in range(len(l) - 1):
          tmp = fractions.gcd(tmp, l[i + 1])
      if tmp != 1:
          print("gcd is 1")
          return False
  
      for i in range(len(l)):
          if fractions.gcd(l[i], sum(l) - l[i]) == 1:
              print("not special")
              return False
  
      return True
  
  
  def main(n):
      if n == 3:
          return "2 5 63"
  
      sub1 = [str(i * 3) for i in range(1, 10001) if i % 2 == 1]
      sub2 = [str(i) for i in range(1, 30000) if i % 2 == 0 and i % 3 != 0]
      sub3 = [str(i) for i in range(1, 30001) if i % 6 == 0]
      if n <= 5003:
          if n % 2 == 0:
              s = "2 4 " + " ".join([str(x) for x in sub1[0 : (n - 2)]])
              return s
          else:
              s = "2 4 6 " + " ".join([str(x) for x in sub1[0 : (n - 3)]])
              return s
      elif n <= 15000:
          if n % 2 == 0:
              s = " ".join(sub2[0 : (n - 5000)]) + " " + " ".join(sub1)
              return s
          else:
              s = " ".join(sub2[0 : (n - 5001)]) + " 6 " + " ".join(sub1)
              return s
      else:
          s = (
              " ".join(sub2)
              + " "
              + " ".join(sub1)
              + " "
              + " ".join(sub3[0 : (n - 15000)])
          )
          return s
  
  
  if __name__ == "__main__":
      n = int(input())
      # print(check(main(n)))
      # print(main(20000))
      print(main(n))
      # print(check("2 4 3 20001"))
      # for i in range(5001, 5006):
      # 	ans = main(i)
      # 	print(i, check(ans))
  
problem_description: Statement
  
  Gotou just received a dictionary. However, he doesn't recognize the language
  used in the dictionary. He did some analysis on the dictionary and realizes
  that the dictionary contains all possible **diverse** words in lexicographical
  order.
  
  A word is called **diverse** if and only if it is a nonempty string of English
  lowercase letters and all letters in the word are distinct. For example,
  `atcoder`, `zscoder` and `agc` are diverse words while `gotou` and `connect`
  aren't diverse words.
  
  Given a diverse word S, determine the next word that appears after S in the
  dictionary, i.e. the lexicographically smallest diverse word that is
  lexicographically larger than S, or determine that it doesn't exist.
  
  Let X = x_{1}x_{2}...x_{n} and Y = y_{1}y_{2}...y_{m} be two distinct strings.
  X is lexicographically larger than Y if and only if Y is a prefix of X or
  x_{j} > y_{j} where j is the smallest integer such that x_{j} \neq y_{j}.
samples: [{"input": "atcoder", "output": "atcoderb\n    \n\n`atcoderb` is the lexicographically smallest diverse word that is\nlexicographically larger than `atcoder`. Note that `atcoderb` is\nlexicographically smaller than `b`.\n\n* * *"}, {"input": "abc", "output": "abcd\n    \n\n* * *"}, {"input": "zyxwvutsrqponmlkjihgfedcba", "output": "-1\n    \n\nThis is the lexicographically largest diverse word, so the answer is `-1`.\n\n* * *"}, {"input": "abcdefghijklmnopqrstuvwzyx", "output": "abcdefghijklmnopqrstuvx"}]