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: import sys
  
  input_methods = ["clipboard", "file", "key"]
  using_method = 0
  input_method = input_methods[using_method]
  
  IN = lambda: map(int, input().split())
  mod = 1000000007
  
  # +++++
  
  
  def main():
      # a = int(input())
      n, l = IN()
      ss = []
      for _ in range(n):
          s = input()
          ss.append(s)
      ss.sort()
      return "".join(ss)
  
  
  # +++++
  isTest = False
  
  
  def pa(v):
      if isTest:
          print(v)
  
  
  def input_clipboard():
      import clipboard
  
      input_text = clipboard.get()
      input_l = input_text.splitlines()
      for l in input_l:
          yield l
  
  
  if __name__ == "__main__":
      if sys.platform == "ios":
          if input_method == input_methods[0]:
              ic = input_clipboard()
              input = lambda: ic.__next__()
          elif input_method == input_methods[1]:
              sys.stdin = open("inputFile.txt")
          else:
              pass
          isTest = True
      else:
          pass
          # input = sys.stdin.readline
  
      ret = main()
      if ret is not None:
          print(ret)
  
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`."}]