You are given a sequence of numbers a1, a2, ..., an, and a number m.

Check if it is possible to choose a non-empty subsequence aij such that the sum of numbers in this subsequence is divisible by m.

Input

The first line contains two numbers, n and m (1 ≤ n ≤ 106, 2 ≤ m ≤ 103) — the size of the original sequence and the number such that sum should be divisible by it.

The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109).

Output

In the single line print either "YES" (without the quotes) if there exists the sought subsequence, or "NO" (without the quotes), if such subsequence doesn't exist.

Examples

Input

3 5
1 2 3


Output

YES


Input

1 6
5


Output

NO


Input

4 6
3 1 1 3


Output

YES


Input

6 6
5 5 5 5 5 5


Output

YES

Note

In the first sample test you can choose numbers 2 and 3, the sum of which is divisible by 5.

In the second sample test the single non-empty subsequence of numbers is a single number 5. Number 5 is not divisible by 6, that is, the sought subsequence doesn't exist.

In the third sample test you need to choose two numbers 3 on the ends.

In the fourth sample test you can take the whole subsequence.
import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;

import static java.lang.Math.*;

 public class Solution implements Runnable {
	 static Vector<Integer>[] tree;
    public void solve() throws Exception {
    	int n=sc.nextInt();
    	int m=sc.nextInt();
    	int arr[]=new int[n];
    	int a[]=new int[m];
    	
    	for(int i=0;i<n;i++)
    	{
    		arr[i]=sc.nextInt();
    		arr[i]=arr[i]%m;
    		if(arr[i]==0)
    		{
    			System.out.println("YES");
    			return;
    		}
    		
    	
    		
    	}
    	if(n>m)
    	{
    		System.out.println("YES");
    		return;
    		
    	}
    	int dp[][]=new int[n][m];
    	for(int i=0;i<n;i++)
    	{
    		dp[i][arr[i]]=1;
    	}
    	for(int i=0;i<n;i++)
    	{
    		for(int j=0;j<m;j++)
    		{
    			if(i-1>=0)
    			{
    				if(dp[i-1][j]==1)
    					dp[i][j]=1;
    			}
    			if(i-1>=0 && dp[i-1][j]==1)
    			{
    				
    					dp[i][(j+arr[i])%m]=1;
    			}
    		}
    	}
    	if(dp[n-1][0]==1)
    		System.out.println("YES");
    	else System.out.println("NO");
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    			
    			
    			
    		
    }
    
    
    static Throwable uncaught;

    BufferedReader in;
    FastScanner sc;
    PrintWriter out;

    @Override
    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            sc = new FastScanner(in);
            solve();
        } catch (Throwable uncaught) {
            Solution.uncaught = uncaught;
        } finally {
            out.close();
        }
    }

    public static void main(String[] args) throws Throwable {
        Thread thread = new Thread(null, new Solution(), "", (1 << 26));
        thread.start();
        thread.join();
        if (Solution.uncaught != null) {
            throw Solution.uncaught;
        }
    }

}

class FastScanner {

    BufferedReader in;
    StringTokenizer st;

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

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

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

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

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

}