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

public class A {

    private static long modulo = 1000000007;

    private static void solve() {
        int n = in.nextInt();
        int m = in.nextInt();
        int b = in.nextInt();
        modulo = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }
        int[][] dp = new int[m + 1][b + 1];
        dp[0][0] = 1;
        for (int i = 0; i < n; i++) {
            for (int v = 0; v < m; v++) {
                for (int j = 0; j <= b; j++) {
                    if (j + a[i] <= b) {
                        dp[v + 1][j + a[i]] += (dp[v + 1][j + a[i]] + dp[v][j]) % modulo;
                    }
                }
            }
        }
        long result = 0;
        for (int j = 0; j <= b; j++) {
            result = (result + dp[m][j]) % modulo;
        }
        out.println(result);
    }

    private static long inverse(long a) {
        long result = 1;
        int n = (int) modulo - 2;
        while (n != 0) {
            if ((n & 1) == 1)
                result = (result * a) % modulo;
            a = (a * a) % modulo;
            n >>= 1;
        }
        return result;
    }

    private static long pow(long a, long n) {
        if (n == 0) return 1;
        if (n % 2 == 0) {
            long ans = pow(a, n / 2);
            return ans * ans;
        } else {
            return a * pow(a, n - 1);
        }
    }

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

    private static void closeStreams() {
        in.close();
        out.close();
    }

    private static final FastScanner in = new FastScanner();
    private static final PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

    public static class FastScanner {

        private BufferedReader br;
        private 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;
        }

        void close() {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}


import java.util.Scanner;

public class WritingCode2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int b = sc.nextInt();
        int mod = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }

        //locs, progamers, bugs
        int[][] d1 = new int[m + 1][b + 1];
        for (int j = 0; j <= m; j++) {
            int bugs = a[0] * j;
            if (bugs <= b) {
                d1[j][bugs] = 1;
            } else {
                break;
            }
        }
        d1[0][0] = 1;
        //programmer
        for (int i = 1; i < n; i++) {
            int[][] d2 = new int[m + 1][b + 1];
            d2[0][0] = 1;

            //loc
            for (int j = 1; j <= m; j++) {
                for (int k = 0; k <= b; k++) {
                    d2[j][k] = d1[j][k];
                    if (k - a[i] >= 0) {
                        d2[j][k] = (d2[j][k] + d2[j - 1][k - a[i]]) % mod;
                    }
                }
                //d[j][i] = (d[j - 1][i] + d[j][i - 1]) % mod;
            }
            d1 = d2;
        }
        int res = 0;
        for (int k = 0; k <= b ; k++) {
            res = (res +  d1[m][k]) % mod;
        }

        System.out.println(res);
    }
}


import java.util.Scanner;

public class WritingCode2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int b = sc.nextInt();
        int mod = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }

        //locs, progamers, bugs
        int[][][] d = new int[m + 1][b + 1][n];
        for (int j = 0; j <= m; j++) {
            int bugs = a[0] * j;
            if (bugs <= b) {
                d[j][bugs][0] = 1;
            } else {
                break;
            }
        }
        for (int i = 0; i < n; i++) {
            d[0][0][i] = 1;
        }
        //programmer
        for (int i = 1; i < n; i++) {
            //loc
            for (int j = 1; j <= m; j++) {
                for (int k = 0; k <= b; k++) {
                    d[j][k][i] = d[j][k][i - 1];
                    if (k - a[i] >= 0) {
                        d[j][k][i] = (d[j][k][i] + d[j - 1][k - a[i]][i]) % mod;
                    }
                }
                //d[j][i] = (d[j - 1][i] + d[j][i - 1]) % mod;
            }
        }
        int res = 0;
        for (int k = 0; k <= b ; k++) {
            res = (res +  d[m][k][n-1]) % mod;
        }

        System.out.println(res);
    }
}


public class WritingTheCode {

	private int[][] dp = new int[504][504];
	private int n;

	public int solve(int m, int b, int[] a, int mod) {
		n = a.length;
		java.util.Arrays.sort(a);

		dp[0][0] = 1;
		for(int k = 0; k < n; k++) {
			for(int i = 0; i < m; i++) {
				for(int j = 0; j <= b; j++) {
					if(j + a[k] > b) continue;
					dp[i + 1][j + a[k]] = (dp[i + 1][j + a[k]] + dp[i][j]) % mod;
				}
			}
		}

		int sum = 0;
		for(int i = 0; i <= b; i++) {
			sum = (sum + dp[m][i]) % mod;
		}

		return sum;
	}

	public static void main(String[] args) {

		java.util.Scanner s = new java.util.Scanner(System.in);
		int n = s.nextInt();
		int[] a = new int[n];
		int m = s.nextInt();
		int b = s.nextInt();
		int mod = s.nextInt();
		for(int i = 0; i < n; i++)
			a[i] = s.nextInt();
		s.close();

		WritingTheCode wtc = new WritingTheCode();
		int h = wtc.solve(m, b, a, mod);
		System.out.println(h);
	}

}


public class WritingTheCode {

	private int[][] dp = new int[504][504];
	private int n;

	public int solve(int m, int b, int[] a, int mod) {
		n = a.length;
		java.util.Arrays.sort(a);

		dp[0][0] = 1;
		for(int k = 0; k < n; k++) {
			for(int i = 0; i < m; i++) {
				for(int j = 0; j < b; j++) {
					if(j + a[k] > b) continue;
					dp[i + 1][j + a[k]] = (dp[i + 1][j + a[k]] + dp[i][j]) % mod;
				}
			}
		}

		int sum = 0;
		for(int i = 0; i <= b; i++) {
			sum = (sum + dp[m][i]) % mod;
		}

		return sum;
	}

	public static void main(String[] args) {

		java.util.Scanner s = new java.util.Scanner(System.in);
		int n = s.nextInt();
		int[] a = new int[n];
		int m = s.nextInt();
		int b = s.nextInt();
		int mod = s.nextInt();
		for(int i = 0; i < n; i++)
			a[i] = s.nextInt();
		s.close();

		WritingTheCode wtc = new WritingTheCode();
		int h = wtc.solve(m, b, a, mod);
		System.out.println(h);
	}

}


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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author ilyakor
 */
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);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {

    public static final int inf = 1000 * 1000 * 500;

    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        char[][] s = new char[n][];
        for (int i = 0; i < n; ++i) {
            s[i] = in.nextToken().toCharArray();
            Assert.assertTrue(s[i].length == m);
        }
        int[][] w = new int[n][m];
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                w[i][j] = in.nextInt();
        ArrayList<ii> a = new ArrayList<>();
        int smask = 0;
        for (int i = 0; i < m; ++i) {
            int[] masks = new int[26];
            int[] costs = new int[26];
            int[] maxs = new int[26];
            for (int j = 0; j < n; ++j) {
                int c = s[j][i] - 'a';
                masks[c] |= (1 << j);
                costs[c] += w[j][i];
                maxs[c] = Math.max(maxs[c], w[j][i]);
            }
            for (int j = 0; j < 26; ++j)
                if (masks[j] > 0) {
                    if (costs[j] - maxs[j] == 0)
                        smask |= masks[j];
                    else
                        a.add(new ii(masks[j], costs[j] - maxs[j]));
                }
        }

        int[] d = new int[1 << n];
        Arrays.fill(d, inf);
        d[smask] = 0;
        d[0] = 0;
        for (int i = 0; i < d.length; ++i) {
            if (d[i] >= inf) continue;
            for (ii entry : a) {
                if (i != (i | entry.first)) {
                    int val = d[i] + entry.second;
                    if (d[i | entry.first] > val)
                        d[i | entry.first] = val;
                }
            }
        }
        Assert.assertTrue(d[(1 << n) - 1] < inf);
        out.printLine(d[(1 << n) - 1]);
    }
}

