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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace AtCoder
{
    class Modular
    {
        private const int M = 1000000007;
        private static readonly List<int> facs = new List<int> { 1 };
        private long value;

        public Modular(long value)
        {
            this.value = value;
        }
        public static implicit operator Modular(long a)
        {
            return new Modular(a % M);
        }
        public static Modular operator +(Modular a, Modular b)
        {
            return (a.value + b.value) % M;
        }
        public static Modular operator -(Modular a, Modular b)
        {
            return ((a.value - b.value) % M + M) % M;
        }
        public static Modular operator *(Modular a, Modular b)
        {
            return a.value * b.value % M;
        }
        private static Modular Pow(Modular a, int n)
        {
            switch (n)
            {
            case 0:
                return new Modular(1);
            case 1:
                return a;
            default:
                var p1 = Pow(a, n / 2);
                var p2 = p1 * p1;
                return ((n % 2) == 0) ? p2 : p2 * a;
            }
        }
        public static Modular operator /(Modular a, Modular b)
        {
            return a * Pow(b, M - 2);
        }
        private static Modular Fac(int n)
        {
            for (int i = facs.Count; i <= n; ++i)
            {
                facs.Add((int)(Math.BigMul(facs.Last(), i) % M));
            }
            return new Modular(facs[n]);
        }
        public static Modular Ncr(int n, int r)
        {
            return (n < r)  ? new Modular(0)
                 : (n == r) ? new Modular(1)
                            : Fac(n) / Fac(r) / Fac(n - r);
        }
        public static explicit operator int(Modular a)
        {
            return (int)a.value;
        }
    }

    class Program
    {
        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }

        static int Solve(int N, int M, int K)
        {
            Modular a = 0, b = 0;
            for (int i = 0; i < N; ++i) { a += Math.BigMul(N - i, i); }
            for (int i = 0; i < M; ++i) { b += Math.BigMul(M - i, i); }
            return (int)((a * M * M + b * N * N) * Modular.Ncr(N * M - 2, K - 2));
        }

        static void Main(string[] args)
        {
            var V = ReadInts();
            Console.WriteLine(Solve(V[0], V[1], V[2]));
        }
    }
}