Problem:
Score : 500 points

Problem Statement

We have a grid of squares with N rows and M columns. Let (i, j) denote the square at the i-th row from the top and j-th column from the left. We will choose K of the squares and put a piece on each of them.

If we place the K pieces on squares (x_1, y_1), (x_2, y_2), ..., and (x_K, y_K), the cost of this arrangement is computed as:

\sum_{i=1}^{K-1} \sum_{j=i+1}^K (|x_i - x_j| + |y_i - y_j|)

Find the sum of the costs of all possible arrangements of the pieces. Since this value can be tremendous, print it modulo 10^9+7.

We consider two arrangements of the pieces different if and only if there is a square that contains a piece in one of the arrangements but not in the other.

Constraints

2 \leq N \times M \leq 2 \times 10^5

2 \leq K \leq N \times M

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M K

Output

Print the sum of the costs of all possible arrangements of the pieces, modulo 10^9+7.

Sample Input 1

2 2 2

Sample Output 1

8

There are six possible arrangements of the pieces, as follows:

((1,1),(1,2)), with the cost |1-1|+|1-2| = 1

((1,1),(2,1)), with the cost |1-2|+|1-1| = 1

((1,1),(2,2)), with the cost |1-2|+|1-2| = 2

((1,2),(2,1)), with the cost |1-2|+|2-1| = 2

((1,2),(2,2)), with the cost |1-2|+|2-2| = 1

((2,1),(2,2)), with the cost |2-2|+|1-2| = 1

The sum of these costs is 8.

Sample Input 2

4 5 4

Sample Output 2

87210

Sample Input 3

100 100 5000

Sample Output 3

817260251

Be sure to print the sum modulo 10^9+7.

Solution in Ruby (2.3.3) (judge verdict: Runtime Error)

require "pp"

class Com
  def initialize max, mod
    @mod = mod.to_i
    @fac = []
    @finv = []
    @inv = []
    @fac[0] = @fac[1] = 1
    @finv[0] = @finv[1] = 1
    @inv[1] = 1
    (2..max).each do |i|
      @fac[i] = @fac[i-1] * i % @mod
      @inv[i] = @mod - @inv[@mod % i] * (@mod / i) % @mod
      @finv[i] = @finv[i-1] * @inv[i] % @mod
    end
  end

  def com n, k
    return 0 if n < k
    return 0 if n < 0 || k < 0
    return @fac[n] * (@finv[k] * @finv[n-k] % @mod) % @mod
  end
end

class Main
  def run
    mod = 1000000007
    # Read
    n, m, k = gets.split(" ").map(&:to_i)

    # C_(m*n-2, k-2)
    com = Com.new(m*n-2, 1000000007)
    com = com.com(m*n-2, k-2)

    # x part
    x_part = (1...m).map{|d| d * (m-d) * n * n * com }.inject(&:+) % mod
    y_part = (1...n).map{|d| d * (n-d) * m * m * com }.inject(&:+) % mod

    puts (x_part + y_part) % mod
  end
end

main = Main.new()
main.run()