#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


namespace seg {
using Value = int;
constexpr int MAX_NUM_NODES = 40'000'010;
int n, id, ls[MAX_NUM_NODES], rs[MAX_NUM_NODES];
Value vals[MAX_NUM_NODES];
void init(int n_) {
  n = n_;
  id = 0;
}
int newNode() {
  const int u = id++;
  ls[u] = rs[u] = -1;
  vals[u] = Value();
  return u;
}
int build(int l, int r) {
  const int u = newNode();
  if (l + 1 == r) return u;
  const int mid = (l + r) / 2;
  ls[u] = build(l, mid);
  rs[u] = build(mid, r);
  return u;
}

int clone(int u, Value lz) {
  if (!lz) return u;
  const int v = id++;
  ls[v] = ls[u];
  rs[v] = rs[u];
  vals[v] = vals[u] + lz;
  return v;
}
int cat(int u, int v, int l, int r, int pos, Value lzU, Value lzV) {
// cerr<<"[cat] "<<u<<" "<<v<<" "<<l<<" "<<r<<" "<<pos<<" "<<lzU<<" "<<lzV<<endl;
  if (pos <= l) return clone(v, lzV);
  if (pos >= r) return clone(u, lzU);
  const int mid = (l + r) / 2;
  const int w = newNode();
  ls[w] = cat(ls[u], ls[v], l, mid, pos, lzU + vals[u], lzV + vals[v]);
  rs[w] = cat(rs[u], rs[v], mid, r, pos, lzU + vals[u], lzV + vals[v]);
  return w;
}
int cat(int u, int v, int pos, Value lzU, Value lzV) {
  return cat(u, v, 0, n, pos, lzU, lzV);
}

Value get(int u, int l, int r, int pos) {
  assert(l <= pos); assert(pos < r);
  if (l + 1 == r) return vals[u];
  const int mid = (l + r) / 2;
  if (pos < mid) {
    return vals[u] + get(ls[u], l, mid, pos);
  } else {
    return vals[u] + get(rs[u], mid, r, pos);
  }
}
Value get(int u, int pos) {
  return get(u, 0, n, pos);
}
}  // seg


int N, Q;
vector<int> A;

int main() {
  for (; ~scanf("%d%d", &N, &Q); ) {
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%d", &A[i]);
    }
    
    vector<int> nxt(N);
    {
      vector<int> app(N + 1, N);
      for (int i = N; --i >= 0; ) {
        nxt[i] = app[A[i]];
        app[A[i]] = i;
      }
    }
// cerr<<"nxt = "<<nxt<<endl;
    
    // l -> (r -> ans)
    seg::init(N + 1);
    vector<int> segs(N + 1, -1);
    segs[N] = seg::build(0, N + 1);
    for (int i = N; --i >= 0; ) {
      /*
        i: 0
        [i+1, nxt[i]]: segs[i+1] + 1
        [nxt[i]+1, N]: segs[nxt[i]+1]
      */
// cerr<<COLOR("91")<<N<<" "<<i+1<<" "<<i+1<<COLOR()<<endl;
      segs[i] = seg::cat(segs[N], segs[i + 1], i + 1, 0, 1);
      if (nxt[i] < N) {
// cerr<<COLOR("92")<<i<<" "<<nxt[i]+1<<" "<<nxt[i]+1<<COLOR()<<endl;
        segs[i] = seg::cat(segs[i], segs[nxt[i] + 1], nxt[i] + 1, 0, 0);
      }
    }
    
    int lastans = 0;
    for (; Q--; ) {
      int L, R;
      scanf("%d%d", &L, &R);
      L ^= lastans;
      R ^= lastans;
      --L;
// cerr<<COLOR("33")<<L<<" "<<R<<COLOR()<<endl;
      // if (!(0 <= L && L < R && R <= N)) exit(0);
      const int ans = seg::get(segs[L], R);
      printf("%d\n", ans);
      lastans = ans;
    }
  }
  return 0;
}