class InputReader {
    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

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

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

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

    public int readSkipSpace() {
        int c;
        do {
            c = read();
        } while (isSpace(c));
        return c;
    }

    public String nextToken() {
        int c = readSkipSpace();
        StringBuilder sb = new StringBuilder();
        while (!isSpace(c)) {
            sb.append((char) c);
            c = read();
        }
        return sb.toString();
    }

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

}

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

}

class Assert {

    public static void assertTrue(boolean flag) {
        if (!flag)
            throw new AssertionError();
    }

}

class ii implements Comparable<ii> {
    public int first;
    public int second;

    public ii() {
    }

    public ii(int first, int second) {
        this.first = first;
        this.second = second;
    }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ii ii = (ii) o;

        if (first != ii.first) return false;
        if (second != ii.second) return false;

        return true;
    }

    public int hashCode() {
        int result = first;
        result = 31 * result + second;
        return result;
    }

    public int compareTo(ii o) {
        if (first != o.first) {
            return first < o.first ? -1 : 1;
        }
        if (second != o.second) {
            return second < o.second ? -1 : 1;
        }
        return 0;
    }

}


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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author ilyakor
 */
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);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        int b = in.nextInt();
        int mod = in.nextInt();

        int[] a = new int[n];
        for (int i = 0; i < n; ++i)
            a[i] = in.nextInt();

        int[][] d = new int[m + 1][b + 1];
        d[0][0] = 1;
        for (int it = 0; it < n; ++it) {
            for (int i = 0; i <= m; ++i)
                for (int j = 0; j <= b; ++j) {
                    if (i + 1 <= m && j + a[it] <= b) {
                        d[i + 1][j + a[it]] += d[i][j];
                        d[i + 1][j + a[it]] %= mod;
                    }
                }
        }

        int res = 0;
        for (int i = 0; i <= b; ++i)
            res = (res + d[m][i]) % mod;
        out.printLine(res);

    }
}

class InputReader {
    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

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

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

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

    public int readSkipSpace() {
        int c;
        do {
            c = read();
        } while (isSpace(c));
        return c;
    }

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

}

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

}


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

public class P543A{
	static long mod=1000000007;

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

    	//int t=in.readInt();
        //	while(t-->0)
        	//{
        	int n=in.readInt();
        	int m=in.readInt();
        	int b=in.readInt();
        	mod=in.readInt();
    	//long n=in.readLong();
    	int a[]=new int[n];
    	for(int i=0;i<n;i++)
    	{
    		a[i]=in.readInt();
    	}
    	long dp[][]=new long[m+1][b+1];
    	dp[0][0]=1;
    	for(int i=0;i<n;i++)
    	{
    		for(int j=0;j<=m;j++)
    		{
    			for(int k=0;k<=b;k++)
    			{
    				if(j+1<=m&&k+a[i]<=b)
    				{
    					dp[j+1][k+a[i]]+=dp[j][k];
    					dp[j+1][k+a[i]]%=mod;
    				}

    			}
    		}
    	}

    	long ans=0;
    	for(int i=0;i<=b;i++)
    	{
    		ans+=dp[m][i];
    		ans%=mod;
    	}
    	//String a=in.readString();

		  pw.println(ans);

    	//}

    	pw.close();
    }

    /* returns nCr mod m */
   	public static long comb(long n, long r, long m)
   	{
   		long p1 = 1, p2 = 1;
   		for (long i = r + 1; i <= n; i++) {
   			p1 = (p1 * i) % m;
   		}
   		p2 = factMod(n - r, m);
   		p1 = divMod(p1, p2, m);
   		return p1 % m;
   	}
   /* returns a/b mod m, works only if m is prime and b divides a */
   	public static long divMod(long a, long b, long m)
   	{
   		long c = powerMod(b, m - 2, m);
   		return ((a % m) * (c % m)) % m;
   	}
   /* calculates factorial(n) mod m */
   	public static long factMod(long n, long m) {
   		long result = 1;
   		if (n <= 1)
   			return 1;
   		while (n != 1) {
   			result = ((result * n--) % m);
   		}
   		return result;
   	}
   /* This method takes a, b and c as inputs and returns (a ^ b) mod c */
   	public static long powerMod(long a, long b, long c) {
   		long result = 1;
   		long temp = 1;
   		long mask = 1;
   		for (int i = 0; i < 64; i++) {
   			mask = (i == 0) ? 1 : (mask * 2);
   			temp = (i == 0) ? (a % c) : (temp * temp) % c;
   			/* Check if (i + 1)th bit of power b is set */
   			if ((b & mask) == mask) {
   				result = (result * temp) % c;
   			}
   		}
   		return result;
   	}

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

public static int gcd(int x,int y)
{
	if(x%y==0)
		return y;
	else
		return gcd(y,x%y);
}
public static int abs(int a,int b)
{
	return (int)Math.abs(a-b);
}
public static long abs(long a,long b)
{
	return (long)Math.abs(a-b);
}
public static int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}
public static int min(int a,int b)
{
	if(a>b)
		return b;
	else
		return a;
}
public static long max(long a,long b)
{
	if(a>b)
		return a;
	else
		return b;
}
public static long min(long a,long b)
{
	if(a>b)
		return b;
	else
		return a;
}

static boolean isPowerOfTwo (long v) {
	return (v & (v - 1)) == 0;
}
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 long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}
static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

	public int compareTo(Pair o) {
		// TODO Auto-generated method stub
		if(this.a!=o.a)
		return Integer.compare(this.a,o.a);
		else
			return Integer.compare(this.b, o.b);
		//return 0;
	}
	public boolean equals(Object o) {
        if (o instanceof Pair) {
            Pair p = (Pair)o;
            return p.a == a && p.b == b;
        }
        return false;
    }
    public int hashCode() {
        return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
    }
}

static long sort(int a[],int n)
{  	int b[]=new int[n];
	return mergeSort(a,b,0,n-1);}
static long mergeSort(int a[],int b[],long left,long right)
{ long c=0;if(left<right)
 {   long mid=left+(right-left)/2;
	 c= mergeSort(a,b,left,mid);
	 c+=mergeSort(a,b,mid+1,right);
	 c+=merge(a,b,left,mid+1,right); }
	return c;	 }
