output_description: Print the sum of the scores, modulo 10^9 + 7.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W K
attempt: mod = int(1e9) + 7  # <-- input modulo
  maxf = 10000100  # <-- input factional limitation
  
  
  def make_fact(n, k):
      tmp = n
      perm = [i for i in range(k)]
      L = [0 for _ in range(k)]
      for i in range(k):
          L[i] = tmp % (i + 1)
          tmp //= i + 1
      LL = [0 for _ in range(k)]
      for i in range(k):
          LL[i] = perm[L[-i - 1]]
          for j in range(L[-i - 1] + 1, k):
              perm[j - 1] = perm[j]
      return LL
  
  
  def doubling(n, m, modulo=mod):
      y = 1
      base = n
      tmp = m
      while tmp != 0:
          if tmp % 2 == 1:
              y *= base
              if modulo > 0:
                  y %= modulo
          base *= base
          if modulo > 0:
              base %= modulo
          tmp //= 2
      return y
  
  
  def inved(a, modulo=mod):
      x, y, u, v, k, l = 1, 0, 0, 1, a, modulo
      while l != 0:
          x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)
          k, l = l, k % l
      return x % modulo
  
  
  fact = [1 for _ in range(maxf + 1)]
  invf = [1 for _ in range(maxf + 1)]
  
  for i in range(maxf):
      fact[i + 1] = (fact[i] * (i + 1)) % mod
  invf[-1] = inved(fact[-1])
  for i in range(maxf, 0, -1):
      invf[i - 1] = (invf[i] * i) % mod
  
  
  def comb(n, k):
      return fact[n] * invf[n - k] * invf[k] % mod
  
  
  H, W, K = map(int, input().split())
  S = (
      (
          ((K + 1) * (K + 2) * (2 * K + 3)) // 6
          - H * (K + 1) * (K + 2) // 2
          + H
          - 1
          + K * (W + 1)
      )
      * comb(H + W - 2, H - 1)
      % mod
  )
  if H >= 2:
      S += (W + 1) * ((K + 1) * (K + 2) // 2 - 1) * comb(H + W - 2, H - 2)
  if W >= 2:
      S += (K * (K + 1) // 2 - K * (H - 1)) * comb(H + W - 2, H)
  print(S * invf[H + W - K] * fact[H] * fact[W] % mod)
  
problem_description: Statement
  
  There is a rectangular sheet of paper with height H+1 and width W+1. We
  introduce an xy-coordinate system so that the four corners of the sheet are
  (0, 0), (W + 1, 0), (0, H + 1) and (W + 1, H + 1).
  
  This sheet can be cut along the lines x = 1,2,...,W and the lines y =
  1,2,...,H. Consider a sequence of operations of length K where we choose K of
  these H + W lines and cut the sheet along those lines one by one in some
  order.
  
  Let the score of a cut be the number of pieces of paper that exist just after
  the cut. The score of a sequence of operations is the sum of the scores of all
  of the K cuts.
  
  Find the sum of the scores of all possible sequences of operations of length
  K. Since this value can be extremely large, print the number modulo 10^9 + 7.
samples: [{"input": "2 1 2", "output": "34\n    \n\nLet x_1, y_1 and y_2 denote the cuts along the lines x = 1, y = 1 and y = 2,\nrespectively. The six possible sequences of operations and the score of each\nof them are as follows:\n\n  * y_1, y_2: 2 + 3 = 5\n  * y_2, y_1: 2 + 3 = 5\n  * y_1, x_1: 2 + 4 = 6\n  * y_2, x_1: 2 + 4 = 6\n  * x_1, y_1: 2 + 4 = 6\n  * x_1, y_2: 2 + 4 = 6\n\nThe sum of these is 34.\n\n* * *"}, {"input": "30 40 50", "output": "616365902\n    \n\nBe sure to print the sum modulo 10^9 + 7."}]