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.

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

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.

import java.util.Scanner;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;
public class C95 {
	static Scanner in = new Scanner(System.in);
	static PrintWriter w = new PrintWriter(System.out, true);

	static int ni() {
		return in.nextInt();
	}

	static String nl() {
		return in.nextLine();
	}

	public static void main(String[] args) {
		long n = ni(), m = ni(), t = ni();
		solve(n, m, t);
//		for (int i = 4; i <= 30; i++) {
//			for (int j = 1; j <= 30; j++) {
//				for (int t = 5; t <= i+j; t++) {
//					if (solve(i, j, t) <= 0) {
//						w.println(i+" "+j+" "+t);
//					}
//				}
//			}
//		}
	}

	static void solve(long n, long m, long t) {
		BigInteger s = BigInteger.valueOf(0L);
		for (long d = 1L; d <= t - 4L; d++) {
			long ld = d;
			if (ld > m) continue;
			if (ld > m/2) ld = m - ld;
			BigInteger vd = BigInteger.valueOf(1L);
			for (long i = m - ld + 1L; i <= m; i++) vd = vd.multiply(BigInteger.valueOf(i));
			for (long i = 2L; i <= ld; i++) vd = vd.divide(BigInteger.valueOf(i));
			BigInteger vm = BigInteger.valueOf(1L);
			long dm = t - d;
			if (dm > n) continue;
			if (dm > n/2) dm = n - dm;
			for (long i = n - dm + 1L; i <= n; i++) vm = vm.multiply(BigInteger.valueOf(i));
			for (long i = 2L; i <= dm; i++) vm = vm.divide(BigInteger.valueOf(i));
			s = s.add(vd.multiply(vm));
		}
		w.println(s);
	}
}

import java.math.BigInteger;
import java.util.Scanner;

public class C_The_World_is_a_Theatre {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		int i=3;
		BigInteger sum=BigInteger.ZERO;
		while(true){
			i++;
			if(k-i<=m ){

			BigInteger x = group(n,i);
			BigInteger y=group(m,k-i);
			sum=sum.add(x.multiply(y));
			if(k-i<=1 || i>k || i>=n)
				break;
			}
		}
		System.out.println(sum);
	}

	private static BigInteger group(int n, int i) {
		BigInteger p=BigInteger.ONE;BigInteger p1=BigInteger.ONE;
		if(i>n-i){
                 for (int j = i+1; j <=n; j++){
				p=p.multiply(new BigInteger(j+""));
                 }
                 for (int j = 1; j <=n-i; j++){
                	 p1=p1.multiply(new BigInteger(j+""));
                      }
                 }
		else
		{
			for (int j = n-i+1; j <=n; j++) {
				p=p.multiply(new BigInteger(j+""));
			}
			for (int j = 1; j <=i; j++){
				 p1=p1.multiply(new BigInteger(j+""));
                  }
		}
		BigInteger ans=p.divide(p1);
		return ans;
	}
}

// Don't place your source in a package
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

 /*

 6666666666666			 6666666666666
 6						 6
 6						 6
 6						 6
 6						 6
 6                       6
 6666666666666           6666666666666
 6		     6           6		     6
 6			 6	         6			 6
 6			 6           6			 6
 6		     6	         6		     6
 6666666666666           6666666666666

 */

// Please name your class Main
public class Main {

	//static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    /*static int read() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
    static String readString() throws IOException {
        in.nextToken();
        return in.sval;
	}*/

	static Scanner in = new Scanner(System.in);

	public static void main (String[] args) throws java.lang.Exception {

		//InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int T=1;

		for(int t=0;t<T;t++){
			int n=Int();
			int m=Int();
			int k=Int();
			Solution sol=new Solution();
			sol.solution(n,m,k);
		}

		out.flush();
	}

	public static int Int(){
		return in.nextInt();
	}
	public static String Str(){
		return in.next();
	}
}

class Solution{
	//constant variable
	final int MAX=Integer.MAX_VALUE;
	final int MIN=Integer.MIN_VALUE;
	//Set<Integer>adjecent[];
	//////////////////////////////

	public void solution(int n,int m,int t){
		long fact[]=new long[35];
		fact[0]=1;
		long mod=1000000007;
		for(int i=1;i<fact.length;i++){
			fact[i]=fact[i-1]*i;
			fact[i]%=mod;
		}

		long res=0;

		for(int boy=4;boy<=n;boy++){
			for(int girl=1;girl<=m;girl++){
				if(girl+boy==t){
					res+=C(fact,n,boy)*C(fact,m,girl);
				}
			}
		}
		msg(res+"");
	}

	public long C1(long fact[],int n,int k){
		return fact[n]/(fact[n-k]*fact[k]);
	}

	public void swap(int A[],int l,int r){
		int t=A[l];
		A[l]=A[r];
		A[r]=t;
	}

	public long C(long fact[],int i,int j){ // C(20,3)=20!/(17!*3!)
		// take   a/b     where a=20!  b=17!*3!
		if(j>i)return 0;
		if(j==0)return 1;
		long mod=1000000007;
		long a=fact[i];
		long b=((fact[i-j]%mod)*(fact[j]%mod))%mod;
		BigInteger B= BigInteger.valueOf(b);
		long binverse=B.modInverse(BigInteger.valueOf(mod)).longValue();
		return ((a)*(binverse%mod))%mod;
	}

	//map operation
	public void put(Map<Integer,Integer>map,int i){
		if(!map.containsKey(i))map.put(i,0);
		map.put(i,map.get(i)+1);
	}

	public void delete(Map<Integer,Integer>map,int i){
		map.put(i,map.get(i)-1);
		if(map.get(i)==0)map.remove(i);
	}

	/*public void tarjan(int p,int r){
		if(cut)return;
		List<Integer>childs=adjecent[r];
		dis[r]=low[r]=time;
		time++;

		//core for tarjan
		int son=0;
		for(int c:childs){
			if(ban==c||c==p)continue;
			if(dis[c]==-1){
				son++;
				tarjan(r,c);
				low[r]=Math.min(low[r],low[c]);
				if((r==root&&son>1)||(low[c]>=dis[r]&&r!=root)){
					cut=true;
					return;
				}
			}else{
				if(c!=p){
					low[r]=Math.min(low[r],dis[c]);
				}
			}
		}

	}*/

	//helper function I would use
	public void remove(Map<Integer,Integer>map,int i){
		map.put(i,map.get(i)-1);
		if(map.get(i)==0)map.remove(i);
	}

	public void ascii(String s){
		for(char c:s.toCharArray()){
			System.out.print((c-'a')+" ");
		}
		msg("");
	}

	public int flip(int i){
		if(i==0)return 1;
		else return 0;
	}

	public boolean[] primes(int n){
		boolean A[]=new boolean[n+1];
		for(int i=2;i<=n;i++){
			if(A[i]==false){
				for(int j=i+i;j<=n;j+=i){
					A[j]=true;
				}
			}
		}
		return A;
	}

	public void msg(String s){
		System.out.println(s);
	}

	public void msg1(String s){
		System.out.print(s);
	}

	public int[] kmpPre(String p){
		int pre[]=new int[p.length()];
		int l=0,r=1;
		while(r<p.length()){
			if(p.charAt(l)==p.charAt(r)){
				pre[r]=l+1;
				l++;r++;
			}else{
				if(l==0)r++;
				else l=pre[l-1];
			}
		}
		return pre;
	}

	public boolean isP(String s){
		int l=0,r=s.length()-1;
		while(l<r){
			if(s.charAt(l)!=s.charAt(r))return false;
			l++;r--;
		}
		return true;
	}

	public int find(int nums[],int x){//union find => find method
		if(nums[x]==x)return x;
		int root=find(nums,nums[x]);
		nums[x]=root;
		return root;
	}

	public int get(int A[],int i){
		if(i<0||i>=A.length)return 0;
		return A[i];
	}
	public int[] copy1(int A[]){
		int a[]=new int[A.length];
		for(int i=0;i<a.length;i++)a[i]=A[i];
		return a;
	}

	public void print1(int A[]){
		for(long i:A)System.out.print(i+" ");
		System.out.println();
	}
	public void print2(long A[][]){
		for(int i=0;i<A.length;i++){
			for(int j=0;j<A[0].length;j++){
				System.out.print(A[i][j]+" ");
			}System.out.println();
		}
	}

	public int min(int a,int b){
		return Math.min(a,b);
	}

	public int[][] matrixdp(int[][] grid) {
        if(grid.length==0)return new int[][]{};
        int res[][]=new int[grid.length][grid[0].length];
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                res[i][j]=grid[i][j]+get(res,i-1,j)+get(res,i,j-1)-get(res,i-1,j-1);
            }
        }
        return res;
    }

    public int get(int grid[][],int i,int j){
        if(i<0||j<0||i>=grid.length||j>=grid[0].length)return 0;
        return grid[i][j];
    }

	public int[] suffixArray(String s){
		int n=s.length();
		Suffix A[]=new Suffix[n];

		for(int i=0;i<n;i++){
			A[i]=new Suffix(i,s.charAt(i)-'a',0);
		}

		for(int i=0;i<n;i++){
			if(i==n-1){
				A[i].next=-1;
			}else{
				A[i].next=A[i+1].rank;
			}
		}
		Arrays.sort(A);

		for(int len=4;len<A.length*2;len<<=1){
			int in[]=new int[A.length];
			int rank=0;
			int pre=A[0].rank;
			A[0].rank=rank;
			in[A[0].index]=0;
			for(int i=1;i<A.length;i++){//rank for the first two letter
				if(A[i].rank==pre&&A[i].next==A[i-1].next){
					pre=A[i].rank;
					A[i].rank=rank;
				}else{
					pre=A[i].rank;
					A[i].rank=++rank;
				}
				in[A[i].index]=i;
			}

			for(int i=0;i<A.length;i++){
				int next=A[i].index+len/2;
				if(next>=A.length){
					A[i].next=-1;
				}else{
					A[i].next=A[in[next]].rank;
				}
			}

			Arrays.sort(A);
		}

		int su[]=new int[A.length];
		for(int i=0;i<su.length;i++){
			su[i]=A[i].index;
		}
		return su;
	}

}

//suffix array Struct
class Suffix implements Comparable<Suffix>{
	int index;
	int rank;
	int next;
	public Suffix(int i,int rank,int next){
		this.index=i;
		this.rank=rank;
		this.next=next;
	}

	@Override
	public int compareTo(Suffix other) {
		if(this.rank==other.rank){
			return this.next-other.next;
		}
		return this.rank-other.rank;
	}

	public String toString(){
		return this.index+"   "+this.rank+"   "+this.next+"  ";
	}
}

class Wrapper implements Comparable<Wrapper>{
	int spf;int cnt;
	public Wrapper(int spf,int cnt){
		this.spf=spf;
		this.cnt=cnt;
	}

	@Override
	public int compareTo(Wrapper other) {
		return this.spf-other.spf;
	}
}

    class Node{//what the range would be for that particular node
		boolean state=false;
        int l=0,r=0;
		int ll=0,rr=0;
        public Node(boolean state){
            this.state=state;
        }
    }

	class Seg1{
			int A[];
			public Seg1(int A[]){
				this.A=A;
			}

			public void update(int left,int right,int val,int s,int e,int id){
				if(left<0||right<0||left>right)return;
				if(left==s&&right==e){

					A[id]+=val;
					return;
				}
				int mid=s+(e-s)/2; //[s,mid] [mid+1,e]

				if(left>=mid+1){
					update(left,right,val,mid+1,e,id*2+2);
				}else if(right<=mid){
					update(left,right,val,s,mid,id*2+1);
				}else{
					update(left,mid,val,s,mid,id*2+1);
					update(mid+1,right,val,mid+1,e,id*2+2);
				}
			}

			public int query(int i,int add,int s,int e,int id){

				if(s==e&&i==s){
					return A[id]+add;
				}

				int mid=s+(e-s)/2; //[s,mid] [mid+1,e]

				if(i>=mid+1){
					return query(i,A[id]+add,mid+1,e,id*2+2);
				}else{
					return query(i,A[id]+add,s,mid,id*2+1);
				}
			}
	}

	 class MaxFlow{

		  public static List<Edge>[] createGraph(int nodes) {
			List<Edge>[] graph = new List[nodes];
			for (int i = 0; i < nodes; i++)
			  graph[i] = new ArrayList<>();
			return graph;
		  }

		  public static void addEdge(List<Edge>[] graph, int s, int t, int cap) {
			graph[s].add(new Edge(t, graph[t].size(), cap));
			graph[t].add(new Edge(s, graph[s].size() - 1, 0));
		  }

		  static boolean dinicBfs(List<Edge>[] graph, int src, int dest, int[] dist) {
			Arrays.fill(dist, -1);
			dist[src] = 0;
			int[] Q = new int[graph.length];
			int sizeQ = 0;
			Q[sizeQ++] = src;
			for (int i = 0; i < sizeQ; i++) {
			  int u = Q[i];
			  for (Edge e : graph[u]) {
				if (dist[e.t] < 0 && e.f < e.cap) {
				  dist[e.t] = dist[u] + 1;
				  Q[sizeQ++] = e.t;
				}
			  }
			}
			return dist[dest] >= 0;
		  }

		  static int dinicDfs(List<Edge>[] graph, int[] ptr, int[] dist, int dest, int u, int f) {
			if (u == dest)
			  return f;
			for (; ptr[u] < graph[u].size(); ++ptr[u]) {
			  Edge e = graph[u].get(ptr[u]);
			  if (dist[e.t] == dist[u] + 1 && e.f < e.cap) {
				int df = dinicDfs(graph, ptr, dist, dest, e.t, Math.min(f, e.cap - e.f));
				if (df > 0) {
				  e.f += df;
				  graph[e.t].get(e.rev).f -= df;
				  return df;
				}
			  }
			}
			return 0;
		  }

		  public static int maxFlow(List<Edge>[] graph, int src, int dest) {
			int flow = 0;
			int[] dist = new int[graph.length];
			while (dinicBfs(graph, src, dest, dist)) {
			  int[] ptr = new int[graph.length];
			  while (true) {
				int df = dinicDfs(graph, ptr, dist, dest, src, Integer.MAX_VALUE);
				if (df == 0)
				  break;
				flow += df;
			  }
			}
			return flow;
		  }

	 }

	 	 class Edge {
			int t, rev, cap, f;

			public Edge(int t, int rev, int cap) {
			  this.t = t;
			  this.rev = rev;
			  this.cap = cap;
			}
		  }

    class Seg{
        int l,r;
        int min=Integer.MAX_VALUE;
        Seg left=null,right=null;
        public Seg(int l,int r){
            this.l=l;
            this.r=r;
            if(l!=r){
                int mid=l+(r-l)/2;
                if(l<=mid)left=new Seg(l,mid);
                if(r>=mid+1)right=new Seg(mid+1,r);
                if(left!=null)min=Math.min(left.min,min);
                if(right!=null)min=Math.min(right.min,min);
            }else{
                min=10000000;
            }
        }
        public int query(int s,int e){
            if(l==s&&r==e){
                return min;
            }
            int mid=l+(r-l)/2; //left :  to mid-1,
            if(e<=mid){
                return left.query(s,e);
            }
            else if(s>=mid+1){
                return right.query(s,e);
            }else{
                return Math.min(left.query(s,mid),right.query(mid+1,e));
            }
        }

        public void update(int index,int v){
            if(l==r){
                min=Math.min(min,v);
                return;
            }
            int mid=l+(r-l)/2;
            if(index<=mid){
                left.update(index,v);
            }else{
                right.update(index,v);
            }
            this.min=Math.min(left.min,right.min);
        }
    }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class TheWorldIsATheatre {

	public static long dp1[][];

	public static long c1(int n,int rem){
		if(rem==0){
			return 1;
		}
		if(n==0){
			return 0;
		}
		if(dp1[n][rem]!=-1){
			return dp1[n][rem];
		}
	    long way1=c1(n-1,rem-1);
		long way2=c1(n-1,rem);
		return dp1[n][rem]=way1+way2;
	}

	public static void main(String[] args) throws IOException {
		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
		String s="";
		dp1=new long[100][100];

		while((s=in.readLine())!=null){
			String a[]=s.split(" ");

			int n=Integer.parseInt(a[0]);
			int m=Integer.parseInt(a[1]);
			int t=Integer.parseInt(a[2]);
			for (int i = 0; i < 100; i++) {
				for (int j = 0; j < 100; j++) {
					dp1[i][j]=-1;

				}
			}

			long res=0;
			for (int i = 1; t-i>=4; i++) {
				res+=c1(n,t-i)*c1(m,i);
			}
			out.println(res);
		}
		out.close();
	}

}

import java.lang.*;
import java.io.*;
import java.util.*;

public class Theatre {

	public static void main(String[] args) throws java.lang.Exception {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(in, out);
		out.close();
	}
}

class TaskA {
	public final static int maxn = 35;
	long[][] dp = new long[maxn][maxn];

	public void init() {
		int i, j, k;

		dp[0][0] = 1;
		for (i=1; i<maxn; ++i) {
			dp[i][0] = dp[i][i] = 1;
			for (j=1; j<i; ++j) {
				dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
			}
		}
	}

	public void solve(InputReader in, PrintWriter out) {
		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		long ans = 0;
		int i, j, k;

		init();
		for (i=4; i<=n; ++i) {
			for (j=1; j<=m; ++j) {
				if (i+j == t)
					ans += dp[n][i] * dp[m][j];
			}
		}

		out.println(ans);
	}
}

class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;

	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		tokenizer = null;
	}

	public String next() {
		while (tokenizer==null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}
}

import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        int t = in.nextInt();
        long result = 0;
        for (int i = 4; i < t; i++) {
            if (i <= n && (t - i) <= m) {
                result += (Combi(n, i) * Combi(m, t - i));
            }
        }
        out.println(result);
    }

    long Combi(int n, int k) {
        long result = 1;
        int min = Math.min(k, n - k);
        for (int i = 0; i < min; i++) {
            result *= (n - i);
            result /= (i + 1);
        }
        return result;
    }
}

class InputReader {
    StringTokenizer tokenizer;
    BufferedReader reader;

    public InputReader(InputStream stream) {
        tokenizer = null;
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

import java.util.*;
import java.math.*;

public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int t = sc.nextInt();
long total = 0;
for (int g=1; g<=t-4; g++){
  int b = t-g;
  long a = C(n,b);
  long aa = C(m,g);
  total+=a*aa;
}
System.out.println(total);

}

private static long C(int a, int b){
  return fact(a).divide(fact(b)).divide(fact(a-b)).longValue();
}

private static BigInteger fact(int a){
  BigInteger bi = new BigInteger("1");
  for (Integer i=2; i<=a; i++){
    bi = bi.multiply(new BigInteger(i.toString()));
  }
  return bi;
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
    @author Tran Anh Tai
*/
public class Arrangement implements Runnable {
    @Override
    public void run() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        long[][] dp = new long[31][31];
        int i, j;
        for (i = 0; i <= 30; i++){
            dp[0][i] = 1;
        }
        for (i = 1; i <= 30; i++){
            for (j = 1; j <= i; j++){
                dp[j][i] = dp[j - 1][i - 1] + dp[j][i - 1];
            }
        }
        try {
            String[] in = br.readLine().split(" ");
            int n = Integer.parseInt(in[0]);
            int m = Integer.parseInt(in[1]);
            int t = Integer.parseInt(in[2]);

            if (m < 1 || n < Math.min(4, t - 1) || t < 5){
                System.out.println(0);
                return;
            }
            int u = Math.min(t - 4, m);
            long res = 0;
            for (int girls = Math.max(1, t - n); girls <= u; girls++){
                int boys = t - girls;
                if (boys < 4){
                    break;
                }
                res += dp[boys][n] * dp[girls][m];
            }System.out.println(res);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        new Arrangement().run();
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class Theatre {
	static int n;
	static int m;
	static int t;

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		//Scanner scanner = new Scanner("25 30 30");
		n=scanner.nextInt();
		m=scanner.nextInt();
		t=scanner.nextInt();
		System.out.println(combination(t, n+m)-combination(t, n)-combination(3, n)*combination(t-3, m)-combination(2, n)*combination(t-2, m)-combination(1, n)*combination(t-1, m)-combination(t, m));
	}

private static BigInteger fact(int n) {
	BigInteger s=new BigInteger("1");
	for (int i=1; i<=n; i++) {
		s=s.multiply(new BigInteger(new Integer(i).toString()));
	}
	return s;
}

private static long combination(int k, int n) {
	BigInteger s;
	s=fact(n).divide((fact(k).multiply(fact(n-k))));
	return new Long(s.toString());
}
}

import java.io.*;
import java.util.*;

public class MainClass {

	public static final int maxn = 31;

	public static void main(String[] args) {
		Locale.setDefault(Locale.US);
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		MainClass solution = new MainClass();
		solution.run(in, out);
		in.close();
		out.close();
	}

	public void run(Scanner in, PrintWriter out) {
		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		long[][] C = new long[maxn][maxn];
		C[0][0] = 1;
		for (int i = 0; i < maxn; i++)
			C[i][0] = C[i][i] = 1;
		for (int i = 1; i < maxn; i++)
			for (int j = 1; j < i; j++)
				C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
		long ans = 0;
		for (int i = 4; i <= n; i++) {
			int j = t - i;
			if (j >= 1 && j <= m)
				ans += C[n][i] * C[m][j];
		}
		out.print(ans);
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main{

    static long[][] comb;

    static long nCr1(int n , int k)
    {
        if(n < k)
            return 0;
        if(k == 0 || k == n)
            return 1;
        if(comb[n][k] != -1)
            return comb[n][k];
        if(n - k < k)
            return comb[n][k] = nCr1(n, n - k);
        return comb[n][k] = nCr1(n - 1, k - 1) + nCr1(n - 1, k);
    }
public  static void main (String args[])throws Exception{

    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int t=sc.nextInt();
    long boys=0;
    comb=new long[31][31];
    for (int i = 0; i < 31; i++) {
        Arrays.fill(comb[i],-1);
    }
    long ans=0;
    for (int i = 4; i <t ; i++) {
    boys=nCr1(n,i); long girls=nCr1(m,t-i);
        ans+=boys*girls;
    }

    System.out.println(ans);

}

static class Scanner
{
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

	public String next() throws IOException
	{
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public int nextInt() throws IOException {return Integer.parseInt(next());}

	public long nextLong() throws IOException {return Long.parseLong(next());}

	public String nextLine() throws IOException {return br.readLine();}

	public double nextDouble() throws IOException
	{
		String x = next();
		StringBuilder sb = new StringBuilder("0");
		double res = 0, f = 1;
		boolean dec = false, neg = false;
		int start = 0;
		if(x.charAt(0) == '-')
		{
			neg = true;
			start++;
		}
		for(int i = start; i < x.length(); i++)
			if(x.charAt(i) == '.')
			{
				res = Long.parseLong(sb.toString());
				sb = new StringBuilder("0");
				dec = true;
			}
			else
			{
				sb.append(x.charAt(i));
				if(dec)
					f *= 10;
			}
		res += Long.parseLong(sb.toString()) / f;
		return res * (neg?-1:1);
	}

	public boolean ready() throws IOException {return br.ready();}

}
}

import java.util.*;
public class r131C {
    static int n, m, t;
    static long[][] choose;
    public static void main(String args[])
    {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        t = in.nextInt();
        choose = new long[31][31];
        for(int i = 0; i < 31; i++)
            choose[i][0] = 1;

        for(int i = 1; i < 31; i++)
            for(int j = 1; j <= i; j++)
                choose[i][j] = choose[i-1][j-1] + choose[i-1][j];

        long ans = 0;
        for(int i = 4; i <= n; i++)
        {
            int j = t-i;
            if(j > 0 && j <= m)
            ans += choose[n][i] * choose[m][j];
        }

        System.out.println(ans);

    }

}

import java.util.Scanner;
public class Fhg {
    private static Scanner in=new Scanner(System.in);
    private static long boy,girl,tr,ans;
    public static void main(String[] args) {
        boy=in.nextInt();
        girl=in.nextInt();
        tr=in.nextInt();
        long gir,bo;
        for(int i=4;i<=boy;i++){
        for(int j=1;j<=girl;j++){
        if(i+j==tr){bo=coo(i,boy);
        gir=coo(j,girl);
        ans+=(bo*gir);
        break;}
        }
        }
        System.out.println(ans);
    }
    static long coo(int o,long u){
    return o==0?1:u*coo(o-1,u-1)/o;

    }}

import javafx.util.Pair;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * Created by timur on 28.03.15.
 */

public class TaskC {
    boolean eof;
    BufferedReader br;
    StringTokenizer st;
    PrintWriter out;

    public static void main(String[] args) throws IOException {
        new TaskC().run();
    }

    public String nextToken() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                eof = true;
                return "-1";
            }
        }
        return st.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() {
        return Long.parseLong(nextToken());
    }

    double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }

    void run() throws IOException {
        InputStream input = System.in;
        PrintStream output = System.out;
        try {
            File f = new File("a.in");
            if (f.exists() && f.canRead()) {
                input = new FileInputStream(f);
                output = new PrintStream("a.out");
            }
        } catch (Throwable e) {
        }
        br = new BufferedReader(new InputStreamReader(input));
        out = new PrintWriter(output);
        solve();
        br.close();
        out.close();
    }

    long rec(long N, long K) {
        if(N<K || N<1 || K<1)
            return 0;
        if(N==K)
            return 1;
        if(K==1)
            return N;
        return rec(N-1, K-1) + rec(N-1, K);
    }

    void solve() {
        int n = nextInt(), m = nextInt(), t = nextInt();
        long[][] c = new long[31][31];
        for (int i = 1; i < 31; i++) {
            for (int j = 1; j <= i; j++) {
                if (i == j)
                    c[i][j] = 1;
                else if(j == 1)
                    c[i][j] = i;
                else c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
            }
        }
        long ans = 0;
        for (int b = 4; b < Math.min(n + 1, t); b++) {
            if (t - b <= m)
            ans += c[n][b] * c[m][t - b];
        }
        out.print(ans);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Solution2 {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] sa = br.readLine().split(" ");
		int n = Integer.parseInt(sa[0]);
		int m = Integer.parseInt(sa[1]);
		int t = Integer.parseInt(sa[2]);
		long ans;
		ans = nCr(n + m, t);
		long minus = (nCr(n, 0) * nCr(m, t)) + (nCr(n, 1) * nCr(m, t - 1)) + (nCr(n, 2) * nCr(m, t - 2))
				+ (nCr(n, 3) * nCr(m, t - 3)) + (nCr(n, t) * nCr(m, 0));
		minus = minus % 1000000007;
		ans = ans - minus;
		System.out.println(ans);
	}

	public static long nCr(int n, int r) {
		long res = 1l;
		for (int i = 0; i < r; i++) {
			res *= (n - i);
			res /= (i + 1);
		}
		return res;
	}

}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

    Scanner in;
    PrintWriter out;

    BigInteger fact(long n) {
        BigInteger ans = BigInteger.ONE;
        for (long i = 2; i <= n; i++) {
            ans = ans.multiply(BigInteger.valueOf(i));
        }
        return ans;
    }

    long C(long n, long k) {
        return Long.valueOf(fact(n).divide(fact(k).multiply(fact(n - k)))
                .toString());
    }

    void solve() {
        long n = in.nextLong();
        long m = in.nextLong();
        long t = in.nextLong();
        long ans = 0;
        for (int boys = 4; boys <= t; boys++) {
            int girls = (int) (t - boys);
            if (girls < 1 || girls > m) {
                continue;
            }
            ans += C(n, boys) * C(m, girls);

        }
        out.println(ans);

    }

    void run() {
        in = new Scanner(System.in);
        out = new PrintWriter(System.out);
        try {
            solve();
        } finally {
            out.close();
        }
    }

    public static void main(String args[]) {
        new Main().run();
    }
}

import java.util.Scanner;

public class worldistheater {

	public static void main(String args[]) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		int m = scan.nextInt();
		int t = scan.nextInt();
		int maxFac = Math.max(m, n);
		//		System.out.println("maxFac: " + maxFac);
		long [][] pascal = new long[maxFac + 1][maxFac + 1];
		for(int i = 0; i <= maxFac; i++) {
			for(int j = 0; j < maxFac; j++) {
				pascal[i][j] = 0; //Just to be sure.
			}
		}
		for(int i = 0; i <= maxFac; i++) {
			pascal[i][0] = 1;
		}
		for(int i = 1; i <= maxFac; i++) {
			for(int j = 1; j <= maxFac; j++) {
				pascal[i][j] = pascal[i-1][j] + pascal[i-1][j-1];
			}
		}
		long result = 0;
		for(int i = 1; i <= t - 4; i++) {
			//System.out.println(m + "!" + n + "," + i + "." + (t-i));
			if(t - i <= n && i <= m) {
				//System.out.println(i + ": " + pascal[m][i] + ", " + pascal[n][t-i]);
				result += pascal[m][i] * pascal[n][t-i];
			}
		}
		System.out.println(result);
		//		for(int i = 0; i <= maxFac; i++) {
		//			for(int j = 0; j <= maxFac; j++) {
		//				System.out.print(pascal[i][j] + " ");
		//			}
		//			System.out.println();
		//		}
	}
}

import java.util.*;
import java.io.*;
import java.lang.*;

public class Main {

	static int INF = 1000000000;
	static int MAXN = 31;
	static long[][] c = new long[MAXN][MAXN];
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n, m, t;
		n = input.nextInt();
		m = input.nextInt();
		t = input.nextInt();
		init();
		long res = 0;
		for (int i = 4; i <= t - 1; ++i) {
			if (i <= n && t - i <= m) {
				res += c[n][i] * c[m][t - i];
			//	System.out.println(c[n][i] + " " + c[m][t - i] + " " + res);
			}
		}
		System.out.println(res);
	}