static long merge(int a[],int  b[],long left,long mid,long right)
{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
while(i<=(int)mid-1&&j<=(int)right)
{ if(a[i]<=a[j]) {b[k++]=a[i++]; }
else	{ b[k++]=a[j++];c+=mid-i;}}
while (i <= (int)mid - 1)   b[k++] = a[i++];
while (j <= (int)right) b[k++] = a[j++];
for (i=(int)left; i <= (int)right; i++)
	a[i] = b[i];  return c;  }

   static  class InputReader
    {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private 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 readInt()
        {
            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 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();
        }
        public double readDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, readInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, readInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
        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 boolean isSpaceChar(int c)
        {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next()
        {
            return readString();
        }

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

//BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	//StringBuilder sb=new StringBuilder("");
	 //InputReader in = new InputReader(System.in);
	//PrintWriter pw=new PrintWriter(System.out);
	//String line=br.readLine().trim();

	//int t=Integer.parseInt(br.readLine());
  //	while(t-->0)
  	//{
  	//int n=Integer.parseInt(br.readLine());
	//long n=Long.parseLong(br.readLine());
	//String l[]=br.readLine().split(" ");
  //int m=Integer.parseInt(l[0]);
	//int k=Integer.parseInt(l[1]);
	//String l[]=br.readLine().split(" ");
	//l=br.readLine().split(" ");
	/*int a[]=new int[n];
	for(int i=0;i<n;i++)
	{
		a[i]=Integer.parseInt(l[i]);
	}*/
	   //System.out.println(" ");

	//}
}


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

public class P543A{
	static long mod=1000000007;

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

    	//int t=in.readInt();
        //	while(t-->0)
        	//{
        	int n=in.readInt();
        	int m=in.readInt();
        	int b=in.readInt();
        	mod=in.readInt();
    	//long n=in.readLong();
    	int a[]=new int[n];
    	for(int i=0;i<n;i++)
    	{
    		a[i]=in.readInt();
    	}
    	long dp[][]=new long[m+1][b+1];
    	dp[0][0]=1;
    	for(int i=0;i<n;i++)
    	{
    		for(int j=0;j<m;j++)
    		{
    			for(int k=0;k+a[i]<=b;k++)
    			{

    					dp[j+1][k+a[i]]+=dp[j][k];
    					dp[j+1][k+a[i]]%=mod;

    			}
    		}
    	}

    	long ans=0;
    	for(int i=0;i<=b;i++)
    	{
    		ans+=dp[m][i];
    		ans%=mod;
    	}
    	//String a=in.readString();

		  pw.println(ans);

    	//}

    	pw.close();
    }

    /* returns nCr mod m */
   	public static long comb(long n, long r, long m)
   	{
   		long p1 = 1, p2 = 1;
   		for (long i = r + 1; i <= n; i++) {
   			p1 = (p1 * i) % m;
   		}
   		p2 = factMod(n - r, m);
   		p1 = divMod(p1, p2, m);
   		return p1 % m;
   	}
   /* returns a/b mod m, works only if m is prime and b divides a */
   	public static long divMod(long a, long b, long m)
   	{
   		long c = powerMod(b, m - 2, m);
   		return ((a % m) * (c % m)) % m;
   	}
   /* calculates factorial(n) mod m */
   	public static long factMod(long n, long m) {
   		long result = 1;
   		if (n <= 1)
   			return 1;
   		while (n != 1) {
   			result = ((result * n--) % m);
   		}
   		return result;
   	}
   /* This method takes a, b and c as inputs and returns (a ^ b) mod c */
   	public static long powerMod(long a, long b, long c) {
   		long result = 1;
   		long temp = 1;
   		long mask = 1;
   		for (int i = 0; i < 64; i++) {
   			mask = (i == 0) ? 1 : (mask * 2);
   			temp = (i == 0) ? (a % c) : (temp * temp) % c;
   			/* Check if (i + 1)th bit of power b is set */
   			if ((b & mask) == mask) {
   				result = (result * temp) % c;
   			}
   		}
   		return result;
   	}

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

public static int gcd(int x,int y)
{
	if(x%y==0)
		return y;
	else
		return gcd(y,x%y);
}
public static int abs(int a,int b)
{
	return (int)Math.abs(a-b);
}
public static long abs(long a,long b)
{
	return (long)Math.abs(a-b);
}
public static int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}
public static int min(int a,int b)
{
	if(a>b)
		return b;
	else
		return a;
}
public static long max(long a,long b)
{
	if(a>b)
		return a;
	else
		return b;
}
public static long min(long a,long b)
{
	if(a>b)
		return b;
	else
		return a;
}

static boolean isPowerOfTwo (long v) {
	return (v & (v - 1)) == 0;
}
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 long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}
static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

	public int compareTo(Pair o) {
		// TODO Auto-generated method stub
		if(this.a!=o.a)
		return Integer.compare(this.a,o.a);
		else
			return Integer.compare(this.b, o.b);
		//return 0;
	}
	public boolean equals(Object o) {
        if (o instanceof Pair) {
            Pair p = (Pair)o;
            return p.a == a && p.b == b;
        }
        return false;
    }
    public int hashCode() {
        return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
    }
}

static long sort(int a[],int n)
{  	int b[]=new int[n];
	return mergeSort(a,b,0,n-1);}
static long mergeSort(int a[],int b[],long left,long right)
{ long c=0;if(left<right)
 {   long mid=left+(right-left)/2;
	 c= mergeSort(a,b,left,mid);
	 c+=mergeSort(a,b,mid+1,right);
	 c+=merge(a,b,left,mid+1,right); }
	return c;	 }
static long merge(int a[],int  b[],long left,long mid,long right)
{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
while(i<=(int)mid-1&&j<=(int)right)
{ if(a[i]<=a[j]) {b[k++]=a[i++]; }
else	{ b[k++]=a[j++];c+=mid-i;}}
while (i <= (int)mid - 1)   b[k++] = a[i++];
while (j <= (int)right) b[k++] = a[j++];
for (i=(int)left; i <= (int)right; i++)
	a[i] = b[i];  return c;  }

   static  class InputReader
    {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private 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 readInt()
        {
            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 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();
        }
        public double readDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, readInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, readInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
        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 boolean isSpaceChar(int c)
        {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next()
        {
            return readString();
        }

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

//BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	//StringBuilder sb=new StringBuilder("");
	 //InputReader in = new InputReader(System.in);
	//PrintWriter pw=new PrintWriter(System.out);
	//String line=br.readLine().trim();

	//int t=Integer.parseInt(br.readLine());
  //	while(t-->0)
  	//{
  	//int n=Integer.parseInt(br.readLine());
	//long n=Long.parseLong(br.readLine());
	//String l[]=br.readLine().split(" ");
  //int m=Integer.parseInt(l[0]);
	//int k=Integer.parseInt(l[1]);
	//String l[]=br.readLine().split(" ");
	//l=br.readLine().split(" ");
	/*int a[]=new int[n];
	for(int i=0;i<n;i++)
	{
		a[i]=Integer.parseInt(l[i]);
	}*/
	   //System.out.println(" ");

	//}
}


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

public class WritingCode {

	public static void main(String[] args) {
		InputReader ir = new InputReader(System.in);
		int n = ir.nextInt(), m = ir.nextInt(), b = ir.nextInt(), mod = ir.nextInt();
		int[] a = new int [n+1];
		for (int i = 1; i <= n; ++i) {
			a[i] = ir.nextInt();
		}
		int dp[][][] = new int [n+1][m+1][b+1];
		dp[0][0][0] = 1;
		for (int programmer = 1; programmer <= n; ++programmer) {
			for (int lines = 0; lines <= m; ++lines) {
				for (int bugs = 0; bugs <= b; ++bugs) {
					dp[programmer][lines][bugs] = dp[programmer-1][lines][bugs];
					if (lines >= 1 && bugs >= a[programmer]) {
						dp[programmer][lines][bugs] +=
								dp[programmer][lines-1][bugs-a[programmer]];
					}
				}
			}
		}
		OutputWriter ow = new OutputWriter(System.out);
		int answer = 0;
		for (int bugs = 0; bugs <= b; ++bugs) {
			answer += dp[n][m][bugs];
			answer %= mod;
		}
		ow.printLine(answer);
		ow.close();
	}

}
class InputReader {
    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

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

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

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

    public int readSkipSpace() {
        int c;
        do {
            c = read();
        } while (isSpace(c));
        return c;
    }

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

    public int nextInt(){return (int)nextLong();}

    public String nextString() {
    	String result = "";
    	int c = readSkipSpace();
    	do {
    		result += (char) c;
    		c = read();
    	} while(!isSpace(c));
    	return result;
    }

}

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

}


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

