DZY has a hash table with p buckets, numbered from 0 to p - 1. He wants to insert n numbers, in the order they are given, into the hash table. For the i-th number xi, DZY will put it into the bucket numbered h(xi), where h(x) is the hash function. In this problem we will assume, that h(x) = x mod p. Operation a mod b denotes taking a remainder after division a by b.

However, each bucket can contain no more than one element. If DZY wants to insert an number into a bucket which is already filled, we say a "conflict" happens. Suppose the first conflict happens right after the i-th insertion, you should output i. If no conflict happens, just output -1.

Input

The first line contains two integers, p and n (2 ≤ p, n ≤ 300). Then n lines follow. The i-th of them contains an integer xi (0 ≤ xi ≤ 109).

Output

Output a single integer — the answer to the problem.

Examples

Input

10 5
0
21
53
41
53


Output

4


Input

5 5
0
1
2
3
4


Output

-1
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;


public class Main {
static class FastScanner {

BufferedReader reader;
StringTokenizer tokenizer;

public FastScanner(InputStream stream) {
this.reader = new BufferedReader(new InputStreamReader(stream));
}

public int nextInt() throws IOException {
return Integer.parseInt(next());
}

public int[] nextIntegerArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = nextInt();
}
return a;
}

public long[] nextLongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < a.length; i++) {
a[i] = nextLong();
}
return a;
}

public int nextInt(int radix) throws IOException {
return Integer.parseInt(next(), radix);
}

public long nextLong() throws IOException {
return Long.parseLong(next());
}

public long nextLong(int radix) throws IOException {
return Long.parseLong(next(), radix);
}

public double nextDouble() throws IOException {
return Double.parseDouble(next());
}

public BigInteger nextBigInteger() throws IOException {
return new BigInteger(next());
}

public BigInteger nextBigInteger(int radix) throws IOException {
return new BigInteger(next(), radix);
}

public String next() throws IOException {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
return this.next();
}
return tokenizer.nextToken();
}

public void close() throws IOException {
this.reader.close();
}
}

                   //SOLUTION //


	FastScanner in = new FastScanner(System.in);
	PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) throws IOException{
    new Main().solve();
    }//void main
	
	void solve() throws IOException{
		 int i,p = in.nextInt(), n  = in.nextInt();
		 boolean[] check = new boolean[p];
		 for(i =1; i <= n; i++){
			 int t = in.nextInt()%p;
			 if(!check[t])
				 check[t]=true;
			 else
				 {out.println(i);break;}
		 }
		 if(i == n+1)
			 out.println(-1);
	     in.close();
	     out.flush();
		 out.close();
	}
}