use std::io::{self, BufRead, Write};
use std::cmp::max;

fn main() {
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines().map(|l| l.unwrap());
    
    let first_line = match lines.next() {
        Some(l) => l,
        None => return,
    };
    let parts: Vec<&str> = first_line.split_whitespace().collect();
    let n: usize = parts[0].parse().unwrap();
    let q: usize = parts[1].parse().unwrap();
    
    let b_limit = 25000.min(n);
    let split_k = 1000.min(b_limit);
    
    let mut score_starts = vec![0usize; b_limit + 2];
    let mut current_start = 0;
    for k in 2..=b_limit {
        score_starts[k] = current_start;
        current_start += k;
    }
    
    let mut score_small = vec![0u32; score_starts[split_k] + split_k + 1];
    let mut score_large = vec![0u16; current_start + 1];
    
    let mut freq_starts = vec![0usize; b_limit + 2];
    let mut curr_freq_start = 0;
    for k in 2..=b_limit {
        freq_starts[k] = curr_freq_start;
        curr_freq_start += (n / k) + 2;
    }
    let mut freq = vec![0u16; curr_freq_start];
    for k in 2..=b_limit {
        freq[freq_starts[k]] = k as u16; 
    }
    
    let mut max_score = vec![0u32; b_limit + 1];
    let mut freq_global_max = vec![0u32; 100005];
    freq_global_max[0] = (b_limit - 1) as u32;
    let mut global_max_small = 0u32;
    
    let mut has = vec![false; n + 1];
    let mut active: Vec<usize> = Vec::with_capacity(q);
    
    let mut ans = 0u32;
    let mut stdout = io::BufWriter::new(io::stdout());
    
    for line in lines {
        if line.trim().is_empty() { continue; }
        let x: usize = line.trim().parse().unwrap();
        let add = !has[x];
        
        if add {
            has[x] = true;
            active.push(x);
        } else {
            has[x] = false;
            if let Some(pos) = active.iter().position(|&val| val == x) {
                active.swap_remove(pos);
            }
        }
        
        let mut k = 2;
        while k <= b_limit {
            if k > x {
                let s = x;
                while k <= b_limit {
                    let idx = score_starts[k] + s;
                    let mut c = if k <= split_k { score_small[idx] } else { score_large[idx] as u32 };
                    
                    freq[freq_starts[k] + c as usize] -= 1;
                    if add { c += 1; } else { c -= 1; }
                    freq[freq_starts[k] + c as usize] += 1;
                    
                    if k <= split_k { score_small[idx] = c; } else { score_large[idx] = c as u16; }
                    
                    if add {
                        if c > max_score[k] {
                            freq_global_max[max_score[k] as usize] -= 1;
                            max_score[k] = c;
                            freq_global_max[c as usize] += 1;
                            if c > global_max_small { global_max_small = c; }
                        }
                    } else {
                        if max_score[k] == c + 1 && freq[freq_starts[k] + (c + 1) as usize] == 0 {
                            freq_global_max[max_score[k] as usize] -= 1;
                            max_score[k] = c;
                            freq_global_max[c as usize] += 1;
                            while global_max_small > 0 && freq_global_max[global_max_small as usize] == 0 {
                                global_max_small -= 1;
                            }
                        }
                    }
                    k += 1;
                }
                break;
            }
            
            let q_val = x / k;
            let next_k = (x / q_val).min(b_limit);
            let mut s = x - q_val * k;
            
            while k <= next_k {
                let idx = score_starts[k] + s;
                let mut c = if k <= split_k { score_small[idx] } else { score_large[idx] as u32 };
                
                freq[freq_starts[k] + c as usize] -= 1;
                if add { c += 1; } else { c -= 1; }
                freq[freq_starts[k] + c as usize] += 1;
                
                if k <= split_k { score_small[idx] = c; } else { score_large[idx] = c as u16; }
                
                if add {
                    if c > max_score[k] {
                        freq_global_max[max_score[k] as usize] -= 1;
                        max_score[k] = c;
                        freq_global_max[c as usize] += 1;
                        if c > global_max_small { global_max_small = c; }
                    }
                } else {
                    if max_score[k] == c + 1 && freq[freq_starts[k] + (c + 1) as usize] == 0 {
                        freq_global_max[max_score[k] as usize] -= 1;
                        max_score[k] = c;
                        freq_global_max[c as usize] += 1;
                        while global_max_small > 0 && freq_global_max[global_max_small as usize] == 0 {
                            global_max_small -= 1;
                        }
                    }
                }
                s -= q_val;
                k += 1;
            }
        }
        
        if add {
            if global_max_small > ans { ans = global_max_small; }
            for &y in &active {
                if x == y { continue; }
                let d = x.abs_diff(y);
                if d <= b_limit { continue; }
                
                let max_c = d / (b_limit + 1);
                for c in 1..=max_c {
                    if d % c == 0 {
                        let k_val = d / c;
                        if k_val > b_limit && k_val <= n / max(1, ans as usize) {
                            let mut count = 1;
                            let mut curr = x + k_val;
                            while curr <= n {
                                if has[curr] { count += 1; }
                                curr += k_val;
                            }
                            let mut curr_back = if x > k_val { x - k_val } else { 0 };
                            while curr_back >= 1 {
                                if has[curr_back] { count += 1; }
                                curr_back = if curr_back > k_val { curr_back - k_val } else { 0 };
                            }
                            if count > ans { ans = count; }
                        }
                    }
                }
            }
        } else {
            if ans > global_max_small {
                let mut found = false;
                for i in 0..active.len() {
                    let u = active[i];
                    for j in (i + 1)..active.len() {
                        let v = active[j];
                        let d = u.abs_diff(v);
                        if d <= b_limit { continue; }
                        
                        let max_c = d / (b_limit + 1);
                        for c in 1..=max_c {
                            if d % c == 0 {
                                let k_val = d / c;
                                if k_val > b_limit && k_val <= n / (ans as usize - 1) {
                                    let mut count = 1;
                                    let mut curr = u + k_val;
                                    while curr <= n {
                                        if has[curr] { count += 1; }
                                        curr += k_val;
                                    }
                                    let mut curr_back = if u > k_val { u - k_val } else { 0 };
                                    while curr_back >= 1 {
                                        if has[curr_back] { count += 1; }
                                        curr_back = if curr_back > k_val { curr_back - k_val } else { 0 };
                                    }
                                    if count >= ans {
                                        found = true;
                                        break;
                                    }
                                }
                            }
                        }
                        if found { break; }
                    }
                    if found { break; }
                }
                if !found { ans -= 1; }
            } else {
                ans = global_max_small;
            }
        }
        
        if active.is_empty() { ans = 0; }
        else if ans == 0 { ans = 1; }
        
        let _ = writeln!(stdout, "{}", ans);
    }
}