// Arup Guha
// 12/18/2016
// Solution to 2016 Dec USACO Platinum Problem: Team Building (written in contest)

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

public class team {

	final public static long MOD = 1000000009L;

	public static int nJ;
	public static int[] john;
	public static int nP;
	public static int[] paul;
	public static int gSize;

	public static int[] beat;

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

		// Get input.
		Scanner stdin = new Scanner(new File("team.in"));
		nJ = stdin.nextInt();
		nP = stdin.nextInt();
		gSize = stdin.nextInt();
		john = new int[nJ];
		for (int i=0; i<nJ; i++) john[i] = stdin.nextInt();
		paul = new int[nP];
		for (int i=0; i<nP; i++) paul[i] = stdin.nextInt();
		Arrays.sort(john);
		Arrays.sort(paul);

		// beat[i] will store the lowest index of Paul's cow that beats John's cow i.
		int[] beat = new int[nJ];

		int p1 = 0, p2 = 0;
		while (p1 < nJ) {

			// avoid array out of bounds.
			if (p2 == nP) {
				beat[p1++] = nP;
				continue;
			}

			// Iterate p2 while john[p1] is better.
			while (p2 < nP && john[p1] > paul[p2]) p2++;
			beat[p1++] = p2;
		}

		// dp[i][j][k] stores # of ways for first cows 0-i of John, 0-j of Paul with teams of k+1 cows, how many ways John wins.
		long[][][] dp = new long[nP][nJ][gSize];
		dp[0][0][0] = beat[0] > 0 ? 1 : 0;

		// First row, just based on teams of one cow.
		for (int i=0; i<nP; i++) {
			for (int j=0; j<nJ; j++) {
				if (i == 0 && j == 0) continue;
				else if (j == 0) dp[i][j][0] = Math.min(beat[j],i+1);
				else dp[i][j][0] = dp[i][j-1][0] + Math.min(beat[j],i+1);
			}
		}

		// Speeds up DP stores cumulative sum array.
		long[][][] aux = new long[nP][nJ][gSize];
		for (int i=0; i<nP; i++)
			for (int j=0; j<nJ; j++)
				aux[i][j][0] = i > 0 ? aux[i-1][j][0] + dp[i][j][0] : dp[i][j][0];

		// Go through group sizes.
		for (int k=1; k<gSize; k++) {

			// Number of cows for Paul and John.
			for (int i=1; i<nP; i++) {
				for (int j=1; j<nJ; j++) {

					// Range for adding values in our DP array.
					int low = Math.max(0,k-2);
					int high = Math.min(beat[j]-2,i-1);

					if (low > high) continue;

					// This is the sum of everything upto the last dp item we want to add.
					long add = aux[high][j-1][k-1];

					// If we need to subtract a prefix out, we do it here.
					if (low > 0)
						add = (add - aux[low-1][j-1][k-1]+MOD)%MOD;

					// Here is what we add when John gets 1 more cow.
					dp[i][j][k] = (dp[i][j-1][k] + add)%MOD;

					// Adjusted cumulative sum, now that we have the DP array.
					aux[i][j][k] = (aux[i-1][j][k]+dp[i][j][k])%MOD;

				} // end j


			} // end i
		}

		// Here is our result.
		PrintWriter out = new PrintWriter(new FileWriter("team.out"));
		out.println(dp[nP-1][nJ-1][gSize-1]);
		out.close();
		stdin.close();
	}
}