#include <bits/stdc++.h>
using namespace std;
int64_t cnt, n, q, L, R;
int64_t seg[10000];
vector<int> a;
void Update(int pos, int L, int R, int x, int val) {
  if (x < L || x > R) return;
  if (L == R) {
    seg[pos] = val;
    return;
  }
  int mid = (L + R) >> 1;
  Update(pos << 1, L, mid, x, val);
  Update(pos << 1 | 1, mid + 1, R, x, val);
  seg[pos] = seg[pos << 1] + seg[pos << 1 | 1];
}
int64_t Get(int pos, int L, int R, int x, int y) {
  if (R < x || y < L) return 0;
  if (x <= L && R <= y) return seg[pos];
  int mid = (L + R) >> 1;
  return Get(pos << 1, L, mid, x, y) + Get(pos << 1 | 1, mid + 1, R, x, y);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n;
  a.resize(n);
  for (auto &i : a) cin >> i;
  for (int i = 0; i <= n - 1; ++i) {
    cnt += Get(1, 1, n, a[i] + 1, n);
    Update(1, 1, n, a[i], 1);
  }
  int64_t state = cnt & 1;
  cin >> q;
  for (int i = 1; i <= q; ++i) {
    cin >> L >> R;
    int64_t step = (R - L + 1) / 2;
    if (step & 1) state ^= 1;
    if (state & 1)
      cout << "odd" << '\n';
    else
      cout << "even" << '\n';
  }
  return 0;
}

### Prompt

Generate a CPP solution to the following problem:

A permutation of size n is an array of size n such that each integer from 1 to n occurs exactly once in this array. An inversion in a permutation p is a pair of indices (i, j) such that i > j and ai < aj. For example, a permutation [4, 1, 3, 2] contains 4 inversions: (2, 1), (3, 1), (4, 1), (4, 3).

You are given a permutation a of size n and m queries to it. Each query is represented by two indices l and r denoting that you have to reverse the segment [l, r] of the permutation. For example, if a = [1, 2, 3, 4] and a query l = 2, r = 4 is applied, then the resulting permutation is [1, 4, 3, 2].

After each query you have to determine whether the number of inversions is odd or even.

Input

The first line contains one integer n (1 ≤ n ≤ 1500) — the size of the permutation. 

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of the permutation. These integers are pairwise distinct.

The third line contains one integer m (1 ≤ m ≤ 2·105) — the number of queries to process.

Then m lines follow, i-th line containing two integers li, ri (1 ≤ li ≤ ri ≤ n) denoting that i-th query is to reverse a segment [li, ri] of the permutation. All queries are performed one after another.

Output

Print m lines. i-th of them must be equal to odd if the number of inversions in the permutation after i-th query is odd, and even otherwise.

Examples

Input

3
1 2 3
2
1 2
2 3


Output

odd
even


Input

4
1 2 4 3
4
1 1
1 4
1 4
2 3


Output

odd
odd
odd
even

Note

The first example:

  1. after the first query a = [2, 1, 3], inversion: (2, 1); 
  2. after the second query a = [2, 3, 1], inversions: (3, 1), (3, 2). 



The second example:

  1. a = [1, 2, 4, 3], inversion: (4, 3); 
  2. a = [3, 4, 2, 1], inversions: (3, 1), (4, 1), (3, 2), (4, 2), (4, 3); 
  3. a = [1, 2, 4, 3], inversion: (4, 3); 
  4. a = [1, 4, 2, 3], inversions: (3, 2), (4, 2). 

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
int64_t cnt, n, q, L, R;
int64_t seg[10000];
vector<int> a;
void Update(int pos, int L, int R, int x, int val) {
  if (x < L || x > R) return;
  if (L == R) {
    seg[pos] = val;
    return;
  }
  int mid = (L + R) >> 1;
  Update(pos << 1, L, mid, x, val);
  Update(pos << 1 | 1, mid + 1, R, x, val);
  seg[pos] = seg[pos << 1] + seg[pos << 1 | 1];
}
int64_t Get(int pos, int L, int R, int x, int y) {
  if (R < x || y < L) return 0;
  if (x <= L && R <= y) return seg[pos];
  int mid = (L + R) >> 1;
  return Get(pos << 1, L, mid, x, y) + Get(pos << 1 | 1, mid + 1, R, x, y);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n;
  a.resize(n);
  for (auto &i : a) cin >> i;
  for (int i = 0; i <= n - 1; ++i) {
    cnt += Get(1, 1, n, a[i] + 1, n);
    Update(1, 1, n, a[i], 1);
  }
  int64_t state = cnt & 1;
  cin >> q;
  for (int i = 1; i <= q; ++i) {
    cin >> L >> R;
    int64_t step = (R - L + 1) / 2;
    if (step & 1) state ^= 1;
    if (state & 1)
      cout << "odd" << '\n';
    else
      cout << "even" << '\n';
  }
  return 0;
}

```