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.Scanner;

public class CodeForces_ModuloSum {
	private static final String yes = "YES";
	private static final String no = "NO";
	
	private final int[] rem_;
	private final int[][][] feasible_;
	
	private int n_, m_;
	public CodeForces_ModuloSum() {
		Scanner in = new Scanner(System.in);
		n_ = in.nextInt();
		m_ = in.nextInt();
		rem_ = new int[m_];
		feasible_ = new int[m_][m_][2];
		int x;
		for(int i = 0; i < n_; i++) {
			x = in.nextInt();
			rem_[x % m_]++;
		}
		for(int i = 0; i < m_; i++)
			for(int j = 0; j < m_; j++)
				for(int k = 0; k < 2; k++)
					feasible_[i][j][k] = -1;
	}
	
	private void solve() {
		if(rem_[0] > 0) {
			System.out.println(yes);
			return;
		}
		fill(m_ - 1, 0, true);
		System.out.println((feasible_[m_-1][0][1] == 1) ? yes: no);
	}
	
	private void fill(int k, int r0, boolean stillEmpty) {
		int idx = stillEmpty? 1: 0;
		if(feasible_[k][r0][idx] != -1)
			return;
		int r = -1;
		if(k == 1) {
			if(r0 > 0)
				r = (rem_[1] >= r0)? 1: 0;
			else {
				// r0 == 0
				if(stillEmpty)
					r = (rem_[1] >= m_)? 1: 0;
				else
					r = 1;
			}
		} else {
			for(int i0 = 0; i0 <= rem_[k]; i0++) {
				boolean empty = stillEmpty && (i0 == 0);
				int idx0 = empty? 1: 0;
				int newR0 = (m_ + (r0 - i0 * k) % m_) % m_;
				fill(k - 1, newR0, empty);
				if(feasible_[k-1][newR0][idx0] == 1) {
					r = 1;
					break;
				}
			}
			if(r == -1)
				r = 0;
		}
		feasible_[k][r0][idx] = r;
	}
	
	
	public static void main(String[] args) {
		new CodeForces_ModuloSum().solve();
	}
}