public class WritingCode {

	public static void main(String[] args) {
		InputReader ir = new InputReader(System.in);
		int n = ir.nextInt(), m = ir.nextInt(), b = ir.nextInt(), mod = ir.nextInt();
		int[] a = new int [n+1];
		for (int i = 1; i <= n; ++i) {
			a[i] = ir.nextInt();
		}
		int dp[][] = new int [m+1][b+1];
		dp[0][0] = 1;
		for (int programmer = 1; programmer <= n; ++programmer) {
			for (int lines = 0; lines <= m; ++lines) {
				for (int bugs = 0; bugs <= b; ++bugs) {
					if (lines >= 1 && bugs >= a[programmer]) {
						dp[lines][bugs] +=
								dp[lines-1][bugs-a[programmer]];
						dp[lines][bugs] %= mod;
					}
				}
			}
		}
		OutputWriter ow = new OutputWriter(System.out);
		int answer = 0;
		for (int bugs = 0; bugs <= b; ++bugs) {
			answer += dp[m][bugs];
			answer %= mod;
		}
		ow.printLine(answer);
		ow.close();
	}

}
class InputReader {
    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

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

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

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

    public int readSkipSpace() {
        int c;
        do {
            c = read();
        } while (isSpace(c));
        return c;
    }

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

    public int nextInt(){return (int)nextLong();}

    public String nextString() {
    	String result = "";
    	int c = readSkipSpace();
    	do {
    		result += (char) c;
    		c = read();
    	} while(!isSpace(c));
    	return result;
    }

}

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

}


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

public class WritingCode {

	public static void main(String[] args) {
		InputReader ir = new InputReader(System.in);
		int n = ir.nextInt(), m = ir.nextInt(), b = ir.nextInt(), mod = ir.nextInt();
		int[] a = new int [n+1];
		for (int i = 1; i <= n; ++i) {
			a[i] = ir.nextInt();
		}
		int dp[][][] = new int [2][m+1][b+1];
		dp[0][0][0] = 1;
		for (int programmer = 1; programmer <= n; ++programmer) {
			for (int lines = 0; lines <= m; ++lines) {
				for (int bugs = 0; bugs <= b; ++bugs) {
					dp[programmer%2][lines][bugs] = dp[(programmer-1)%2][lines][bugs];
					if (lines >= 1 && bugs >= a[programmer]) {
						dp[programmer%2][lines][bugs] +=
								dp[programmer%2][lines-1][bugs-a[programmer]];
						dp[programmer%2][lines][bugs] %= mod;
					}
				}
			}
		}
		OutputWriter ow = new OutputWriter(System.out);
		int answer = 0;
		for (int bugs = 0; bugs <= b; ++bugs) {
			answer += dp[n%2][m][bugs];
			answer %= mod;
		}
		ow.printLine(answer);
		ow.close();
	}

}
class InputReader {
    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

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

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

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

    public int readSkipSpace() {
        int c;
        do {
            c = read();
        } while (isSpace(c));
        return c;
    }

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

    public int nextInt(){return (int)nextLong();}

    public String nextString() {
    	String result = "";
    	int c = readSkipSpace();
    	do {
    		result += (char) c;
    		c = read();
    	} while(!isSpace(c));
    	return result;
    }

}

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

}


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

public class WritingCode {

	public static void main(String[] args) {
		InputReader ir = new InputReader(System.in);
		int n = ir.nextInt(), m = ir.nextInt(), b = ir.nextInt(), mod = ir.nextInt();
		int[] a = new int [n+1];
		for (int i = 1; i <= n; ++i) {
			a[i] = ir.nextInt();
		}
		int dp[][][] = new int [2][m+1][b+1];
		dp[0][0][0] = 1;
		for (int programmer = 1; programmer <= n; ++programmer) {
			for (int lines = 0; lines <= m; ++lines) {
				for (int bugs = 0; bugs <= b; ++bugs) {
					dp[programmer%2][lines][bugs] = dp[(programmer-1)%2][lines][bugs];
					if (lines >= 1 && bugs >= a[programmer%2]) {
						dp[programmer%2][lines][bugs] +=
								dp[programmer%2][lines-1][bugs-a[programmer%2]];
					}
				}
			}
		}
		OutputWriter ow = new OutputWriter(System.out);
		int answer = 0;
		for (int bugs = 0; bugs <= b; ++bugs) {
			answer += dp[n%2][m][bugs];
			answer %= mod;
		}
		ow.printLine(answer);
		ow.close();
	}

}
class InputReader {
    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

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

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

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

    public int readSkipSpace() {
        int c;
        do {
            c = read();
        } while (isSpace(c));
        return c;
    }

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

    public int nextInt(){return (int)nextLong();}

    public String nextString() {
    	String result = "";
    	int c = readSkipSpace();
    	do {
    		result += (char) c;
    		c = read();
    	} while(!isSpace(c));
    	return result;
    }

}

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

}


import java.util.Scanner;

public class ezdp {
	static int[][] memo;

	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 b = in.nextInt();
		int mod = in.nextInt();
		memo = new int[m + 1][b + 1];
		for(int i =0 ; i < memo.length; i++){
			for(int j = 0; j < memo[0].length; j++){
				memo[i][j]=-1;
			}
		}
		memo[0][0]=1;
		int sum = 0;
		for (int programmer = 0; programmer < n; programmer++) {
			int a = in.nextInt();
			for (int bugs = 0; bugs <= b; bugs++) {
				for (int lines = 0; lines <= m; lines++) {
					if (memo[lines][bugs] != -1 && lines + 1 <= m && bugs + a <= b) {
						memo[lines + 1][bugs + a] =(memo[lines+1][bugs+a]==-1?0:memo[lines+1][bugs+a])+memo[lines][bugs];
						memo[lines + 1][bugs + a] %= mod;
					}
				}
			}
		}
		for(int bugs = 0; bugs <= b; bugs++){
			if (memo[m][bugs] != -1)
				sum += memo[m][bugs];
			sum%=mod;
		}
		System.out.println(sum);
	}

}


import java.util.Scanner;

