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: def power_func(a, b, p):
      """a^b mod p を求める"""
      if b == 0:
          return 1
      if b % 2 == 0:
          d = power_func(a, b // 2, p)
          return d * d % p
      if b % 2 == 1:
          return (a * power_func(a, b - 1, p)) % p
  
  
  from math import factorial
  
  H, W, A, B = map(int, input().split())
  p = 10**9 + 7
  ans = 0
  X = [1]
  Y = [1]
  for i in range(H + W - 2):
      fact = factorial(i + 1) % p
      X += [fact]
      Y += [power_func(fact, p - 2, p)]
  for i in range(B, W):
      ans += (
          X[H - A - 1 + i]
          * X[A + W - 2 - i]
          * (Y[H - A - 1] * Y[i] * Y[A - 1] * Y[W - 1 - i])
          % p
      )
  
  print(ans)
  
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`."}]