#include <bits/stdc++.h>
struct DSU {
 private:
  int32_t* parents;
  int32_t* sizes;
  std::vector<std::pair<int32_t, int32_t> > actions;
  int32_t get_root(int32_t v) {
    if (parents[v] == v) return v;
    return get_root(parents[v]);
  }

 public:
  DSU(int32_t n) {
    parents = new int32_t[n];
    sizes = new int32_t[n];
    for (int32_t i = 0; i < n; i++) {
      parents[i] = i;
      sizes[i] = 1;
    }
  }
  bool same(int32_t v1, int32_t v2) { return get_root(v1) == get_root(v2); }
  void join(int32_t v1, int32_t v2) {
    int32_t root1 = get_root(v1), root2 = get_root(v2);
    if (root1 == root2) {
      actions.emplace_back(-1, -1);
      return;
    }
    if (sizes[root1] > sizes[root2]) {
      int32_t tmp = root1;
      root1 = root2;
      root2 = tmp;
    }
    parents[root1] = root2;
    sizes[root2] += sizes[root1];
    actions.emplace_back(root1, root2);
  }
  void pop() {
    if (actions.back().first != -1) {
      sizes[parents[actions.back().first]] -= sizes[actions.back().first];
      parents[actions.back().first] = actions.back().first;
    }
    actions.pop_back();
  }
};
struct Tracker {
 private:
  DSU all_dsu;
  DSU comp_dsu;
  int32_t num_edges = 0;
  int32_t broken_since = -1;
  std::set<int32_t>* graph;
  std::vector<int32_t> actions_time;

 public:
  Tracker(int32_t n) : all_dsu(n), comp_dsu(n) {
    graph = new std::set<int32_t>[n];
  }
  void add_edge(int32_t v1, int32_t v2) {
    if (all_dsu.same(v1, v2)) {
      if (comp_dsu.same(v1, v2)) {
        if (broken_since == -1) broken_since = num_edges;
      } else {
      }
    } else {
      if (graph[v2].size() > 0) {
        comp_dsu.join(v1, *graph[v2].begin());
        actions_time.push_back(num_edges);
      }
      if (graph[v1].size() > 0) {
        comp_dsu.join(v2, *graph[v1].begin());
        actions_time.push_back(num_edges);
      }
    }
    all_dsu.join(v1, v2);
    graph[v1].insert(v2);
    graph[v2].insert(v1);
    num_edges++;
  }
  void pop_edge(int32_t v1, int32_t v2) {
    num_edges--;
    if (num_edges == broken_since) broken_since = -1;
    all_dsu.pop();
    graph[v1].erase(v2);
    graph[v2].erase(v1);
    while (actions_time.size() > 0 && actions_time.back() >= num_edges) {
      comp_dsu.pop();
      actions_time.pop_back();
    }
  }
  bool get_ans() { return broken_since == -1; }
};
std::vector<std::pair<int32_t, int32_t> >* segtree;
void add_edge(int32_t node, int32_t left, int32_t right, int32_t query_left,
              int32_t query_right, std::pair<int32_t, int32_t> edge) {
  if (left >= query_right || right <= query_left) return;
  if (left >= query_left && right <= query_right) {
    segtree[node].push_back(edge);
    return;
  }
  int32_t m = (left + right) / 2;
  add_edge(node * 2 + 1, left, m, query_left, query_right, edge);
  add_edge(node * 2 + 2, m, right, query_left, query_right, edge);
}
void get_ans(int32_t node, int32_t left, int32_t right, Tracker& tracker) {
  for (int32_t i = 0; i < segtree[node].size(); i++)
    tracker.add_edge(segtree[node][i].first, segtree[node][i].second);
  if (right - left == 1) {
    std::cout << (tracker.get_ans() ? "YES" : "NO") << "\n";
    for (int32_t i = 0; i < segtree[node].size(); i++)
      tracker.pop_edge(segtree[node][i].first, segtree[node][i].second);
    return;
  }
  int32_t m = (left + right) / 2;
  get_ans(node * 2 + 1, left, m, tracker);
  get_ans(node * 2 + 2, m, right, tracker);
  for (int32_t i = 0; i < segtree[node].size(); i++)
    tracker.pop_edge(segtree[node][i].first, segtree[node][i].second);
}
int main() {
  int32_t n, num_queries;
  std::cin >> n >> num_queries;
  segtree = new std::vector<std::pair<int32_t, int32_t> >[4 * num_queries];
  std::map<std::pair<int32_t, int32_t>, int32_t> segments;
  for (int32_t q = 0; q < num_queries; q++) {
    int32_t v1, v2;
    std::cin >> v1 >> v2;
    v1--;
    v2--;
    if (v1 > v2) {
      int32_t tmp = v1;
      v1 = v2;
      v2 = tmp;
    }
    auto it = segments.find({v1, v2});
    if (it == segments.end())
      segments[{v1, v2}] = q;
    else {
      add_edge(0, 0, num_queries, it->second, q, {v1, v2});
      segments.erase(it);
    }
  }
  for (auto it = segments.begin(); it != segments.end(); it++)
    add_edge(0, 0, num_queries, it->second, num_queries, it->first);
  Tracker tracker(n);
  get_ans(0, 0, num_queries, tracker);
  return 0;
}