public class ezdp {
	static Integer[][] memo;

	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 b = in.nextInt();
		int mod = in.nextInt();
		memo = new Integer[m + 1][b + 1];
		memo[0][0]=1;
		int sum = 0;
		for (int programmer = 0; programmer < n; programmer++) {
			int a = in.nextInt();
			for (int bugs = 0; bugs <= b; bugs++) {
				for (int lines = 0; lines <= m; lines++) {
					if (memo[lines][bugs] != null && lines + 1 <= m && bugs + a <= b) {
						memo[lines + 1][bugs + a] =(memo[lines+1][bugs+a]==null?0:memo[lines+1][bugs+a])+memo[lines][bugs];
						memo[lines + 1][bugs + a] %= mod;
					}
				}
			}
		}
		for(int bugs = 0; bugs <= b; bugs++){
			if (memo[m][bugs] != null)
				sum += memo[m][bugs];
			sum%=mod;
		}
		System.out.println(sum);
	}

}


import java.util.Scanner;

public class ezdp {
	static int[][] memo;

	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 b = in.nextInt();
		int mod = in.nextInt();
		memo = new int[m + 1][b + 1];
		for(int i =0 ; i < memo.length; i++){
			for(int j = 0; j < memo.length; j++){
				memo[i][j]=-1;
			}
		}
		memo[0][0]=1;
		int sum = 0;
		for (int programmer = 0; programmer < n; programmer++) {
			int a = in.nextInt();
			for (int bugs = 0; bugs <= b; bugs++) {
				for (int lines = 0; lines <= m; lines++) {
					if (memo[lines][bugs] != -1 && lines + 1 <= m && bugs + a <= b) {
						memo[lines + 1][bugs + a] =(memo[lines+1][bugs+a]==-1?0:memo[lines+1][bugs+a])+memo[lines][bugs];
						memo[lines + 1][bugs + a] %= mod;
					}
				}
			}
		}
		for(int bugs = 0; bugs <= b; bugs++){
			if (memo[m][bugs] != -1)
				sum += memo[m][bugs];
			sum%=mod;
		}
		System.out.println(sum);
	}

}


import java.util.Scanner;

public class ezdp {
	static int[][] memo;

	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 b = in.nextInt();
		int mod = in.nextInt();
		memo = new int[m + 1][b + 1];
		memo[0][0]=1;
		int sum = 0;
		for (int programmer = 0; programmer < n; programmer++) {
			int a = in.nextInt();
			for (int bugs = 0; bugs <= b; bugs++) {
				for (int lines = 0; lines <= m; lines++) {
					if (lines + 1 <= m && bugs + a <= b) {
						memo[lines + 1][bugs + a] =(memo[lines+1][bugs+a]==-1?0:memo[lines+1][bugs+a])+memo[lines][bugs];
						memo[lines + 1][bugs + a] %= mod;
					}
				}
			}
		}
		for(int bugs = 0; bugs <= b; bugs++){
			sum += memo[m][bugs];
			sum%=mod;
		}
		System.out.println(sum);
	}

}


import java.util.Scanner;

public class ezdp {
	static Integer[][] memo;

	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 b = in.nextInt();
		int mod = in.nextInt();
		memo = new Integer[m + 1][b + 1];
		memo[0][0]=1;
		int sum = 0;
		for (int programmer = 0; programmer < n; programmer++) {
			int a = in.nextInt();
			for (int bugs = 0; bugs <= b; bugs++) {
				for (int lines = 0; lines <= m; lines++) {
					if (memo[lines][bugs] != null && lines + 1 <= m && bugs + a <= b) {
						memo[lines + 1][bugs + a] =(memo[lines+1][bugs+a]==null?0:memo[lines+1][bugs+a])+memo[lines][bugs];
						memo[lines + 1][bugs + a] %= mod;
					}
				}
			}
		}
		for(int bugs = 0; bugs <= b; bugs++){
			if (memo[m][bugs] != null)
				sum += memo[m][bugs];
		}
		System.out.println(sum);
	}

}


// ~/BAU/ACM-ICPC/Teams/A++/BlackBurn95
// ~/sudo apt-get Accpeted

import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

    static int n,m,b,MOD;
    static int [] a;
    static int [][][] dp;

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

        tk = new StringTokenizer(in.readLine());
        n = parseInt(tk.nextToken());
        m = parseInt(tk.nextToken());
        b = parseInt(tk.nextToken());
        MOD = parseInt(tk.nextToken());

        a = new int[n];
        dp = new int[n][m+1][b+1];
        tk = new StringTokenizer(in.readLine());
        for(int i=0; i<n; i++) {
            a[i] = parseInt(tk.nextToken());
            for(int j=0; j<=m; j++)
                Arrays.fill(dp[i][j], -1);
        }

        System.out.println(calc(0,m,0));
    }

    static int calc(int i,int l,int t) {
        if(i==n) {
            if(l==0) return 1;
            return 0;
        }

        if(dp[i][l][t]!=-1)
            return dp[i][l][t];

        int ans = calc(i+1,l,t);
        if(l>0 && t + a[i]<=b) ans = (ans + calc(i,l-1,t+a[i]))%MOD;

        return dp[i][l][t] = ans;
    }
}


// ~/BAU/ACM-ICPC/Teams/A++/BlackBurn95
// ~/sudo apt-get Accpeted

import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

    static int n,m,b,MOD;
    static int [] a;
    static int [][][] dp;

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

        tk = new StringTokenizer(in.readLine());
        n = parseInt(tk.nextToken());
        m = parseInt(tk.nextToken());
        b = parseInt(tk.nextToken());
        MOD = parseInt(tk.nextToken());

        a = new int[n];
        dp = new int[2][m+1][b+1];
        tk = new StringTokenizer(in.readLine());
        for(int i=0; i<n; i++)
            a[i] = parseInt(tk.nextToken());

        for(int i=0; i<=b; i++)
            dp[n%2][0][i] = 1;
        for(int i=n-1; i>=0; i--)
            for(int j=0; j<=m; j++)
                for(int k=b; k>=0; k--) {
                    dp[i%2][j][k] = dp[(i+1)%2][j][k];
                    if(j>0 && k+a[i]<=b)
                        dp[i%2][j][k] = (dp[i%2][j][k] + dp[i%2][j-1][k+a[i]])%MOD;
                }

        int ans = 0;
        //for(int i=0; i<=b; i++)
            ans = (ans + dp[0][m][0])%MOD;

        System.out.println(ans);
    }

    static int calc(int i,int l,int t) {
        if(i==n) {
            if(l==0) return 1;
            return 0;
        }

        if(dp[i][l][t]!=-1)
            return dp[i][l][t];

        int ans = calc(i+1,l,t);
        if(l>0 && t + a[i]<=b) ans = (ans + calc(i,l-1,t+a[i]))%MOD;

        return dp[i][l][t] = ans;
    }
}


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

public class test {
    int INF = (int)1e9;
    long MOD = 1000000007;

    int[][][] dp;
    int[] a;
    int mod;
    int n, m, b;

