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.*;
	public class Main {
		public static long mod= (long) (1e9 +7);
		static int kill[],sum[];
		static int n;
		static Pair p[];
		public static void main(String args[])
		{
			InputReader s= new InputReader(System.in);
			OutputStream outputStream= System.out;
			PrintWriter out= new PrintWriter(outputStream);
			int n= s.nextInt();
			int m= s.nextInt();
			int a[]= new int[n];
			for(int i=0;i<n;i++)
				a[i]= s.nextInt();
			
			if(n>m)
				out.println("YES");
			else{
				int dp[][]= new int[n+1][m+1];
				dp[0][0] = 1;
				for(int i=0;i<n;i++){
					for(int j=0;j<m;j++){
						dp[i+1][j] += dp[i][j];
						dp[i+1][(j+a[i])%m] += dp[i][j];
					}
				}
				
				for(int i=0;i<=n;i++){
					if(dp[i][0]>1){
						System.out.println("YES");
						return;
					}
				}
				System.out.println("NO");
			}
			out.close();
		}
		
		static long combinations(long n,long r){   // O(r)
			if(r==0 || r==n) return 1;
			r= Math.min(r, n-r);
			long ans=n;  // nC1=n;
			for(int i=1;i<r;i++){
				ans= ans*(n-i);
				ans= ans/(i+1);
			}
			return ans;
			
		}
		public static void debug(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		static long modulo(long a,long b,long c) {
			long x=1;
			long y=a;
			while(b > 0){
				if(b%2 == 1){
					x=(x*y)%c;
				}
				y = (y*y)%c; // squaring the base
				b /= 2;
			}
			return  x%c;
		}
		static void catalan_numbers(int n) {
			long catalan[]= new long[n+1];
		    catalan[1] = 1;
		    for (int i = 2; i <= n; i++) {
		        for (int j = 1; j <= i - 1; j++) {
		            catalan[i] = catalan[i] + ((catalan[j]) * catalan[i - j]);
		        }
		    }
		}
		
		static ArrayList<Integer> primeFactors(int n)   // O(sqrt(n))
		{
		    // Print the number of 2s that divide n
			ArrayList<Integer> arr= new ArrayList<>();
		    while (n%2 == 0)
		    {
		        arr.add(2);
		        n = n/2;
		    }
		 
		    // n must be odd at this point.  So we can skip one element (Note i = i +2)
		    for (int i = 3; i <= Math.sqrt(n); i = i+2)
		    {
		        // While i divides n, print i and divide n
		        while (n%i == 0)
		        {
		            arr.add(i);
		            n = n/i;
		        }
		    }
		    // This condition is to handle the case when n is a prime number
		    // greater than 2
		    if (n > 2)
		        arr.add(n);
		    
		    return arr;
		}
	
		public static int expo(int a, int b){
			if (b==0)
		        return 1;
		    if (b==1)
		        return a;
		    if (b==2)
		        return a*a;
	
		    if (b%2==0){
		            return expo(expo(a,b/2),2);
		    }
		    else{
		        return a*expo(expo(a,(b-1)/2),2);
		    }
		}
		static class Pair implements Comparable<Pair>
		{
			int f;
			int s;
			Pair(int ii, int cc)
			{
				f=ii;
				s=cc;
			}
			
			public int compareTo(Pair o) 
			{
				return Integer.compare(this.f, o.f);
			}
			
		}
		
		public static int[] sieve(int N){    // O(n*log(logn))
			int arr[]= new int[N+1];
			for(int i=2;i<=Math.sqrt(N);i++){
				if(arr[i]==0){
					for(int j= i*i;j<= N;j= j+i){
						arr[j]=1;
					}
				}
			}
			return arr;
			// All the i for which arr[i]==0 are prime numbers.
		}
		static long gcd(long a,long b){       // O(logn)
			if(b==0) return a;
			return gcd(b,a%b);
		}
		static class InputReader {
	
		    public BufferedReader reader;
		    public StringTokenizer tokenizer;
	 
		    public InputReader(InputStream inputstream) {
		      reader = new BufferedReader(new InputStreamReader(inputstream));
		      tokenizer = null;
		    }
		    
		    public String nextLine(){
		    	String fullLine=null;
		    	while (tokenizer == null || !tokenizer.hasMoreTokens()) {
		            try {
		              fullLine=reader.readLine();
		            } catch (IOException e) {
		              throw new RuntimeException(e);
		            }
		            return fullLine;
		          }
		          return fullLine;
		    }
			public String next() {
		      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
		        try {
		          tokenizer = new StringTokenizer(reader.readLine());
		        } catch (IOException e) {
		          throw new RuntimeException(e);
		        }
		      }
		      return tokenizer.nextToken();
		    }
			public long nextLong() {
			      return Long.parseLong(next());
			    }
		    public int nextInt() {
		      return Integer.parseInt(next());
		    }
		  }
	}