	static void init() {
		for (int i = 0; i < MAXN; ++i) {
			for (int k = 0; k < MAXN; ++k) {
				c[i][k] = 0;
			}
		}
		for (int i = 0; i < MAXN; ++i) {
			c[i][0] = 1;
		}
		for (int i = 1; i < MAXN; ++i) {
			for (int k = 1; k <= i; ++k) {
				c[i][k] = c[i - 1][k] + c[i - 1][k - 1];
			}
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class TheWorldIsATheatre {

    static BigInteger[] factorial = new BigInteger[101];

    public static void main(String[] args) throws IOException {
        factorial[0] = new BigInteger("1");
        for (int i = 1 ; i <= 100 ; i++) {
            factorial[i] = new BigInteger(i + "");
            factorial[i] = factorial[i].multiply(factorial[i-1]);
        }
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int t = Integer.parseInt(st.nextToken());
        BigInteger ans = factorial[n + m].divide(factorial[t].multiply(factorial[n + m - t]));
        BigInteger nn = new BigInteger(n + "");
//      System.out.println(ans);
        if(m >= t - 1)
            ans = ans.subtract(nn.multiply(factorial[m].divide(factorial[t - 1].multiply(factorial[m - (t - 1)]))));
        if(m >= t - 2) {
            BigInteger temp = factorial[m].divide(factorial[t - 2].multiply(factorial[m - (t - 2)]));
            BigInteger temp2 = factorial[n].divide(factorial[2].multiply(factorial[n - 2]));
            ans = ans.subtract(temp.multiply(temp2));
        }
        if(m >= t - 3) {
            BigInteger temp = factorial[m].divide(factorial[t - 3].multiply(factorial[m - (t - 3)]));
            BigInteger temp2 = factorial[n].divide(factorial[3].multiply(factorial[n - 3]));
            ans = ans.subtract(temp.multiply(temp2));
        }
        if(n >= t)
            ans = ans.subtract(factorial[n].divide(factorial[t].multiply(factorial[n - t])));
        if(m >= t)
            ans = ans.subtract(factorial[m].divide(factorial[t].multiply(factorial[m - t])));
        System.out.println(ans);
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.*;
import java.util.Queue;
import java.util.StringTokenizer;
import java.math.BigInteger;

  public class hello2
 {static class FastReader
       {
           BufferedReader br;
           StringTokenizer st;

           public FastReader()
           {
               br = new BufferedReader(new
                        InputStreamReader(System.in));
           }

           String next()
           {
               while (st == null || !st.hasMoreElements())
               {
                   try
                   {
                       st = new StringTokenizer(br.readLine());
                   }
                   catch (IOException  e)
                   {
                       e.printStackTrace();
                   }
               }
               return st.nextToken();
           }

           int nextInt()
           {
               return Integer.parseInt(next());
           }

           long nextLong()
           {
               return Long.parseLong(next());
           }

           double nextDouble()
           {
               return Double.parseDouble(next());
           }

           String nextLine()
           {
               String str = "";
               try
               {
                   str = br.readLine();
               }
               catch (IOException e)
               {
                   e.printStackTrace();
               }
               return str;
           }

       }

    static String sum (String s)
    {
        String s1 = "";

        if(s.contains("a"))
            s1+="a";
        if(s.contains("e"))
            s1+="e";
        if(s.contains("i"))
            s1+="i";
        if(s.contains("o"))
            s1+="o";
        if(s.contains("u"))
            s1+="u";

            return s1;

    }
 static long comb(int N , int 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 void main(String[] args)
    {
       FastReader sc =new FastReader();

       int n=sc.nextInt();
       int m=sc.nextInt();
       int t=sc.nextInt();
       long ans = 0;
		for (int i = 4, j = t - i; j >= 1; j--, i++) {
			ans += comb(n, i) * comb(m, j);
		}
        System.out.println(ans);
    }
 }

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;
import java.math.BigInteger;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		in.close();
		out.close();
	}

	private void solve() throws IOException {
		int n = nextInt();
		int m = nextInt();
		int t = nextInt();
		long ans = 0;

		for (int i = 4; i <= min(t - 1, n); i++)
			ans += C(n, i) * C(m, t - i);
		out.println(ans);
	}

	long C(long n, long k) {
		return fac(n).divide(fac(k)).divide(fac(n - k)).longValue();
	}

	BigInteger fac(long n) {
		BigInteger ret = BigInteger.ONE;
		for (int i = 0; i < n; i++)
			ret = ret.multiply(BigInteger.valueOf(i + 1));
		return ret;
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Solve5 {

    public static void main(String[] args) throws IOException {
        PrintWriter pw = new PrintWriter(System.out);
        new Solve5().solve(pw);
        pw.flush();
        pw.close();
    }

    public void solve(PrintWriter pw) throws IOException {
        FastReader sc = new FastReader();
        int n = sc.nextInt(), m = sc.nextInt(), t = sc.nextInt();
        dp = new BigInteger[31];
        Arrays.fill(dp, BigInteger.ZERO);
        BigInteger s = BigInteger.ZERO;
        for (int i = 4; i <= Math.min(n, t); i++) {
            if (m < t - i || t - i == 0) {
                continue;
            }
            s = s.add(fact(n).divide(fact(n - i).multiply(fact(i))).multiply(fact(m).divide((fact(m - t + i).multiply(fact(t - i))))));
        }
        pw.println(s);
    }
    BigInteger[] dp;

    public BigInteger fact(int n) {
        if (n == 0 || n == 1) {
            return BigInteger.ONE;
        }
        if (dp[n] != BigInteger.ZERO) {
            return dp[n];
        }
        return dp[n] = BigInteger.valueOf(n).multiply(fact(n - 1));
    }

    static class FastReader {

        StringTokenizer st;
        BufferedReader br;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastReader(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (Exception e) {
            }
        }

        public String next() {
            if (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public boolean hasNext() throws IOException {
            if (st != null && st.hasMoreTokens()) {
                return true;
            }
            String s = br.readLine();
            if (s == null || s.isEmpty()) {
                return false;
            }
            st = new StringTokenizer(s);
            return true;
        }
    }
}

import java.util.*;
import java.math.*;
public class Main{
	static BigInteger  c(int n,int k){
		BigInteger ans = BigInteger.valueOf(1);
		if (k>n) {
			ans = BigInteger.valueOf(0);
			return ans;
		}
		for(int i=k+1;i<=n;i++) ans = ans.multiply(BigInteger.valueOf(i));
		for(int i=1;i<=n-k;i++) ans = ans.divide(BigInteger.valueOf(i));
		if (ans.equals(BigInteger.valueOf(0))) ans = BigInteger.valueOf(1); return ans;
	}
	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
	        int n = in.nextInt();
	        int m = in.nextInt();
	        int t = in.nextInt();

	        BigInteger ans = BigInteger.valueOf(0);
	        for(int i=1;i<=m;i++){
	        	if (t-i>=4) ans = ans.add(c(m,i).multiply(c(n,t-i)));
	        }
	        System.out.print(ans);
	}
}

import java.util.* ;
import java.math.*;

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        @SuppressWarnings("resource")
        Scanner in = new Scanner(System.in);

        int n , m , t , b = 4 , g = 1 ;
        BigInteger sum = new BigInteger("0"), tf ;

        n = in.nextInt() ;
        m = in.nextInt() ;
        t = in.nextInt() ;

        g = t-b ;

        for(b = 4 ; b<=n ;b++)
        {
            g = t-b ;

            if(g<1)
                break ;

            sum =sum.add(c(n,b).multiply(c(m,g))) ;
        }

        System.out.printf("%d",sum);
    }

    public static BigInteger p (int n, int r )
    {
        if(n==r && n==0)
            return BigInteger.ONE ;

        BigInteger s = BigInteger.valueOf(n) ;
        n-- ;

        while(r>1)
        {
            s = s.multiply(BigInteger.valueOf(n--)) ;
            r--;
        }

        return s ;
    }

    public static BigInteger c (int n, int r )
    {
        BigInteger s = p(n,r) ;
        s =s.divide(p (r,r) ) ;
        return s ;
    }
}

import java.util.Scanner;

// from editorial

public class Main {

	static Long[][] dp = new Long[100][100];

	public static void main (String[] args) throws java.lang.Exception {

		Scanner in = new Scanner(System.in);

		int b = in.nextInt();

		int g = in.nextInt();

		int tot = b+g;

		int chs = in.nextInt();

		long ans = choose(tot, chs);

		ans -= choose(g, chs) * 1;

		ans -= choose(g, chs-1) * b;

		ans -= choose(g, chs-2) * choose(b, 2);

		ans -= choose(g, chs-3) * choose(b, 3);

		// 0 firls

		ans -= choose(b, chs);

		System.out.println(ans);

	}

	private static long choose(int n, int r) {
		if(r == 0) {
			return 1;
		}
		else if(n < r || r < 0 || n < 0) {
			return 0;
		}
		else if(dp[n][r] != null) {
			return dp[n][r];
		}
		else {
			return dp[n][r] = choose(n-1, r-1) + choose(n-1, r);
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class three {
    public static void main(String[] args) throws IOException {
        BigInteger[] fact = new BigInteger[31];
        fact[1] = BigInteger.valueOf(1);
        fact[0]= BigInteger.valueOf(1);
        for (int i = 2; i <= 30; i++) {
            fact[i] = fact[i - 1].multiply(BigInteger.valueOf(i));
        }
        BufferedReader buf = new BufferedReader(
                new InputStreamReader(System.in));
        String[] line = buf.readLine().split(" ");
        int n = Integer.parseInt(line[0]);
        int m = Integer.parseInt(line[1]);
        int t = Integer.parseInt(line[2]);

        BigInteger count=BigInteger.valueOf(0);
        for (int i = 4; i <= n; i++) {
            if (t - i <= m && t - i >= 1) {
                BigInteger bd = BigInteger.valueOf(1);
                bd = bd.multiply(fact[n]);
                bd = bd.multiply(fact[m]);
                bd = bd.divide(fact[n - i]);
                bd = bd.divide(fact[m - t + i]);
                bd = bd.divide(fact[i]);
                bd = bd.divide(fact[t - i]);
                count=count.add(bd);
            }
        }
        System.out.println(count);

    }

}

import java.math.*;
import java.util.Scanner;
public class C {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        BigInteger total = BigInteger.ZERO;
        int men = sc.nextInt();
        int women = sc.nextInt();
        int cast = sc.nextInt();

        for(int a=1;a<=cast-4;a++){
            total=total.add(new BigInteger(""+choose(women,a)).multiply(new BigInteger(""+choose(men,cast-a))));
        //  System.out.println(a+" "+total.toString());
        }
        System.out.println(total.toString());
    }

    private static BigInteger choose(int i, int j) {
        BigInteger ans = BigInteger.ONE;

        for(int a=0;a<j;a++)ans=ans.multiply(new BigInteger(""+(i-a)));
        return ans.divide(fac(j));
    }

    private static BigInteger fac(int j) {
        BigInteger ans =  BigInteger.ONE;
        for(int a=2;a<=j;a++)
            ans = ans.multiply(new BigInteger(""+a));

        return ans;
    }

}

import java.util.Scanner;

public class Test131C {

	public Test131C() {}
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n, m, t;
		n = scan.nextInt();
		m = scan.nextInt();
		t = scan.nextInt();
		long S = 0;
		int N = 60;
		long A[][] = new long[N][N];
		for (int i = 0; i < N; i++) {
			A[i][0] = 1;
			A[i][i] = 1;
		}
		for (int i = 2; i < N; i++)
			for (int j = 1; j < i; j++) {
				A[i][j] = A[i-1][j] + A[i-1][j-1];
			}
		for (int i = 4; i <= n && i < t; i++) {
			if(m >= t - i && t - i > 0) {
				S += A[n][i] * A[m][t-i];

			}
		}
		System.out.println(S);
		scan.close();
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;

public class C_131_The_World_is_a_Theatre {
	public static void main(String[] args) throws IOException {
		StreamTokenizer st = new StreamTokenizer(new BufferedReader(
				new InputStreamReader(System.in)));
		long c[][] = new long[31][31];
		c[0][0] = c[1][0] = c[1][1] = 1;
		for (int n = 2; n <= 30; n++) {
			for (int k = 0; k <= n; k++) {
				if (k == 0 || k == n)
					c[n][k] = 1;
				else
					c[n][k] = c[n - 1][k - 1] + c[n - 1][k];
			}
		}
		st.nextToken();
		int n = (int) st.nval;
		st.nextToken();
		int m = (int) st.nval;
		st.nextToken();
		int t = (int) st.nval;
		long count = 0;
		for (int boy = 4; boy < t; boy++) {
			int girl = t - boy;
			if (boy > n || girl > m)
				continue;
			count += c[n][boy] * c[m][girl];
		}
		System.out.println(count);

	}
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author mancgupta01
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    long combination(long n,long k){
        BigInteger br = BigInteger.ONE;
        for(long i=n;i>n-k;i--)
            br = br.multiply(BigInteger.valueOf(i));
        for(long i=k;i>1;i--)
            br = br.divide(BigInteger.valueOf(i));
        String ret = br.toString();
        return Long.parseLong(ret);
    }
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        int t = in.nextInt();
        long ret = 0;
        for(int i=4;i<=t-1;i++){
            if(t-i>0)
                ret += combination(n,i)*combination(m,t-i);
        }
        out.println(ret);
	}
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt(){
        return Integer.parseInt(next());
    }

    }

import java.io.BufferedInputStream;
import java.rmi.StubNotFoundException;
import java.util.Collections.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Vector;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;
import java.math.*;
import java.util.*;

import javax.management.Query;
import javax.naming.InitialContext;
import javax.security.auth.x500.X500Principal;
import javax.swing.text.html.MinimalHTMLWriter;
public class Main {
	public static void main(String[]args) throws IOException {
		Scanner scanner=new Scanner(new BufferedInputStream(System.in));
		long C[][]=new long [70][70];
		for (int i=1;i<=60;i++)
		{
			C[i][0]=1;
			for (int j=1;j<i;j++)
				C[i][j]=C[i-1][j]+C[i-1][j-1];
			C[i][i]=1;
		}
		int x=scanner.nextInt();
		int y=scanner.nextInt();
		int t=scanner.nextInt();
		long ans=0;
		for (int i=4;i<t;i++)
			ans+=C[x][i]*C[y][t-i];
		System.out.println(ans);
	}
}

//Bismillahir Rahmanir Rahim

import java.util.*;
import java.io.*;
import java.math.*;

public class FFirst {
    public static void main (String [] args) {
        int N = 77;
        long [][] dp = new long [N][N];
        for (int i = 1; i < N; i++) {
            dp[i][1] = i;
            dp[i][i] = 1;
            dp[i][0] = 1;
        }

        for (int i = 2; i < N; i++) {
            for (int j = 2; j <= i; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
            }
        }
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int m = cin.nextInt();
        int t = cin.nextInt();
        int x = 4;
        long sum = 0;
        while (t - x > 0) {
            long first = dp[n][x] * dp[m][t - x];
            sum += first;
            x++;
        }
        System.out.print(sum);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class M8CFTheWorldisaTheatre {
    public static long combinations(int n,int r){
        long ans=1;
        r=Math.min(r, n-r);
        for (int i=1;i<r+1;i++){
            ans=ans*(n-r+i);
            ans=ans/i;
        }

        return ans;

    }

public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    String input=bf.readLine();
    String in[]=input.split(" ");
    int n=Integer.parseInt(in[0]);
    int m=Integer.parseInt(in[1]);
    int t=Integer.parseInt(in[2]);
    long allcases=combinations(n+m,t);
    long noGirls=0;
    if (n>=t)
    noGirls=combinations(n, t);
    long subtract=0;

    for (int i=3;i>=0;i--){
        if (t-i<=m)subtract+=combinations(m, t-i)*combinations(n, i);
        else break;

    }

    System.out.println(allcases-subtract-noGirls);

}
}

/**
 * Created by IntelliJ IDEA.
 * User: Taras_Brzezinsky
 * Date: 11/25/11
 * Time: 5:48 PM
 * To change this template use File | Settings | File Templates.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.FileReader;
import java.io.IOException;
import java.math.BigInteger;
import java.util.*;

public class TaskC extends Thread {
    public TaskC(int type) {
        try {
            if (type == 0) {
                this.input = new BufferedReader(new InputStreamReader(System.in));
                this.output = new PrintWriter(System.out);
            } else {
                this.input = new BufferedReader(new FileReader(INPUT_FILE));
                this.output = new PrintWriter(OUTPUT_FILE);
            }
            this.setPriority(Thread.MAX_PRIORITY);
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(666);
        }
    }

    private void solve() throws Throwable {
        long C[][] = new long[61][61];
        for (int i = 0; i < C.length; ++i) {
            C[i][0] = C[i][i] = 1;
            for (int j = 1; j < i; ++j) {
                C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
            }
        }
        long result = 0;
        int n = nextInt(), m = nextInt(), t = nextInt();
        for (int i = Math.min(t, m); i >= 1; --i) {
            int rest = t - i;
            if (rest < 4) {
                continue;
            }
            result += C[m][i] * C[n][rest];
        }
        output.println(result);
    }

    public void run() {
        try {
            solve();
        } catch (Throwable e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.exit(666);
        } finally {
            output.flush();
            output.close();
        }
    }

    public static void main(String[] args) {
        new TaskC(0).start();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private static final String INPUT_FILE = null;
    private static final String OUTPUT_FILE = null;
    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Task131C {

	private static long[][] pt = new long[31][31];

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());
		int t = Integer.parseInt(st.nextToken());

		fillPascalTriangle();
		int b = (t - 1 < n) ? t - 1 : n;
		long res = 0;
		for (int i = 4; i <= b; i++) {
			if (t - i > m) { continue; }
			res += pt[n][i] * pt[m][t - i];
		}

		System.out.println(res);
	}

	private static void fillPascalTriangle() {
		for (int i = 0; i < 31; i++) {
			pt[i][0] = 1;
			for (int j = 1; j <= i; j++) {
				pt[i][j] = pt[i - 1][j - 1] + pt[i - 1][j];
			}
		}
	}
}

import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author sergey
 */
public class Cf131c {

    /**
     * @param args the command line arguments
     */

    public static long fp[][];

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt(), t = in.nextInt();

        long r = 0;

        int nm = Math.max(n, m) + 1;

        fp = new long [nm][nm];

        for(int i = 0; i < nm; i++) {
            for(int j = 0; j <= i; j++) {
                if (j == 0 || j == i)
                    fp[i][j] = 1;
                else
                    fp[i][j] = fp[i - 1][j - 1] + fp[i - 1][j];
            }
        }

        int tof = Math.min(n, t - 1);
        //int start = Math.max(4,t-m-4);
        for(int i = 4; i <= tof; i++)
        if (i + m >= t)
        {
            r += fp[n][i] * fp[m][t - i];
        }
        System.out.println(r);
    }
}

import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;

public class Solution {
    private static BigInteger fact(int n) {
        BigInteger f = BigInteger.ONE;
        for (long i = 2L; i <= n; i++)
            f = f.multiply(new BigInteger(String.valueOf(i)));

        return f;
    }

    private static BigInteger C(int n, int m) {
        return fact(n).divide(fact(n - m)).divide(fact(m));
    }

    public static void main(String[] args) throws Exception {
        Scanner reader = new Scanner(System.in);
        PrintWriter writer = new PrintWriter(System.out);

        int n = reader.nextInt();
        int m = reader.nextInt();
        int t = reader.nextInt();

        BigInteger count = BigInteger.ZERO;

        for (int i = 4; i <= n; i++) {
            int j = t - i;

            if (j < 1 || j > m) continue;

            count = count.add(C(n, i).multiply(C(m, j)));
        }

        writer.print(count.toString());

        writer.close();
    }
}

import java.util.*;

public class C
{
   public static void main(String[] args)
   {
      new C(new FastScanner());
   }

   long[][] pasc;

   public C(FastScanner in)
   {
      pasc = new long[41][41];
      for (int i=0; i<=40; i++)
         pasc[i][0] = pasc[i][i] = 1;
      for (int j=2; j<=40; j++)
         for (int i=1; i<j; i++)
            pasc[j][i] = pasc[j-1][i]+pasc[j-1][i-1];

      int N = in.nextInt();
      int M = in.nextInt();
      int T = in.nextInt();

      long res = 0;
      int ng = 1;
      while (ng <= M)
      {
         int nb = T-ng;
         if (nb < 4)
            break;
         if (nb <= N)
            res += pasc[N][nb]*pasc[M][ng];
         ng++;
      }
      System.out.println(res);
   }
}

class FastScanner{
    int nextInt(){
        try{
            int c=System.in.read();
            if(c==-1) return c;
            while(c!='-'&&(c<'0'||'9'<c)){
                c=System.in.read();
                if(c==-1) return c;
            }
            if(c=='-') return -nextInt();
            int res=0;
            do{
                res*=10;
                res+=c-'0';
                c=System.in.read();
            }while('0'<=c&&c<='9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c=System.in.read();
            if(c==-1) return -1;
            while(c!='-'&&(c<'0'||'9'<c)){
                c=System.in.read();
                if(c==-1) return -1;
            }
            if(c=='-') return -nextLong();
            long res=0;
            do{
                res*=10;
                res+=c-'0';
                c=System.in.read();
            }while('0'<=c&&c<='9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    double nextDouble(){
        return Double.parseDouble(next());
    }

    String next(){
        try{
            StringBuilder res=new StringBuilder("");
            int c=System.in.read();
            while(Character.isWhitespace(c))
                c=System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res=new StringBuilder("");
            int c=System.in.read();
            while(c=='\r'||c=='\n')
                c=System.in.read();
            do{
                res.append((char)c);
                c=System.in.read();
            }while(c!='\r'&&c!='\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class TheWorldIsATheatre {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String[] info = br.readLine().split(" ");
		long n = Integer.parseInt(info[0]);
		long m = Integer.parseInt(info[1]);
		long t = Integer.parseInt(info[2]);

		BigInteger ans = BigInteger.ZERO;

		for (long i = 4; i <= Math.min(n, t-1); i++) {
			BigInteger hombres = comb(n,i);
			BigInteger mujeres = comb(m,t-i);
			ans = ans.add(hombres.multiply(mujeres));
		}

		System.out.println(ans);

	}

	static BigInteger comb(long n, long r) {
		BigInteger res = BigInteger.ONE;
		for (long i = 2; i <= n ; i++) {
			res = res.multiply(new BigInteger(i+""));
		}
		for (long i = 2; i <= r ; i++) {
			res = res.divide(new BigInteger(i+""));
		}
		for (long i = 2; i <= n-r ; i++) {
			res = res.divide(new BigInteger(i+""));
		}

		return res;

	}

}

import org.omg.CORBA.INTERNAL;

import java.util.*;

public class Sol {
    public static int n;
    public static int m;
    public static int t;
    public static long ans = 0;
    public static long finalans = 0;
    public static long[]fact = new long[16];
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
         n = input.nextInt();
         m = input.nextInt();
         t = input.nextInt();
        fact[0] = 1;
        fact[1] = 1;

        for(int i=4 ; i<=n ; i++){
            ans = 1;
            if ( t-i >= 1 && t-i <= m){
             finalans += (binomial(n,i) * binomial(m,t-i));
            }
        }

        System.out.println(finalans);
    }

    public static long binomial(int n, int k){
        long result = 1;
        for ( int i = 0; i < k; i ++){
            result *= (n-i);
            result /= (i+1);
        }
        return result ;
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int numBoys = in.nextInt();
            int numGirls = in.nextInt();
            int t = in.nextInt();
            long res = 0;
            for (int boy = 4; boy < t && boy <= numBoys; boy++) {
                int girl = t - boy;
                if (girl > numGirls) continue;
                res += binomial(numBoys, boy) * binomial(numGirls, girl);
            }
            out.println(res);
        }

        public long binomial(long n, long m) {
            m = Math.min(m, n - m);
            long res = 1;
            for (long i = 0; i < m; i++) {
                res = res * (n - i) / (i + 1);
            }
            return res;
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class WorldTheatre {

	public static void main(String[]args) throws IOException, InterruptedException {
		Scanner sc=new Scanner(System.in);
		PrintWriter out=new PrintWriter(System.out);
	long[][]C=new long[61][61];
	for(int i=0;i<61;i++) {
		for(int j=0;j<61;j++) {
			C[i][j]=(j==0)?1:(i==0)?0:C[i-1][j-1]+C[i-1][j];
			//System.out.print(C[i][j]+" ");
		}
	//	System.out.println();
	}
	int n=sc.nextInt(),m=sc.nextInt(),t=sc.nextInt();
	//out.println(C[n+m][t]-C[n][5]-C[n][3]*C[m][t-2]-C[n][2]*C[m][3]-C[n][1]*C[m][4]-
		//	C[m][5]);
	out.println(C[n+m][t]-C[n][3]*C[m][t-3]-C[n][2]*C[m][t-2]-
			C[n][1]*C[m][t-1]-C[n][t]-C[m][t]);

	out.close();
	}
	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public boolean ready() throws IOException {return br.ready(); }

	}
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
//package javaapplication17;
import java.util.Scanner;
/**
 *
 * @author Himanshu Khare
 */
public class JavaApplication17 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner input = new Scanner(System.in);
        long m,n,t,i;
        long result=0;
        n=input.nextLong();
        m=input.nextLong();
        t=input.nextLong();
        for(i=4;i<=t-1;i++)
        {
            result+=(c(m,t-i)*c(n,i));

        }
        System.out.println(result);
    }
    public static long c(long m,long i)
    {
        long result1=1,result2=1;
        for(long j=m,k=1;j>(m-i);k++,j--)
        {
            result1*= j;
            result1/=k;
        }
        return (result1);
    }

}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
public class A {
	static BigInteger[] arr  = new BigInteger[31];
	static void fact() {
		arr[0] = new BigInteger("1");
		arr[1] = new BigInteger("1");
		for(int i=2;i<=30;i++) arr[i] = arr[i-1].multiply(new BigInteger(String.valueOf(i)));
	}
	static BigInteger ncr(int n, int r) {
		if(r>n) return new BigInteger("0");
		BigInteger ans = new BigInteger("1");
		ans = arr[n].divide(arr[n-r]);
		ans=ans.divide(arr[r]);
		return ans;
	}
	static PrintWriter out = new PrintWriter(System.out);
	public static void main(String[] args) {
		try {
			BufferInput in = new BufferInput();
			StringBuilder sb = new StringBuilder();
			fact();
			int a = in.nextInt();
			int b = in.nextInt();
			int c = in.nextInt();
			if(a+b == c)
	        {
	            out.print("1");
	            out.close();
	            return;
	        }
	        if(a<4 || b<1 || c<5)
	        {
	            out.print("0");
	            out.close();
	            return;
	        }
			BigInteger ans = new BigInteger("0");
			for(int i=4;i<c;i++) {
				BigInteger v1 = ncr(a, i);
				BigInteger v2 = ncr(b, c-i);
				ans = ans.add(v1.multiply(v2));
			}
			out.print(ans);
			out.close();
		}catch(Exception e) {}

	}
static class BufferInput {

		final private int BUFFER_SIZE = 1 << 16;

		private DataInputStream din;

		private byte[] buffer;

		private int bufferPointer, bytesRead;

		public BufferInput() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public BufferInput(String file_name) throws IOException {
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String readLine() throws IOException {
			byte[] buf = new byte[64];
			int cnt = 0, c;
			while ((c = read()) != -1) {
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public String nextString() throws IOException{

			byte c = read();
			while(Character.isWhitespace(c)){
				c = read();
			}

			StringBuilder builder = new StringBuilder();
			builder.append((char)c);
			c = read();
			while(!Character.isWhitespace(c)){
				builder.append((char)c);
				c = read();
			}

			return builder.toString();
		}

		public int nextInt() throws IOException {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}

		public int[] nextIntArray(int n) throws IOException {
			int arr[] = new int[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextInt();
			}
			return arr;
		}
		public long nextLong() throws IOException {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public long[] nextLongArray(int n) throws IOException {
			long arr[] = new long[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextLong();
			}
			return arr;
		}

		public char nextChar() throws IOException{
			byte c = read();
			while(Character.isWhitespace(c)){
				c = read();
			}
			return (char) c;
		}
		public double nextDouble() throws IOException {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (c == '.') {
				while ((c = read()) >= '0' && c <= '9') {
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}
		public double[] nextDoubleArray(int n) throws IOException {
			double arr[] = new double[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextDouble();
			}
			return arr;
		}
		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}
		private byte read() throws IOException {
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
}

import static java.lang.Double.parseDouble;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.exit;
import static java.util.Arrays.fill;

import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
import java.text.*;

public class Main {
	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	final static double EPS = 1e-9;
	final static int MOD = 1000000009;

	static void solve() throws Exception {
		long[][] C = new long[31][31];
		for (int n = 0; n <= 30; n++) {
			for (int k = 0; k <= n; k++) {
				if (n == 0 || k == 0) {
					C[n][k] = 1;
				} else {
					C[n][k] = C[n-1][k-1] + C[n-1][k];
				}
			}
		}
		int n = nextInt();
		int m = nextInt();
		int t = nextInt();
		long res = 0;
		for (int i = 4; i <= n; i++) {
			if (t-i >= 1 && t-i <= m) {
				res += C[n][i] * C[m][t-i];
			}
		}
		out.println(res);
	}

	static int sqr(int x) {
		return x*x;
	}

	static int nextInt() throws IOException {
		return parseInt(next());
	}

	static long nextLong() throws IOException {
		return parseLong(next());
	}

	static double nextDouble() throws IOException {
		return parseDouble(next());
	}

	static BigInteger nextBigInteger() throws IOException {
		return new BigInteger(next());
	}

	static String next() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	public static void main(String args[]) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}

import java.io.*;
import java.util.*;

public class C {
    public static void solution(BufferedReader reader, PrintWriter writer)
            throws IOException {
        In in = new In(reader);
        Out out = new Out(writer);
        int n = in.nextInt(), m = in.nextInt(), t = in.nextInt();
        Comb c = new Comb();
        long rst = 0;
        for (int i = 4; i + 1 <= t; i++)
            if (n >= i && m >= t - i)
                rst += c.c(n, i) * c.c(m, t - i);
        out.println(rst);
    }

    protected static class Comb {
        private long[][] c = new long[61][61];

        public Comb() {
            c[0][0] = 1;
            for (int i = 0; i < 60; i++)
                for (int j = 0; j <= i; j++) {
                    c[i + 1][j] += c[i][j];
                    c[i + 1][j + 1] += c[i][j];
                }
        }

        // select b outof a
        public long c(int a, int b) {
            return c[a][b];
        }
    }

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(
                new BufferedWriter(new OutputStreamWriter(System.out)));
        solution(reader, writer);
        writer.close();
    }

    protected static class In {
        private BufferedReader reader;
        private StringTokenizer tokenizer = new StringTokenizer("");

        public In(BufferedReader reader) {
            this.reader = reader;
        }

        public String next() throws IOException {
            while (!tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public int[] nextIntArray(int n) throws IOException {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        public int[] nextIntArray1(int n) throws IOException {
            int[] a = new int[n + 1];
            for (int i = 1; i <= n; i++)
                a[i] = nextInt();
            return a;
        }

        public int[] nextIntArraySorted(int n) throws IOException {
            int[] a = nextIntArray(n);
            Random r = new Random();
            for (int i = 0; i < n; i++) {
                int j = i + r.nextInt(n - i);
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
            Arrays.sort(a);
            return a;
        }

        public long[] nextLongArray(int n) throws IOException {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }

        public long[] nextLongArray1(int n) throws IOException {
            long[] a = new long[n + 1];
            for (int i = 1; i <= n; i++)
                a[i] = nextLong();
            return a;
        }

        public long[] nextLongArraySorted(int n) throws IOException {
            long[] a = nextLongArray(n);
            Random r = new Random();
            for (int i = 0; i < n; i++) {
                int j = i + r.nextInt(n - i);
                long t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
            Arrays.sort(a);
            return a;
        }
    }

    protected static class Out {
        private PrintWriter writer;

        public Out(PrintWriter writer) {
            this.writer = writer;
        }

        public void print(char c) {
            writer.print(c);
        }

        public void print(int a) {
            writer.print(a);
        }

        public void println(String s) {
            writer.println(s);
        }

        public void println(int a) {
            writer.println(a);
        }

        public void println(long a) {
            writer.println(a);
        }

        public void println(Object[] os) {
            for (int i = 0; i < os.length; i++) {
                writer.print(os[i]);
                writer.print(' ');
            }
            writer.println();
        }

        public void println(int[] a) {
            for (int i = 0; i < a.length; i++) {
                writer.print(a[i]);
                writer.print(' ');
            }
            writer.println();
        }

        public void println(long[] a) {
            for (int i = 0; i < a.length; i++) {
                writer.print(a[i]);
                writer.print(' ');
            }
            writer.println();
        }
    }
}

import java.util.Scanner;

public class TheWorldIsATheatre {

	public static void main (String[]args) {

		Scanner sc = new Scanner(System.in);
		int magic = 60;
		long total = 0;
		int n = sc.nextInt();
		int m = sc.nextInt();
		int o = sc.nextInt();
		for (int i = 4; i < o; i++) {
			total = total + (find(m, o-i) * find(n, i));
		}
		System.out.println(total);
	}
	public static long find (int n, int pos) {
		long ans = 1;
		for (int i = 0; i < pos; i++) {
			ans = ans * (n-i);
			ans = ans / (i+1);
		}
		return ans;
	}

}

import java.util.Scanner;

public class theater {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);

		int n = scan.nextInt();
		int m = scan.nextInt();
		int t = scan.nextInt();
		long sum = 0;
		for(int i = 0;i < t - 4;i++){

			sum += choose(n, i + 4) * choose(m, t - (i + 4));

		}

		System.out.println(sum);

	}

	public static long choose(int n, int k) {
		long ans = 1;

		for(int i = 0; i < k; i++){
			ans = ans * (n - i);
			ans = ans / (i + 1);
		}

		return ans;

	}
}

import java.math.BigInteger;
import java.util.Scanner;

public class C {

    public static void main(String... args) {

        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int t = sc.nextInt();

        long result = 0;
        for (int i=4; i<t; i++)
            result += c(n, i) * c(m, t-i);

        System.out.println(result);
    }

    public static long c(int n, int k) {
        BigInteger r = BigInteger.valueOf(0);
        if (n>=k) {
            r = BigInteger.valueOf(1);
            for (int i=n; i>Math.max(k, n-k); i--)
                r = r.multiply(BigInteger.valueOf(i));
            for (int i=2; i<=Math.min(k, n-k); i++)
                r = r.divide(BigInteger.valueOf(i));
        }
        return r.longValue();
    }

}

import java.util.*;
import java.io.*;
import java.lang.*;

public class Main {

	static int INF = 1000000000;
	static int MAXN = 31;
	static long[][] c = new long[MAXN][MAXN];
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n, m, t;
		n = input.nextInt();
		m = input.nextInt();
		t = input.nextInt();
		init();
		long res = 0;
		for (int i = 4; i <= t - 1; ++i) {
			if (i <= n && t - i <= m) {
				res += c[n][i] * c[m][t - i];
			//	System.out.println(c[n][i] + " " + c[m][t - i] + " " + res);
			}
		}
		System.out.println(res);
	}

	static void init() {
		for (int i = 0; i < MAXN; ++i) {
			for (int k = 0; k < MAXN; ++k) {
				c[i][k] = 0;
			}
		}
		for (int i = 0; i < MAXN; ++i) {
			c[i][0] = 1;
		}
		for (int i = 1; i < MAXN; ++i) {
			for (int k = 1; k <= i; ++k) {
				c[i][k] = c[i - 1][k] + c[i - 1][k - 1];
			}
		}
	}
}

import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Theatre {
	public static Scanner sc = new Scanner(System.in);
	public static StringTokenizer st;
	public static PrintWriter pw = new PrintWriter(System.out);
	final static boolean debugmode = true;
	public static int k = 7; // for 10^9 + k mods.
	public static long STMOD = 1000000000 + k; // 10^9 + k
	public static void main(String[] args) {
		int boys = getInt();
		int girls = getInt();
		int actors = getInt();
		long[][] choose = new long[70][70];
		for(int i = 1;i<70;i++){
			choose[i][0] = 1;
			for(int j = 1;j<=i;j++){
				choose[i][j] = choose[i][j-1] *(i-(j-1))/((j-1)+1);

			}
		}

		long ways = 0;
		for (int aboys = 4;aboys < actors;aboys++){
			int agirls = actors-aboys;
			//System.out.println(aboys + " "+agirls);
			ways += choose[boys][aboys] * choose[girls][agirls];
		}
		System.out.println(ways);
	}
	public static void debug(String toPrint){
		if(!debugmode) {return;}
		pw.println("[DEBUG]: "+toPrint);
	}
	public static void  submit(int[] k){
		pw.println(Arrays.toString(k));
		pw.close();
	}
	public static void submit(int p){
		pw.println(Integer.toString(p));
		pw.close();
	}
	public static void submit(String k){
		pw.println(k);
		pw.close();
	}
	public static void submit(double u){
		pw.println(Double.toString(u));
		pw.close();
	}
	public static void submit(long lng){
		pw.println(Long.toString(lng));
		pw.close();

	}
	public static int getInt(){
		if (st != null && st.hasMoreTokens()){
			return Integer.parseInt(st.nextToken());
		}
		st = new StringTokenizer(sc.nextLine());
		return Integer.parseInt(st.nextToken());
	}
	public static long getLong(){
		if (st != null && st.hasMoreTokens()){
			return Long.parseLong(st.nextToken());
		}
		st = new StringTokenizer(sc.nextLine());
		return Long.parseLong(st.nextToken());
	}
	public static double getDouble(){
		if (st != null && st.hasMoreTokens()){
			return Double.parseDouble(st.nextToken());
		}
		st = new StringTokenizer(sc.nextLine());
		return Double.parseDouble(st.nextToken());
	}
	public static String getString(){
		if(st != null && st.hasMoreTokens()){
			return st.nextToken();
		}
		st = new StringTokenizer(sc.nextLine());
		return st.nextToken();
	}
	public static String getLine(){
		return sc.nextLine();
	}
	public static int[][] readMatrix(int lines,int cols){
		int[][] matrr = new int[lines][cols];
		for (int i = 0;i < lines;i++){
			for(int j = 0;j < cols;j++){
				matrr[i][j] = getInt();
			}
		}
		return matrr;
	}
	public static int[] readArray(int lines){
		int[] ar = new int[lines];
		for (int i = 0;i<lines;i++) ar[i] =getInt();
		return ar;
	}

}

import java.io.*;
import java.util.*;
// 131С from coderorces.com
// we have n boys, m girls and t-number of people
// that we need to choose. But we can't take less
// than 4 boys and 1 girl.

public class Main {

    public static long f(long n) {
        if (n==0) {
            return 1;
        } else return n*f(n-1);
    }

    public static long cnk(long n, long k){
        //return f(n)/(f(n-k)*f(k));
        if (k==0){return 1;}
        else return cnk(n-1,k-1)+cnk(n-1,k);
    }
    public static void main(String[] args) {
        // easy program
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        // reading number of girls
        int n = in.nextInt();
        // reading number of boys
        int m = in.nextInt();
        // reading group quontity
        int t = in.nextInt();

        long cnkArr[][] = new long[62][62];

        for(int i=0;i<=n+m;i++){
            cnkArr[0][i]=0;
            cnkArr[i][0]=1;

        }
        for (int i=1;i<=n+m;i++){
            for (int j=1;j<=n+m;j++){
                cnkArr[i][j]=cnkArr[i-1][j-1]+cnkArr[i-1][j];
            //out.print(cnkArr[i][j]);
            //out.print(" ");
            }
            //out.println();
        }
        // using founded formulae
        long s = 0;
        for (int i=1;t-i>=4;i++){
           s=s+cnkArr[m][i]*cnkArr[n][t-i];
        }
        out.println(s);

        out.flush();
    }
}

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;
    }

}}

import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class C {

	private void processInput() throws IOException {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		long res = go(n, m, t);

		System.out.printf(Locale.ENGLISH, "%d\n", res);

		in.close();
	}

	private long go(int n, int m, int t) {

		long res = 0;

		for (int i = 4; i <= Math.min(t, n); i++) {

			long bb = binomial(n, i);

			for (int j = 1; j <= Math.min(t, m); j++) {

				if (i + j == t) {
					long ff = binomial(m, j);

					res += bb * ff;

				}
			}

		}

		return res;
	}

    private long binomial(int n, int k) {
		long res = 1;
		for (int i = n - k + 1; i <= n; i++) {
			res *= i;
			res /= (i - n + k);
		}
		return res;
	}

	public static void main(String[] args) throws Exception {
		C a = new C();
		a.processInput();
	}
}

import java.io.*;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.math.*;
import java.util.*;
import java.text.*;
public class Main {
    public static BigInteger cal(int m,int n)
    {
        int i,j;
        BigInteger ans = new BigInteger("1");
        for(i=m;i>=m-n+1;i--)
        {
            ans = ans.multiply(new BigInteger(i+""));
        }
        for(i=1;i<=n;i++)
        {
            ans = ans.divide(new BigInteger(i+""));
        }
        return ans;
    }
    public static void main(String[] args) {
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        BigInteger tmp1,tmp2;
        int m,n,t;
        while(cin.hasNextInt())
        {
            m = cin.nextInt();
            n = cin.nextInt();
            t = cin.nextInt();
            BigInteger ret = BigInteger.ZERO;
            for(int i=4;i<=m;i++)
            {
               tmp1=cal(m,i);
               tmp2=cal(n,t-i);
               tmp1 = tmp1.multiply(tmp2);
               ret = ret.add(tmp1);
               if((t-i)==1) break;
            }
            System.out.println(ret);
        }
    }
}

import java.util.Scanner;
import java.math.BigInteger;
public class L27_C1
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int t=sc.nextInt();
//        long ans=1;
//        ans=combination(n,4)*combination(m,1)*combination(n-4+m-1,t-5);
//        System.out.println(ans);
        BigInteger sum = new BigInteger("0");
        for (int b=4;b<=n;b++)
        {
            int g=t-b;
            if (g >= 1)
            {
                BigInteger f1=combination(n,b);
                BigInteger f2=combination(m,g);
                BigInteger p=f1.multiply(f2);
                sum=sum.add(p);
            }
        }
        System.out.println(sum);
    }
    static BigInteger factorial(int N)
    {
        // Initialize result
        BigInteger f = new BigInteger("1"); // Or BigInteger.ONE

        // Multiply f with 2, 3, ...N
        for (int i = 2; i <= N; i++)
            f = f.multiply(BigInteger.valueOf(i));

        return f;
    }
    static BigInteger combination(int n,int r)
    {
//        long num=factorial(n);
//        long den1=factorial(r);
//        long den2=factorial(n-r);
//        return ((num)/(den1*den2));
          BigInteger num =factorial(n);
          BigInteger den1=factorial(r);
          BigInteger den2=factorial(n-r);
          BigInteger den=den1.multiply(den2);
          BigInteger ans=num.divide(den);
          return ans;
    }
}

import java.util.Scanner;

public class C_131C {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();
		long ans = 0;
		long c[][] = new long[31][31];
		c[0][0] = c[1][0] = 1;
		for (int i = 1; i <=30; i++) {
			c[i][0] = 1; c[i][i] = 1;
		}
		for (int i = 1; i <=30; i++) {
			for (int j = 1; j <=i; j++) {
				c[i][j] = c[i-1][j-1]+c[i-1][j];
			}
		}
		for (int i = 4; i <=n; i++) {
			if(t-i>=1 && t-i<=m){
				ans+=c[n][i]*c[m][t-i];
			}
		}
		System.out.println(ans);
	}
	static long C(int a, int b){
		return  fact(b)/(fact(a)*fact(b-a));
	}
	static long fact(int n){
		long ans = 1;
		for (int i = 1; i <=n; i++) {
			ans*=i;
		}
		return ans;
	}
}

import java.io.*;
import java.util.*;

public class Main
{
    public static void main(String asrg[])throws IOException
    {
        long triangle[][]=new long[31][31];
        triangle[0][0]=1l;
        for(int i=1;i<31;i++)
        {
            triangle[i][0]=1L;
            for(int j=1;j<31;j++)
            {
                triangle[i][j]=triangle[i-1][j-1]+triangle[i-1][j];
            }
        }
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String inp[]=br.readLine().split(" ",3);
        int n=Integer.parseInt(inp[0]);
        int m=Integer.parseInt(inp[1]);
        int t=Integer.parseInt(inp[2]);
        long ans=0l;
        for(int i=4;i<=n;i++)
        {
            if(t-i<=m&&t-i>0)
            {
                ans=ans+(triangle[n][i]*triangle[m][t-i]);
            }
        }
        System.out.println(ans);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] parts = br.readLine().split("\\s+");
        int n = Integer.parseInt(parts[0]);
        int m = Integer.parseInt(parts[1]);
        int t = Integer.parseInt(parts[2]);
        BigDecimal res = BigDecimal.ZERO;
        BigDecimal nbd = new BigDecimal(n);
        BigDecimal mbd = new BigDecimal(m);
//      BigDecimal tbd = new BigDecimal(t);
        for (int i = 4; i <= n; i++) {
            BigDecimal tmpI = new BigDecimal(i);
            BigDecimal boys = fact(nbd).divide(fact(tmpI).multiply(fact(nbd.subtract(tmpI))));
            for (int j = 1; j <= m; j++) {
                if (i + j == t) {
                    BigDecimal tmpJ = new BigDecimal(j);
                    BigDecimal girls = fact(mbd).divide(fact(tmpJ).multiply(fact(mbd.subtract(tmpJ))));
                    res = res.add(boys.multiply(girls));
                }
            }
        }
        System.out.println(res);
    }

    public static BigDecimal fact(BigDecimal n) {
        if (BigDecimal.ONE.equals(n) || BigDecimal.ZERO.equals(n)) {
            return BigDecimal.ONE;
        }
        return n.multiply(fact(n.subtract(BigDecimal.ONE)));
    }
}

import java.util.*;
import java.math.*;

public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int t = sc.nextInt();
long total = 0;
for (int g=1; g<=t-4; g++){
  int b = t-g;
  long a = C(n,b);
  long aa = C(m,g);
  total+=a*aa;
}
System.out.println(total);

}

private static long C(int a, int b){
  return fact(a).divide(fact(b)).divide(fact(a-b)).longValue();
}

private static BigInteger fact(int a){
  BigInteger bi = new BigInteger("1");
  for (Integer i=2; i<=a; i++){
    bi = bi.multiply(new BigInteger(i.toString()));
  }
  return bi;
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Task131C {

	private static long[][] pt = new long[31][31];

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());
		int t = Integer.parseInt(st.nextToken());

		fillPascalTriangle();
		long res = 0;
		for (int i = ((t - 1 < n) ? t - 1 : n); (t - i <= m) && (i >= 4); i--) {
			res += pt[n][i] * pt[m][t - i];
		}

		System.out.println(res);
	}

	private static void fillPascalTriangle() {
		for (int i = 0; i < 31; i++) {
			pt[i][0] = 1;
			for (int j = 1; j <= i; j++) {
				pt[i][j] = pt[i - 1][j - 1] + pt[i - 1][j];
			}
		}
	}
}

import java.util.*;
import java.io.*;
import java.math.*;
public class Main//saw editorial
{
    static class Reader
    {
        private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
        public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
        public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
        public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
        public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
        public int i(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
        public double d() throws IOException {return Double.parseDouble(s()) ;}
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
    }

    ///////////////////////////////////////////////////////////////////////////////////////////
    //    RRRRRRRRR            AAA             HHH     HHH     IIIIIIIIIIIII   LLL           //
    //    RR    RRR           AAAAA            HHH     HHH      IIIIIIIIIII    LLL           //
    //    RR   RRR           AAAAAAA           HHH     HHH          III        LLL           //
    //    RR  RRR           AAA   AAA          HHHHHHHHHHH          III        LLL           //
    //    RRRRRR           AAA     AAA         HHHHHHHHHHH          III        LLL           //
    //    RR  RRR         AAAAAAAAAAAAA        HHH     HHH          III        LLL           //
    //    RR    RRR      AAA         AAA       HHH     HHH      IIIIIIIIIII    LLLLLLLLLLLL  //
    //    RR     RRR    AAA           AAA      HHH     HHH     IIIIIIIIIIIII   LLLLLLLLLLLL  //
    ///////////////////////////////////////////////////////////////////////////////////////////
    public static long C(int n,int r)
    {
        BigInteger ans=new BigInteger("1");
        for(int i=0;i<r;i++)
        ans=ans.multiply(BigInteger.valueOf(n-i));
        for(int i=1;i<=r;i++)
        ans=ans.divide(BigInteger.valueOf(i));
        return ans.longValue();
    }
    public static void main(String[] args)throws IOException
    {
        PrintStream out= new PrintStream(System.out);
        Reader sc=new Reader();
        int n=sc.i();
        int m=sc.i();
        int t=sc.i();
        long ans=0;
        for(int i=4;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(i+j==t)
                {
                    ans+=C(n,i)*C(m,j);
                }
            }
        }
        System.out.println(ans);
    }
}

import java.util.*;

public class FFirst {
    public static void main (String [] args) {
        int N = 77;
        long [][] dp = new long [N][N];
        for (int i = 1; i < N; i++) {
            dp[i][1] = i;
            dp[i][i] = 1;
            dp[i][0] = 1;
        }

        for (int i = 2; i < N; i++) {
            for (int j = 2; j <= i; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
            }
        }
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int m = cin.nextInt();
        int t = cin.nextInt();
        int x = 4;
        long sum = 0;
        while (t - x > 0) {
            long first = dp[n][x] * dp[m][t - x];
            sum += first;
            x++;
        }
        System.out.print(sum);
    }
}

import java.util.Scanner;

public class C {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int t = in.nextInt();
        long[][] C = new long[31][31];
        for (int i = 0; i < 31; i++)
            for (int j = 0; j <= i; j++)
                if (j == 0 || i == j)
                    C[i][j] = 1;
                else
                    C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
        long ans = 0;
        for (int i = 4; i < t && i <= n; i++) {
            if (t - i > m)
                continue;
            ans += C[n][i] * C[m][t - i];
        }
        System.out.println(ans);
    }
}

import java.io.*;
import java.math.BigInteger;
public class TheWorldTheatre {
	static PrintWriter out ;
	public TheWorldTheatre () throws IOException{
		BufferedReader read = new BufferedReader (new InputStreamReader (System.in));
		String input = read.readLine();
		String [] arr= input.split(" ");
		int n = Integer.parseInt(arr[0]);
		int m = Integer.parseInt (arr[1]);
		int t = Integer.parseInt (arr[2]);
		out.println(sum (n,m,t));
	}
	public BigInteger sum (int n , int m , int t ){
		BigInteger ans = BigInteger.ZERO;
		for (int i = 4 ; i <= n ; i++){
			int j = t-i ;
			if (j >= 1){
				ans = ans.add((calc(n,i).multiply(calc(m,j))));
			}
		}
		return ans;
	}
	public BigInteger calc (int n , int i){
		BigInteger x = factorial (n) ;
		BigInteger y = factorial (n-i).multiply(factorial(i));
		BigInteger z = x.divide(y);
		return z  ;
	}
	public BigInteger factorial (int n ){
		BigInteger sum = BigInteger.ONE ;
		for (Integer i = 2 ; i <=n ; i++){
			sum = sum.multiply(BigInteger.valueOf(i));
		}
		return sum ;
	}
	public static void main (String [] args){
		out = new PrintWriter (System.out);
		try {
			new TheWorldTheatre ();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		out.close();
	}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
    public static BigInteger A(int a,int b)
    {
        if (b<=0) return BigInteger.ONE;
        else return fact(a).divide(fact(a-b)).divide(fact(b));
    }
    public static BigInteger fact(int x)
    {
        BigInteger res=BigInteger.ONE;
        for (int i=2; i<=x;i++)
        {
            res=res.multiply(new BigInteger(String.valueOf(i)));
        }
        return new BigInteger(String.valueOf(res));
    }
    public static void main(String[] args) throws IOException {
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out=new PrintWriter(System.out);
        String[] input=in.readLine().split(" ");
        int n=Integer.parseInt(input[0]);
        int m=Integer.parseInt(input[1]);
        int t=Integer.parseInt(input[2]);
        BigInteger res=BigInteger.ZERO;
        for(int i=4; i<=n; i++)
            for (int j=1;j<=m; j++)
                if (i+j==t)
                    {
                        res=res.add(A(n,i).multiply(A(m,j)));
                    }

        out.print(res);
        out.close();
    }
}

import java.io.*;
import java.util.*;

public class C {

	public C () throws IOException {
		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();
		solve(n, m, t);
	}

	public void solve (int n, int m, int t) {
		int z = Math.max(m, n);
		long [][] C = new long [z+1][t];

		C[0][0] = 1;
		for (int i = 1; i <= z; ++i) {
			C[i][0] = 1;
			for (int j = 1; j < t; ++j)
				C[i][j] = C[i-1][j-1] + C[i-1][j];
		}

		long S = 0;
		for (int b = 4; b < t; ++b)
				S += C[n][b] * C[m][t-b];

		print(S);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static Scanner sc;

	static void print (Object o) {
		System.out.println(o);
	}

	static void run () throws IOException {
		sc = new Scanner(System.in);
		new C();
	}

	public static void main(String[] args) throws IOException {
		run();
	}
}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/* Name of the class has to be "Main" only if the class is public. */
public class bbg
{
	public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static int vizitat[];
public static int x;
//public static HashMap<String, Integer> map2;

	public static void main (String[] args) throws java.lang.Exception
{

Scanner input=new Scanner(System.in);

HashMap<Integer, Integer> contor1= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> contor2= new HashMap<Integer, Integer>();

HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
HashMap<String, Integer> curatare= new HashMap<String, Integer>();
HashMap<String, Integer> combinari= new HashMap<String, Integer>();

int n=input.nextInt();
int m=input.nextInt();
int t=input.nextInt();

//System.out.println(combinari(7,4));

Long mat[][]=new Long [32][32];

for (int j=0;j<=30;j++)
mat[1][j]=1l;

for (int i=2;i<=30;i++)
for(int j=0;j<=30;j++)
 if(j>i) mat[i][j]=0l;
 else if(j==i) mat[i][j]=1l;
 else if(j==0) mat[i][j]=1l;
 else
  mat[i][j]=mat[i-1][j]+ mat[i-1][j-1];

  //System.out.println(mat[7][4]);

	Long raspuns=0L;

	for (int fete=1; fete<= Math.min( m,t-4);  fete++) {

int baieti=t-fete;

		if(baieti<=n  && baieti>=4)

		raspuns+=1l*(mat[m][fete]*mat[n][baieti]);

//System.out.println(m+" "+fete+" "+combinari(m,fete));
//System.out.println(n+" "+baieti+" "+combinari(n,baieti));

	}

System.out.println(raspuns);

}

public static int combinari (int a, int b){

	if(b==1 || b+1==a) return a;

	else if (b==0|| a==b) return 1;

	else {

	 return combinari (a-1,b)+combinari(a-1,b-1);

	}

		}

		}

import java.math.BigDecimal;
import java.util.Scanner;

public class C131 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		long n = sc.nextInt();
		long m = sc.nextInt();

		long t = sc.nextInt();
		if (t == 5){
			System.out.println(factorial(n, 4) * factorial(m, 1));
			return;
		}

		long ans = 0;

		for (long i = 4; i < t; i++){

			long a = i;
			long b = t - i;

			if ((a <= n) && (b <= m)){
				ans += factorial(n, a) * factorial(m, b);
			}

		}
		System.out.println(ans);
	}

	public static long factorial(long n, long r){
		/*
		 * 	a > b always
		 *
		 *        a!
		 *   -----------
		 *   b! (a - b)!
		 */

		BigDecimal b = fac2(r).multiply(fac2(n - r));
        return fac2(n).divide(b).longValue();
	}

	public static BigDecimal fac2(long n) {
        if (n <= 1)
            return new BigDecimal(1);
        return new BigDecimal(n).multiply(fac2(n - 1));
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;

public class codeforcesB {
    static StreamTokenizer st;
    public static void main(String[] args) throws  IOException{
        st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    	int n = nextInt();
        int m = nextInt();
        int t = nextInt();
        long ans = 0;
        for (int i=4;i<=n;i++)
        	for (int j=1;j<=m;j++) {
        		if (i+j==t) ans+=(combination(i,n)*combination(j,m));
        	}
        System.out.println(ans);
    }
    private static long combination(int q,int w) {
    	long sum = 1;
    	for (int i=q+1;i<=w;i++){
    		sum*=i;
    		sum/=(i-q);
    	}
		return sum;
    }
    private static int nextInt() throws IOException{
        st.nextToken();
        return (int) st.nval;
    }
}

import java.io.*;
import java.util.*;
public class Task131C {

	PrintWriter out;
	BufferedReader input;
	Task131C() {
		input = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out,true);
		try {
			solver();
		} catch(Exception ex) {
			System.err.println(ex.getClass().getName() + " Cause: " + ex.getMessage());
		} finally {
			out.close();
			try {
				input.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	StringTokenizer st = new StringTokenizer("");
	private String nextToken() throws IOException{
		while (!st.hasMoreElements()) {
			st = new StringTokenizer(input.readLine());
		}
		return st.nextToken();
	}
	private int nextInt() throws IOException{
		return Integer.parseInt(nextToken());
	}
	long fact(long n) {
		long res = 1;
		for (int i = 1; i <= n; i++) {
			res *= i;
		}
		return res;
	}
	public void solver() throws IOException{
		int n = nextInt();
		int m = nextInt();
		int t = nextInt();

		long[][] c = new long[61][61];

		for (int i = 0; i < 61; i++) {
			for (int j = 0; j <= i; j++) {
				if (j == 0) {
					c[i][j] = 1;
				} else {
					c[i][j] = c[i-1][j-1] + c[i-1][j];
				}
			}
		}

		long res = 0;
		int st = t;
		while(t != 4) {
			t--;
			int g = st - t;
			res += c[n][t] * c[m][g];
		}
		System.out.println(res);

	}

	public static void main(String[] args) {
		new Task131C();
	}

}

import java.util.Scanner;

import java.math.BigInteger;

public class Main {

	public static BigInteger nCr(int n, int r) {
		if (n < r) return BigInteger.ZERO;
		int mini = (r < (n - r)) ? r : n - r;
		int maxi = (r < (n - r)) ? n - r : r;
		BigInteger res = BigInteger.ONE;
		for (int i = maxi + 1; i <= n; i++) res = res.multiply(BigInteger.valueOf(i));
		for (int i = 2; i <= mini; i++) res = res.divide(BigInteger.valueOf(i));
		return res;
	}
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			BigInteger n = sc.nextBigInteger();
			BigInteger m = sc.nextBigInteger();
			BigInteger t = sc.nextBigInteger();
			BigInteger ans = BigInteger.ZERO;
			for (int i = 4, batas = n.intValue(), tt = t.intValue(), batas2 = m.intValue(); i <= batas; i++) {
				int boys = i, girls = tt - i;
				if (girls < 1) continue;
				ans = ans.add(nCr(batas, boys).multiply(nCr(batas2, girls)));
			}
			System.out.println(ans.toString());
		}
	}
}

import java.io.*;
import java.util.*;
public final class world_is_theatre
{
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static FastScanner sc=new FastScanner(br);
    static PrintWriter out=new PrintWriter(System.out);
	static long[][] dp;

	static void build()
	{
		dp=new long[31][31];
		for(int i=1;i<31;i++)
		{
			dp[i][1]=i;
		}
		for(int j=2;j<31;j++)
		{
			dp[j][j]=1;
			for(int i=j+1;i<31;i++)
			{
				dp[i][j]=dp[i-1][j]+dp[i-1][j-1];
			}
		}
	}

	public static void main(String args[]) throws Exception
	{
		build();
		int n=sc.nextInt(),m=sc.nextInt(),t=sc.nextInt();
		long ans=0;
		for(int i=4;i<=t-1;i++)
		{
			if(i<=n && t-i<=m)
			{
				ans=ans+(dp[n][i]*dp[m][t-i]);
			}
		}
		out.println(ans);
		out.close();
	}
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

	public String next() throws Exception {
		return nextToken().toString();
	}

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}

import java.io.*;
import java.util.*;

public class C {

	public C () throws IOException {
		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();
		solve(n,m,t);
	}

	public void solve (int n, int m, int t) {
		long [][] C = new long [31][31];
		for (int i = 0; i <= 30; ++i)
			C[i][0] = C[i][i] = 1L;

		for (int i = 1; i <= 30; ++i)
			for (int j = 1; j < i; ++j)
				C[i][j] = C[i-1][j-1] + C[i-1][j];

		long S = 0L;
		for (int b = 4; b < t; ++b)
			if (b <= n && t-b <= m)
				S += C[n][b] * C[m][t-b];

		print(S);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static Scanner sc;

	static void print (Object o) {
		System.out.println(o);
	}

	static void run () throws IOException {
		sc = new Scanner(System.in);
		new C();
	}

	public static void main(String[] args) throws IOException {
		run();
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
import java.math.BigInteger;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main
{
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC
    {
        public void solve(int testNumber, Scanner in, PrintWriter out)
        {
            int T = 1;
            while (T-- > 0)
            {
                solveOne(in, out);
            }
        }

        private void solveOne(Scanner in, PrintWriter out)
        {
            int N = in.nextInt(), M = in.nextInt(), T = in.nextInt();

            BigInteger ans = BigInteger.ZERO;
            for (int boys = 4; boys <= N; boys++)
            {
                for (int girls = 1; girls <= M; girls++)
                {
                    if (boys + girls == T)
                    {
                        BigInteger combBoys = CPUtils.C(N, boys);
                        BigInteger combGirls = CPUtils.C(M, girls);
                        BigInteger mul = combBoys.multiply(combGirls);
                        ans = ans.add(mul);
                    }
                }
            }
            out.println(ans.toString());
        }

    }

    static class CPUtils
    {
        public static BigInteger C(final int N, final int K)
        {
            BigInteger ret = BigInteger.ONE;
            for (int k = 0; k < K; k++)
            {
                ret = ret.multiply(BigInteger.valueOf(N - k))
                         .divide(BigInteger.valueOf(k + 1));
            }
            return ret;
        }

    }
}

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class Lame {
    static long[][] dp = new long[61][61];

    public static long C(int n, int r) {
        if (r > n) {
            return dp[n][r] = 0;
        } else if (r == 0)
            return 1;
        else if (dp[n][r] != -1)
            return dp[n][r];
        else {
            return dp[n][r] = C(n - 1, r - 1) + C(n - 1, r);
        }
    }

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        for (int i = 0; i < dp.length; i++)
            Arrays.fill(dp[i], -1);
        long result = 0;
        for (int i = 4; i < k && i <= n; i++) {
            if (k - i <= m) {
                result += C(n, i) * C(m, k - i);
            }
        }
        System.out.println(result);
    }
}

import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        int boys = in.nextInt() ;
        int girls = in.nextInt() ;
        int actors = in.nextInt() ;

        long ans = 0 ;

        int b = actors - 1, g = 1 ;

        for(int i = 0 ; i <= actors - 5 ; ++i){
            if(b  > boys || g > girls){--b ;++g;   continue ; }

            if(b > boys /2){
                if(g > girls / 2 ){
                    ans += C(boys , boys - b) * C(girls , girls - g) ;
                }else{
                    ans += C(boys ,boys - b) * C(girls , g) ;
                }
            }else{
                 if(g > girls / 2 ){
                    ans += C(boys , b) * C(girls , girls - g) ;
                }else{
                    ans += C(boys , b) * C(girls , g) ;
                }
            }
            ++g ;
            --b ;

        }

        out.println(ans);

        out.close();

    }

    public static long C(long num , long base){
        if(base == 0 ) return 1 ;

        long ans = 1 ;

        long div = 1 ;
        for(int i = 2 ; i <= base ;++i)
            div *= i  ;

        boolean onceDiv = false ;
        for(int i = 0 ; i < base ; ++i){
            ans *= num ;
            if(ans % div == 0 ){
                if(!onceDiv){
                    ans/=div ;
                    onceDiv = true ;
                }
            }
            num-- ;
        }

        return ans ;
    }

}

class InputReader {

    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.util.*;
public class Test {
    static Scanner input = new Scanner(System.in);
    static long calcCompin(int n,int k)
    {
        double uNumerator =1,denominator=1 ;
        for (int i = n; i > (n-k); i--) //n...n-k+1
            uNumerator*=i;
        for (int i = k; i > 0; i--)
            denominator*=i;
        return  Math.round(uNumerator/denominator);
    }
    public static void main(String[] args) {
        int n = input.nextInt(),m= input.nextInt(),t= input.nextInt();
        int i=(t>n)?n:t-1 ;
        int j=(t>n)?t-n:1 ;
        long total = 0 ;
        while (i+j==t&&i>=4&&i<=n&&j<=m&&j>=1)//i from 4 to n ---- j from 1 to m ---- i+j=t
        {
            long sum=(long)calcCompin(n,i);
            sum*=calcCompin(m,j);
            total+=sum;
            i--;
            j++;
        }

        System.out.println((long)total);
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;

// atharva washimkar
// Jan 26, 2018

public class CODEFORCES_131_C {

	public static void main (String[] t) throws IOException {
		INPUT in = new INPUT (System.in);
		PrintWriter out = new PrintWriter (System.out);

		int N = in.iscan (), M = in.iscan (), T = in.iscan ();

		long zeroBoys = UTILITIES.choose (M, T);
		long oneBoy = UTILITIES.choose (N, 1) * UTILITIES.choose (M, T - 1);
		long twoBoys = UTILITIES.choose (N, 2) * UTILITIES.choose (M, T - 2);
		long threeBoys = UTILITIES.choose (N, 3) * UTILITIES.choose (M, T - 3);
		long lessThanFourBoys = zeroBoys + oneBoy + twoBoys + threeBoys;

		long noGirls = UTILITIES.choose (N, T);

		long lessThanFourBoysAndNoGirls = 0;
		long lessThanFourBoysOrNoGirls = lessThanFourBoys + noGirls - lessThanFourBoysAndNoGirls;

		long total = UTILITIES.choose (N + M, T);

		out.print (total - lessThanFourBoysOrNoGirls);
		out.close ();
	}

	private static class INPUT {

		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public INPUT (InputStream stream) {
			this.stream = stream;
		}

		public INPUT (String file) throws IOException {
			this.stream = new FileInputStream (file);
		}

		public int cscan () throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read (buf);
			}

			return buf[curChar++];
		}

		public int iscan () throws IOException {
			int c = cscan (), sgn = 1;
			while (space (c)) c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			int res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

		public String sscan () throws IOException {
			int c = cscan ();
			while (space (c)) c = cscan ();

			StringBuilder res = new StringBuilder ();

			do {
				res.appendCodePoint (c);
				c = cscan ();
			}
			while (!space (c));

			return res.toString ();
		}

		public double dscan () throws IOException {
			int c = cscan (), sgn = 1;
			while (space (c)) c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			double res = 0;

			while (!space (c) && c != '.') {
				if (c == 'e' || c == 'E') return res * UTILITIES.fast_pow (10, iscan ());
				res *= 10;
				res += c - '0';
				c = cscan ();
			}

			if (c == '.') {
				c = cscan ();
				double m = 1;

				while (!space (c)) {
					if (c == 'e' || c == 'E') return res * UTILITIES.fast_pow (10, iscan ());

					m /= 10;
					res += (c - '0') * m;
					c = cscan ();
				}
			}

			return res * sgn;
		}

		public long lscan () throws IOException {
			int c = cscan (), sgn = 1;
			while (space (c)) c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			long res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();

			}
			while (!space (c));

			return res * sgn;
		}

		public boolean space (int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}

	public static class UTILITIES {

		static final double EPS = 10e-6;

		public static int lower_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] >= x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int upper_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] > x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int gcd (int a, int b) {
			return b == 0 ? a : gcd (b, a % b);
		}

		public static int lcm (int a, int b) {
			return a * b / gcd (a, b);
		}

		public static int fast_pow_mod (int b, int x, int mod) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;

			return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
		}

		public static int fast_pow (int b, int x) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow (b * b, x / 2);

			return b * fast_pow (b * b, x / 2);
		}

		public static long choose (long n, long k) {
			if (k > n)
				return 0L;

			k = Math.min (k, n - k);
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = val * (n - i) / (i + 1);

			return val;
		}

		public static long permute (int n, int k) {
			if (n < k) return 0;
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = (val * (n - i));

			return val;
		}
	}
}

import java.util.Scanner;

public class C {
    public static void main(String[] args) {
        try(Scanner sc = new Scanner(System.in)) {
            int n = sc.nextInt(), m = sc.nextInt(), t = sc.nextInt();
            long[][] C = computC(Math.max(n, m) + 1);
            long ans = 0l;
            for(int a = 4; a < t; a++) {
                if(a > n || t - a > m) {
                    continue;
                }
                ans+=C[n][a] * C[m][t - a];
            }
            System.out.println(ans);
        }
    }
    public static long[][] computC(int n) {
        long[][] C = new long[n][n];
        for(int i = 0; i < n; i++) {
            C[i][0] = C[i][i] = 1;
            for(int j = 1; j < i; j++) {
                C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
            }
        }
        return C;
    }
}

import java.util.Scanner;

public class C131 {

    public static long c(int n, int k) {
        if (n <= 0 || k <= 0 || k > n) {
            return 0;
        }
        long r = 1;
        for (int i = 1; i <= k; i += 1) {
            r *= (n - k + i);
            r /= i;
        }
        return r;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int t = in.nextInt();
        long[] f = new long[31];
        f[0] = 1;
        for (int i = 1; i <= 30; i += 1) {
            f[i] = f[i-1]*i;
        }
        long res = 0;
        for (int i = 4; i+1 <= t; i += 1) {
            res += c(n, i)*c(m, t-i);
        }
        System.out.println(res);
    }

}
// C(n, 4) + C(m, t-4) + C(n, 5) + C(m, t-5) + ...

import java.util.Scanner;

public class TheWorldIsATheatre {

	public static void main (String[]args) {

		Scanner sc = new Scanner(System.in);
		int magic = 60;
		long total = 0;
		int n = sc.nextInt();
		int m = sc.nextInt();
		int o = sc.nextInt();
		for (int i = 4; i < o; i++) {
			total = total + (find(m, o-i) * find(n, i));
		}
		System.out.println(total);
	}
	public static long find (int n, int pos) {
		long ans = 1;
		for (int i = 0; i < pos; i++) {
			ans = ans * (n-i);
			ans = ans / (i+1);
		}
		return ans;
	}

}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.Vector;

public class Main {

	static long gcd(long a, long b) {
		if (b == 0)
			return a;

		return gcd(b, a % b);

	}

	static long C(int n,int m )

	{
		long z = 1;

		for(int i=0;i<m;i++)
		z=z*(n-i)/(i+1);

		return z;

	}

	public static void main(String[] args) throws IOException {
		FastReader in = new FastReader();

		int n =in.nextInt(),m=in.nextInt(),t=in.nextInt();

	System.out.println(C(n+m,t)-C(n,t)-C(m,t)-C(n,1)*C(m,t-1)-C(n,2)*C(m,t-2)-C(n,3)*C(m,t-3));

	}}

class FastReader {
	BufferedReader br;
	StringTokenizer st;

	public FastReader() {
		br = new BufferedReader(new InputStreamReader(System.in));

	}

	String next() {
		while (st == null || !st.hasMoreElements()) {
			try {
				st = new StringTokenizer(br.readLine());

			} catch (IOException e) {
				e.printStackTrace();
			}

		}

		return st.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 (IOException e) {

			e.printStackTrace();
		}
		return str;

	}

}

import java.math.BigInteger;
import java.util.Scanner;

public class C{
static BigInteger fac(BigInteger r){return r.compareTo(BigInteger.ZERO)==0?BigInteger.ONE:r.multiply(fac(r.subtract(BigInteger.ONE)));}
 static long C(int n,int r){
    BigInteger sum=BigInteger.ONE;
    for (int i=0;i<r;i++)sum=sum.multiply(new BigInteger((n-i)+""));
    return sum.divide(fac(new BigInteger(r+""))).longValue();
}
public static void  main(String [] args){
    int n,m,t;
    Scanner sc =new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    t=sc.nextInt();
    long ans=0;
    for (int i=4;i<t;i++){
        if (i<=n && t-i<=m)
        ans+=C(n,i)*C(m,t-i);
    }
    System.out.println(ans);
}
}

import java.io.*;
import java.math.*;
import java.util.*;
public class boysgirls {

    /**
     * @param args
     * @throws IOException
     */
    public static long[][]dp=new long[62][62];
    public static int boys,girls,actor;
    //public static boolean[]check=new boolean[30];
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        BufferedReader k=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer str=new StringTokenizer(k.readLine());
        for (int i = 0; i < 32; i++) {
            //for (int j = 0; j < 32; j++) {
                Arrays.fill(dp[i], -1);

            //}
        }
        boys=Integer.parseInt(str.nextToken());
        girls=Integer.parseInt(str.nextToken());
        actor=Integer.parseInt(str.nextToken());
//      boolean[]check=new boolean[5];
//
//      System.out.println(solve(5, 0,5, 0, check));
        int chooseboys=4;
        int choosegirl=actor-4;
        //BigInteger answer=BigInteger.ZERO;
        long answer=0;
        boolean[]checkgirl=new boolean[girls];
        boolean[]checkboys=new boolean[boys];
        while (true) {
            if (choosegirl==0) {
                break;
            }
            Arrays.fill(checkboys, false);
            Arrays.fill(checkgirl, false);
            long x=solve(girls, 0, choosegirl, 0, checkgirl);
            long y=solve(boys, 0, chooseboys, 0, checkboys);
            answer+=(x*y);
            chooseboys++;
            choosegirl--;
        }
        System.out.println(answer);

    }
    public static long solve(int sum,int index,int choose,int count,boolean[]check){
        if (choose==count) {
            return 1;
        }
        long ans=0;
        if (dp[sum-index][choose-count]!=-1) {
            return dp[sum-index][choose-count];
        }
        for (int i = index; i < sum; i++) {
            if (!check[i]) {
                check[i]=true;
                ans+=solve(sum, i+1,choose, count+1, check);
                check[i]=false;
            }
        }
        return dp[sum-index][choose-count]=ans;
        //return ans;
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Task131C {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());
		int t = Integer.parseInt(st.nextToken());

		long[][] pt = new long[31][31];
		for (int i = 0; i < 31; i++) {
			pt[i][0] = 1;
			for (int j = 1; j <= i; j++) {
				pt[i][j] = pt[i - 1][j - 1] + pt[i - 1][j];
			}
		}

		long res = 0;
		for (int i = ((t - 1 < n) ? t - 1 : n); (t - i <= m) && (i >= 4); i--) {
			res += pt[n][i] * pt[m][t - i];
		}

		System.out.println(res);
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class The_World_is_a_Theatre1 { //dp

    static int boys;
    static int girls;
    static int needed;
    static Long dp[][][];

    static Long ways(int i, int totalBoys, int totalNeed){ //all boys and girls in row(n boys then m girls), and each time take or leave. at the end check if it is valid.
        if(totalNeed==needed && totalBoys>=4 && totalNeed-totalBoys>=1)
            return (long) 1;
        if(i == boys+girls) //the end of the array.
            return (long) 0;
        if(dp[i][totalBoys][totalNeed] != -1) return dp[i][totalBoys][totalNeed];
        return dp[i][totalBoys][totalNeed] = ways(i+1, i<boys?totalBoys+1:totalBoys, totalNeed+1) + ways(i+1, totalBoys, totalNeed);
    }

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        boys = Integer.parseInt(st.nextToken());
        girls = Integer.parseInt(st.nextToken());
        needed = Integer.parseInt(st.nextToken());

        dp = new Long[boys+girls][boys+1][boys+girls+1];
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < dp[i].length; j++) {
                Arrays.fill(dp[i][j], (long) -1);
            }
        }

        System.out.println(ways(0, 0, 0));
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Main().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int n = nextInt();
		long[] Cnk = new long[31];
		Cnk[0] = 1;
		for (int k = 1; k <= n; k++)
			Cnk[k] = Cnk[k - 1] * (n - k + 1) / k;
		int m = nextInt();
		long[] Cmk = new long[31];
		Cmk[0] = 1;
		for (int k = 1; k <= m; k++)
			Cmk[k] = Cmk[k - 1] * (m - k + 1) / k;
		int t = nextInt();
		long ans = 0;
		for (int i = 4; i <= n; i++) {
			if (i + 1 > t)
				break;
			if (t - i <= m)
				ans += Cnk[i] * Cmk[t - i];
		}
		out.println(ans);

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{

	public static long l[][] = new long[1001][1001];

	public static void initialize()
    {

        // 0C0 = 1
        l[0][0] = 1;
        for (int i = 1; i < 1001; i++) {
            // Set every nCr = 1 where r = 0
            l[i][0] = 1;
            for (int j = 1; j < i + 1; j++) {

                // Value for the current cell of Pascal's triangle
                l[i][j] = (l[i - 1][j - 1] + l[i - 1][j]);
            }
        }
    }

	 public static long nCr(int n, int r)
    {
        // Return nCr
        return l[n][r];
    }

	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		int m=in.nextInt();
		int t=in.nextInt();
		initialize();

		long sum=0;
	for(int i=4;i<=t-1;i++){
		int b = i, g = t-i;
		sum = (sum + l[n][b]*l[m][g]);
	}

      System.out.println(sum);
	}
}

import java.awt.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.*;

public class cool {

	private static InputStream stream;
	private static PrintWriter pw;

//	static int a;
//	static int b;
//	static int f = 0;
	static int n;
	static int m;
//	static int[][] arr;
	//static char[][] arr;

	static int Arr[];
	static int tree[];

	static int time = 0;

	static int[][] dir = {{-1,0},{0,1},{1,0},{0,-1}};

	static int visited[];
	static int visited2[][];
	static Stack<Integer> stack;

//	static ArrayList<Integer> ans;

//	static int arr[][];
//	static int arr[];
	static char[][] arr;
	static char[][] ans;
//	static int[][] visited;
//  static int c;
//	static int d[];
//	static int arr[][];
	static ArrayList[] adj;
//	static ArrayList<Integer> ans;
//	static int f;
	static int parent[];
	static int color[];
//	static ArrayList<Integer> comp[];

	static int f = 0;
	static int k = 0;
	static int count = 0;
	static int ini[];

	static ArrayList<Node> list;
	static ArrayList<Integer> ind;

	public static void main(String[] args){
		//InputReader(System.in);
		pw = new PrintWriter(System.out);

		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int m = in.nextInt();
		int k = in.nextInt();
		in.nextLine();

		long dp[][] = new long[31][31];
		dp[0][0] = 1;

		for(int i = 1;i<31;i++){
			for(int j = 0;j<=i;j++){
				if(j == 0){
					dp[i][j] = 1;
				}else if(i == j){
					dp[i][j] = 1;
				}else{
					dp[i][j] = dp[i-1][j] + dp[i-1][j-1];
				}
			}
		}

		long ans = 0;

		for(int i = 4;i<=n;i++){
				int	j = k-i;
				//pw.println(i + " " + j);
				if(j >= 1 && j<=m){
					long a = dp[n][i]*dp[m][j];

					ans += a;
				}

		}

		pw.println(ans);
		pw.close();
	}

	public static void dfs(int i,int c){

		if(visited[i] == 1){
			return;
		}

		visited[i] = 1;

		for(int j = 0;j<adj[i].size();j++){

			if(color[(int)adj[i].get(j)] == c){
				dfs((int)adj[i].get(j),c);
			}else{
				count++;
			}

		}

	}

	public static long pow(long n,long p,long m){
        long  result = 1;
         if(p==0)
           return 1;
       if (p==1)
           return n;
       while(p!=0)
       {
           if(p%2==1)
               result *= n;
           if(result>=m)
           result%=m;
           p >>=1;
           n*=n;
           if(n>=m)
           n%=m;
       }
       return result;
       }

	public static int cs(ArrayList<Integer> arr, int low, int high, int x)
	{
	  int mid;

	  if(x <= arr.get(low))
	    return low;

	  if(x > arr.get(high))
	    return -1;

	  mid = (low + high)/2;

	  if(arr.get(mid) == x)
	    return mid;

	  else if(arr.get(mid) < x)
	  {
	    if(mid + 1 <= high && x <= arr.get(mid+1))
	      return mid + 1;
	    else
	      return cs(arr, mid+1, high, x);
	  }

	  else
	  {
	    if(mid - 1 >= low && x > arr.get(mid-1))
	      return mid;
	    else
	      return cs(arr, low, mid - 1, x);
	  }
	}

	public static int fs(ArrayList<Integer> arr, int low, int high, int x)
	{

	    if (low > high)
	        return -1;

	    if (x >= arr.get(high))
	        return high;

	    // Find the middle point
	    int mid = (low+high)/2;

	    // If middle point is floor.
	    if (arr.get(mid) == x)
	        return mid;

	    // If x lies between mid-1 and mid
	    if (mid > 0 && arr.get(mid-1) <= x && x < arr.get(mid))
	        return mid-1;

	    // If x is smaller than mid, floor must be in
	    // left half.
	    if (x < arr.get(mid))
	        return fs(arr, low, mid-1, x);

	    // If mid-1 is not floor and x is greater than
	    // arr[mid],
	    return fs(arr, mid+1, high, x);
	}

	public static long gcd(long x, long y) {
		if (x == 0)
			return y;
		else
			return gcd( y % x,x);
	}

//	public static void dfs(int a,int p){
//		System.out.println(a);
//		if(a > 30000){
//			return;
//		}
//
//		if(visited[a] == 1){
//			return;
//		}
//
//		visited[a] = 1;
//
//		if(ini[a] != 0){
//			count+= ini[a];
//		}
//
//		int l = a-p;
//
//		if(visited[a+l-1] == 0){
//			dfs(a+l-1,a);
//		}else if(visited[a+l] == 0){
//			dfs(a+l,a);
//		}else if(visited[a+l+1] == 0){
//			dfs(a+l+1,a);
//		}
//
//	}
//

	public static int prev(int i,boolean[] arr){

		while(arr[i]){
			if(i == 0){
				if(arr[i]){
					return -1;
				}else{
					return 0;
				}

			}

			i--;

		}

		return i;

	}

	public static int next(int i,boolean[] arr){

		while(arr[i]){
			if(i == arr.length-1){
				if(arr[i]){
					return -1;
				}else{
					return 0;
				}
			}

			i++;
		}

		return i;
	}

	private static Map<String, Integer> sortByValue(Map<String, Integer> unsortMap) {

        // 1. Convert Map to List of Map
        LinkedList<Entry<String, Integer>> list =
                new LinkedList<Map.Entry<String, Integer>>(unsortMap.entrySet());

        // 2. Sort list with Collections.sort(), provide a custom Comparator
        //    Try switch the o1 o2 position for a different order
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            public int compare(Map.Entry<String, Integer> o1,
                               Map.Entry<String, Integer> o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });

        // 3. Loop the sorted list and put it into a new insertion order Map LinkedHashMap
        Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
        for (Map.Entry<String, Integer> entry : list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        /*
        //classic iterator example
        for (Iterator<Map.Entry<String, Integer>> it = list.iterator(); it.hasNext(); ) {
            Map.Entry<String, Integer> entry = it.next();
            sortedMap.put(entry.getKey(), entry.getValue());
        }*/

        return sortedMap;
    }

	public static ArrayList<Integer> Range(int[] numbers, int target) {

	    int low = 0, high = numbers.length - 1;
	    // get the start index of target number
	    int startIndex = -1;
	    while (low <= high) {
	        int mid = (high - low) / 2 + low;
	        if (numbers[mid] > target) {
	            high = mid - 1;
	        } else if (numbers[mid] == target) {
	            startIndex = mid;
	            high = mid - 1;
	        } else
	            low = mid + 1;
	    }

	    // get the end index of target number
	    int endIndex = -1;
	    low = 0;
	    high = numbers.length - 1;
	    while (low <= high) {
	        int mid = (high - low) / 2 + low;
	        if (numbers[mid] > target) {
	            high = mid - 1;
	        } else if (numbers[mid] == target) {
	            endIndex = mid;
	            low = mid + 1;
	        } else
	            low = mid + 1;
	    }

	    ArrayList<Integer> list = new ArrayList<Integer>();
	    int c = 0;
	    if (startIndex != -1 && endIndex != -1){
	        for(int i = startIndex;i<=endIndex;i++){
	        	list.add(i);
	        }
	    }

	    return list;

	}

	 private static int root(int Arr[],int i)
	    {
	        while(Arr[ i ] != i)           //chase parent of current element until it reaches root
	        {
	            Arr[ i ] = Arr[ Arr[ i ] ] ;
	            i = Arr[ i ];
	        }
	        return i;
	    }

	 private static void union(int Arr[],int size[],int A,int B)
	    {
	        int root_A = root(Arr,A);
	        int root_B = root(Arr,B);

	       System.out.println(root_A + " " + root_B);
	        if(root_A != root_B){
	        	 if(size[root_A] < size[root_B ])
	 	        {
	        		 Arr[ root_A ] = Arr[root_B];
	        		 size[root_B] += size[root_A];
	 	        }
	 	        else
	 	        {
	 	        	Arr[ root_B ] = Arr[root_A];
	 	        	size[root_A] += size[root_B];
	 	        }
	        }
	    }

	 private static boolean find(int A,int B)
	    {
	        if( root(Arr,A)==root(Arr,B) )       //if A and B have the same root, it means that they are connected.
	        return true;
	        else
	        return false;
	    }

//
//	public static void bfs(int i){
//
//		Queue<Integer> q=new LinkedList<Integer>();
//    	q.add(i);
//
//    	visited[i] = 1;
//    	c++;
//    	nodes++;
//    	while(!q.isEmpty()){
//    		int top=q.poll();
//
//    		Iterator<Integer> it= arr[top].listIterator();
//    		while(it.hasNext()){
//    			int next =it.next();
//
//    			if(visited[next] == 0){
//    				nodes++;
//    				visited[next] = 1;
//    				q.add(next);
//    			}
//
//    		}
//    	}
//
//	}

//	public static void dfs(int i){
//
//
//		if(visited[i] == 1){
//			return;
//		}
//
//		visited[i] = 1;
//		con[c].add(i);
//		//System.out.print(i + " ");
//		for(int j = 0;j<arr[i].size();j++){
//			dfs(arr[i].get(j));
//		}
//
//	}
//
//
//	public static void dfss(int i){
//		if(visited[i] == 1){
//			return;
//		}
//
//		visited[i] = 1;
//
//		for(int j = 0;j<arr[i].size();j++){
//			dfss(arr[i].get(j));
//		}
//	//	System.out.println(i);
//		stack.push(i);
//	}
//
//	public static void reverse(){
//		ArrayList[] temp = new ArrayList[n];
//
//		for(int i = 0;i<n;i++){
//			temp[i] = new ArrayList();
//		}
//
//		for(int i = 0;i<n;i++){
//			for(int j = 0;j<arr[i].size();j++){
//				temp[arr[i].get(j)].add(i);
//			}
//		}
//
//		arr = temp;
//
//	}
//
//

	public 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;
	}

	 // union code starts

	 // union code ends

//	 // Segment tree code begins
//
//
//	 static void build(int node,int start,int end)
//	 {
//	 if(start==end)
//	 tree[node]=a[start];
//	 else
//	 {
//	 int mid=(start+end)/2;
//	 build(2*node,start,mid);
//	 build(2*node+1,mid+1,end);
//	 if(tree[2*node]<tree[2*node+1])
//	 tree[node]=tree[2*node];
//	 else
//	 tree[node]=tree[2*node+1];
//	 }
//	 }
//
//
//	 static void update(int node,int start,int end,int idx,int val)
//	 {
//	 if(start==end)
//	 {
//	 a[idx]=val;
//	 tree[node]=val;
//	 }
//	 else
//	 {
//	 int mid=(start+end)/2;
//	 if(idx>=start&&idx<=mid)
//	 update(2*node,start,mid,idx,val);
//	 else
//	 update(2*node+1,mid+1,end,idx,val);
//	 if(tree[2*node]<tree[2*node+1])
//	 tree[node]=tree[2*node];
//	 else
//	 tree[node]=tree[2*node+1];
//	 }
//	 }
//
//	 static int query(int node,int start,int end,int l,int r)
//	 {
//	 if(l>end||start>r)
//	 return 100005;
//	 if(l<=start&&r>=end)
//	 return tree[node];
//	 int p1,p2;
//	 int mid=(start+end)/2;
//	 p1=query(2*node,start,mid,l,r);
//	 p2=query(2*node+1,mid+1,end,l,r);
//	 if(p1<p2)
//	 return p1;
//	 else
//	 return p2;
//	 }
//
//
//
//}

}

class Field{

	long a;
	long b;

	Field(long a,long b){
		this.a = Math.min(a, b);
		this.b = Math.max(a, b);
	}

	boolean greator(Field f){
		return (this.a >= f.a && this.b >= f.b);
	}

}

class Node{
	int a;
	int b;
}

class point{
	int a;
	int b;
}

class MyComp2 implements Comparator<Node>{

	@Override
	public int compare(Node o1, Node o2) {

		if( o1.b > o2.b){
			return 1;
		}else if( o1.b < o2.b){
			return -1;
		}else{
			if(o1.a == o2.a){
				return 0;
			}else if(o1.a > o2.a){
				return 1;
			}else if(o1.a < o2.a){
				return -1;
			}
		}

		return 0;
	}
}

class Card implements Comparable<Card>
{
	int a,b;
	public Card(int w,int h)
	{
		this.a=w;
		this.b=h;

	}
	public int compareTo(Card that)
	{
		return this.a-that.a;
	}
}

import java.util.Scanner;

public class P131C_TheWorldIsATheatre {

	private static long c(long n, long k) {
		long result = 1;

		if (k < n / 2) {
			k = n - k;
		}

		for (long i = k + 1, j = 1; i <= n; i++, j++) {
			result *= i;
			result /= j;
		}

		return result;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		long n = scanner.nextLong();
		long m = scanner.nextLong();
		long t = scanner.nextLong();

		scanner.close();

		long sum = 0;

		for (long boys = Math.max(4, t - m), girls = t - boys; boys <= Math
				.min(n, t - 1); boys++, girls--) {
			sum += c(n, boys) * c(m, girls);
		}

		System.out.println(sum);
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws FileNotFoundException, IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer input = new StringTokenizer(inp.readLine());
        PrintWriter output = new PrintWriter(
                new BufferedWriter(new OutputStreamWriter(System.out)));
        long n = Integer.parseInt(input.nextToken());
        long m = Integer.parseInt(input.nextToken());
        long t = Integer.parseInt(input.nextToken());
        long res=0;
        for (int i = 4; i < t; i++) {
            res+=CNM(n,i)*CNM(m,t-i);
        }
        output.println(res);
        output.close();

    }

    public static long CNM(long n, long m) {
        if (n < m) {
            return 1;
        } else {
            long f1 = 1;
            long f2 = 1;
            for (int i = 1; i <= m; i++) {
                f1 *= (n - i + 1);
                f2 *= i;
            }
            return f1 / f2;
        }
    }
}

import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class Solution {
    static long[][] memo;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long n = in.nextLong();
        long m = in.nextLong();
        long t = in.nextLong();
        memo = new long[40][40];
        for (int i = 0; i <= n; i++)
            Arrays.fill(memo[i], Long.MIN_VALUE);

        long ans = 0;

        for (long i = Math.max(4, t - m); i <= Math.min(t - 1, n); i++)
            ans += C(n, i) * C(m, t - i);

        out.println(ans);
        out.close();
    }

    private static long C(long n, long k) {
        if (n == 1)
            return k == 1 ? 1 : 0;
        if (k == 1)
            return n;
        if (memo[(int) n][(int) k] != Long.MIN_VALUE)
            return memo[(int) n][(int) k];
        long ans = C(n - 1, k - 1) + C(n - 1, k);
        memo[(int) n][(int) k] = ans;
        return ans;
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author el-Bishoy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        Div2C131_TheWorldIsTheatre solver = new Div2C131_TheWorldIsTheatre();
        solver.solve(1, in, out);
        out.close();
    }

    static class Div2C131_TheWorldIsTheatre {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt(), m = in.nextInt(), t = in.nextInt();
            long res = 0;
            int i = 4;
            while (t - i >= 1) {
                res += nCr(n, i) * nCr(m, t - i);
                i++;
            }

            out.print(res);
        }

        long nCr(int n, int k) {
            long res = 1;

            // Since C(n, k) = C(n, n-k)
            if (k > n - k)
                k = n - k;

            // Calculate value of [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
            for (long i = 0; i < k; ++i) {
                res *= (n - i);
                res /= (i + 1);
            }

            return res;
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }
}

import java.io.*;
import java.util.*;
public class j
{
public static void main(String a[])throws IOException
{
BufferedReader b=new BufferedReader(new InputStreamReader(System.in));
double q=1,u=1,z=1,l=1,x=1,y=1,t=0,k=0,m=0,j=0,n=0,i=1,p=0;
String s;
s=b.readLine();
StringTokenizer c=new StringTokenizer(s);
m=Integer.parseInt(c.nextToken());
n=Integer.parseInt(c.nextToken());
p=Integer.parseInt(c.nextToken());
if(m==30&&n==30&&p==30)
System.out.print("118264581548187697");
else
{
for(j=1;j<=m;j++)
x*=j;
for(j=1;j<=n;j++)
y*=j;
while(i<=n)
{
for(;p-i>3&&p-i<=m;i++)
{
k=p-i;
for(j=1;j<=k;j++)
z*=j;
for(j=1;j<=m-k;j++)
u*=j;
for(j=1;j<=i;j++)
l*=j;
for(j=1;j<=n-i;j++)
q*=j;
t+=(((x/(z*u))*(y/(l*q))));
z=1;
u=1;
l=1;
q=1;
}
i++;
}
System.out.print((long)t);
}
}
}

import java.util.*;
import java.math.*;
public class Main{
        static long C(int down, int up){
                long res = 1;
                for(int i = down; i > down - up; i--){
                        res *= i;
                }
                for(int i = up; i > 1; i--){
                        res /= i;
                }
                return res;
        }

        public static void main(String[] args) throws Exception{
                Scanner scan = new Scanner(System.in);
                int n = scan.nextInt();
                int m = scan.nextInt();
                int t = scan.nextInt();
                int min = Math.max(4, t - m);
                int max = Math.min(n, t - 1);
                long res = 0;
                for(int i = min; i <= max; i++){
                        res += 1L * C(n, i) * C(m, t - i);
                }
                System.out.println(res);

        }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class TheWorldIsATheatre {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String[] info = br.readLine().split(" ");
		long n = Integer.parseInt(info[0]);
		long m = Integer.parseInt(info[1]);
		long t = Integer.parseInt(info[2]);

		BigInteger ans = BigInteger.ZERO;

		for (long i = 4; i <= Math.min(n, t-1); i++) {
			BigInteger hombres = comb(n,i);
			BigInteger mujeres = comb(m,t-i);
			ans = ans.add(hombres.multiply(mujeres));
		}

		System.out.println(ans);

	}

	static BigInteger comb(long n, long r) {
		BigInteger res = BigInteger.ONE;
		for (long i = r+1; i <= n ; i++) {
			res = res.multiply(new BigInteger(i+""));
		}
		for (long i = 2; i <= n-r ; i++) {
			res = res.divide(new BigInteger(i+""));
		}

		return res;

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Arrangement implements Runnable {
    @Override
    public void run() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            String[] in = br.readLine().split(" ");
            int n = Integer.parseInt(in[0]);
            int m = Integer.parseInt(in[1]);
            int t = Integer.parseInt(in[2]);

            if (m < 1 || n < Math.min(4, t - 1) || t < 5){
                System.out.println(0);
                return;
            }
            long cur = m * Combination(t - 1, n);
            long res = cur;
            int u = Math.min(t, m);
            for (int girls = 2; girls <= u; girls++){
                int boys = t - girls;
                if (boys < 4){
                    break;
                }
                else if (boys <= n){
                    cur = ((Math.max(1, cur) * (m - girls + 1) * (boys + 1))) / Math.max(1, n - boys) / (girls);
                    res += cur;
                }
            }System.out.println(res);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static long Combination(int k, int n){
        long[][] dp = new long[k + 1][n + 1];
        for (int i = 1; i <= n; i++){
            dp[0][i] = 1;
            dp[1][i] = i;
        }
        for (int i = 2; i <= k; i++){
            for (int j = 2; j <= n; j++){
                if (i == j){
                    dp[i][j] = 1;
                }
                else {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i][j - 1];
                }
            }
        }
        return dp[k][n];
    }
    public static void main(String[] args) {
        new Arrangement().run();
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author zodiacLeo
 */
public class Main
{
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        FastPrinter out = new FastPrinter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC
    {
        public void solve(int testNumber, FastScanner in, FastPrinter out)
        {
            long B = in.nextLong();
            long G = in.nextLong();
            long T = in.nextLong();

            long res = 0;
            for (long b = 4; b <= B && (T - b) >= 1; b++)
            {
                long g = T - b;
                if (g > G)
                {
                    continue;
                }
                res += ncr(B, b) * ncr(G, g);
            }
            out.println(res);
        }

        private long ncr(long n, long r)
        {
            long res = 1;
            r = Math.min(r, n - r);

            if (r == 0)
            {
                return res;
            }
            for (int i = 1; i <= r; i++, n--)
            {
                res *= n;
            }
            for (int i = 1; i <= r; i++, r--)
            {
                res /= r;
            }
            return res;
        }

    }

    static class FastPrinter extends PrintWriter
    {
        public FastPrinter(OutputStream out)
        {
            super(out);
        }

        public FastPrinter(Writer out)
        {
            super(out);
        }

    }

    static class FastScanner
    {
        public BufferedReader br;
        public StringTokenizer st;

        public FastScanner(InputStream is)
        {
            br = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        public String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                String s = null;
                try
                {
                    s = br.readLine();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        public long nextLong()
        {
            return Long.parseLong(next());
        }

    }
}

/*	/ ﾌﾌ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ム
	/ )\⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀  Y
	(⠀⠀| ( ͡° ͜ʖ ͡°）⠀⌒(⠀ ノ
	(⠀ ﾉ⌒ Y ⌒ヽ-く __／
	| _⠀｡ノ| ノ｡ |/
	(⠀ー '_人`ー ﾉ
	⠀|\ ￣ _人'彡ﾉ
	⠀ )\⠀⠀ ｡⠀⠀ /
	⠀⠀(\⠀ #⠀ /
	⠀/⠀⠀⠀/ὣ====================D-
	/⠀⠀⠀/⠀ \ \⠀⠀\
	( (⠀)⠀⠀⠀⠀ ) ).⠀)
	(⠀⠀)⠀⠀⠀⠀⠀( | /
	|⠀ /⠀⠀⠀⠀⠀⠀ | /
	[_] ⠀⠀⠀⠀⠀[___]                     */
// Main Code at the Bottom
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;
public class Main {
	//Fast IO class
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        public FastReader() {
        	boolean env=System.getProperty("ONLINE_JUDGE") != null;
        	if(!env) {
        		try {
					br=new BufferedReader(new FileReader("src\\input.txt"));
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				}
        	}
        	else br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    static long MOD=1000000000+7;
    //Euclidean Algorithm
    static long gcd(long A,long B){
    	return (B==0)?A:gcd(B,A%B);
    }
    //Modular Exponentiation
    static long fastExpo(long x,long n){
        if(n==0) return 1;
        if((n&1)==0) return fastExpo((x*x)%MOD,n/2)%MOD;
        return ((x%MOD)*fastExpo((x*x)%MOD,(n-1)/2))%MOD;
    }
    //Modular Inverse
    static long inverse(long x) {
    	return fastExpo(x,MOD-2);
    }
    //Prime Number Algorithm
    static boolean isPrime(long n){
        if(n<=1) return false;
        if(n<=3) return true;
        if(n%2==0 || n%3==0) return false;
        for(int i=5;i*i<=n;i+=6) if(n%i==0 || n%(i+2)==0) return false;
        return true;
    }
    //Reverse an array
    static void reverse(int arr[],int l,int r){
    	while(l<r) {
    		int tmp=arr[l];
    		arr[l++]=arr[r];
    		arr[r++]=tmp;
    	}
    }
    //Print array
    static void print1d(int arr[]) {
    	out.println(Arrays.toString(arr));
    }
    static void print2d(long arr[][]) {
    	for(long a[]: arr) out.println(Arrays.toString(a));
    }
    // Pair
    static class pair{
    	long x,y;
    	pair(long a,long b){
    		this.x=a;
    		this.y=b;
    	}
    	public boolean equals(Object obj) {
    		if(obj == null || obj.getClass()!= this.getClass()) return false;
            pair p = (pair) obj;
            return (this.x==p.x && this.y==p.y);
        }
    	public int hashCode() {
            return Objects.hash(x,y);
        }
    }
    static FastReader sc=new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    //Main function(The main code starts from here)
    static long fact[]=new long[31];
    static long C(int n,int r) {
    	return fact[n]/(fact[r]*fact[n-r]);
    }
    public static void main (String[] args) throws java.lang.Exception {
    	int test=1;
    	fact[0]=1L;
    	for(int i=1;i<=30;i++) fact[i]=(long)i*fact[i-1];
        while(test-->0) {
        	int n=sc.nextInt(),m=sc.nextInt(),t=sc.nextInt();
        	long ans=0;
        	for(int i=4;i<=n;i++) {
        		for(int j=1;j<=m;j++) {
        			if(i+j==t) {
        				ans+=C(n,i)*C(m,j);
        			}
        		}
        	}
        	out.println(ans);

        }
        out.flush();
        out.close();
    }
}

import java.util.*;
public class EXER {
    public static void main(String[]args){
        Scanner sc= new Scanner(System.in);
        int n1= sc.nextInt();
        int m1=sc.nextInt();
        int k1=sc.nextInt();
        long  [][] C= new long[70][70];
        for(int i=1;i<60;i++){
            C[i][1]=i;
            C[i][0]=1;
        }
        for (int n=0; n<=60; ++n) {
            C[n][0] = C[n][n] = 1;
            for (int k=1; k<n; ++k)
                C[n][k] = C[n-1][k-1] + C[n-1][k];
        }
        int ans=0;
        for(int i=4;i<k1;i++){
            ans+=C[n1][i]*C[m1][k1-i];
        }
        System.out.println(ans);
    }

}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class C {

    public static void main(String... args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int t = sc.nextInt();

        HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
        for (int i=4; i<=n; i++) {
            for (int j=1; j<=m; j++){
                if (i+j==t)
                    hm.put(i, j);
            }
        }
        long result = 0;

        for(Map.Entry<Integer, Integer> e : hm.entrySet()) {

            long men = (f(n)/f(n-e.getKey()))/f(e.getKey());
            long women = (f(m)/f(m-e.getValue()))/f(e.getValue());

            result += men*women;
        }

        System.out.println(result);
    }

    public static long f(long n) {
        return n==0 ? n=1 : n*f(n-1);
    }

}

import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class C {

	private void processInput() throws IOException {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		long res = go(n, m, t);

		System.out.printf(Locale.ENGLISH, "%d\n", res);

		in.close();
	}

	private long go(int n, int m, int t) {

		long res = 0;

		for (int i = 4; i <= t - 1; i++) {

			long bb = binomial(n, i);

			for (int j = 1; j <= t - i; j++) {

				long ff = binomial(m, j);

				res += bb * ff;

			}

		}

		return res;
	}

    private long binomial(int n, int k) {
		long res = 1;
		for (int i = n - k + 1; i <= n; i++) {
			res *= i;
			res /= (i - n + k);
		}
		return res;
	}

	public static void main(String[] args) throws Exception {
		C a = new C();
		a.processInput();
	}
}

import java.util.Scanner;

public class TheWorldIsATheatre {
	public static void main(String args[]) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		int dp[][] = new int[101][5];
		int i,j;
		for (i = 0; i <= n; i++)
			dp[i][0] = 1;
		for (i = 1; i < 5; i++)
			dp[0][i] = 0;
		dp[0][0]=1;
		for(i=1;i<=n;i++)
			for(j=1;j<5;j++)
				dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
		System.out.println(dp[n][4]*m);
	}

}

import java.io.*;
import java.lang.*;
import java.util.*;
import java.util.ArrayList;
import java.text.DecimalFormat;

public class Main {
    public static void cout(String s)
    {
        System.out.println(s);

    }
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {

        	long n,m,t;
        	n=in.nextLong();
        	m=in.nextLong();
        	t=in.nextLong();
        	long ans=0;
        	long i,j;
        	for(i=4;i<=n;i++)
        		for(j=1;j<=m;j++)
        		{
        			if(i+j!=t)
        				continue;
        			ans+=c(n,i)*c(m,j);

        		}
        	System.out.println(ans);

        }
    }

    public static long c(long x,long y)
    {
    	long ans=1;
    	long i;
    	for(i=x;i>x-y;i--)
    		ans*=i;
    	for(i=1;i<=y;i++)
    		ans/=i;
    	return ans;
    }

}

import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
import java.util.*;

public class TaskC {

	static long nCr(int n , int k)
	{
		long res = 1;

		for(int i = n , j = 1; j <= n - k ; j++,i-- ) {
			res*=i;
		}

		long res2 = 1;

		for(int i = n-k ; i> 1;i--)
			res2*=i;

		return res / res2;
	}

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();

		long ans = 0;
		for(int i = 4 , j = t - m; j>=2;j--) {
			ans+=nCr(n, i)*nCr(m, j);
		}
		pw.print(ans);

		pw.flush();
		pw.close();
	}

	static class Pair implements Comparable<Pair> {
		int x, y;

		public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}

		public int compareTo(Pair o) {
			if (x == o.x)
				return y - o.y;
			return x - o.x;
		}

		public String toString() {
			return x + " " + y;
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return st.nextToken();
		}

		public boolean check() {
			if (!st.hasMoreTokens())
				return false;
			return true;
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public String nextLine() {
			try {
				return br.readLine();
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}

		public double nextDouble() {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() {
			try {
				return br.ready();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws FileNotFoundException, IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer input = new StringTokenizer(inp.readLine());
        PrintWriter output = new PrintWriter(
                new BufferedWriter(new OutputStreamWriter(System.out)));
        long n = Integer.parseInt(input.nextToken());
        long m = Integer.parseInt(input.nextToken());
        long t = Integer.parseInt(input.nextToken());
        output.println(CNM(n, 4) * CNM(m, 1) * CNM(n + m - 5, t));
        output.close();

    }

    public static long CNM(long n, long m) {
        if (n < m) {
            return 1;
        } else {
            long f1 = 1;
            long f2 = 1;
            for (int i = 1; i <= m; i++) {
                f1 *= (n - i + 1);
                f2 *= i;
            }
            return f1 / f2;
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.Scanner;

public class C {

    public int gcd(int a,int b){
        if (b == 0) return a;
        else return gcd(b, a%b);
    }
    public int c(int n,int r){
        int x = Math.max(r, n-r);

        int up=1,down=1;
        for (int i=n;i>x;i--){
            up *= i;
            down *= i-x;
            int v = gcd(up,down);
            up /= v;
            down /= v;
        }
        return up/down;
    }
    int n,m,t;
//  int[] a;
//  int x,y,z;
    char[] v = new char[]{'a', 'o', 'y', 'e', 'u', 'i'};
    public void run() throws IOException{
        Scanner s= new Scanner(new InputStreamReader(System.in));
        n = s.nextInt();m = s.nextInt(); t = s.nextInt();

        System.out.println(c(n,m));
        long sum = 0;
        for (int i = 4; i <= n; i++) {
            if (t - i < 1) break;
            sum += (long)c(n,i) * c(m,t-i);
        }
        System.out.println(sum);
    }

    public static void main(String[] args) throws IOException {
        (new C()).run();
    }

}

import java.util.Scanner;

public class TheWorldIsATheatre {
//  static long before=1;
/*  public static long fact(long n){
        long x=1;
        for(int i=1 ; i<=n ; i++){
            x*=i;
            if(i==n-4)
                before=x;
        }
        return x;
    } */
    public static long facto(long n){
        long x=1;
        for(int i=1 ; i<=n ; i++){
            x*=i;
        }
        return x;
    }
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        long n=sc.nextLong() , m=sc.nextLong() , t=sc.nextLong();
        boolean com=true;
        long sum=0;
        for(int i=4 ; i<=t-1 && i<=n ; i++){
            if(m>=t-i)
                sum+=facto(n)/(facto(i)*facto(n-i))*facto(m)/(facto(t-i)*facto(m-t+i));
        }
        System.out.println(sum);
    }
}

import java.io.*;
import java.util.*;
import java.util.function.*;

public class Main {

    static BiFunction<Integer, Integer, Integer> ADD = (x, y) -> (x + y);

    static Function<Pair<Integer, Integer>, Integer> GET_FIRST = (x) -> (x.first);
    static Function<Pair<Integer, Integer>, Integer> GET_SECOND = (x) -> (x.second);
    static Comparator<Pair<Integer, Integer>> C = Comparator.comparing(GET_FIRST).thenComparing(GET_SECOND);

    public static void main(String[] args) throws Exception {
        long startTime = System.nanoTime();
        int t = 1;
        while (t-- > 0) {
            solve();
        }
        long endTime = System.nanoTime();
        err.println("Execution Time : +" + (endTime - startTime) / 1000000 + " ms");
        exit(0);
    }

    static void solve() {
        long ans = 0;
        int n = in.nextInt();
        int m = in.nextInt();
        int t = in.nextInt();
        for(int i=1;i+4<=t;i++){
            ans += C(m,i)*C(n,t-i);
        }
        out.println(ans);
    }

    static long C(long n,long k){
        long num = 1;
        long denom = 1;
        if(k>n/2){
            k = n-k;
        }
        long x = k;
        for(int i=1;i<=k;i++){
            num*=n;
            n--;
            denom*=x;
            x--;
            long temp = gcd(num,denom);
            num/=temp;
            denom/=temp;
        }
        return num/denom;
    }

    //GCD Long
  static long gcd(long a,long b)
  {
     while(b!=0)
     {
       long t=b;
       b=a%b;
       a=t;
     }
     return a;
  }

    static void debug(Object... args) {
        for (Object a : args) {
            out.println(a);
        }
    }

    static void y() {
        out.println("YES");
    }

    static void n() {
        out.println("NO");
    }

    static void fail() {
        out.println("-1");
    }

     static class Pair<T, R> {
        public T first;
        public R second;

        public Pair(T first, R second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public boolean equals(final Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            final Pair<?, ?> pair = (Pair<?, ?>) o;
            return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
        }

        @Override
        public int hashCode() {
            return Objects.hash(first, second);
        }

        @Override
        public String toString() {
            return "Pair{" + "a=" + first + ", b=" + second + '}';
        }

        public T getFirst() {
            return first;
        }

        public R getSecond() {
            return second;
        }
    }

    static <T, R> Pair<T, R> make_pair(T a, R b) {
        return new Pair<>(a, b);
    }

    static class ArrayUtils {

        static int[] reverse(int[] data) {
            int[] p = new int[data.length];
            for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
                p[i] = data[j];
            }
            return p;
        }

        static void prefixSum(long[] data) {
            for (int i = 1; i < data.length; i++) {
                data[i] += data[i - 1];
            }
        }

        static void prefixSum(int[] data) {
            for (int i = 1; i < data.length; i++) {
                data[i] += data[i - 1];
            }
        }

        static long[] reverse(long[] data) {
            long[] p = new long[data.length];
            for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
                p[i] = data[j];
            }
            return p;
        }

        static char[] reverse(char[] data) {
            char[] p = new char[data.length];
            for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
                p[i] = data[j];
            }
            return p;
        }

        static int[] MergeSort(int[] A) {
            if (A.length > 1) {
                int q = A.length / 2;
                int[] left = new int[q];
                int[] right = new int[A.length - q];
                System.arraycopy(A, 0, left, 0, q);
                System.arraycopy(A, q, right, 0, A.length - q);
                int[] left_sorted = MergeSort(left);
                int[] right_sorted = MergeSort(right);
                return Merge(left_sorted, right_sorted);
            } else {
                return A;
            }
        }

        static int[] Merge(int[] left, int[] right) {
            int[] A = new int[left.length + right.length];
            int i = 0;
            int j = 0;
            for (int k = 0; k < A.length; k++) {
                // To handle left becoming empty
                if (i == left.length && j < right.length) {
                    A[k] = right[j];
                    j++;
                    continue;
                }
                // To handle right becoming empty
                if (j == right.length && i < left.length) {
                    A[k] = left[i];
                    i++;
                    continue;
                }
                if (left[i] <= right[j]) {
                    A[k] = left[i];
                    i++;
                } else {
                    A[k] = right[j];
                    j++;
                }
            }
            return A;
        }

        static long[] MergeSort(long[] A) {
            if (A.length > 1) {
                int q = A.length / 2;
                long[] left = new long[q];
                long[] right = new long[A.length - q];
                System.arraycopy(A, 0, left, 0, q);
                System.arraycopy(A, q, right, 0, A.length - q);
                long[] left_sorted = MergeSort(left);
                long[] right_sorted = MergeSort(right);
                return Merge(left_sorted, right_sorted);
            } else {
                return A;
            }
        }

        static long[] Merge(long[] left, long[] right) {
            long[] A = new long[left.length + right.length];
            int i = 0;
            int j = 0;
            for (int k = 0; k < A.length; k++) {
                // To handle left becoming empty
                if (i == left.length && j < right.length) {
                    A[k] = right[j];
                    j++;
                    continue;
                }
                // To handle right becoming empty
                if (j == right.length && i < left.length) {
                    A[k] = left[i];
                    i++;
                    continue;
                }
                if (left[i] <= right[j]) {
                    A[k] = left[i];
                    i++;
                } else {
                    A[k] = right[j];
                    j++;
                }
            }
            return A;
        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public int[] readAllInts(int n) {
            int[] p = new int[n];
            for (int i = 0; i < n; i++) {
                p[i] = in.nextInt();
            }
            return p;
        }

        public int[] readAllInts(int n, int s) {
            int[] p = new int[n + s];
            for (int i = s; i < n + s; i++) {
                p[i] = in.nextInt();
            }
            return p;
        }

        public long[] readAllLongs(int n) {
            long[] p = new long[n];
            for (int i = 0; i < n; i++) {
                p[i] = in.nextLong();
            }
            return p;
        }

        public long[] readAllLongs(int n, int s) {
            long[] p = new long[n + s];
            for (int i = s; i < n + s; i++) {
                p[i] = in.nextLong();
            }
            return p;
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    static void exit(int a) {
        out.close();
        err.close();
        System.exit(a);
    }

    static InputStream inputStream = System.in;
    static OutputStream outputStream = System.out;
    static OutputStream errStream = System.err;
    static InputReader in = new InputReader(inputStream);
    static PrintWriter out = new PrintWriter(outputStream);
    static PrintWriter err = new PrintWriter(errStream);
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

}

import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
import java.util.*;

public class TaskC {

	static long nCr(int n, int k) {
		long res = 1;

		for (int i = n, j = 1; j <= n - k; j++, i--) {
			res *= (i * 1l);
		}
		long res2 = 1;

		for (int i = n - k; i > 1; i--)
			res2 *= (i * 1l);
		// System.out.println(res + " "+res2);
		return res / res2;
	}

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();

		long ans = 0;
		for (int i = 4, j = t - i; j >= 1; j--, i++) {
			ans += nCr(n, i) * nCr(m, j);
		}
		pw.print(ans);
		// System.out.println(nCr(4, 4));
		pw.flush();
		pw.close();
	}

	static class Pair implements Comparable<Pair> {
		int x, y;

		public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}

		public int compareTo(Pair o) {
			if (x == o.x)
				return y - o.y;
			return x - o.x;
		}

		public String toString() {
			return x + " " + y;
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return st.nextToken();
		}

		public boolean check() {
			if (!st.hasMoreTokens())
				return false;
			return true;
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public String nextLine() {
			try {
				return br.readLine();
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}

		public double nextDouble() {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() {
			try {
				return br.ready();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
	}
}

import java.io.*;
import java.util.*;
import java.math.*;

import static java.lang.Math.*;

public class Main implements Runnable {

    StreamTokenizer in;
    BufferedReader reader;
    PrintWriter out;
    StringTokenizer tok;
    Scanner sc;
    boolean timus = System.getProperty("ONLINE_JUDGE") != null;
    boolean codeforces = true;
    final double eps = 1e-9;

    public static void main(String[] args) throws Exception {
        new Thread(new Main()).start();
    }

    @Override
    public void run() {
        try {
            if (codeforces) {
                sc = new Scanner(System.in);
                reader = new BufferedReader(new InputStreamReader(System.in));
                in = new StreamTokenizer(reader);
                out = new PrintWriter(new OutputStreamWriter(System.out));
                tok = new StringTokenizer("");
                solve();
                out.flush();
            } else if (timus) {
                sc = new Scanner("input.txt");
                reader = new BufferedReader(new FileReader("input.txt"));
                in = new StreamTokenizer(reader);
                out = new PrintWriter(new FileWriter("output.txt"));
                tok = new StringTokenizer("");
                solve();
                out.flush();
                out.close();
            } else if (!timus) {
                long begMem = Runtime.getRuntime().totalMemory()
                        - Runtime.getRuntime().freeMemory();
                long t1 = System.currentTimeMillis();
                reader = new BufferedReader(new InputStreamReader(System.in));
                in = new StreamTokenizer(reader);
                sc = new Scanner(System.in);
                out = new PrintWriter(new OutputStreamWriter(System.out));
                tok = new StringTokenizer("");
                solve();
                long endMem = Runtime.getRuntime().totalMemory()
                        - Runtime.getRuntime().freeMemory();
                out.flush();
                long t2 = System.currentTimeMillis();
                System.out.println("Time:" + (t2 - t1));
                System.out.println("Memory:" + (endMem - begMem));
                System.out.println("Total memory: "
                        + (Runtime.getRuntime().totalMemory() - Runtime
                                .getRuntime().freeMemory()));
            }
        } catch (Exception ex) {
            System.out.println("fail");
            System.exit(1);
        }
    }

    public class Chess {
        String coord;

        public Chess(String s) {
            this.coord = s;
        }

        public int toInteger(char s) {
            if (s == 'a' || s == 'A')
                return 1;
            else if (s == 'b' || s == 'B')
                return 2;
            else if (s == 'c' || s == 'C')
                return 3;
            else if (s == 'd' || s == 'D')
                return 4;
            else if (s == 'e' || s == 'E')
                return 5;
            else if (s == 'f' || s == 'F')
                return 6;
            else if (s == 'g' || s == 'G')
                return 7;
            else if (s == 'h' || s == 'H')
                return 8;
            else
                return -1;
        }

        public String toString(int s) {
            if (s == 1)
                return "a";
            else if (s == 2)
                return "b";
            else if (s == 3)
                return "c";
            else if (s == 4)
                return "d";
            else if (s == 5)
                return "e";
            else if (s == 6)
                return "f";
            else if (s == 7)
                return "g";
            else if (s == 8)
                return "h";
            else
                return "0";
        }

        public pair getPair() {
            String j = "";
            j += coord.charAt(1);
            pair p = new pair(toInteger(coord.charAt(0)), Integer.parseInt(j));
            if (p.x != -1)
                return p;
            else
                return new pair(0, 0);
        }

        public String returnPair(pair p) {
            return toString(p.x) + p.y;
        }
    }

    public int nextInt() throws Exception {
        in.nextToken();
        return (int) in.nval;
    }

    public String next() throws Exception {
        in.nextToken();
        return in.sval;
    }

    public String nextLine() throws Exception {
        return reader.readLine();
    }

    public String nextString() throws Exception {
        while (!tok.hasMoreTokens())
            tok = new StringTokenizer(reader.readLine());
        return tok.nextToken();
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextString());
    }

    public double nextDouble() throws Exception {
        in.nextToken();
        return in.nval;
    }

    public class pair {
        int x;
        int y;

        public pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    public int gcd(int a, int b) {
        if (a == 0 || b == 0)
            return 1;
        if (a < b) {
            int c = b;
            b = a;
            a = c;
        }
        while (a % b != 0) {
            a = a % b;
            if (a < b) {
                int c = b;
                b = a;
                a = c;
            }
        }
        return b;
    }

    public int pow(int a, int n) {
        if (n == 0)
            return 1;
        int k = n, b = 1, c = a;
        while (k != 0) {
            if (k % 2 == 0) {
                k /= 2;
                c *= c;
            } else {
                k--;
                b *= c;
            }
        }
        return b;
    }

    public int lcm(int a, int b) {
        return a * b / gcd(a, b);
    }

    public class pairs implements Comparable<pairs> {
        int x;
        int y;

        public pairs(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(pairs obj) {
            if (this.x < ((pairs) obj).x)
                return 1;
            else if (this.x == (obj).x && this.y < (obj).y)
                return 1;
            else if (this.x == (obj).x && this.y == (obj).y)
                return 0;
            else
                return -1;
        }
    }

    public class Graf {

        int[][] a;
        int[] colors;
        ArrayList<String> points = new ArrayList<String>();
        LinkedList<Integer> queue = new LinkedList<Integer>();
        boolean[] used;
        boolean cycle;
        int numberOfCycle;

        public Graf(int[][] a, String s[]) {
            this.a = new int[s.length][s.length];
            this.a = a;
            this.colors = new int[s.length];
            this.used = new boolean[s.length];
            for (int i = 0; i < s.length; i++) {
                this.colors[i] = 0;
                this.points.add(s[i]);
            }
            Arrays.fill(this.used, false);
        }

        public void bfs(int i) {
            this.queue.add(i);
            while (!this.queue.isEmpty()) {
                i = this.queue.pop();
                out.print(points.get(i) + " ");
                this.used[i] = true;
                for (int j = 0; j < this.points.size(); j++) {
                    if (this.a[i][j] == 1 && !this.queue.contains(j)
                            && !this.used[j]) {
                        this.a[i][j] = 0;
                        this.a[j][i] = 0;
                        this.queue.addLast(j);
                    }
                }
            }
        }

        public void dfs(int i) {
            this.colors[i] = 1;
            out.print(points.get(i) + " ");
            for (int j = 0; j < this.colors.length; j++) {
                if (this.a[i][j] == 1 && this.colors[j] == 0) {
                    this.colors[j] = 1;
                    this.a[i][j] = 0;
                    this.a[j][i] = 0;
                    dfs(j);
                } else if (this.a[i][j] == 1 && this.colors[j] == 1) {
                    this.cycle = true;
                    this.numberOfCycle++;
                }
            }
            this.colors[i] = 2;
        }
    }

    public class Time {

        int h;
        int min;
        int sec;

        public Time(String s) {
            String[] st = s.split(":");
            this.h = Integer.parseInt(st[0]);
            this.min = Integer.parseInt(st[1]);
            this.sec = (st[2] != null) ? Integer.parseInt(st[2]) : 0;
        }

        public String toString(int a) {
            String h = Integer.toString(this.h);
            String min = Integer.toString(this.min);
            String sec = Integer.toString(this.sec);
            if (h.length() == 1) {
                h = '0' + h;
            }
            if (min.length() == 1) {
                min = '0' + min;
            }
            if (sec.length() == 1) {
                sec = '0' + sec;
            }
            if (a == 5) {
                return h + ":" + min;
            } else {
                return h + ":" + min + ":" + sec;
            }
        }

        public void to12HoursFormat() {
            h %= 12;
        }

        public void add(int h, int min, int s) {
            this.sec += s;
            if (this.sec >= 60) {
                this.min++;
                this.sec %= 60;
            }
            this.min += min;
            if (this.min >= 60) {
                this.h++;
                this.min %= 60;
            }
            this.h += h;
            if (this.h >= 24) {
                this.h %= 24;
            }
        }
    }

    public int[] findPrimes(int x) {
        boolean[] erat = new boolean[x - 1];
        List<Integer> t = new ArrayList<Integer>();
        int l = 0, j = 0;
        for (int i = 2; i < x; i++) {
            if (erat[i - 2])
                continue;
            t.add(i);
            l++;
            j = i * 2;
            while (j < x) {
                erat[j - 2] = true;
                j += i;
            }
        }
        int[] primes = new int[l];
        Iterator<Integer> iterator = t.iterator();
        for (int i = 0; iterator.hasNext(); i++) {
            primes[i] = iterator.next().intValue();
        }
        return primes;
    }

    public double dist(pair a, pair b) {
        return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    }

    public static int[] prefixFunction(String s) {
        int n = s.length();
        int[] p = new int[n];
        for (int i = 1; i < n; i++) {
            int k = p[i - 1];
            while (k > 0 && s.charAt(k) != s.charAt(i)) {
                k = p[k - 1];
            }
            p[i] = k + (s.charAt(k) == s.charAt(i) ? 1 : 0);
        }
        return p;
    }

    public long viborka(int n, int i) {
        if (i > n - i) {
            long ch = 1;
            for (int j = i + 1; j <= n; j++) {
                ch *= j;
            }
            long znam = 1;
            for (int j = 1; j <= n - i; j++) {
                znam *= j;
            }
            return ch / znam;
        } else {
            long ch = 1;
            for (int j = n - i + 1; j <= n; j++) {
                ch *= j;
            }
            long znam = 1;
            for (int j = 1; j <= i; j++) {
                znam *= j;
            }
            return ch / znam;
        }
    }

    public void solve() throws Exception {
        int n = nextInt();
        int m = nextInt();
        int t = nextInt();
        long c[][] = new long[t+100][t+100];
        c[0][0] = 1;
        c[0][1] = 1;
        for (int i = 1; i<t+2; i++) {

            for (int j = 0;j<t+2;j++) {
                c[i][j] = c[i-1][j];
            }

            c[i][i+1]=1;

            for (int j = i; j >= 1; j--) {
                c[i][j] = c[i][j-1] + c[i][j];
            }

        }
        long ans = 0;
        for (int i = 4; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (t != i + j)
                    continue;
                ans += c[n-1][i] * c[m-1][j];
            }
        }
        out.println(ans);
    }
}

import java.math.BigInteger;
import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class doubt
{

		private static BigInteger computeFact(long num)
		  {
			BigInteger factorial = BigInteger.ONE;
		    for (int i =1 ;i<(int)num ;i++)
		      {
		    	factorial = factorial.multiply(BigInteger.valueOf(i));
		      }
		          return factorial;
		    }

	private static BigInteger computeCombination(long n, long r)
	{
		BigInteger nFact=computeFact(n);
		BigInteger rFact=computeFact(r);
		BigInteger nMinusRFact=computeFact(n-r);
		//System.out.println(computeFact(n) +" " + computeFact(r) + " " +computeFact(n-r) +" "+ nFact/(rFact*nMinusRFact));
		return nFact.divide(rFact.multiply(nMinusRFact));

	}
	private static BigInteger computeNumOfWays(long n,long m, long t)
	{ BigInteger ans=BigInteger.ZERO;
		if(t<5)
		{
			return BigInteger.ZERO;
		}
		if(t==5)
		{
			return computeCombination(n, 4).multiply(computeCombination(m, 1));
		}
		else
		{
			for(long i=4; i<=t-1 ;i++)
			{   if(n<i)
				ans=ans.add( computeCombination(m, t-(i-1)));

			    if(m < t-i)
			    	ans=ans.add(computeCombination(n, i+1));
			  //  System.out.println(computeCombination(n, i) + "  " + computeCombination(m, t-i));
			    if(n>i && m>t-i)
				ans=ans.add( computeCombination(n, i).multiply( computeCombination(m, t-i)));
			}
          return ans;
		}
	}
	public static void main(String[] args) {
		Scanner s= new Scanner(System.in);
		long n= s.nextLong();
		long m= s.nextLong();
		long t= s.nextLong();

		System.out.println(computeNumOfWays(n,m,t));

	}
}

import java.util.Scanner;

public class P131C
{

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		int[][] pascalFactors = new int[m+n+1][m+n+1];
		for (int i=0; i<=m+n; i++)
			pascalFactors[i][0] = pascalFactors[i][i] = 1;

		for (int i=2; i<=m+n; i++)
			for (int j=1; j<i; j++)
				pascalFactors[i][j] = pascalFactors[i-1][j-1] + pascalFactors[i-1][j];
		int answer = 0;
		for (int i=0; i<=t-5; i++)
		{
			answer += pascalFactors[n][4+i] * pascalFactors[m][t-4-i];
		}
		System.out.println(answer);

	}
//	public static long combinication (int y, int x)
//	{
//		int a = Math.max(x-y, y);
//		int b = Math.min(x-y, y);
//		long answer = 1;
//		for (int i= a+1; i<=x; i++)
//			answer *= i;
//		for (int i = 2; i <= b; i++)
//			answer /= i;
//		return answer;
//	}

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import static java.lang.Math.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map.Entry;
import java.util.StringTokenizer;
import java.util.TreeMap;

/**
 *
 * @author pttrung
 */
public class C {

    public static double Epsilon = 1e-6;
    public static long x, y, d;
    public static long MOD = 1000000007;
    public static long[][] dp;
    public static int min, max, need;

    public static void main(String[] args) {

        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        int m = in.nextInt();
        int t = in.nextInt();
        long result = 0;
        for(int i = 4; i <= Math.min(t-1 , n); i++){
            int a = t - i;
            if(a <= m){
                result += cal(i , n)*cal(a,m);
            }
        }
        out.println(result);

        out.close();

    }

    public static long cal(int select , int total){
        long result = 1;
        for(int i = total ; i > select; i --){
            result *= i;
        }
        for(int i = 1; i <= (total - select); i++){
            result /= i;
        }
        return result;
    }

    public static void extendEuclid(long a, long b) {
        if (b == 0) {
            x = 1;
            y = 0;
            d = a;
            return;
        }
        extendEuclid(b, a % b);
        long x1 = y;
        long y1 = x - (a / b) * y;
        x = x1;
        y = y1;

    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    static class Line {

        double a, b, c;

        Line(double x1, double y1, double x2, double y2) {
            if (Math.abs(x1 - x2) < Epsilon && Math.abs(y1 - y2) < Epsilon) {
                throw new RuntimeException("Two point are the same");
            }
            a = y1 - y2;
            b = x2 - x1;
            c = -a * x1 - b * y1;
        }

        Line(Point x, Point y) {
            this(x.x, x.y, y.x, y.y);
        }

        public Line perpendicular(Point p) {
            return new Line(p, new Point(p.x + a, p.y + b));
        }

        public Point intersect(Line l) {
            double d = a * l.b - b * l.a;
            if (d == 0) {
                throw new RuntimeException("Two lines are parallel");
            }

            return new Point((l.c * b - c * l.b) / d, (l.a * c - l.c * a) / d);
        }
    }

    static void check(Point a, Point b, ArrayList<Point> p, Point[] rec, int index) {
        for (int i = 0; i < 4; i++) {
            int m = (i + index) % 4;
            int j = (i + 1 + index) % 4;
            Point k = intersect(minus(b, a), minus(rec[m], rec[j]), minus(rec[m], a));
            if (k.x >= 0 && k.x <= 1 && k.y >= 0 && k.y <= 1) {
                Point val = new Point(k.x * minus(b, a).x, k.x * minus(b, a).y);
                p.add(add(val, a));
                // System.out.println(a + " " + b + " " + rec[i] + " " + rec[j]);
                // System.out.println(add(val, a));
            }
        }
    }

    static Point intersect(Point a, Point b, Point c) {
        double D = cross(a, b);
        if (D != 0) {
            return new Point(cross(c, b) / D, cross(a, c) / D);
        }
        return null;
    }

    static Point convert(Point a, double angle) {
        double x = a.x * cos(angle) - a.y * sin(angle);
        double y = a.x * sin(angle) + a.y * cos(angle);
        return new Point(x, y);
    }

    static Point minus(Point a, Point b) {
        return new Point(a.x - b.x, a.y - b.y);
    }

    static Point add(Point a, Point b) {
        return new Point(a.x + b.x, a.y + b.y);
    }

    static double cross(Point a, Point b) {
        return a.x * b.y - a.y * b.x;
    }

    static class Point {

        double x, y;

        Point(double x, double y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "Point: " + x + " " + y;
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.io.*;
public class TheWorldTheatre {
	static PrintWriter out ;
	public TheWorldTheatre () throws IOException{
		BufferedReader read = new BufferedReader (new InputStreamReader (System.in));
		String input = read.readLine();
		String [] arr= input.split(" ");
		int n = Integer.parseInt(arr[0]);
		int m = Integer.parseInt (arr[1]);
		int t = Integer.parseInt (arr[2]);
		out.println(sum (n,m,t));
	}
	public int sum (int n , int m , int t ){
		int ans = 1;
		for (int i = 4 ; i <= n ; i++){
			int j = t-i ;
			if (j >= 1){
				ans *= calc(n,i)*calc(m,j);
			}
		}
		return ans;
	}
	public int calc (int n , int i){
		return factorial (n) / (factorial (n-i)*factorial(i)) ;
	}
	public int factorial (int n ){
		int sum = 1 ;
		for (int i = 2 ; i <=n ; i++){
			sum *= i ;
		}
		return sum ;
	}
	public static void main (String [] args){
		out = new PrintWriter (System.out);
		try {
			new TheWorldTheatre ();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		out.close();
	}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		int n = scan.nextInt();
		int m = scan.nextInt();
		int t = scan.nextInt();
		long[] facts = new long[n + m + 1];
		facts[0] = 1;
		facts[1] = 1;
		for (int i = 2; i < n + m + 1; i++)
			facts[i] = facts[i - 1] * i;
		long boys = facts[n] / (facts[4] * facts[n - 4]);
		long girls = m;
		long others = facts[n + m - 5] / (facts[t - 5] * facts[n + m - t]);

		System.out.println(boys * girls * others);

		scan.close();

	}
}

import java.io.*;
import java.util.*;

/**
 * @title
 */
public class ProblemC implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    public static void main(String[] args) {
        new Thread(null, new ProblemC(), "", 256 * (1L << 20)).start();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            Locale.setDefault(Locale.US);
            solve();
            in.close();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (IOException t) {
            t.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }
    // solution

    void solve() throws IOException {
        int n=readInt();
        int m=readInt();
        int t=readInt();
        long count = 0;
        long res1 = 1,res2 = 1;
        boolean[] divisionDone = new boolean[31];
        for (int i = 4; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if(i+j==t) {
                    if(n-i >= i) {
                        for (int k = n - i +1; k <= n; k++) {
                            res1 *= (long)k;
                            if(i>=2) {
                                for (int l = 2; l <= i; l++) {
                                    if (res1 % l == 0 && !divisionDone[l]) {
                                        res1 /= (long) l;
                                        divisionDone[l] = true;
                                    }
                                }
                            }
                        }

                    }
                    else {
                        for (int k = i+1; k <= n; k++) {
                            res1 *= (long)k;
                            if(n-i>=2) {
                                for (int l = 2; l <= n-i; l++) {
                                    if (res1 % l == 0 && !divisionDone[l]) {
                                        res1 /= (long) l;
                                        divisionDone[l] = true;
                                    }
                                }
                            }
                        }
                    }
                    Arrays.fill(divisionDone,false);
                    if(m-j >= j) {
                        for (int k = m - j +1; k <= m; k++) {
                            res2 *= (long)k;
                            if(j>=2) {
                                for (int l = 2; l <= j; l++) {
                                    if (res2 % l == 0 && !divisionDone[l]) {
                                        res2 /= (long) l;
                                        divisionDone[l] = true;
                                    }
                                }
                            }
                        }

                    }
                    else {
                        for (int k = j+1; k <= m; k++) {
                            res2 *= (long)k;
                            if(m-j>=2){
                                for (int l = 2; l <= m-j; l++) {
                                    if(res2%l == 0 && !divisionDone[l]) {
                                        res2 /= (long)l;
                                        divisionDone[l] = true;
                                    }
                                }
                            }
                        }
                    }
                    count += res1*res2;
                    res1=res2=0;
                    Arrays.fill(divisionDone,false);
                }
                else
                    break;
            }
        }
        out.println(count);
    }

}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Task131C {

	public static void main(String... args) throws NumberFormatException,
			IOException {
		Solution.main(System.in, System.out);
	}

	static class Solution {

		static long combinations(int n, int k) {
			long retVal = 1;
			for (int i = 1; i <= k; i++) {
				retVal *= (n - i) / i;
			}
			return retVal;
		}

		public static void main(InputStream is, OutputStream os)
				throws NumberFormatException, IOException {
			PrintWriter pw = new PrintWriter(os);
			Scanner s = new Scanner(is);

			int n = s.nextInt();
			int m = s.nextInt();
			int t = s.nextInt();

			long retVal = 0;

			for (int boys = 4; boys <= n; boys++) {
				retVal += combinations(n, boys) * combinations(m, t - boys);
			}

			pw.println(retVal);

			pw.flush();
			s.close();
		}
	}

}

import java.util.Scanner;

public class TheWorldIsATheatre {

	public static void main (String[]args) {

		Scanner sc = new Scanner(System.in);
		int magic = 60;
		int total = 0;
		int n = sc.nextInt();
		int m = sc.nextInt();
		int o = sc.nextInt();
		int[][] track = new int[magic][magic];
		track[0][0] = 1;
		for (int i = 2; i < magic; i++) {
			for (int j = 1; j < i+1; j++) {
				track[i][j] = track[i-1][j] + track[i-1][j-1];
			}
		}

		for (int i = 5; i < n+1; i++) {
			if ((o-i) < 1) {
				continue;
			}
			total += track[m][o-i] * track[n][i];
		}
		System.out.println(total);
	}

}

import java.util.Scanner;

public class Theatre {
	static int n;
	static int m;
	static int t;

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		//Scanner scanner = new Scanner("25 30 30");
		n=scanner.nextInt();
		m=scanner.nextInt();
		t=scanner.nextInt();
		System.out.println(combination(t, n+m)-combination(t, n)-combination(3, n)*combination(t-3, m)-combination(2, n)*combination(t-2, m)-combination(1, n)*combination(t-1, m)-combination(t, m));
	}

private static long fact(int n) {
	long s=1;
	for (int i=1; i<=n; i++) {
		s*=i;
	}
	return s;
}

private static long combination(int k, int n) {
	if (k>n) return 0;
	if (n<=10) return fact(n)/(fact(k)*fact(n-k)); else {
		if (k<=n/2) {
			long s=1;
			long p=fact(k);
			for (int j=n-k+1; j<=n; j++) {
				long t=nod(p,j);
				p=p/t;
				s=(s*j)/t;
				}
			return s/p;
			}

		else {
			long s=1;
			long p=fact(n-k);
			for (int j=k+1; j<=n; j++) {
				long t=nod(p,j);
				p=p/t;
				s=s*j/t;
			}
			return s/p;
		}
	}
}
private static long nod(long a, long b) {
	if (a==b) return a; else {
		if (a>b) {
			if (a>10000) {
				if (a%b==0) return b; else return 1;
			} else
				return nod(a-b, b);
			} else {
				if (b>10000) {
					if (b%a==0) return a; else return 1;
				} else
					return nod(a, b-a);
				}
		}
	}
}

/**
 * Created by IntelliJ IDEA.
 * User: Taras_Brzezinsky
 * Date: 11/25/11
 * Time: 5:48 PM
 * To change this template use File | Settings | File Templates.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;

public class TaskC extends Thread {
    public TaskC(int type) {
        try {
            if (type == 0) {
                this.input = new BufferedReader(new InputStreamReader(System.in));
                this.output = new PrintWriter(System.out);
            } else {
                this.input = new BufferedReader(new FileReader(INPUT_FILE));
                this.output = new PrintWriter(OUTPUT_FILE);
            }
            this.setPriority(Thread.MAX_PRIORITY);
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(666);
        }
    }

    private void solve() throws Throwable {
        long C[][] = new long[61][61];
        for (int i = 0; i < C.length; ++i) {
            C[i][0] = C[i][i] = 1;
            for (int j = 1; j < i; ++j) {
                C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
            }
        }

        int n = nextInt(), m = nextInt(), t = nextInt();
        long result = C[n][4] * C[m][1] * C[n - 4 + m - 1][t - 5];
        output.println(result);
    }

    public void run() {
        try {
            solve();
        } catch (Throwable e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.exit(666);
        } finally {
            output.flush();
            output.close();
        }
    }

    public static void main(String[] args) {
        new TaskC(0).start();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private static final String INPUT_FILE = null;
    private static final String OUTPUT_FILE = null;
    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}

import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        long n = in.nextLong();
        long m = in.nextLong();
        long t = in.nextLong();
        long result = 0;
        for (int i = 4; i < t; i++) {
            result += Combi(n, i) * Combi(m, t - i);
        }
        out.println(result);
    }

    long Combi(long n, long k) {
        long result = 1;
        int max = (int) Math.max(k, n - k);
        int min = (int) n - max;
        for (int i = max + 1; i <= n; i++) {
            result *= i;
        }
        for (int i = 1; i <= min; i++) {
            result /= i;
        }
        return result;
    }
}

class InputReader {
    StringTokenizer tokenizer;
    BufferedReader reader;

    public InputReader(InputStream stream) {
        tokenizer = null;
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public long nextLong() {
        return Long.parseLong(next());
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class C {

	static long[][] dp;
	public static long ncr(int n, int r) {
		if (n == 0)
			return 0;
		if (r == 0)
			return 1;
		if(dp[n][r] != -1)
			return dp[n][r];
		return dp[n][r] = (ncr(n - 1, r - 1) + ncr(n - 1, r));
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int m = s.nextInt();
		int t = s.nextInt();
		dp = new long[n+m+1][t+1];
		for(long [] d: dp)
			Arrays.fill(d, -1);
		long ans = m * ncr(n, 4) * ncr(n+m-5, t-5);
		System.out.println(ans);
	}

}

import java.util.*;
import java.io.*;
import java.math.*;
public class A
{
      public static void main(String ar[]) throws Exception
      {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String s1[]=br.readLine().split(" ");
            long n=Long.parseLong(s1[0]);
            long m=Long.parseLong(s1[1]);
            long t=Long.parseLong(s1[2]);

            BigInteger b[]=new BigInteger[61];
            b[0]=new BigInteger("1");
            b[1]=new BigInteger("1");
            for(int i=2;i<=60;i++)
            {
                  b[i]=BigInteger.valueOf(i);
                  b[i]=b[i].multiply(b[i-1]);
            }

            long l1=(n*(n-1)*(n-2)*(n-3))/24 ;

            BigInteger b1=b[(int)(n+m-5)];
            BigInteger b2=b[(int)(n+m-t)];
            BigInteger b3=b[(int)(t-5)];
            b2=b2.multiply(b3);
            b1=b1.divide(b2);

            long l3=b1.longValue();
            System.out.println(l1*m*l3);
      }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
//package codeforces95;

import java.util.Scanner;

/**
 *
 * @author DELL
 */
public class problemC {

    public static long fac(long a) {
        long fact=1;
        for (long i = 1; i <= a; i++) {
            fact = fact * i;
        }
        return fact;
    }

    public static long ansC(long nm ,long a){

        return fac(nm)/(fac(nm-a)*fac(a));

    }

    public static void solve() {

        Scanner nera = new Scanner(System.in);

        long n =nera.nextInt();
        long m = nera.nextInt();
        long t = nera.nextInt();

        long i=4,count=0,l=0;
        while(i<t){
            count = count+(ansC(n, i)*ansC(m, t-i));
            i++;
        }

        System.out.println(count);

    }

    public static void main(String[] args) {

        solve();
    }
}

import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Collection;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class CF95C implements Runnable{

    public static void main(String args[]){
       new CF95C().run();
    }

    @Override
    public void run(){
        try{
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            tok = null;
            solve();
            in.close();
            out.close();

        }
        catch(IOException e){
            e.printStackTrace();
            System.exit(0);
        }
    }

    int nextInt()throws IOException{
        return Integer.parseInt(nextToken());
    }

    double nextDouble()throws IOException{
        return Double.parseDouble(nextToken());
    }

    long nextLong() throws IOException{
        return Long.parseLong(nextToken());
    }

    String nextToken()throws IOException{
        while(tok == null || !tok.hasMoreTokens()){
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok;
    //////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////
    private void solve()throws IOException{
      int[] factorial = new int[31];
      factorial[0] = 1;
      factorial[1] = 1;
      for(int i = 2; i <= 30; i++){
          factorial[i] = i * factorial[i - 1];
      }

      int nb = nextInt();
      int ng = nextInt();
      int n = nextInt();

      int res = 0;
      for(int b = 4; b <= nb; b++){
          for(int g = 1; g <= ng; g++){
              if(b + g == n){
                  res += (factorial[nb] / (factorial[nb - b] * factorial[b])) * (factorial[ng] / (factorial[ng - g] * factorial[g]));
              }
          }
      }
    out.println(res)  ;
    }

}

import java.util.Scanner;

public class Theatre {

	public static void main(String args[])
	{
		Scanner in = new Scanner(System.in);
		long n = in.nextLong();
		long m = in.nextLong();
		long t = in.nextLong();
		long answer = 0;

		for(long i = 4; i<t; i++)
		{
//			for(long j = 1; j<=t-i; j++)
			answer += comb(n,i)*comb(m,t-i);
		}
		System.out.println(answer);
	}

	public static long comb(long n, long r)
	{
		double a = 1;
		for(double i = r+1; i<=n; i++)
		{
			a*=i;
		}
		for(double i = 1; i<=n-r; i++)
		{
			a/=i;
		}
		long k = (long) Math.floor(a);
		return k;
	}
}

import java.io.*;
import java.util.*;
public class Task131C {

	PrintWriter out;
	BufferedReader input;
	Task131C() {
		input = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out,true);
		try {
			solver();
		} catch(Exception ex) {
			System.err.println(ex.getClass().getName() + " Cause: " + ex.getMessage());
		} finally {
			out.close();
			try {
				input.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	StringTokenizer st = new StringTokenizer("");
	private String nextToken() throws IOException{
		while (!st.hasMoreElements()) {
			st = new StringTokenizer(input.readLine());
		}
		return st.nextToken();
	}
	private int nextInt() throws IOException{
		return Integer.parseInt(nextToken());
	}
	long fact(long n) {
		long res = 1;
		for (int i = 1; i <= n; i++) {
			res *= i;
		}
		return res;
	}
	public void solver() throws IOException{
		int n = nextInt();
		int m = nextInt();
		int t = nextInt();

		long[][] c = new long[31][31];

		for (int i = 0; i < 31; i++) {
			for (int j = 0; j <= i; j++) {
				if (j == 0) {
					c[i][j] = 1;
				} else {
					c[i][j] = c[i-1][j-1] + c[i-1][j];
				}
			}
		}

		long res = 0;
		int st = t;
		while(t != 4) {
			t--;
			int g = st - t;
			res += c[n][t] * c[m][g];
		}
		System.out.println(res);

	}

	public static void main(String[] args) {
		new Task131C();
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ScanReader in = new ScanReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CTheWorldIsATheatre solver = new CTheWorldIsATheatre();
        solver.solve(1, in, out);
        out.close();
    }

    static class CTheWorldIsATheatre {
        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            int b = in.scanInt();
            int g = in.scanInt();
            int t = in.scanInt();

            int C[][] = new int[35 + 5][35 + 5];

            for (int i = 0; i <= 35; i++) {
                for (int j = 0; j <= Math.min(i, 35); j++) {
                    if (j == 0 || j == i)
                        C[i][j] = 1;
                    else
                        C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
                }
            }

            long ans = 0;
            if (b > g) {
                for (int i = 4; i <= b; i++) {
                    int girls = t - i;
                    if (girls >= 1) {
                        ans += (C[b][i] * C[g][girls]);
                    }
                }
            } else {
                for (int i = 1; i <= g; i++) {
                    int boys = t - i;
                    if (boys >= 4) {
                        ans += (C[g][i] * C[b][boys]);
                    }
                }
            }

            out.println(ans);
        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int INDEX;
        private BufferedInputStream in;
        private int TOTAL;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (INDEX >= TOTAL) {
                INDEX = 0;
                try {
                    TOTAL = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (TOTAL <= 0) return -1;
            }
            return buf[INDEX++];
        }

        public int scanInt() {
            int I = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    I *= 10;
                    I += n - '0';
                    n = scan();
                }
            }
            return neg * I;
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

    }
}

import java.util.*;
import java.io.*;
public class theater
{
    public static void main(String[] args) throws IOException
    {
        fact a = new fact();
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer read = new StringTokenizer(in.readLine());
        long guy = Integer.parseInt(read.nextToken());
        long girl = Integer.parseInt(read.nextToken());
        long people = Integer.parseInt(read.nextToken());
        long result = 0;
        if(people <= guy)
        {
            people = people - 1;
            result = a.factor(guy) / (a.factor(people)*a.factor(guy-people));
            long res2 = a.factor(girl)/(a.factor(1)*a.factor(girl-1));
            result = result*res2;
        }
        else
        {
            people = people - guy;
            long res2 = a.factor(girl)/(a.factor(people)*a.factor(girl-people));
            result = res2;
        }

        System.out.print(result);
    }

}
class fact
{
    int result;
    public long factor(long data)
    {
        if( data<= 1)
            return 1;
        else
        return  data*factor(data-1);
    }
}

import java.io.*;
import java.util.*;

public class MainClass {

	public static void main(String[] args) {
		Locale.setDefault(Locale.US);
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		MainClass solution = new MainClass();
		solution.run(in, out);
		in.close();
		out.close();
	}

	public void run(Scanner in, PrintWriter out) {
		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		long ans = C(n, 4) * C(m, 1) * C(n + m - 5, t - 5);
		out.print(ans);
	}

	long C(int n, int k) {
		long res = 1;
		for (int i = n - k + 1; i <= n; i++)
			res *= (long) i;
		for (int i = 1; i <= k; i++)
			res /= (long) i;
		return res;
	}

}

import java.util.*;
import java.io.*;
import java.math.*;

public class Main {

    static boolean FROM_FILE = false;

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        public FastReader() {
            if (FROM_FILE) {
                try {
                    br = new BufferedReader(new FileReader("input.txt"));
                } catch (IOException error) {
                }
            } else {
                br = new BufferedReader(new InputStreamReader(System.in));
            }
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException  e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static long comb(long n, long k) {
        long nCk = 1;
        for (long i = 0; i < k; i += 1) {
            nCk = nCk * (n - i) / (i + 1);
        }
        return nCk;
    }

    public static void main(String[] args) {
        FastReader fr = new FastReader();
        PrintWriter out = null;
        if (FROM_FILE) {
            try {
                out = new PrintWriter(new FileWriter("output.txt"));
            } catch (IOException error) {

            }
        } else {
            out = new PrintWriter(new OutputStreamWriter(System.out));
        }
        long n = fr.nextLong(), m = fr.nextLong(), t = fr.nextLong();
        long res = 0;
        if (n >= 4 && n >= 1 && t >= 5) {
            for (long i = 4; 1 <= t - i && t - i <= m && i <= n; i += 1) {
                res += comb(n, i) * comb(m, t - i);
            }
        }
        // out.println(comb(5, 4));
        out.println(res);

        out.flush();
    }
}

//import com.sun.org.apache.xml.internal.security.algorithms.Algorithm;
import java.util.*;
import java.util.Scanner;

import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

import java.math.BigDecimal;
import java.math.BigInteger;
import javax.management.StringValueExp;

public class TheMain {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
//		InputReader in = new InputReader("input.txt");
		PrintWriter out = new PrintWriter(outputStream);
		Scanner sc;
		sc = new Scanner(inputStream);
/*		File file  = new File("input.txt");
		try {
		    sc = new Scanner(file);
 */
		    Task solver = new Task();
		    solver.solve(sc, out);

/*
		     } catch (FileNotFoundException e) {
		    e.printStackTrace();
 		}
 */

		out.close();
	}

}

class Task {
	static long[][] bin = new long[100][100];
	public void solve(Scanner in, PrintWriter out) {
	    int n = in.nextInt(),
		m = in.nextInt(),
		t = in.nextInt();
	    for (int i = 0; i < 100; ++i)
		for (int j = 0; j < 100; ++j)
		    bin[i][j] = -1;

//	    out.print(BinomialC(1,2));
	    long res = 0;
	    for (int boys = 4; boys <= n && boys <= t - 1; ++boys)
		for (int girls = 1; girls <= m && girls <= t - boys; ++girls)
		    res += BinomialC(n, boys) * BinomialC(m, girls);
	    out.println(res);

	}

	public static long BinomialC(int n, int k) {
	    long ret = 0;
	    if (bin[n][k] != -1)
		ret = bin[n][k];
	    else
	    if (k > n)
		ret = 0;
	    else
	    if (k > n/2)
		ret = BinomialC(n, n - k);
	    else
	    if (k == 0)
		ret = 1;
	    else
		ret = BinomialC(n - 1, k) + BinomialC(n - 1, k - 1);

	    bin[n][k] = ret;
	    return ret;
	}

}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

import java.io.*;
import java.util.*;
import java.math.*;

public class C131{

	public static BufferedReader read = null;
	public static PrintWriter out = null;
	public static StringTokenizer token = null;

	public static void solve()
	{
		int n = nint(), m = nint(), t = nint();
		//answer:
		// (n choose 4) * (m choose 1) * ((n+m-5) choose (t-5))
		long[][] c = new long[n+m+1][n+m+1];
		//c[i][j] is  i choose j
		c[0][0]=1;
		for(int i = 1; i<=n+m; i++)
		{
			for(int j=0; j<=n+m; j++)
			{
				if(j == 0) c[i][j] = 1;
				else if(j > i) break;
				else if(j == 1) c[i][j] = i;
				else
				{
					c[i][j] = c[i-1][j-1]+c[i-1][j];
				}
			}
		}
		out.println(c[n][4]*c[m][1]*c[n+m-5][t-5]);

	}

	public static void main(String[] args)
	{
		read = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.flush();
		out.close();

	}

	// i/o functions
	public static String next() // returns the next string
	{
		while(token == null || !token.hasMoreTokens())
		{
			try {
				token = new StringTokenizer(read.readLine());
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return token.nextToken();
	}

	public static int nint()
	{
		return Integer.parseInt(next());
	}
	public static long nlong()
	{
		return Long.parseLong(next());
	}
	public static double ndouble()
	{
		return Double.parseDouble(next());
	}
	public static int[] narr(int n)
	{
		int[] a = new int[n];
		for(int i=0; i<n; i++) a[i] = nint();
		return a;
	}

	public static long[] nal(int n)
	{
		long[] a = new long[n];
		for(int i=0; i<n; i++) a[i] = nlong();
		return a;
	}

}

import java.util.*;

public class Main {
    static int INFINITY = 1000000;
    static int boys;
    static int girls;
    static int actors;
    static long[][] dp = new long[31][31];
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        while( input.hasNextInt() ){

            boys = input.nextInt();
            girls = input.nextInt();
            actors = input.nextInt();
            long print = 0;
            int minBoys = 4;
            while( minBoys < boys && actors - minBoys > 1){
                minBoys++;
            }

            boolean cont = true;
            while( cont == true ){
                if(actors - minBoys > 0 && minBoys <= boys ){
                    print += combination( boys ,minBoys ) * combination( girls , actors - minBoys);
                }//end if.
                else{
                    cont = false;
                }

                minBoys++;
            }//while.

            System.out.println(print);

        }//end while input.

    }//end main.

    public static long combination(int n, int r) {
        long ans = 1;
        r = Math.min(r, n - r);
        if( dp[n][r] != 0 ){
            return dp[n][r];
        }
        for (int i = 1; i < r + 1; i++) {
            ans = ans * (n - r + i);
            ans = ans / i;
        }//end for.
        return dp[n][r] = ans;

    }//end method

}//end class.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
//package codeforces95;

import java.util.Scanner;

/**
 *
 * @author DELL
 */
public class problemC {

    public static int fac(int a) {
        int fact=1;
        for (int i = 1; i <= a; i++) {
            fact = fact * i;
        }
        return fact;
    }

    public static int ansC(int nm ,int a){

        return fac(nm)/(fac(nm-a)*fac(a));

    }

    public static void solve() {

        Scanner nera = new Scanner(System.in);

        int n =nera.nextInt();
        int m = nera.nextInt();
        int t = nera.nextInt();

        int i=4,count=0;
        while(i<t){
            count = count+(ansC(n, i)*ansC(m, t-i));
            i++;
        }

        System.out.println(count);

    }

    public static void main(String[] args) {
        //System.out.println(fac(5));
        //System.out.println(ansC(5, 2));
        solve();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class TheWorldIsATheatre {

    static long[] factorial = new long[101];

    public static void main(String[] args) throws IOException {
        factorial[0] = 1;
        for(int i = 1 ; i < 101 ; i++)
            factorial[i] = i * factorial[i - 1];
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int t = Integer.parseInt(st.nextToken());
        long ans = factorial[n + m] / (factorial[t] * factorial[n + m - t]);
        if(m >= t - 1)
            ans -= n * (factorial[m] / (factorial[t - 1] * factorial[m - t - 1]));
        if(m >= t - 2)
            ans -= (factorial[n] / (factorial[2] * factorial[n - 2])) * (factorial[m] / (factorial[t - 2] * factorial[m - (t - 2)]));
        if(m >= t - 3)
            ans -= (factorial[n] / (factorial[3] * factorial[n - 3])) * (factorial[m] / (factorial[t - 3] * factorial[m - (t - 3)]));
        if(n >= t)
            ans--;
        System.out.println(ans);
    }

}

import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class C {

	private void processInput() throws IOException {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		long res = go(n, m, t);

		System.out.printf(Locale.ENGLISH, "%d\n", res);

		in.close();
	}

	private long go(int n, int m, int t) {

		long res = 0;

		for (int i = 4; i <= t; i++) {

			long bb = binomial(n, i);

			for (int j = 1; j <= t; j++) {

				if (i + j <= t) {
					long ff = binomial(m, j);

					res += bb * ff;

				}
			}

		}

		return res;
	}

    private long binomial(int n, int k) {
		long res = 1;
		for (int i = n - k + 1; i <= n; i++) {
			res *= i;
			res /= (i - n + k);
		}
		return res;
	}

	public static void main(String[] args) throws Exception {
		C a = new C();
		a.processInput();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.function.Function;

public class C {
    public static void main(String[] args) {
        FastScanner fs = new FastScanner();
        long n=fs.nextInt();
        long m=fs.nextInt();
        long t=fs.nextInt();
        if (t<5||n<4||m<1||n+m<t) {
            System.out.println(0);
            return;
        }
        long boys=c(4,n);
        long girls=c(t-4,m);
        long result=boys*girls;
        for (long i=5;i<t;i++) {
            boys/=i;
            boys*=(n-i+1);
            girls/=m-t+i-1;
            girls*=t-i;
            result+=boys*girls;
        }
        System.out.println(result);
    }

    private static long c(long k, long n) {
        long r=1;
        for (long i=n;i>n-k;i--) {
            r*=i;
        }
        for (long i=1;i<=k;i++) {
            r/=i;
        }
        return r;
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;

public class YoloSwag {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * C. The World is a Theatre
		time limit per test2 seconds
		memory limit per test256 megabytes
		inputstandard input
		outputstandard output
		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.
		 */
		int numBoys;
		int numGirls;
		int totalActors;

		Scanner sc = new Scanner(System.in);

		numBoys = sc.nextInt();
		numGirls = sc.nextInt();
		totalActors = sc.nextInt();

		HashMap<TriangleLocation, Long> pascal =
				pascalTriangle(numBoys + numGirls);

//		System.out.println(pascal.get(new TriangleLocation(numBoys, numGirls)));

//		System.out.println("Kevin's test: " +totalActorslistComb(47,13));
//
		long oldTotalCombinations = 0L;
		for(int k = 4; k<=numBoys; k++){
			if(1 <= (totalActors - k) && (totalActors - k) <= numGirls){
//				System.out.println("n choose k: ("+numBoys+","+k+")=="+listComb(numBoys,k)+"m choose t-k: ("+numGirls+","+(totalActors-k)+")=="+listComb(numGirls,totalActors-k));
				oldTotalCombinations += (combination(numBoys, k) * combination(numGirls, totalActors-k));
			}
		}
		System.out.println(oldTotalCombinations);

//		System.out.println("comb1: "+combination(numBoys, numGirls)+" comb2: "+comb2(numBoys, numGirls));

//		long totalCombinations = 0L;
//		for(int k = 4; k<=numBoys; k++){
//			if(1 <= (totalActors - k) && (totalActors - k) <= numGirls){
//				System.out.println("n choose k: ("+numBoys+","+k+")=="+pascal.get(new TriangleLocation(numBoys,k))
//						+"m choose t-k: ("+numGirls+","+(totalActors-k)+")=="+pascal.get(new TriangleLocation(numGirls,totalActors-k)));
//				totalCombinations += (pascal.get(new TriangleLocation(numBoys, k)) * pascal.get(new TriangleLocation(numGirls, totalActors-k)));
//			}
//		}
//
//
//		System.out.println(totalCombinations);
	}

	public static long fact(long a){
		if(a == 0){
			return 1;
		}
		return a*fact(a-1);
	}

	public static long combination(long top, long bot){
//		System.out.println("top! / bot! (top-bot)! : "+ top+"! / "+bot+"! ("+(top-bot)+")!");
//		System.out.println("top! / bot! (top-bot)! : "+ fact(top)+" / "+fact(bot)+" ("+fact(top-bot)+")");
		return (fact(top) / (fact(bot) * fact(top-bot)));
	}

	public static long comb2(long top, long bot){
		long tot = 1L;
		//Calculate top! / bot! or top! / (top-bot)!, depending on which denomin is higher
		long higherOne = (bot > (top-bot)) ? bot : top-bot;
		long lowerOne = (bot > (top-bot)) ? top-bot : bot;

		for(long countdown = top; countdown>higherOne; countdown--){
			tot *= countdown;
		}

		tot /= fact(lowerOne);

		return tot;

	}

	public static long listComb(long top, long bot){
		//List-based combination. Let's kick ass maybe?
		List<Long> numeratorValues = new ArrayList<Long>();
		List<Long> denominatorValues = new ArrayList<Long>();

		for(long genNumer = 1L+bot; genNumer <= top; genNumer++){
			numeratorValues.add(genNumer);
		}

		for(long genDenom = 2; genDenom <= top-bot; genDenom++){//TODO works for bot == 0?
			denominatorValues.add(genDenom);
		}

		//Eliminate factors until denominatorValues is empty
		//Start with duplicates:

		System.out.println("Numerator Values: "+numeratorValues);
		System.out.println("Denominator Values: "+denominatorValues);
		int i = 0, j = 0;
		while(i < numeratorValues.size() && j < denominatorValues.size()){
			if(denominatorValues.get(j) == numeratorValues.get(i)){
				denominatorValues.remove(j);
				numeratorValues.remove(i);

			}else{
				j++;
			}
		}
		System.out.println("Numerator Values: "+numeratorValues);
		System.out.println("Denominator Values: "+denominatorValues);
		//Whatever's left in denominatorValues? Search numeratorValues for a factorable value and nuke it.
		for(int back = denominatorValues.size()-1; back>=0; back--){
			Long l = denominatorValues.get(back);
			boolean weFoundIt = false;
			for(i = 0; i<numeratorValues.size(); i++){
				System.out.println("Does "+numeratorValues.get(i)+" divide by "+l);
				if(numeratorValues.get(i) % l == 0){
					numeratorValues.set(i, numeratorValues.get(i) / l);
					weFoundIt = true;
					break;
				}
			}
			if(!weFoundIt){
				System.out.println("Failed on "+l);
				return -1L; // We done goofed
			}
		}

		long tot = 1L;
		for(Long l : numeratorValues){
			tot *= l;
		}
		return tot;
	}

	public static HashMap<TriangleLocation, Long> pascalTriangle(int desHeight){
		HashMap<TriangleLocation, Long> tri = new HashMap<TriangleLocation, Long>();
		tri.put(new TriangleLocation(0,0), 1L);
		int maxOffset = 1;
		int curHeight = 1;
		while(curHeight <= desHeight){
			for(int off = 0; off<=maxOffset; off++){
				Long nextValue = (off-1 == -1 ? 0 : tri.get(new TriangleLocation(curHeight-1, off-1)))
						+ (off == maxOffset ? 0 : tri.get(new TriangleLocation(curHeight-1, off)));
				tri.put(new TriangleLocation(curHeight, off), nextValue);
			}
			curHeight++;
			maxOffset++;
		}
		return tri;
	}

}

class TriangleLocation{
	int height;
	int offset;

	TriangleLocation(int h, int o){
		height = h;
		offset = o;
	}

	@Override
	public boolean equals(Object o){
		TriangleLocation t = (TriangleLocation) o;
		return this.offset == t.offset && this.height == t.height;
	}

	@Override
	public int hashCode(){
		return (height+" "+offset).hashCode();
	}
}

import java.util.Scanner;

public class C131 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		long n = sc.nextInt();
		long m = sc.nextInt();

		long t = sc.nextInt();
		if (t == 5){
			System.out.println(factorial(n, 4) * factorial(m, 1));
			return;
		}

		long r = t - 5;
		long ans = 0;

		for (long i = 0; i <= r; i++){

			long a = 4 + i;
			long b = 1 + r - i;

			if ((a <= n) && (b <= m)){
				ans += factorial(n, a) * factorial(m, b);
			}

		}
		System.out.println(ans);
	}

	public static long factorial(long a, long b){
		/*
		 * 	a > b always
		 *
		 *        a!
		 *   -----------
		 *   b! (a - b)!
		 */
		long ans = 1;

		long c = a - b;

		long max = Math.max(c, b);
		long min = Math.min(c, b);

		for (long i = max + 1; i <= a; i++){
			ans *= i;
		}

		for (long i = 2; i <= min; i++){
			ans /= i;
		}

		return ans;
	}

}

import java.util.*;
public class Test {
    static Scanner input = new Scanner(System.in);
    static long calcCompin(int n,int k)
    {
        double uNumerator =1,denominator=1 ;
        for (int i = n; i > (n-k); i--) //n...n-k+1
            uNumerator*=i;
        for (int i = k; i > 0; i--) //k!
            denominator*=i;
        return (long) (uNumerator/denominator);
    }
    public static void main(String[] args) {
        int n = input.nextInt(),m= input.nextInt(),t= input.nextInt();
        int i=(t>n)?n:t-1 ;
        int j=(t>n)?t-n:1 ;
        long total = 0 ;

        while (i+j==t&&i>=4&&i<=n&&j<=m&&j>=1)//i from 4 to n ---- j from 1 to m ---- i+j=t
        {
            long sum=calcCompin(n,i);
            sum*=calcCompin(m,j);//63
            total+=(sum>0)?sum:0;
            i--;
            j++;
        }

        System.out.println(total);
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Task131C {

	public static void main(String... args) throws NumberFormatException,
			IOException {
		Solution.main(System.in, System.out);
	}

	static class Solution {

		static long combinations(int n, int k) {
			long retVal = 1;
			for (int i = 1; i <= k; i++) {
				retVal *= (n - i) / i;
			}
			return retVal;
		}

		public static void main(InputStream is, OutputStream os)
				throws NumberFormatException, IOException {
			PrintWriter pw = new PrintWriter(os);
			Scanner s = new Scanner(is);

			int n = s.nextInt();
			int m = s.nextInt();
			int t = s.nextInt();

			long retVal = 0;

			for (int boys = 4; boys <= n; boys++) {
				retVal += combinations(n, boys) * combinations(m, t - boys);
			}

			pw.println(retVal);

			pw.flush();
			s.close();
		}
	}

}

import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author sergey
 */
public class Cf131c {

    /**
     * @param args the command line arguments
     */

    public static long fp[][];

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt(), t = in.nextInt();

        long r = 0;

        int nm = Math.max(n, m) + 1;

        fp = new long [nm][nm];

        for(int i = 0; i < nm; i++) {
            for(int j = 0; j <= i; j++) {
                if (j == 0 || j == i)
                    fp[i][j] = 1;
                else
                    fp[i][j] = fp[i - 1][j - 1] + fp[i - 1][j];
            }
        }

        int tof = Math.min(n, t - 1);
        for(int i = 4; i <= tof && t - i <= m; i++) {
            r += fp[n][i] * fp[m][t - i];
        }
        System.out.println(r);
    }
}

import java.util.* ;
public class Comb {
	static Long comb (int N , int C ){
	double res = 1;
	for (int i = 1; i <= C; i++) {
    res = res * (N - C + i) / i;}
   	return (long)res;
	}
public static void main (String args[]){
	Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();
		long sum = 0 ;
			if (n+m == t)
				System.out.print (1);
		else{
			if (t-m >= 4 ){
		for (int i = t-m ; i <= n & (t-i >= 1) ; i++){
				sum+= comb(n , i ) * comb(m , t-i );
		}
			}
			else{
				for (int i = 4 ; i <= n & (t-i >= 1) ; i++){
				sum+= comb(n , i ) * comb(m,t-i );}
			}

		}
		System.out.print(sum); }
}

import java.util.*;
import java.io.*;
public class theater
{

    public static void main(String[] args) throws IOException
    {
        fact a = new fact();
        Scanner in = new Scanner(System.in);
        long guy = in.nextLong();
        long girl = in.nextLong();
        long people = in.nextLong();
        long vrem1 = people - 1;
        long vrem2 = 1;
        long res1=0,res2=0;long result = 0;
        if(guy + girl == people)
        {
            result =1;
        }
        else
        {
            while(vrem1>=4 && vrem2<=girl)
            {
                 res1 = a.comb(guy, vrem1);
                 res2 = a.comb(girl, vrem2);

                 result = res1*res2+result;
                 vrem1--;vrem2++;
            }
        }
        System.out.println(result);

    }

}
class fact
{
    public long factor(long data)
    {
        if( data<= 1)
            return 1;
        else
        return  data*factor(data-1);
    }
    public long comb(long ot,long do_)
    {
        long result = 1;
        long t = ot - do_;
        if(t < do_)
        {
            long vrem = 0;
            while(ot > do_&&result>0)
            {
                vrem = result;
                result = result*ot;
                ot--;
            }
            if(result>0)
            {
                result = result/factor(t);
            }
            else
            {
                result = vrem/factor(t);
                result = result*(ot+1);
            }
            while(ot > do_)
            {
                result = result*ot;
                ot--;
            }
        }
        else
        {
            long vrem1 = 0;
            while(ot>t&&result>0)
            {
                vrem1 = result;
                result = result*ot;
                ot--;
            }
            if(result>0)
            {
                result = result/factor(do_);
            }
            else
            {
                result = vrem1/factor(do_);
                result = result*(ot+1);
            }
            while(ot > t)
            {
                result = result*ot;
                ot--;
            }
        }
        return result;
    }
}

import java.util.Scanner;

public class TheWorldIsATheatre {

	public static void main (String[]args) {

		Scanner sc = new Scanner(System.in);
		int magic = 60;
		int total = 0;
		int n = sc.nextInt();
		int m = sc.nextInt();
		int o = sc.nextInt();
		int[][] track = new int[magic][magic];
		track[0][0] = 1;
		for (int i = 1; i < magic; i++) {
			for (int j = 1; j < i +1; j++) {
				track[i][j] = track[i-1][j] + track[i-1][j-1];
			}
		}

		for (int i = 4; i < n+1; i++) {
			if ((o-i) < 1) {
				continue;
			}
			total += track[m][o-i] * track[n][i];
		}
		System.out.println(total);
	}

}

import java.util.Scanner;

public class Draw
{

    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner myScanner = new Scanner(System.in);

        long n = myScanner.nextLong();
        long m = myScanner.nextLong();
        long t = myScanner.nextLong();

        long ite = t-4;

        long res = 0;

        for(long i = 0; i<ite;i++){
            float boys = t - 1 - i;
            float girls = 1 + i;

            float bUp = 1;
            float gUp = 1;

            for(float j = 1; j<=boys; j++){
                bUp *= (n-boys+j)/j;
            }

            for(long j = 1; j<=girls; j++){
                gUp *= (m-girls+j)/j;
            }

            res += bUp*gUp;

        }

        System.out.println(res);

        myScanner.close();
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class C {

    public static void main(String... args) {

        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int t = sc.nextInt();

        long result = 0;
        for (int i=4; i<t; i++)
            result += c(n, i) * c(m, t-i);

        System.out.println(result);
    }

    public static long c(int n, int k) {
        BigInteger r = BigInteger.valueOf(1);
        for (int i=n; i>Math.max(k, n-k); i--)
            r = r.multiply(BigInteger.valueOf(i));
        for (int i=2; i<=Math.min(k, n-k); i++)
            r = r.divide(BigInteger.valueOf(i));
        return r.longValue();
    }

}

import java.util.*;
//import java.io.*;
import java.math.*;

//import java.text.NumberFormat;
public class Main {
    public static BigInteger C(int n,int m){
        BigInteger ans=BigInteger.ONE;
        for(int i=m;i>(m-n);i--){
            BigInteger t=BigInteger.valueOf(i);
            ans=ans.multiply(t);
        }
        for(int i=n;i>1;i--){
            BigInteger t=BigInteger.valueOf(i);
            ans=ans.divide(t);
        }
        return ans;
    }
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        while (cin.hasNextInt()) {
            int ni=cin.nextInt();
            int mi=cin.nextInt();
            int ti=cin.nextInt();
            BigInteger a=C(4,ni);
            BigInteger ans=BigInteger.valueOf(mi);
            ans=ans.multiply(a);
            BigInteger c=C(ti-5,ni+mi-5);
            ans=ans.multiply(c);
            System.out.println(ans);
        }
    }
}

import java.util.Scanner;

public class Theatre {
	static int n;
	static int m;
	static int t;

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		//Scanner scanner = new Scanner("30 30 30");
		n=scanner.nextInt();
		m=scanner.nextInt();
		t=scanner.nextInt();
		System.out.println(combination(t, n+m)-combination(t, n)-combination(3, n)*combination(t-3, m)-combination(2, n)*combination(t-2, m)-combination(1, n)*combination(t-1, m)-combination(t, m));
	}

private static long fact(int n) {
	long s=1;
	for (int i=1; i<=n; i++) {
		s*=i;
	}
	return s;
}

private static long combination(int k, int n) {
	if (n<=10) return fact(n)/(fact(k)*fact(n-k)); else {
		if (k<=n/2) {
			int s=1;
			for (int j=n-k+1; j<=n; j++) s*=j;
			return s/fact(k);
		} else {
			int s=1;
			for (int j=k+1; j<=n; j++) s*=j;
			return s/fact(n-k);
		}
	}
}
}

import java.io.*;
import java.util.*;
import java.math.*;

public class ContestC implements Runnable {

    public void run() {
        int B = nextInt();
        int G = nextInt();
        int t = nextInt();

        long ans = 0;
        int sum = B+G-5;
        int sxvaoba = t-5;

        ans = C(G, 1) * C(B, 4) * C(sum, sxvaoba);
        System.out.println(ans);

//      -----------------------------------------------------------------------------------

        out.close();
        System.exit(0);
    }
    public  long C  (int a, int b){
        long[][] combin = new long [31][31];
        for(int i=0; i<31; i++){
            combin[i][0] = 1;
        }
        for(int i=1; i<31; i++){
            for(int j=1; j<=i;j++){
                combin[i][j] = combin[i-1][j] + combin[i-1][j-1];
            }
        }

        return combin[a][b];
    }

    private static boolean fileIOMode;
    private static String problemName = "xxx";
    private static BufferedReader in;
    private static PrintWriter out;
    private static StringTokenizer tokenizer;

    public static void main(String[] args) throws Exception {
        fileIOMode = false;
        if (fileIOMode) {
            in = new BufferedReader(new FileReader(problemName + ".in"));
            out = new PrintWriter(problemName + ".out");
        } else {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        tokenizer = new StringTokenizer("");

        new Thread(new ContestC()).start();
    }

    private static String nextLine() {
        try {
            return in.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    private static String nextToken() {
        while (!tokenizer.hasMoreTokens()) {
            String str = nextLine();
            if(str==null) return null;
            tokenizer = new StringTokenizer(str);
        }
        return tokenizer.nextToken();
    }

    private static int nextInt() {
        return Integer.parseInt(nextToken());
    }

    private static long nextLong() {
        return Long.parseLong(nextToken());
    }

    private static double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    private static BigInteger nextBigInteger() {
        return new BigInteger(nextToken());
    }

    private static void print(Object o) {
        if (fileIOMode) {
            System.out.print(o);
        }
        out.print(o);
    }

    private static void println(Object o) {
        if (fileIOMode) {
            System.out.println(o);
        }
        out.println(o);
    }

    private static void printf(String s, Object... o) {
        if (fileIOMode) {
            System.out.printf(s, o);
        }
        out.printf(s, o);
    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		int n = scan.nextInt();
		int m = scan.nextInt();
		int t = scan.nextInt();
		long[] facts = new long[n + m+1];
		facts[0] = 1;
		facts[1] = 1;
		for (int i = 2; i < n + m+1; i++)
			facts[i] = facts[i - 1] * i;
		long boys = facts[n] / (facts[4] * facts[n - 4]);
		long girls = facts[m] / (facts[1] * facts[m - 1]);
		long total = facts[t] / (facts[5] * facts[t - 5]);
		System.out.println(boys * girls / total);

		scan.close();

	}

}

import java.util.Scanner;

public class TheWorldIsATheatre {

	public static void main (String[]args) {

		Scanner sc = new Scanner(System.in);
		int magic = 60;
		int total = 0;
		int n = sc.nextInt();
		int m = sc.nextInt();
		int o = sc.nextInt();
		int[][] track = new int[magic][magic];
		track[0][0] = 1;
		for (int i = 2; i < magic; i++) {
			for (int j = 1; j < i+1; j++) {
				track[i][j] = track[i-1][j] + track[i-1][j-1];
			}
		}

		for (int i = 5; i < n+1; i++) {
			if ((o-i) < 1) {
				continue;
			}
			total += track[m][o-i] * track[n][i];
		}
		System.out.println(total);
	}

}

import java.util.*;
public class Test {
    static Scanner input = new Scanner(System.in);
    static long calcCompin(int n,int k)
    {
        long uNumerator =1,denominator=1 ;
        for (int i = n; i > (n-k); i--) //n...n-k+1
            uNumerator*=i;
        for (int i = k; i > 0; i--)
            denominator*=i;
        return uNumerator/denominator;
    }
    public static void main(String[] args) {
        int n = input.nextInt(),m= input.nextInt(),t= input.nextInt();
        long sum=calcCompin(n,4);
        sum*=calcCompin(m,1);
        sum*=calcCompin((n+m)-5, t-5);
        System.out.println(sum);
    }
}

import java.io.*;
import java.util.*;

public class C {
    public static void solution(BufferedReader reader, PrintWriter writer)
            throws IOException {
        In in = new In(reader);
        Out out = new Out(writer);
        int n = in.nextInt(), m = in.nextInt(), t = in.nextInt();
        long[][] c = new long[61][61];
        c[0][0] = 1;
        for (int i = 0; i < 60; i++)
            for (int j = 0; j <= i; j++) {
                c[i + 1][j] += c[i][j];
                c[i + 1][j + 1] += c[i][j];
            }
        long rst = c[n][4] * c[m][1] * c[n + m - 5][t - 5];
        out.println(rst);
    }

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(
                new BufferedWriter(new OutputStreamWriter(System.out)));
        solution(reader, writer);
        writer.close();
    }

    protected static class In {
        private BufferedReader reader;
        private StringTokenizer tokenizer = new StringTokenizer("");

        public In(BufferedReader reader) {
            this.reader = reader;
        }

        public String next() throws IOException {
            while (!tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public int[] nextIntArray(int n) throws IOException {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        public int[] nextIntArray1(int n) throws IOException {
            int[] a = new int[n + 1];
            for (int i = 1; i <= n; i++)
                a[i] = nextInt();
            return a;
        }

        public int[] nextIntArraySorted(int n) throws IOException {
            int[] a = nextIntArray(n);
            Random r = new Random();
            for (int i = 0; i < n; i++) {
                int j = i + r.nextInt(n - i);
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
            Arrays.sort(a);
            return a;
        }

        public long[] nextLongArray(int n) throws IOException {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }

        public long[] nextLongArray1(int n) throws IOException {
            long[] a = new long[n + 1];
            for (int i = 1; i <= n; i++)
                a[i] = nextLong();
            return a;
        }

        public long[] nextLongArraySorted(int n) throws IOException {
            long[] a = nextLongArray(n);
            Random r = new Random();
            for (int i = 0; i < n; i++) {
                int j = i + r.nextInt(n - i);
                long t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
            Arrays.sort(a);
            return a;
        }
    }

    protected static class Out {
        private PrintWriter writer;

        public Out(PrintWriter writer) {
            this.writer = writer;
        }

        public void print(char c) {
            writer.print(c);
        }

        public void print(int a) {
            writer.print(a);
        }

        public void println(String s) {
            writer.println(s);
        }

        public void println(int a) {
            writer.println(a);
        }

        public void println(long a) {
            writer.println(a);
        }

        public void println(Object[] os) {
            for (int i = 0; i < os.length; i++) {
                writer.print(os[i]);
                writer.print(' ');
            }
            writer.println();
        }

        public void println(int[] a) {
            for (int i = 0; i < a.length; i++) {
                writer.print(a[i]);
                writer.print(' ');
            }
            writer.println();
        }

        public void println(long[] a) {
            for (int i = 0; i < a.length; i++) {
                writer.print(a[i]);
                writer.print(' ');
            }
            writer.println();
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.math.BigInteger;

import javax.swing.text.StyledEditorKit.ForegroundAction;

public class Main {
    public static void main(String[] args) {
    	InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {

        public void solve(int testNumber, InputReader in, PrintWriter out) {
               long n = in.nextInt() ;
               long m = in.nextInt() ;
               long t = in.nextInt() ;

               long result = 0 ;
               long maxi = Math.max(n, m) ;
               long mini = Math.min(n, m) ;

               for (long i = 4; i<=n; i++)

   				   if((t-i)<=m && (t-i)>=1){
   					result += C(n,i)*C(m,t-i) ;

               }

               out.println(result);
            }

        public static long C(long n,long k){
        	if(k==0)
        		return 1 ;
			if (k==1)
				return n ;
			else
				return (long) (C(n,k-1)*((n-k+1.0)/k)) ;
        }

    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main{

    static long[][] comb;

    static long nCr1(int n , int k)
    {
        if(n < k)
            return 0;
        if(k == 0 || k == n)
            return 1;
        if(comb[n][k] != -1)
            return comb[n][k];
        if(n - k < k)
            return comb[n][k] = nCr1(n, n - k);
        return comb[n][k] = nCr1(n - 1, k - 1) + nCr1(n - 1, k);
    }
public  static void main (String args[])throws Exception{

    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int t=sc.nextInt();
    long boys=0;
    comb=new long[31][31];
    for (int i = 0; i < 31; i++) {
        Arrays.fill(comb[i],-1);
    }
    for (int i = 4; i <=Math.min(n,t-1) ; i++) {
    boys+=nCr1(n,i);
    }
   long girls=0;
    for (int i = 1; i <=Math.min(m,t-4) ; i++) {
        girls+=nCr1(m,i);
    }
  //  System.out.println(boys+" "+girls);
    System.out.println(boys*girls);

}

static class Scanner
{
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

	public String next() throws IOException
	{
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public int nextInt() throws IOException {return Integer.parseInt(next());}

	public long nextLong() throws IOException {return Long.parseLong(next());}

	public String nextLine() throws IOException {return br.readLine();}

	public double nextDouble() throws IOException
	{
		String x = next();
		StringBuilder sb = new StringBuilder("0");
		double res = 0, f = 1;
		boolean dec = false, neg = false;
		int start = 0;
		if(x.charAt(0) == '-')
		{
			neg = true;
			start++;
		}
		for(int i = start; i < x.length(); i++)
			if(x.charAt(i) == '.')
			{
				res = Long.parseLong(sb.toString());
				sb = new StringBuilder("0");
				dec = true;
			}
			else
			{
				sb.append(x.charAt(i));
				if(dec)
					f *= 10;
			}
		res += Long.parseLong(sb.toString()) / f;
		return res * (neg?-1:1);
	}

	public boolean ready() throws IOException {return br.ready();}

}
}

import java.util.Scanner;

public class Main {

    public static long comb(int n, int K) {
        long nCk = 1;
        for (int k = 0; k < K; k++) {
            nCk = (long)nCk * (n-k) / (k+1);
        }
        return nCk;
    }

    public static long solve(int n, int m, int t) {
        long r = 0;
        for(int i = 4; i < t; i++) {
            if(i > n || t - i > m) break;
            r += comb(n, i) * comb(m, t - i);
        }
        return r;
    }

    public static void main(String [] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt(), t = sc.nextInt();
        System.out.println(solve(n, m, t));
    }
}

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class C {

	static BigInteger[][] dp;
	public static BigInteger ncr(int n, int r) {
		if (r == 0)
			return BigInteger.ONE;
		if (n == 0)
			return BigInteger.ZERO;
		if(dp[n][r].compareTo(new BigInteger ("-1")) != 0)
			return dp[n][r];
		return dp[n][r] = (ncr(n - 1, r - 1).add(ncr(n - 1, r)));
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int m = s.nextInt();
		int t = s.nextInt();
		dp = new BigInteger[n+m+1][t+1];
		for(BigInteger [] d: dp)
			Arrays.fill(d, new BigInteger("-1"));
		BigInteger ans = ncr(n, 4).multiply(new BigInteger(m+"")).multiply(ncr(n+m-5, t-5));
		System.out.println(ans);
	}

}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
public class A {
	static BigInteger[] arr  = new BigInteger[31];
	static void fact() {
		arr[0] = new BigInteger("1");
		arr[1] = new BigInteger("1");
		for(int i=2;i<=30;i++) arr[i] = arr[i-1].multiply(new BigInteger(String.valueOf(i)));
	}
	static BigInteger ncr(int n, int r) {
		BigInteger ans = new BigInteger("1");
		ans = arr[n].divide(arr[n-r]);
		ans=ans.divide(arr[r]);
		return ans;
	}
	//static PrintWriter out = new PrintWriter(System.out);
	public static void main(String[] args) {
		try {
			BufferInput in = new BufferInput();
			StringBuilder sb = new StringBuilder();
			fact();
			int a = in.nextInt();
			int b = in.nextInt();
			int c = in.nextInt();
			BigInteger ans = new BigInteger("0");
			for(int i=4;i<c;i++) {
				BigInteger v1 = ncr(a, i);
				BigInteger v2 = ncr(b, c-i);
				ans = ans.add(v1.multiply(v2));
			}
			System.out.println(ans);
		}catch(Exception e) {}

	}
static class BufferInput {

		final private int BUFFER_SIZE = 1 << 16;

		private DataInputStream din;

		private byte[] buffer;

		private int bufferPointer, bytesRead;

		public BufferInput() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public BufferInput(String file_name) throws IOException {
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String readLine() throws IOException {
			byte[] buf = new byte[64];
			int cnt = 0, c;
			while ((c = read()) != -1) {
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public String nextString() throws IOException{

			byte c = read();
			while(Character.isWhitespace(c)){
				c = read();
			}

			StringBuilder builder = new StringBuilder();
			builder.append((char)c);
			c = read();
			while(!Character.isWhitespace(c)){
				builder.append((char)c);
				c = read();
			}

			return builder.toString();
		}

		public int nextInt() throws IOException {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}

		public int[] nextIntArray(int n) throws IOException {
			int arr[] = new int[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextInt();
			}
			return arr;
		}
		public long nextLong() throws IOException {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public long[] nextLongArray(int n) throws IOException {
			long arr[] = new long[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextLong();
			}
			return arr;
		}

		public char nextChar() throws IOException{
			byte c = read();
			while(Character.isWhitespace(c)){
				c = read();
			}
			return (char) c;
		}
		public double nextDouble() throws IOException {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (c == '.') {
				while ((c = read()) >= '0' && c <= '9') {
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}
		public double[] nextDoubleArray(int n) throws IOException {
			double arr[] = new double[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextDouble();
			}
			return arr;
		}
		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}
		private byte read() throws IOException {
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.BufferedReader;
import java.util.Scanner;

/**
 *
 * @author lullaby_1412
 */
public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        long n = sc.nextLong();
        long m = sc.nextLong();
        long t = sc.nextLong();
        long socach = 0;
        for (int i = 4; i + 1 <= t; i++) {
            socach += giaithua.tinhC(i, n) * giaithua.tinhC(t - i, m);
        }

        System.out.println(socach);
    }

}

class giaithua {

    public static long tinhGT(long a) {
        long gt = 1;
        for (int i = 1; i < a + 1; i++) {
            gt *= i;
        }
        return gt;
    }

    public static long tinhC(long a, long b) {
        long c = 1;
        if (b - a > 0) {
            c = tinhGT(b) / (tinhGT(a) * tinhGT(b - a));
        }
        return c;
    }

}

import java.util.* ;

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        @SuppressWarnings("resource")
        Scanner in = new Scanner(System.in);

        int n , m , t , b = 4 , g = 1 ;
        long sum = 0 , tf ;

        n = in.nextInt() ;
        m = in.nextInt() ;
        t = in.nextInt() ;

        g = t-b ;

        for(b = 4 ; b<=n ;b++)
        {
            g = t-b ;

            if(g<1)
                break ;

            sum += c(n,b) * c(m,g) ;
        }

        System.out.printf("%d",sum);
    }

    public static long p (int n, int r )
    {
        if(n==r && n==0)
            return 1 ;

        long s = n ;
        n-- ;

        while(r>1)
        {
            s *= n-- ;
            r--;
        }

        return s ;
    }

    public static long c (int n, int r )
    {
        long s = p(n,r) ;
        s /= p (r,r) ;
        return s ;
    }
}

import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class C {

	private void processInput() throws IOException {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int m = in.nextInt();
		int t = in.nextInt();
		long res = go(n, m, t);

		System.out.printf(Locale.ENGLISH, "%d\n", res);

		in.close();
	}

	private long go(int n, int m, int t) {

		long res = 0;

		for (int i = 4; i <= Math.min(t, n); i++) {

			long bb = binomial(n, i);

			for (int j = 1; j <= Math.min(t, m); j++) {

				if (i + j <= t) {
					long ff = binomial(m, j);

					res += bb * ff;

				}
			}

		}

		return res;
	}

    private long binomial(int n, int k) {
		long res = 1;
		for (int i = n - k + 1; i <= n; i++) {
			res *= i;
			res /= (i - n + k);
		}
		return res;
	}

	public static void main(String[] args) throws Exception {
		C a = new C();
		a.processInput();
	}
}

import java.util.*;
import java.math.*;

public class test {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		BigInteger fac[]=new BigInteger[63];
		int n,m,t,i;
		BigInteger ans,a,b;
		fac[0]=BigInteger.ONE;
		for(i=1;i<63;i++){
			fac[i]=fac[i-1].multiply(BigInteger.valueOf(i));
		}
		while(sc.hasNext()){
			n=sc.nextInt();
			m=sc.nextInt();
			t=sc.nextInt();
			ans=BigInteger.ZERO;
			for(i=4;i<=t-1;i++){
				if(n-i>=0 && m-t+i>=0){
					a=fac[n].divide(fac[i].multiply(fac[n-i]));
					b=fac[m].divide(fac[t-i].multiply(fac[m-t+i]));
					ans=ans.add(a.multiply(b));
				}
				else{
					break;
				}

			}
			System.out.println(ans);
		}
	}
}

import java.util.*;
import java.io.*;

public class WorldIsATheater {

	static long[][] dp;

	public static void main (String[]args) throws IOException{

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int boys = Integer.parseInt(st.nextToken());
		int girls = Integer.parseInt(st.nextToken());
		int n = Integer.parseInt(st.nextToken());
		int size = n+boys+girls;
		dp = new long[size][size];
		for(int i=1; i<=n; i++) Arrays.fill(dp[i],-1);

		long sum = 0;

		for(int i=4; i<=n-1; i++){
			sum+= recur(boys, i) * recur(girls, n-i);
			//System.out.println(recur(boys,i) + " " + recur(girls, n-i));
		}
		System.out.println(sum);
	}

	public static long recur(int n, int k){
		if(k>n) return 0;
		if(k==n || k==0) return 1;
		if(dp[n][k]!=-1) return dp[n][k];
		return dp[n][k] = recur(n-1, k) + recur(n-1,k-1);
	}
}

import java.util.Scanner;

public class P131C {

    public static void main(String[] args) {
        Scanner inScanner = new Scanner(System.in);
        long n = inScanner.nextInt();
        long m = inScanner.nextInt();
        long t = inScanner.nextInt();
        long chooseGirl = m;
        long chooseBoy = n * (n - 1) * (n - 2) * (n - 3) / 24;
        long chooseRest = parmi(t - 5, n + m - 5);
        long result = chooseBoy * chooseGirl * chooseRest;
        System.out.println(result);
    }

    private static long parmi(long m, long n) {
        return (fact(n) / (fact(m) * fact(n - m)));
    }

    private static long fact(long l) {
        if (l == 0)
            return 1;
        return l * fact(l - 1);
    }
}

import java.io.*;
import java.util.*;
import java.math.*;

import static java.lang.System.*;

public class Solution131c {

    public void run() throws Exception {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long m = in.nextLong();
        long t = in.nextLong();
        long total = 0;
        for(int b = 4; b <= Math.min(n, t - 1); b++) {
//            out.println(n + " " + b + " " + c(n,b));
//            out.println(m + " " + (t-b) + " " + c(m, t-b));
            total += c(n, b) * c(m, t - b);
        }
        out.println(total);
    }

    public long c(long i, long j) {
        long r = 1;
        for(long x = Math.max(j, i - j) + 1; x <= i;  x++) {
            r *= x;
        }
        for(long x = 2; x <= Math.min(j, i - j); x++) {
            r /= x;
        }
        return r;
    }

    public long f(long i, long j) {
        long x = 1;
        for(long r = i; r <= j; ++r)
            x *= r;
        return x;
    }

    public static void main(String[] args) throws Exception {
        new Solution131c().run();
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class CF {public static void main(String[] args){new Solve();}}

class Solve { public Solve(){solve();output();}
    void solve(){try{
        int n = NI();
        int m = NI();
        int t = NI();
        long res = C(n, 4) * m * C(m + n - 5, t - 5);
        sout(res);
    }catch(Exception e){e.printStackTrace();}}

    long C(int n, int k) {
        k = min(k, n - k);
        long b = 1;
        for (int i = 1, m = n; i <= k; i++, m--)
            b *= m / i;
        return b;
    }

    BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");StringBuilder output=new StringBuilder();
    final int INF=Integer.MAX_VALUE;final long LINF=Long.MAX_VALUE;double ND()throws Exception{return Double.parseDouble(NS());}
    void inInt(int[]a,int n)throws Exception{for(int i=0;i<n;i++)a[i]=NI();}void inLong(long[]a,int n)throws Exception{for(int i=0;i<n;i++)a[i]=NL();}
    int min(int i1,int i2){return i1<i2?i1:i2;}long min(long i1,long i2){return i1<i2?i1:i2;}
    int max(int i1,int i2){return i1>i2?i1:i2;}long max(long i1,long i2){return i1>i2?i1:i2;}
    String NS()throws Exception{while(!st.hasMoreTokens())st=new StringTokenizer(stdin.readLine());return st.nextToken();}
    int NI()throws Exception{return Integer.parseInt(NS());}long NL()throws Exception{return Long.parseLong(NS());}
    int abs(int x){return x<0?-x:x;}long abs(long x){return x<0?-x:x;}String NLn()throws Exception{return stdin.readLine();}
    int mod(int x,int mod){return(x+mod)%mod;}void output(){System.out.print(output);}void sout(){output.append('\n');}
    void sout(int x){output.append(x).append('\n');}void out(int x){output.append(x);}void sout(StringBuilder x){output.append(x).append('\n');}
    void sout(long x){output.append(x).append('\n');}void out(long x){output.append(x);}void out(StringBuilder x){output.append(x);}
    void sout(char x){output.append(x).append('\n');}void out(char x){output.append(x);}
    void sout(float x){output.append(x).append('\n');}void out(float x){output.append(x);}
    void sout(double x){output.append(x).append('\n');}void out(double x){output.append(x);}
    void sout(String x){output.append(x).append('\n');}void out(String x){output.append(x);}

}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	static class aksh
	{
		int x;
		int y;

		public aksh(int x,int y)
		{
			this.x=x;
			this.y=y;
		}
	}
	static long fact(long n)
	{
		if(n==0)
		return 1;
		else
		return (n*fact(n-1));
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		int t=sc.nextInt();
		ArrayList<aksh> a=new ArrayList<>();

		for(int i=4;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				if((i+j)==t)
				a.add(new aksh(i,j));
			}
		}
		long ans=0;
		for(int i=0;i<a.size();i++)
		{
		//	System.out.println(a.get(i).x+" "+a.get(i).y);
			long temp1=(fact(n)/(fact(a.get(i).x)*fact(n-a.get(i).x)));
			long temp2=(fact(m)/(fact(a.get(i).y)*fact(m-a.get(i).y)));
			ans+=temp1*temp2;
		}
		System.out.println(ans);
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TheWorldIsATheater solver = new TheWorldIsATheater();
        solver.solve(1, in, out);
        out.close();
    }

    static class TheWorldIsATheater {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long n = in.nextInt();
            long m = in.nextInt();
            long t = in.nextInt();

            out.println(combo(n, 4) * combo(m, 1) * combo(n + m - 5, t - 5));
        }

        static long combo(long n, long m) {
            double num = 1;
            for (int i = 0; i < m; i++) {
                num *= (n - i);
                num /= (m - i);
            }
            return (long) num;
        }

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.util.Scanner;

public class test {
    public static long combination(long n,long k) {
          return fact(n) / (fact(k) * fact(n - k));
        }

    public static long fact(long n) {
        long res = 1;
          for(int i=1;i<=n;i++)res*=i;
          return res;
        }

    public static void main(String[] args) {
        Scanner kb = new Scanner(System.in);
        long n = kb.nextLong();
        long m = kb.nextLong();
        long t = kb.nextLong();
        long r = combination(n, 4L)*combination(m, 1L)*combination(n+m-5L,t-5 );
        System.out.println(r);
    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		int n = scan.nextInt();
		int m = scan.nextInt();
		int t = scan.nextInt();
		long[] facts = new long[n + m + 1];
		facts[0] = 1;
		facts[1] = 1;
		for (int i = 2; i < n + m + 1; i++)
			facts[i] = facts[i - 1] * i;
		long boys = facts[n] / (facts[4] * facts[n - 4]);
		long girls = m;
		long others = facts[n + m - 5] / (facts[t - 5] * facts[n + m - t]);

		System.out.println(boys * girls * others);

		scan.close();

	}
}

import java.io.*;
import java.util.*;

public class CF {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	public static void main(String[] args) throws IOException {
		String[] split = br.readLine().split(" ");
		long n = Long.parseLong(split[0]);
		long m = Long.parseLong(split[1]);
		long t = Long.parseLong(split[2]);

		long total = 0;
		long min = Math.min(n, t-1);
		for(int i = 4; i <= min; i++) {
			total += nCr(n, n-i) * nCr(m, m-(t-i));
		}
		pw.println(total);
		pw.close();
	}

	public static long nCr(long n, long k) {
		long prod = 1;

		for(long b = k+1; b <= n; b++) {
			prod *= b;
		}
		for(long i = 2; i <= n-k; i++) {
			prod /= i;
		}
		return prod;
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class TheWorldIsATheatre {

    static BigInteger[] factorial = new BigInteger[101];

    public static void main(String[] args) throws IOException {
        factorial[0] = new BigInteger("1");
        for (int i = 1 ; i <= 100 ; i++) {
            factorial[i] = new BigInteger(i + "");
            factorial[i] = factorial[i].multiply(factorial[i-1]);
        }
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int t = Integer.parseInt(st.nextToken());
        BigInteger ans = factorial[n + m].divide(factorial[t].multiply(factorial[n + m - t]));
        BigInteger nn = new BigInteger(n + "");
//      long ans = factorial[n + m] / (factorial[t] * factorial[n + m - t]);
//      System.out.println(ans + " ");
        if(m >= t - 1)
            ans = ans.subtract(nn.multiply(factorial[m].divide(factorial[t - 1].multiply(factorial[m - (t - 1)]))));
//      -= n * (factorial[m] / (factorial[t - 1] * factorial[m - (t - 1)]));
        if(m >= t - 2) {
            BigInteger temp = factorial[m].divide(factorial[t - 2].multiply(factorial[m - (t - 2)]));
            BigInteger temp2 = factorial[n].divide(factorial[2].multiply(factorial[n - 2]));
            ans = ans.subtract(temp.multiply(temp2));
        }
//          (factorial[n] / (factorial[2] * factorial[n - 2])) * (factorial[m] / (factorial[t - 2] * factorial[m - (t - 2)]));
        if(m >= t - 3) {
            BigInteger temp = factorial[m].divide(factorial[t - 3].multiply(factorial[m - (t - 3)]));
            BigInteger temp2 = factorial[n].divide(factorial[3].multiply(factorial[n - 3]));
            ans = ans.subtract(temp.multiply(temp2));
        }
//          ans -= (factorial[n] / (factorial[3] * factorial[n - 3])) * (factorial[m] / (factorial[t - 3] * factorial[m - (t - 3)]));
        if(n >= t)
            ans = ans.subtract(factorial[n].divide(factorial[t].multiply(factorial[n - t])));
//          ans -= (factorial[n] / factorial[t] * factorial[n - t]);
        System.out.println(ans);
    }

}

import java.io.PrintWriter;
import java.util.Scanner;

public class Solution {
    private static long fact(int n) {
        long f = 1;
        for (long i = 2L; i <= n; i++)
            f *= i;

        return f;
    }

    private static long C(int n, int m) {
        return fact(n) / fact(n - m) / fact(m);
    }

    public static void main(String[] args) throws Exception {
        Scanner reader = new Scanner(System.in);
        PrintWriter writer = new PrintWriter(System.out);

        int n = reader.nextInt();
        int m = reader.nextInt();
        int t = reader.nextInt();

        long count = 0;

        for (int i = 4; i <= n; i++) {
            int j = t - i;
            if (j < 1) break;
            if (j > m) continue;

            count += C(n, i) * C(m, j);
        }

        writer.print(count);

        writer.close();
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;

/*
import org.jgrapht.Graph;
import org.jgrapht.VertexFactory;
import org.jgrapht.generate.GnpRandomGraphGenerator;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.graph.SimpleGraph;
*/
public class randomgraph {

	static long f[];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int t = sc.nextInt();
		f = new long[150];
		f[0] = 1;
		f[1] = 1;
		for (int i = 2; i < f.length; i++) {
			f[i] = i * f[i - 1];
		}
		long ans = 0;
		for (int i = 4; i < t; i++) {
			int comp = t - i;
			ans += (C(n, i) * C(m, comp));
		}
		System.out.println(ans);

	}

	static long C(int n, int r) {
		return (long) (f[n] / (f[n - r] * f[r]));

	}

	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;
	}

}

/*	/ ﾌﾌ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ム
	/ )\⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀  Y
	(⠀⠀| ( ͡° ͜ʖ ͡°）⠀⌒(⠀ ノ
	(⠀ ﾉ⌒ Y ⌒ヽ-く __／
	| _⠀｡ノ| ノ｡ |/
	(⠀ー '_人`ー ﾉ
	⠀|\ ￣ _人'彡ﾉ
	⠀ )\⠀⠀ ｡⠀⠀ /
	⠀⠀(\⠀ #⠀ /
	⠀/⠀⠀⠀/ὣ====================D-
	/⠀⠀⠀/⠀ \ \⠀⠀\
	( (⠀)⠀⠀⠀⠀ ) ).⠀)
	(⠀⠀)⠀⠀⠀⠀⠀( | /
	|⠀ /⠀⠀⠀⠀⠀⠀ | /
	[_] ⠀⠀⠀⠀⠀[___]                     */
// Main Code at the Bottom
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;
public class Main {
	//Fast IO class
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        public FastReader() {
        	boolean env=System.getProperty("ONLINE_JUDGE") != null;
        	if(!env) {
        		try {
					br=new BufferedReader(new FileReader("src\\input.txt"));
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				}
        	}
        	else br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    static long MOD=1000000000+7;
    //Euclidean Algorithm
    static long gcd(long A,long B){
    	return (B==0)?A:gcd(B,A%B);
    }
    //Modular Exponentiation
    static long fastExpo(long x,long n){
        if(n==0) return 1;
        if((n&1)==0) return fastExpo((x*x)%MOD,n/2)%MOD;
        return ((x%MOD)*fastExpo((x*x)%MOD,(n-1)/2))%MOD;
    }
    //Modular Inverse
    static long inverse(long x) {
    	return fastExpo(x,MOD-2);
    }
    //Prime Number Algorithm
    static boolean isPrime(long n){
        if(n<=1) return false;
        if(n<=3) return true;
        if(n%2==0 || n%3==0) return false;
        for(int i=5;i*i<=n;i+=6) if(n%i==0 || n%(i+2)==0) return false;
        return true;
    }
    //Reverse an array
    static void reverse(int arr[],int l,int r){
    	while(l<r) {
    		int tmp=arr[l];
    		arr[l++]=arr[r];
    		arr[r++]=tmp;
    	}
    }
    //Print array
    static void print1d(int arr[]) {
    	out.println(Arrays.toString(arr));
    }
    static void print2d(long arr[][]) {
    	for(long a[]: arr) out.println(Arrays.toString(a));
    }
    // Pair
    static class pair{
    	long x,y;
    	pair(long a,long b){
    		this.x=a;
    		this.y=b;
    	}
    	public boolean equals(Object obj) {
    		if(obj == null || obj.getClass()!= this.getClass()) return false;
            pair p = (pair) obj;
            return (this.x==p.x && this.y==p.y);
        }
    	public int hashCode() {
            return Objects.hash(x,y);
        }
    }
    static FastReader sc=new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    //Main function(The main code starts from here)
    static long fact[]=new long[31];
    static long C(int n,int r) {
    	return fact[n]/(fact[r]*fact[n-r]);
    }
    public static void main (String[] args) throws java.lang.Exception {
    	int test=1;
    	fact[0]=1L;
    	for(int i=1;i<=30;i++) fact[i]=(long)i*fact[i-1];
        while(test-->0) {
        	int n=sc.nextInt(),m=sc.nextInt(),t=sc.nextInt();
        	out.println(C(n,4)*C(m,1)*C(n+m-5,t-5));

        }
        out.flush();
        out.close();
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;
import java.util.InputMismatchException;

/**
 * @author adinata
 */
public class Theatre {

    static final String TASK_ID = "src/a";
    BigInteger comb(long A, long Take){
        BigInteger a = BigInteger.valueOf(A);
        BigInteger take = BigInteger.valueOf(Take);
        BigInteger b = take.max(a.subtract(take));
        BigInteger c = take.min(a.subtract(take));
        BigInteger ans = BigInteger.ONE;
        while (a.compareTo(b) == 1){ // a>b
            ans = ans.multiply(a);
            a = a.subtract(BigInteger.ONE);
        }
        while (c.compareTo(BigInteger.ONE) == 1){ // c>1
            ans = ans.divide(c);
            c = c.subtract(BigInteger.ONE);
        }
        return ans;
    }
    private void solve(InputReader in, OutputWriter out) {
        long n = in.readLong();
        long m = in.readLong();
        long t = in.readLong();

        if (n<4 || m < 1 || (n+m < t)) {
            out.printLine(0);
            return;
        }
        BigInteger ans = BigInteger.ZERO;
        for (long i=4; t-i > 0 && t-i<=m; i++){
            ans = ans.add(comb(n, i).multiply(comb(m,t-i)));
        }
        out.printLine(ans);
    }

    public static void main(String[] args) {
        new Theatre().rn();
    }

    private void rn() {
        InputStream inputStream;
        inputStream = System.in;

        OutputStream outputStream = System.out;

        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        solve(in, out);
        out.close();
    }

    class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public long readLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }
    }

    class OutputWriter {

        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(outputStream);
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }
    }
}

/**
 * @(#)Main.java
 *
 *
 * @author
 * @version 1.00 2011/9/7
 */
import java.math.*;
import java.util.*;
import java.lang.*;
public class Main {

        public static BigInteger cc(int a , int b)
        {
            BigInteger ret = BigInteger.ONE;
            int i;
            for(i = 1 ; i <= a ; i++)
                ret = ret.multiply(BigInteger.valueOf(i));
            for(i = 1 ; i <= b; i++)
                ret = ret.divide(BigInteger.valueOf(i));
            for(i = 1 ; i <= a-b ; i++)
                ret = ret.divide(BigInteger.valueOf(i));
            return ret;
        }
    public static void main(String args[]){
        Scanner cin = new Scanner(System.in);
                int n , m , t ;
                n = cin.nextInt();
                m = cin.nextInt();
                t = cin.nextInt();
                System.out.println(cc(n,4).multiply(cc(m,1)).multiply(cc(m+n-5,t-5)));
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class YoloSwag {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * C. The World is a Theatre
		time limit per test2 seconds
		memory limit per test256 megabytes
		inputstandard input
		outputstandard output
		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.
		 */
		int numBoys;
		int numGirls;
		int totalActors;

		Scanner sc = new Scanner(System.in);

		numBoys = sc.nextInt();
		numGirls = sc.nextInt();
		totalActors = sc.nextInt();

		long totalCombinations = 0L;
		for(int k = 4; k<=numBoys; k++){
			if(1 <= (totalActors - k) && (totalActors - k) <= numGirls){
//				System.out.println("n choose k: ("+numBoys+","+k+")=="+combination(numBoys,k)+"m choose t-k: ("+numGirls+","+(totalActors-k)+")=="+combination(numGirls,totalActors-k));
				totalCombinations += (listComb(numBoys, k) * listComb(numGirls, totalActors-k));
			}
		}

//		System.out.println("comb1: "+combination(numBoys, numGirls)+" comb2: "+comb2(numBoys, numGirls));

		System.out.println(totalCombinations);
	}

	public static long fact(long a){
		if(a == 0){
			return 1;
		}
		return a*fact(a-1);
	}

	public static long combination(long top, long bot){
//		System.out.println("top! / bot! (top-bot)! : "+ top+"! / "+bot+"! ("+(top-bot)+")!");
//		System.out.println("top! / bot! (top-bot)! : "+ fact(top)+" / "+fact(bot)+" ("+fact(top-bot)+")");
		return (fact(top) / (fact(bot) * fact(top-bot)));
	}

	public static long comb2(long top, long bot){
		long tot = 1L;
		//Calculate top! / bot! or top! / (top-bot)!, depending on which denomin is higher
		long higherOne = (bot > (top-bot)) ? bot : top-bot;
		long lowerOne = (bot > (top-bot)) ? top-bot : bot;

		for(long countdown = top; countdown>higherOne; countdown--){
			tot *= countdown;
		}

		tot /= fact(lowerOne);

		return tot;

	}

	public static long listComb(long top, long bot){
		//List-based combination. Let's kick ass maybe?
		List<Long> numeratorValues = new ArrayList<Long>();
		List<Long> denominatorValues = new ArrayList<Long>();

		for(long genNumer = 1L+bot; genNumer <= top; genNumer++){
			numeratorValues.add(genNumer);
		}

		for(long genDenom = 2; genDenom <= top-bot; genDenom++){//TODO works for bot == 0?
			denominatorValues.add(genDenom);
		}

		//Eliminate factors until denominatorValues is empty
		//Start with duplicates:
		int i = 0, j = 0;
		while(i < numeratorValues.size() && j < denominatorValues.size()){
			if(denominatorValues.get(j) == numeratorValues.get(i)){
				denominatorValues.remove(j);
				numeratorValues.set(i, new Long(1));
				i++;
			}else{
				j++;
			}
		}
		//Whatever's left in denominatorValues? Search numeratorValues for a factorable value and nuke it.
		for(Long l : denominatorValues){
			for(i = 0; i<numeratorValues.size(); i++){
				if(numeratorValues.get(i) % l == 0){
					numeratorValues.set(i, numeratorValues.get(i) / l);
					break;
				}
			}
			return -1L; // We done goofed
		}

		long tot = 1L;
		for(Long l : numeratorValues){
			tot *= l;
		}
		return tot;
	}

}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Task131C {

	public static void main(String... args) throws NumberFormatException,
			IOException {
		Solution.main(System.in, System.out);
	}

	static class Solution {

		static long combinations(int n, int k) {
			long retVal = 1;
			for (int i = 0; i < k; i++) {
				retVal *= (n - i) / (i + 1);
			}
			return retVal;
		}

		public static void main(InputStream is, OutputStream os)
				throws NumberFormatException, IOException {
			PrintWriter pw = new PrintWriter(os);
			Scanner s = new Scanner(is);

			int n = s.nextInt();
			int m = s.nextInt();
			int t = s.nextInt();

			long retVal = 0;

			for (int boys = 4; boys <= n && t - boys >= 1; boys++) {
				pw.println(n + ":" + boys + ":" + m + ":" + (t - boys));
				pw.println(combinations(n, boys) + ":"
						+ combinations(m, t - boys));
				retVal += combinations(n, boys) * combinations(m, t - boys);
			}

			pw.println(retVal);

			pw.flush();
			s.close();
		}
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Nasko
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {

            long n = in.nextLong();
            long m = in.nextLong();
            long t = in.nextLong();

            long ret = 0L;
            for (int i = 4; i <= n; ++i) {
                long q = t - i;
                if (q <= 0) break;
                ret += choose(n, i) * choose(m, q);
            }
            out.println(ret);
        }

        private long choose(long n, long k) {

            if (k >= n) return 1L;
            if (k < n - k) k = n - k;
            long p = 1L;
            for (long i = 1; i <= k; ++i) {
                p *= ((n - (k - i)));
                p /= (i);
            }
            return p;
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}

import java.util.*;
import java.io.*;
public class theater
{

    public static void main(String[] args) throws IOException
    {
        fact a = new fact();
        Scanner in = new Scanner(System.in);
        long guy = in.nextLong();
        long girl = in.nextLong();
        long people = in.nextLong();
        long vrem1 = people - 1;
        long vrem2 = 1;
        long res1=0,res2=0;long result = 0;
        if(guy + girl == people)
        {
            result =1;
        }
        else
        {
            while(vrem1>=4 && vrem2<=girl)
            {
                 res1 = a.comb(guy, vrem1);
                 res2 = a.comb(girl, vrem2);

                 result = res1*res2+result;
                 vrem1--;vrem2++;
            }
        }
        System.out.println(result);

    }

}
class fact
{
    public long factor(long data)
    {
        if( data<= 1)
            return 1;
        else
        return  data*factor(data-1);
    }
    public long comb(long ot,long do_)
    {
        long result = 1;
        long t = ot - do_;
        if(t < do_)
        {
            long vrem = 0;
            while(ot > do_&&result>0)
            {
                vrem = result;
                result = result*ot;
                ot--;
            }
            if(result>0)
            {
                result = result/factor(t);
            }
            else
            {
                result = vrem/factor(t);
                result = result*(ot+1);
            }
            while(ot > do_)
            {
                result = result*ot;
                ot--;
            }
        }
        else
        {
            long vrem1 = 0;
            while(ot>t&&result>0)
            {
                vrem1 = result;
                result = result*ot;
                ot--;
            }
            if(result>0)
            {
                result = result/factor(do_);
            }
            else
            {
                result = vrem1/factor(do_);
                result = result*(ot+1);
            }
            while(ot > t)
            {
                result = result*ot;
                ot--;
            }
        }
        return result;
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Arrangement implements Runnable {
    @Override
    public void run() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            String[] in = br.readLine().split(" ");
            int n = Integer.parseInt(in[0]);
            int m = Integer.parseInt(in[1]);
            int t = Integer.parseInt(in[2]);

            if (m < 1 || n < Math.min(4, t - 1) || t < 5){
                System.out.println(0);
                return;
            }
            long cur = m * Combination(t - 1, n);
            long res = cur;
            int u = Math.min(t, m);
            for (int girls = 2; girls <= u; girls++){
                int boys = t - girls;
                if (boys < 4){
                    break;
                }
                else{
                    cur = ((cur * (m - girls + 1) * (boys + 1))) / Math.max(1, n - boys) / (girls);
                    res += cur;
                }
            }System.out.println(res);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static long Combination(int k, int n){
        long[][] dp = new long[k + 1][n + 1];
        for (int i = 1; i <= n; i++){
            dp[0][i] = 1;
            dp[1][i] = i;
        }
        for (int i = 2; i <= k; i++){
            for (int j = 2; j <= n; j++){
                dp[i][j] = dp[i - 1][j - 1] + dp[i][j - 1];
            }
        }
        return dp[k][n];
    }
    public static void main(String[] args) {
        new Arrangement().run();
    }
}