    void solve(InputReader in, PrintWriter out) throws IOException {
        n = in.nextInt();
        m = in.nextInt();
        b = in.nextInt();
        mod = in.nextInt();
        a = new int[n+1];
        for(int i=1; i<=n; i++) {
            a[i] = in.nextInt();
        }
        dp = new int[2][m+1][b+1];

        dp[0][0][0] = 1;

        for(int i=1; i<=n; i++) {
            int p = i%2;
            for(int j=0; j<=m; j++) {
                for(int k=0; k<=b; k++) {
                    dp[p][j][k] = dp[(p+1)%2][j][k];
                    if(j>0 && k>=a[i]) {
                        dp[p][j][k] += dp[p][j-1][k-a[i]];
                        dp[p][j][k] %= mod;
                    }
                }
            }
        }

        int rs = 0;
        for(int i=0; i<=b; i++) {
            rs = (rs+dp[n%2][m][i])%mod;
        }
        out.println(rs);
    }

    public static void main(String[] args) throws IOException {
        if(args.length>0 && args[0].equalsIgnoreCase("d")) {
            DEBUG_FLAG = true;
        }
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;//in.nextInt();
        long start = System.nanoTime();
        while(t-- >0) {
            new test().solve(in, out);
        }
        long end = System.nanoTime();
        debug("\nTime: " + (end-start)/1e6 + " \n\n");
        out.close();
    }

    static boolean DEBUG_FLAG = false;
    static void debug(String s) {
        if(DEBUG_FLAG) System.out.print(s);
    }

    public static void show(Object... o) {
        System.out.println(Arrays.deepToString(o));
    }

    static class InputReader {
        static BufferedReader br;
        static StringTokenizer st;

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

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                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());
        }
    }
}


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

public class test {
    int INF = (int)1e9;
    long MOD = 1000000007;

    long[][][] dp;
    int[] a;
    long mod;
    int n, m, b;

    long go(int i, int l, int bc) {
        if(bc>b) return 0;
        if(l>=m) {
//            show(i, l, bc);
            return 1;
        }
        if(i>n) return 0;
//        show(i, l, bc);
        if(dp[i][l][bc]!=-1)
            return dp[i][l][bc];
        long rs = 0;
        rs += go(i, l+1, bc+a[i]);
        rs = (rs+go(i+1, l, bc))%mod;
        return dp[i][l][bc] = rs%mod;
    }

    void solve(InputReader in, PrintWriter out) throws IOException {
        n = in.nextInt();
        m = in.nextInt();
        b = in.nextInt();
        mod = in.nextInt();
        a = new int[n+1];
        for(int i=1; i<=n; i++) {
            a[i] = in.nextInt();
        }
        dp = new long[n+1][m+1][b+1];
        for(int i=0; i<=n; i++) {
            for(int j=0; j<=m; j++) {
                Arrays.fill(dp[i][j], -1l);
            }
        }
        long rs = go(1, 0, 0);
        out.println(rs);
    }

    public static void main(String[] args) throws IOException {
        if(args.length>0 && args[0].equalsIgnoreCase("d")) {
            DEBUG_FLAG = true;
        }
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;//in.nextInt();
        long start = System.nanoTime();
        while(t-- >0) {
            new test().solve(in, out);
        }
        long end = System.nanoTime();
        debug("\nTime: " + (end-start)/1e6 + " \n\n");
        out.close();
    }

    static boolean DEBUG_FLAG = false;
    static void debug(String s) {
        if(DEBUG_FLAG) System.out.print(s);
    }

    public static void show(Object... o) {
        System.out.println(Arrays.deepToString(o));
    }

    static class InputReader {
        static BufferedReader br;
        static StringTokenizer st;

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

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                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());
        }
    }
}


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

public class check {
    int INF = (int)1e9;
    long MOD = 1000000007;

    int[][][] dp;
    int[] a;
    int mod;
    int n, m, b;

    int go(int i, int l, int bc) {
        if(bc>b) return 0;
        if(l>=m) {
//            show(i, l, bc);
            return 1;
        }
        if(i>n) return 0;
//        show(i, l, bc);
        if(dp[i][l][bc]!=-1)
            return dp[i][l][bc];
        int rs = 0;
        rs += go(i, l+1, bc+a[i]);
        rs = (rs+go(i+1, l, bc))%mod;
        return dp[i][l][bc] = rs%mod;
    }

    void solve(InputReader in, PrintWriter out) throws IOException {
        n = in.nextInt();
        m = in.nextInt();
        b = in.nextInt();
        mod = in.nextInt();
        a = new int[n+1];
        for(int i=1; i<=n; i++) {
            a[i] = in.nextInt();
        }
        dp = new int[n+1][m+1][b+1];
        for(int i=0; i<=n; i++) {
            for(int j=0; j<=m; j++) {
                Arrays.fill(dp[i][j], -1);
            }
        }
        int rs = go(1, 0, 0);
        out.println(rs);
    }

    public static void main(String[] args) throws IOException {
        if(args.length>0 && args[0].equalsIgnoreCase("d")) {
            DEBUG_FLAG = true;
        }
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;//in.nextInt();
        long start = System.nanoTime();
        while(t-- >0) {
            new check().solve(in, out);
        }
        long end = System.nanoTime();
        debug("\nTime: " + (end-start)/1e6 + " \n\n");
        out.close();
    }

    static boolean DEBUG_FLAG = false;
    static void debug(String s) {
        if(DEBUG_FLAG) System.out.print(s);
    }

    public static void show(Object... o) {
        System.out.println(Arrays.deepToString(o));
    }

    static class InputReader {
        static BufferedReader br;
        static StringTokenizer st;

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

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                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());
        }
    }
}


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

public class test {
    int INF = (int)1e9;
    long MOD = 1000000007;

    HashMap<String, Long> dp;
    int[] a;
    long mod;
    int n, m, b;

    long go(int i, int l, int bc) {
        if(bc>b) return 0;
        if(l>=m) {
//            show(i, l, bc);
            return 1;
        }
        if(i>n) return 0;
//        show(i, l, bc);
        String key = i+" "+l+" "+bc;
        if(dp.containsKey(key))
            return dp.get(key);
        long rs = 0;
        rs += go(i, l+1, bc+a[i]);
        rs = (rs+go(i+1, l, bc))%mod;
        rs %= mod;
        dp.put(key, rs);
        return rs;
    }

    void solve(InputReader in, PrintWriter out) throws IOException {
        n = in.nextInt();
        m = in.nextInt();
        b = in.nextInt();
        mod = in.nextInt();
        a = new int[n+1];
        for(int i=1; i<=n; i++) {
            a[i] = in.nextInt();
        }
        dp = new HashMap<String, Long>();
        long rs = go(1, 0, 0);
        out.println(rs);
    }

    public static void main(String[] args) throws IOException {
        if(args.length>0 && args[0].equalsIgnoreCase("d")) {
            DEBUG_FLAG = true;
        }
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;//in.nextInt();
        long start = System.nanoTime();
        while(t-- >0) {
            new test().solve(in, out);
        }
        long end = System.nanoTime();
        debug("\nTime: " + (end-start)/1e6 + " \n\n");
        out.close();
    }

    static boolean DEBUG_FLAG = false;
    static void debug(String s) {
        if(DEBUG_FLAG) System.out.print(s);
    }

    public static void show(Object... o) {
        System.out.println(Arrays.deepToString(o));
    }

    static class InputReader {
        static BufferedReader br;
        static StringTokenizer st;

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

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                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());
        }
    }
}


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

public class writingCodes{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		int m = scan.nextInt();
		int b = scan.nextInt();

		long mod = scan.nextLong();

