#include <bits/stdc++.h>
using namespace std;

class Generator {

 public:
  explicit Generator(int seed) {
    srand(seed);
  }

  int get(int a, int b) {
    return rand() % (b - a) + a;
  }
};

int random(int a, int b) {
  static constexpr int SEED = 6'134'513;
  static Generator generator(SEED);
  return generator.get(a, b);
}

class Sieve {

 public:
  explicit Sieve(int n) : n_(n), least_prime_(n+1, n+1) {
    for (int i = 2; i <= min(n, SQ_); i++) {
      if (least_prime_[i] == n+1) {
        least_prime_[i] = i;
      }
      for (int j = i * i; j <= n; j += i) {
        least_prime_[j] = min(least_prime_[j], i);
      }
    }
    for (int i = SQ_+1; i <= n; i++) {
      if (least_prime_[i] == n+1) {
        least_prime_[i] = i;
      }
    }
  }

  int get_least(int n) const {
    return least_prime_[n];
  }

  bool is_prime(int n) const {
    return least_prime_[n] == n;
  }

  vector<int> small_primes(int n) const {
    vector<int> res;
    res.reserve(n);
    for (int i = 2; i <= n; i++) {
      if (least_prime_[i] == i) {
        res.push_back(i);
      }
    }
    return res;
  }

 private:
  static constexpr int SQ_ = 10'000;
  int n_;
  vector<int> least_prime_;
};



class Queries {

 public:
  explicit Queries(int n) : n_(n) {}

  friend istream& operator>>(istream& is, Queries& queries) {
    is >> queries.q_;
    vector<char> vis(queries.n_ + 1);
    queries.queries_.resize(queries.q_);
    for (auto& [a, sg] : queries.queries_) {
      is >> a;
      sg = vis[a] ? -1 : 1;
      vis[a] ^= 1;
    }
    return is;
  }

  const auto& get() const {
    return queries_;
  }

  int get_n() const {
    return n_;
  }

  int get_q() const {
    return q_;
  }

 private:
  int n_;
  int q_ = 0;
  vector<pair<int, char>> queries_;
};

class IndexedSet {

 public:
  void add(int a) {
    loc_[a] = loc_.size();
    arr_.push_back(a);
  }

  void remove(int a) {
    int wh = loc_[a];
    if (wh == (int) arr_.size() - 1) {
      arr_.pop_back();
      loc_.erase(a);
    }
    else {
      loc_[arr_.back()] = wh;
      swap(arr_[wh], arr_.back());
      arr_.pop_back();
      loc_.erase(a);
    }
  }

  int operator[](int k) const {
    return arr_[k];
  }

  int get_random() const {
    return arr_[random(0, arr_.size())];
  }

  int get_random(int exclude) const {
    int wh = random(0, (int) arr_.size() - 1);
    int ind = loc_.at(exclude);
    wh = (wh >= ind) ? wh + 1 : wh;
    return arr_[wh];
  }

  auto begin() const {
    return arr_.begin();
  }

  auto end() const {
    return arr_.end();
  }

  size_t size() const {
    return arr_.size();
  }

  friend ostream& operator<<(ostream& os, const IndexedSet& container) {
    os << "[Indexed Set]: ";
    for (int v : container) {
      os << v << ", ";
    }
    os << endl;
    return os;
  }


 private:
  unordered_map<int, int> loc_;
  vector<int> arr_;
};

class CandPrimes {

 public:
  explicit CandPrimes(const Queries& queries, const Sieve& sieve) : cands_(queries.get_q()) {
    IndexedSet curr;
    for (int i = 0; i < (int) cands_.size(); i++) {
      auto [a, sg] = queries.get()[i];
      auto& ans = cands_[i];
      if (sg == 1) {
        curr.add(a);
      }
      else {
        curr.remove(a);
      }
      if ((int) curr.size() <= BRUTE) {
        continue;
      }
      for (int roll = 0; roll < ROLLS; roll++) {
        int b = curr.get_random();
        int c = curr.get_random(b);
        int diff = abs(b - c);
        while (diff > 1) {
          int p = sieve.get_least(diff);
          ans.push_back(p);
          diff /= p;
        }
      }
      ans.push_back(2);
      sort(ans.begin(), ans.end());
      ans.erase(unique(ans.begin(), ans.end()), ans.end());
    }
  }

  const auto& operator[](int ind) const {
    return cands_[ind];
  }

 private:
  static constexpr int BRUTE = 1;
  static constexpr int ROLLS = 80;
  vector<vector<int>> cands_;
};

class ScoreTable {

 public:
  void add(pair<int, int> a) {
    auto& ref = cand_to_score_[a];
    if (ref > 0) {
      scores_[ref]--;
    }
    ref++;
    scores_[ref]++;
  }

