There are n boys and m girls attending a theatre club. To set a play "The Big Bang Theory", they need to choose a group containing exactly t actors containing no less than 4 boys and no less than one girl. How many ways are there to choose a group? Of course, the variants that only differ in the composition of the troupe are considered different.

Perform all calculations in the 64-bit type: long long for С/С++, int64 for Delphi and long for Java.

Input

The only line of the input data contains three integers n, m, t (4 ≤ n ≤ 30, 1 ≤ m ≤ 30, 5 ≤ t ≤ n + m).

Output

Find the required number of ways.

Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specificator.

Examples

Input

5 2 5


Output

10


Input

4 3 5


Output

3
//package com.company;
import com.sun.nio.sctp.SctpStandardSocketOptions;
import javax.swing.*;
import java.math.BigInteger;
import java.util.Calendar;
import java.net.StandardSocketOptions;
import java.util.*;
import java.util.Calendar;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Random;
import java.util.StringTokenizer;
import java.io.*;
import java.util.ArrayList;
import java.math.BigInteger;
    /*
                                                DOMINGO_GIRL :)
                                                ─────────▄──────────────▄
                                                ────────▌▒█───────────▄▀▒▌
                                                ────────▌▒▒▀▄───────▄▀▒▒▒▐
                                                ───────▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
                                                ─────▄▄▀▒▒▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
                                                ───▄▀▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▀██▀▒▌
                                                ──▐▒▒▒▄▄▄▒▒▒▒▒▒▒▒▒▒▒▒▒▀▄▒▒▌
                                                ──▌▒▒▐▄█▀▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
                                                ─▐▒▒▒▒▒▒▒▒▒▒▒▌██▀▒▒▒▒▒▒▒▒▀▄▌
                                                ─▌▒▀▄██▄▒▒▒▒▒▒▒▒▒▒▒░░░░▒▒▒▒▌
                                                ─▌▀▐▄█▄█▌▄▒▀▒▒▒▒▒▒░░░░░░▒▒▒▐ Wow
                                                ▐▒▀▐▀▐▀▒▒▄▄▒▄▒▒▒▒▒░░░░░░▒▒▒▒▌
                                                ▐▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒░░░░░░▒▒▒▐
                                                ─▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒▒▒░░░░▒▒▒▒▌
                                                ─▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▐
                                                ──▀▄▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▄▒▒▒▒▌
                                                ────▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀
                                                ───▐▀▒▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀
                                                ──▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▀▀
                                            */

    public class Main {
        static final int mod = (int)1e9+7;
        public static void main(String[] arg) {
            Scanner sc = new Scanner(System.in);
            int n=sc.nextInt();int m=sc.nextInt();int t=sc.nextInt();long res=0;
            //t=Math.max(m,n)+c
            //int c=t-m;

                for (int i = 4, j = t - i; j >= 1; j--, i++) {

                   // nCr += (factorial(n) / (factorial(n - r1) * factorial(r1))) * (factorial(m) / (factorial(m - r2) * factorial(r2)));

                       res += nCr(n,i) * nCr(m,j);
                      // System.out.println(r1 + " " + r2);

                }

            System.out.println(res);

        }

        static long nCr(long N, long K)		// O(K)
        {
            if(K > N)
                return 0;
            long res = 1;
            for(int i = 1; i <= K; ++i)
                res = (N - K + i) * res / i;
            return res;
        }

        public static BigInteger factorial(int n) {
            BigInteger fac=new BigInteger("1");
            for(int i=2;i<=n;++i){
                fac=fac.multiply(BigInteger.valueOf(i));
            }
            return fac;
        }


        public static int CharOccurrences(ArrayList<String>h,int k){
            int count=0;int c=0;
            for(int i=0;i<h.size();i++){
                count=0;
                for(int j=0;j<h.get(i).length();j++){
                    if(h.get(i).charAt(j)=='1')count++;
                }
                if(count==k)c++;
            }
              return c;
        }


        static void recursiveReverse(int[] a, int i)
        {
            int n = a.length;
            if (i == n / 2)
                return;
            swap(a,i,n - i - 1);
            recursiveReverse(a, i + 1);
        }

        static int[] swap(int []arr, int i, int j)
        {
            int temp= arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
            return arr;
        }


        //Knapsack Problem
        public static double knapsackGreedySolution(double profit[],double weight[],int n,int w) {
            double P_W[] = new double[n];
            for (int i = 0; i < n; i++) P_W[i] = (double) profit[i] / (double) weight[i];

            for (int i = 0; i < n - 1; i++) {
                for (int j = i + 1; j < n; j++) {
                    if (P_W[i] < P_W[j]) {
                        double temp = P_W[i];
                        P_W[i] = P_W[j];
                        P_W[j] = temp;

                        double temp2 = profit[i];
                        profit[i] = profit[j];
                        profit[j] = temp2;

                        double temp3 = weight[i];
                        weight[i] = weight[j];
                        weight[j] = temp3;
                    }
                }
            }
            int k = 0;
            double sum = 0;
            while (w > 0) {

                if (weight[k] < w) {
                    sum += profit[k];
                    w -= weight[k];
                } else {
                    sum += (w * profit[k]) / weight[k];
                    w = 0;
                }
                k++;
            }
            return  sum;
        }


        static boolean isPrime(int n)
        {
            // Corner cases
            if (n <= 1) return false;
            if (n <= 3) return true;

            // This is checked so that we can skip
            // middle five numbers in below loop
            if (n % 2 == 0 || n % 3 == 0) return false;

            for (int i = 5; i * i <= n; i = i + 6)
                if (n % i == 0 || n % (i + 2) == 0)
                    return false;

            return true;
        }


        public static boolean checkSegment(int a,int b,int c){

            // check condition
            if (a + b == c || a + c == b || b + c == a)
                return true;
            else
                return false;
        }


        // Function to calculate for validity
        public static boolean checkValidity(int a,
                                        int b, int c)
        {
            // check condition
            if (a + b > c && a + c > b && b + c > a)
                return true;
            else
                return false;
        }

        // Function to convert the obtained fraction
        // into it's simplest form
        static String lowest(int p,int d)
        {
            // Finding gcd of both terms
            int common_factor = gcd(p, d);

            // Converting both terms into simpler
            // terms by dividing them by common factor
            d = d / common_factor;
            p = p / common_factor;

            return p+"/"+d;
        }
        // Function to return gcd of a and b
        static int gcd(int a, int b)
        {
            if (a == 0)
                return b;
            return gcd(b % a, a);
        }


    }