		int[] a = new int[n+1];
		for(int i=1;i<=n;i++){
			a[i] = scan.nextInt();
		}

		long[][][] dp = new long[n+1][m+1][b+1];

	    for(int i=0;i<=n;i++){
	    	dp[i][0][0] = 1;
	    }
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				for(int bug = 0; bug<=b; bug++){
					dp[i][j][bug] = dp[i-1][j][bug];
					if(bug>=a[i]){
					   dp[i][j][bug] += dp[i][j-1][bug-a[i]];
				    }
					dp[i][j][bug] %= mod;
				}
			}
		}

		long ans = 0;
		for(int bug=0;bug<=b;bug++){
			ans += dp[n][m][bug];
			ans %= mod;
		}

		System.out.println(ans);

	}
}


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

public class writingCodes{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		int m = scan.nextInt();
		int b = scan.nextInt();

		long mod = scan.nextLong();

		int[] a = new int[n+1];
		for(int i=1;i<=n;i++){
			a[i] = scan.nextInt();
		}

		long[][] pre_dp = new long[m+1][b+1];
		long[][] dp = new long[m+1][b+1];

	    pre_dp[0][0] = 1;
		dp[0][0] = 1;
		for(int i=1;i<=n;i++){
			pre_dp = dp;
			for(int j=1;j<=m;j++){
				for(int bug = 0; bug<=b; bug++){
					dp[j][bug] = pre_dp[j][bug];
					if(bug>=a[i]){
					   dp[j][bug] += dp[j-1][bug-a[i]];
				    }
					dp[j][bug] %= mod;
				}
			}
		}

		long ans = 0;
		for(int bug=0;bug<=b;bug++){
			ans += dp[m][bug];
			ans %= mod;
		}

		System.out.println(ans);

	}
}


// practice with rainboy
import java.io.*;
import java.util.*;

public class CF543A extends PrintWriter {
	CF543A() { super(System.out, true); }
	Scanner sc = new Scanner(System.in);
	public static void main(String[] $) {
		CF543A o = new CF543A(); o.main(); o.flush();
	}

	void main() {
		int n = sc.nextInt();
		int m = sc.nextInt();
		int b = sc.nextInt();
		int md = sc.nextInt();
		int[][] dp = new int[m + 1][b + 1];
		dp[0][0] = 1;
		while (n-- > 0) {
			int a = sc.nextInt();
			for (int j = 0; j < m; j++)
				for (int c = 0; c + a <= b; c++)
					dp[j + 1][c + a] = (dp[j + 1][c + a] + dp[j][c]) % md;
		}
		int ans = 0;
		for (int c = 0; c <= b; c++)
			ans = (ans + dp[m][c]) % md;
		println(ans);
	}
}


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

public class cf {
    FastScanner in;
    long max(long a,long b){
        if(a>b)return a;
        return b;
    }
    void input(){
        in = new FastScanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int b=in.nextInt();
        int mod=in.nextInt();
        int v[]=new int[3000];
        int dp[][]=new int[600][600];
        int cnt=0;
        for(int i=1;i<=n;i++){
            v[i]=in.nextInt();
        }
        dp[0][0]=1;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                for(int k=v[i];k<=b;k++){
                    dp[j][k]=(dp[j][k]+dp[j-1][k-v[i]])%mod;
                }
            }
        }
        int ans=0;
        for(int i=0;i<=b;i++){
            ans=(ans+dp[m][i])%mod;
        }
        System.out.println(ans);

    }
    public static void main(String[] args){
        new cf().input();
    }
}
class FastScanner {
    BufferedReader br;
    StringTokenizer st;

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

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

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

    boolean hasMoreTokens() {
        while (st == null || !st.hasMoreTokens()) {
            String s = null;
            try {
                s = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (s == null)
                return false;
            st = new StringTokenizer(s);
        }
        return true;
    }

    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.io.*;
import java.util.*;

public class cf {
    FastScanner in;
    long max(long a,long b){
        if(a>b)return a;
        return b;
    }
    void input(){
        in = new FastScanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int b=in.nextInt();
        int mod=in.nextInt();
        int v[]=new int[3000];
        int dp[][]=new int[600][600];
        int cnt=0;
        for(int i=1;i<=n;i++){
            v[i]=in.nextInt();
        }
        dp[0][0]=1;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                for(int k=v[i];k<=b;k++){
                    dp[j][k]=(dp[j][k]+dp[j-1][k-v[i]])%mod;
                }
            }
        }
        int ans=0;
        for(int i=0;i<=b;i++){
            ans=(ans+dp[m][i])%mod;
        }
        System.out.println(ans);

    }
    public static void main(String[] args){
        new cf().input();
    }
}
class FastScanner {
    BufferedReader br;
    StringTokenizer st;

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

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

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