  void remove(pair<int, int> a) {
    auto& ref = cand_to_score_[a];
    scores_[ref]--;
    if (scores_[ref] == 0) {
      scores_.erase(ref);
    }
    ref--;
    if (ref == 0) {
      cand_to_score_.erase(a);
    }
    else {
      scores_[ref]++;
    }
  }

  int get_best() const {
    return scores_.empty() ? 0 : scores_.rbegin()->first;
  }

  auto get_res() const {
    vector<pair<int, int>> res;
    for (auto [p, sc] : cand_to_score_) {
      res.push_back(make_pair(p.first, sc));
    }
    sort(res.begin(), res.end());
    reverse(res.begin(), res.end());
    for (int i = 0; i < (int) res.size() - 1; i++) {
      if (res[i].first == res[i+1].first) {
        res[i+1].second = res[i].second;
      }
    }
    res.erase(unique(res.begin(), res.end()), res.end());
    return res;
  }

  friend ostream& operator<<(ostream& os, const ScoreTable& score_table) {
    os << "[Score Table]: ";
    os << "(scores_ : ";
    for (auto [a, b] : score_table.scores_) {
      os << "{" << a << ": " << b << "}, ";
    }
    os << "), (candidate to score : ";
    for (auto [p, sc] : score_table.cand_to_score_) {
      os << "{(" << p.first << ", " << p.second << "): " << sc << "}, ";
    }
    os << endl;
    return os;
  }

 private:
  map<int, int> scores_;
  map<pair<int, int>, int> cand_to_score_;
};


class Solver {

 public:
  explicit Solver(const Queries& queries, const CandPrimes& cand_primes, const Sieve& sieve) : ans_(queries.get_q()) {
    IndexedSet curr;
    ScoreTable score_table;
    for (int i = 0; i < queries.get_q(); i += K) {
      score_table = solve(i, min(i + K, queries.get_q()), queries, cand_primes, curr, sieve, score_table);
    }
  }

  const auto& get() const {
    return ans_;
  }

 private:
  static constexpr int BRUTE = 1;
  static constexpr int K = 200;
  static constexpr int P = 1000;
  vector<int> ans_;

  ScoreTable solve(int l, int r, const Queries& queries, const CandPrimes& cand_primes, IndexedSet& curr, const Sieve& sieve, const ScoreTable& old_score) {
    vector<int> cands;
    if ((int) curr.size() - K <= queries.get_n() / P + 5) {
      for (int i = l; i < r; i++) {
        cands.insert(cands.end(), cand_primes[i].begin(), cand_primes[i].end());
      }
      sort(cands.begin(), cands.end());
      cands.erase(unique(cands.begin(), cands.end()), cands.end());
    }
    else {
      cands = sieve.small_primes(P);
    }
    auto old_res = old_score.get_res();
    vector<int> to_remove;
    for (auto [p, sc] : old_res) {
      if (sc < max(old_score.get_best() - K, ((int) curr.size() - K) / 2)) {
        to_remove.push_back(p);
      }
    }
    vector<pair<int, int>> pr;
    for (int p : cands) {
      pr.push_back({p, 1});
    }
    for (int p : to_remove) {
      pr.push_back({p, -1});
    }
    sort(pr.begin(), pr.end());
    for (int i = 0; i < (int) pr.size() - 1; i++) {
      if (pr[i].first == pr[i+1].first) {
        pr[i+1].second = -1;
      }
    }
    for (auto& [p, sc] : pr) {
      if (sc == -1) {
        p = 2;
        sc = 1;
      }
    }
    sort(pr.begin(), pr.end());
    pr.erase(unique(pr.begin(), pr.end()), pr.end());
    cands.resize(pr.size());
    for (int i = 0; i < (int) pr.size(); i++) {
      cands[i] = pr[i].first;
    }


    ScoreTable score;


    for (int a : curr) {
      for (int p : cands) {
        score.add({p, a % p});
      }
    }

    for (int i = l; i < r; i++) {
      auto [a, sg] = queries.get()[i];
      if (sg == 1) {
        curr.add(a);
        for (int p : cands) {
          score.add({p, a % p});
        }
      }
      else {
        curr.remove(a);
        for (int p : cands) {
          score.remove({p, a % p});
        }
      }
      ans_[i] = score.get_best();
      // cerr << curr << endl;
      // cerr << score << endl;
    }
    return score;
  }
};


int main() {
  int n;
  cin >> n;
  Queries queries(n);
  cin >> queries;
  Sieve sieve(n);

  CandPrimes cand_primes(queries, sieve);
  Solver solver(queries, cand_primes, sieve);

  for (int v : solver.get()) {
    cout << v << "\n";
  }
}