output_description: Print the lexicographically smallest string that Iroha can produce.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N L
      S_1
      S_2
      :
      S_N
attempt: # Problem: https://atcoder.jp/contests/abc042/tasks/abc042_b
  # Python 2nd Try
  
  import sys
  
  # from collections import defaultdict
  # import heapq,copy
  # from collections import deque
  
  
  def II():
      return int(sys.stdin.readline())
  
  
  def MI():
      return map(int, sys.stdin.readline().split())
  
  
  def LI():
      return list(map(str, sys.stdin.readline().split()))
  
  
  def LS():
      return list(map(str, sys.stdin.readline().split()))
  
  
  def LLI(rows_number):
      return [LI() for _ in range(rows_number)]
  
  
  def solver(allNumber, eachStringList):
      result = ""
      # algorithm
      eachStringList.sort(reverse=False)
      #    print("{}".format(eachStringList))
      result = result.join(eachStringList)
      return result
  
  
  if __name__ == "__main__":
      N, _ = MI()
      SI = []
      for j in range(N):
          tmpList = LS()
          SI.append(tmpList[0])
      print("{}".format(solver(N, SI)))
  
problem_description: Statement
  
  Iroha has a sequence of N strings S_1, S_2, ..., S_N. The length of each
  string is L.
  
  She will concatenate all of the strings in some order, to produce a long
  string.
  
  Among all strings that she can produce in this way, find the lexicographically
  smallest one.
  
  Here, a string s=s_1s_2s_3...s_n is _lexicographically smaller_ than another
  string t=t_1t_2t_3...t_m if and only if one of the following holds:
  
    * There exists an index i(1≦i≦min(n,m)), such that s_j = t_j for all indices j(1≦j<i), and s_i<t_i.
    * s_i = t_i for all integers i(1≦i≦min(n,m)), and n<m.
samples: [{"input": "3 3\n    dxx\n    axx\n    cxx", "output": "axxcxxdxx\n    \n\nThe following order should be used: `axx`, `cxx`, `dxx`."}]