    boolean hasMoreTokens() {
        while (st == null || !st.hasMoreTokens()) {
            String s = null;
            try {
                s = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (s == null)
                return false;
            st = new StringTokenizer(s);
        }
        return true;
    }

    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.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
import java.util.StringTokenizer;

public class P {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(), M = sc.nextInt(), B = sc.nextInt();
		int MOD = sc.nextInt();
		int[] a = sc.nextIntArray(N);
		int[][][] dp = new int[M + 1][B + 1][2];

		for (int i = 0; i <= B; i++)
			dp[0][i][0] = dp[0][i][1] = 1;

		int level = 1;
		for (int cur = 0; cur < N; cur++) {
			for (int remL = 1; remL <= M; remL++) {
				for (int bugs = 0; bugs <= B; bugs++) {
					dp[remL][bugs][level] = 0;
					if (bugs >= a[cur])
						dp[remL][bugs][level] += dp[remL - 1][bugs - a[cur]][level];
					dp[remL][bugs][level] += dp[remL][bugs][1 - level];
					dp[remL][bugs][level] %= MOD;
				}
			}
			level ^= 1;
		}
		System.out.println(dp[M][B][1 - level] % MOD);
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
		}

		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 {
			return Double.parseDouble(next());
		}

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

		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[] shuffle(int[] a, int n) {
			int[] b = new int[n];
			for (int i = 0; i < n; i++)
				b[i] = a[i];
			Random r = new Random();
			for (int i = 0; i < n; i++) {
				int j = i + r.nextInt(n - i);
				int t = b[i];
				b[i] = b[j];
				b[j] = t;
			}
			return b;
		}

		public int[] nextIntArraySorted(int n) throws IOException {
			int[] a = nextIntArray(n);
			a = shuffle(a, n);
			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;
		}
	}
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class P {

	static int N, M, B, MOD;
	static TreeMap<State, Integer> dp;
	static int[] a;

	static class State implements Comparable<State> {
		int cur, remL, remB;

		State(int i, int j, int k) {
			cur = i;
			remL = j;
			remB = k;
		}

		@Override
		public int compareTo(State o) {
			if (cur == o.cur)
				if (remL == o.remL)
					if (remB == o.remB)
						return remL - o.remL;
					else
						return remB - o.remB;
			return cur - o.cur;
		}
	}

	static int solve(int cur, int remL, int remB) {
		if (remL <= 0 && remB >= 0)
			return 1;

		if (cur == N || remB < 0)
			return 0;
		State curS = new State(cur, remL, remB);
		Integer ret = dp.get(curS);

		if (ret != null)
			return ret;

		ret = 0;
		for (int i = 0; i <= remL && i * a[cur] <= remB; ++i)
			ret = (ret % MOD + solve(cur + 1, (remL - i), remB - (i * a[cur])) % MOD) % MOD;
		dp.put(curS, ret);
		return ret;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		B = sc.nextInt();
		MOD = sc.nextInt();
		int[] b = sc.nextIntArraySorted(N);
		a = new int[N];
		for (int i = 0; i < N; i++)
			a[i] = b[N - i - 1];
		dp = new TreeMap<State, Integer>();
		System.out.println(solve(0, M, B) % MOD);
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
		}

		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 {
			return Double.parseDouble(next());
		}

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

		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[] shuffle(int[] a, int n) {
			int[] b = new int[n];
			for (int i = 0; i < n; i++)
				b[i] = a[i];
			Random r = new Random();
			for (int i = 0; i < n; i++) {
				int j = i + r.nextInt(n - i);
				int t = b[i];
				b[i] = b[j];
				b[j] = t;
			}
			return b;
		}

		public int[] nextIntArraySorted(int n) throws IOException {
			int[] a = nextIntArray(n);
			a = shuffle(a, n);
			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;
		}
	}
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class P {

	static int N, M, B, MOD;
	static TreeMap<State, Integer> dp;
	static int[] a;

	static class State implements Comparable<State> {
		int cur, remL, remB;

		State(int i, int j, int k) {
			cur = i;
			remL = j;
			remB = k;
		}

		@Override
		public int compareTo(State o) {
			if (cur == o.cur)
				if (remL == o.remL)
					return remB - o.remB;
				else
					return remL - o.remL;
			return cur - o.cur;
		}
	}

	static int solve(int cur, int remL, int remB) {
		if (remL <= 0 && remB >= 0)
			return 1;

		if (cur == N || remB < 0)
			return 0;
		State curS = new State(cur, remL, remB);
		Integer ret = dp.get(curS);

		if (ret != null)
			return ret;

		ret = 0;
		for (int i = 0; i <= remL && i * a[cur] <= remB; ++i)
			ret = (ret % MOD + solve(cur + 1, (remL - i), remB - (i * a[cur])) % MOD) % MOD;
		dp.put(curS, ret);
		return ret;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		B = sc.nextInt();
		MOD = sc.nextInt();
		int[] b = sc.nextIntArraySorted(N);
		a = new int[N];
		for (int i = 0; i < N; i++)
			a[i] = b[N - i - 1];
		dp = new TreeMap<State, Integer>();
		System.out.println(solve(0, M, B) % MOD);
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
		}

		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 {
			return Double.parseDouble(next());
		}

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

		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[] shuffle(int[] a, int n) {
			int[] b = new int[n];
			for (int i = 0; i < n; i++)
				b[i] = a[i];
			Random r = new Random();
			for (int i = 0; i < n; i++) {
				int j = i + r.nextInt(n - i);
				int t = b[i];
				b[i] = b[j];
				b[j] = t;
			}
			return b;
		}

		public int[] nextIntArraySorted(int n) throws IOException {
			int[] a = nextIntArray(n);
			a = shuffle(a, n);
			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;
		}
	}
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class C {

	static int N, M, B, MOD;
	static int[][][] dp;
	static int[] a;

	static int solve(int cur, int remL, int remB) {
		if (remL <= 0 && remB >= 0)
			return 1;

		if (cur == N || remB < 0)
			return 0;

		if (dp[cur][remL][remB] != -1)
			return dp[cur][remL][remB];

		int ret = 0;
		for (int i = 0; i <= remL; i++)
			ret = (ret % MOD + solve(cur + 1, (remL - i), remB - (i * a[cur])) % MOD) % MOD;
		return dp[cur][remL][remB] = ret;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		B = sc.nextInt();
		MOD = sc.nextInt();
		a = sc.nextIntArray(N);
		dp = new int[N + 1][M + 1][B + 1];
		for (int[][] x : dp)
			for (int[] y : x)
				Arrays.fill(y, -1);
		System.out.println(solve(0, M, B) % MOD);
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
		}

		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 {
			return Double.parseDouble(next());
		}

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

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


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
import java.util.StringTokenizer;

public class P {

	static int N, M, B, MOD;
	static HashMap<State, Integer> dp;
	static int[] a;

	static class State implements Comparable<State> {
		int cur, remL, remB;

		State(int i, int j, int k) {
			cur = i;
			remL = j;
			remB = k;
		}

		@Override
		public int compareTo(State o) {
			if (cur == o.cur)
				if (remL == o.remL)
					return remB - o.remB;
				else
					return remL - o.remL;
			return cur - o.cur;
		}
	}

	static int solve(int cur, int remL, int remB) {
		if (remL <= 0 && remB >= 0)
			return 1;

		if (cur == N || remB < 0)
			return 0;
		State curS = new State(cur, remL, remB);
		Integer ret = dp.get(curS);

		if (ret != null)
			return ret;

		ret = 0;
		for (int i = 0; i <= remL && i * a[cur] <= remB; ++i)
			ret = (ret % MOD + solve(cur + 1, (remL - i), remB - (i * a[cur])) % MOD) % MOD;
		dp.put(curS, ret);
		return ret;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		B = sc.nextInt();
		MOD = sc.nextInt();
		int[] b = sc.nextIntArraySorted(N);
		a = new int[N];
		for (int i = 0; i < N; i++)
			a[i] = b[N - i - 1];
		dp = new HashMap<State, Integer>();
		System.out.println(solve(0, M, B) % MOD);
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
		}

		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 {
			return Double.parseDouble(next());
		}

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

		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[] shuffle(int[] a, int n) {
			int[] b = new int[n];
			for (int i = 0; i < n; i++)
				b[i] = a[i];
			Random r = new Random();
			for (int i = 0; i < n; i++) {
				int j = i + r.nextInt(n - i);
				int t = b[i];
				b[i] = b[j];
				b[j] = t;
			}
			return b;
		}

		public int[] nextIntArraySorted(int n) throws IOException {
			int[] a = nextIntArray(n);
			a = shuffle(a, n);
			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;
		}
	}
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class C {

	static int N, M, B, MOD;
	static int[][][] dp;
	static int[] a;

	static int solve(int cur, int remL, int remB) {
		if (remL <= 0 && remB >= 0)
			return 1;

		if (cur == N || remB < 0)
			return 0;

		if (dp[cur][remL][remB] != -1)
			return dp[cur][remL][remB];

		int ret = 0;
		for (int i = 0; i <= remL && (remB - (i * a[cur]) >= 0); i++)
			ret = (ret % MOD + solve(cur + 1, (remL - i), remB - (i * a[cur])) % MOD) % MOD;
		return dp[cur][remL][remB] = ret;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		B = sc.nextInt();
		MOD = sc.nextInt();
		a = sc.nextIntArray(N);
		dp = new int[N + 1][M + 1][B + 1];
		for (int i = 0; i <= N; i++)
			for (int j = 0; j <= M; j++)
				Arrays.fill(dp[i][j], -1);
		System.out.println(solve(0, M, B) % MOD);
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
		}

		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 {
			return Double.parseDouble(next());
		}

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

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