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
import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;
 public class A{

   static FastReader scan=new FastReader();
    public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
  static LinkedList<Integer>edges[]=new LinkedList[(int)1e5+5];
static int []dx={1,-1,0,0};
static int []dy={0,0,1,-1};
long  get( long x){
    return x*(x-1)/2;
}
static boolean prime[];
 static void sieve(int n) 
    { 
        
        prime = new boolean[n+1]; 
        for(int i=0;i<n;i++) 
            prime[i] = true; 
          
        for(int p = 2; p*p <=n; p++) 
        { 
           
            if(prime[p] == true) 
            { 
                
                for(int i = p*p; i <= n; i += p) 
                    prime[i] = false; 
            } 
        } 
          
        
    } 
public static boolean areSame(int arr[])
    {
        // Put all array elements in a HashSet
        Set<Integer>s=new HashSet<Integer>();
        for(int i=0;i<arr.length;i++)
            s.add(arr[i]);

 
        // If all elements are same, size of
        // HashSet should be 1. As HashSet contains only distinct values.
        return (s.size() == 1);
    }
    public static boolean checkType(int arr[], int n)  
    {    
          
        for(int i=1;i<n;i++)if(arr[i]>=arr[i-1])
            return false;
        return true;
    } 
 
   static int LCM(int a,int b){
    return (Math.abs(a*b))/gcd(a,b);
   }
   static  int freq[];
   static int nCr(int n, int r) 
{
    int f=0;
    for(int i=0;i<(int)1e5;i++)
    {
        f+=(freq[i]>1?freq[i]:0);
    }
    return fact(n) / (fact(r) * 
                  fact(n - r))*f; 
} 
  
// Returns factorial of n 
static int fact(int n) 
{ 
    int res = 1; 
    for (int i = 2; i <= n; i++) 
        res = res * i; 
    return res; 
}
static int gcd(int x,int y){
    if(x==0)
        return y;
    return gcd(y%x,x);
} 


static double dis(double x1,double y1,double x2,double y2)
{
    return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}



 static void reverse(Integer a[]) 
    { 
        Collections.reverse(Arrays.asList(a)); 
//System.out.println(Arrays.asList(a)); 
    }
    static int res=0;
    
   
   static int level[];

   public static int getFirstSetBitPos(int n)
    {
        return (int)((Math.log10(n & -n)) / Math.log10(2));
    }
    
   static LinkedList<Integer>good_list=new LinkedList<Integer>();

    static int dfs(int x,boolean visited[],int count,boolean ingnore_list[]){
        visited[x]=true;
        for(int nn:edges[x])
        {
          //  out.println("FUCK");
            if(!visited[nn]&&!ingnore_list[nn]){
            count =dfs(nn,visited,++count,ingnore_list);
//out.println("FUCK");
        }
        }
    return count;

    }
    static int n,m,p;
    static boolean visited[]=new boolean[(int)1e5+5];
    static int power[]=new int[25000+5];
 static  char grid[][];
 static boolean[][] canTransmit ;
 static int x[]=new int[25000+1];
     static int y[]=new int[25000+1];
static Pair coor[];
static int ret=0;
static int x1=0,x2=Integer.MAX_VALUE,y1=Integer.MAX_VALUE,y2=0;
static void  dfs(int v){
    visited[v]=true;
    x1=Math.max(x1,coor[v].x);
    x2=Math.min(x2,coor[v].x);
    y1=Math.min(y1,coor[v].y);
    y2=Math.max(y2,coor[v].y);
    for( int nn:edges[v]){
        if(!visited[nn]){
        //    ret=nn;
       dfs(nn);
      // ret=nn;
   }
    }
    //System.out.println(ret);
    //return coor[ret];
}
public static void main(String[] args)  throws Exception 
{
  //java.util.Scanner scan=new java.util.Scanner(new File("fenceplan.in"));
 //PrintWriter out = new PrintWriter (new FileWriter("fenceplan.out"));
    long[][] c = IntegerUtils.generateBinomialCoefficients(31);
    // System.out.println(c[2][3]);
     n=scan.nextInt();m=scan.nextInt();p=scan.nextInt();
     long ans=0;

     for(int i=4;i<=n;i++){
        for(int j=1;j<=m;j++)
        {
            if((i+j)!=p)
                continue;
            //out.println(c[m][j]);
            ans+=(c[n][i])*(c[m][j]);
        }
     }
    
    out.println(ans);
 out.close();

    
}

 public static  long pow(long b, long e) {
            long r = 1;
            while (e > 0) {
                if (e % 2 == 1) r = r * b ;
                b = b * b;
                e >>= 1;
            }
            return r;
        }

static long ceil(long a, long b) {
        return (a+b-1)/b;
    }
     static long powMod(long base, long exp, long mod) {
       if (base == 0 || base == 1) return base;
       if (exp == 0) return 1;
       if (exp == 1) return base % mod;
       long R = powMod(base, exp/2, mod) % mod;
       R *= R;
       R %= mod;
       if ((exp & 1) == 1) {
           return base * R % mod;
       }
       else return R % mod;
   }
private static void sort(long[] arr) {
        List<Long> list = new ArrayList<>();
        for (long object : arr) list.add(object);
        Collections.sort(list);
        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
    }
 public static class FastReader {
        BufferedReader br;
        StringTokenizer root;
        
 
        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
 
        String next() {
            while (root == null || !root.hasMoreTokens()) {
                try {
                    root = new StringTokenizer(br.readLine());
                } catch (Exception addd) {
                    addd.printStackTrace();
                }
            }
            return root.nextToken();
        }
 
        int nextInt() {
            return Integer.parseInt(next());
        }
 
        double nextDouble() {
            return Double.parseDouble(next());
        }
 
        long nextLong() {
            return Long.parseLong(next());
        }
 
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (Exception addd) {
                addd.printStackTrace();
            }
            return str;
        }
         public int[] nextIntArray(int arraySize) {
            int array[] = new int[arraySize];
 
            for (int i = 0; i < arraySize; i++) {
                array[i] = nextInt();
            }
 
            return array;
        }
}
public static class Pair{
        public int x, y;
        public Pair(int x1, int y1) {
            x=x1;
            y=y1;
        }
        @Override
        public int hashCode() {
            return (int)(x + 31 * y);
        }
        public String toString() {
            return x + " " + y;
        }
        @Override
        public boolean equals(Object o){
            if (o == this) return true;
            if (o.getClass() != getClass()) return false;
            Pair t = (Pair)o;
            return t.x == x && t.y == y;
        }
static class pair implements Comparable<pair>{
    double i;
    double j;
pair(double i,double j){
    this.i=i;
    this.j=j;
}
pair(){}
public int compareTo(pair o)
{
    int result = Double.compare(i, o.i);
         if ( result == 0 ) {
           // both X are equal -> compare Y too
           result = Double.compare(j, o.j);
         } 
         return result;
      }
}}
static class IntegerUtils {
 
    public static long[][] generateBinomialCoefficients(int n) {
        long[][] result = new long[n + 1][n + 1];
        for (int i = 0; i <= n; i++) {
            result[i][0] = 1;
            for (int j = 1; j <= i; j++)
                result[i][j] = result[i - 1][j - 1] + result[i - 1][j];
        }
        return result;
    }

}}






