import java.util.*;
import java.io.*;

public class InversionCounting {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = Integer.parseInt(sc.nextLine());
		int inversions = 0;
		int[] data = new int[n];

		StringTokenizer st = new StringTokenizer(sc.nextLine());
		for(int i = 0; i < n; i ++) {
			data[i] = Integer.parseInt(st.nextToken());
		}

		for(int i = 0; i < n; i++) {
			for(int j = i + 1; j < n; j++) {
				if(data[i] > data[j])
					inversions++;
			}
		}
		//false = 0, true = 1;
		boolean inversiontype = (inversions % 2 == 1);

		int n2 = Integer.parseInt(sc.nextLine());
		for(int i = 0; i < n2; i++) {
			st = new StringTokenizer(sc.nextLine());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());

			int parity = (b-a)*(b - a + 1)/2;
			if(parity % 2 == 0) {
				if(inversiontype)
					pw.println("odd");
				else
					pw.println("even");
			} else {
				inversiontype = !inversiontype;
				if(inversiontype)
					pw.println("odd");
				else
					pw.println("even");
			}
		}
		pw.close();
	}
}


import java.util.*;

public class inversioncounting {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] permutation = new int[n];
		for (int i = 0; i < n; i++) {
			permutation[i] = sc.nextInt();
		}
		int m = sc.nextInt();
		int[][] reverse = new int[m][2];
		for (int i = 0; i < m; i++) {
			reverse[i][0] = sc.nextInt();
			reverse[i][1] = sc.nextInt();
		}
		int counter = 0;
		for (int i = 0; i < n - 1; i++) {
			for (int j = i + 1; j < n; j++) {
				if (permutation[i] > permutation[j]) {
					counter++;
				}
			}
		}
		boolean bayus = true;
		if (counter % 2 == 1) {
			bayus = false;
		}
		for (int i = 0; i < m; i++) {
			int bobib = reverse[i][1] - reverse[i][0] + 1;
			int bafry = nChoose2(bobib);
			if (bafry%2 == 1) {
				bayus = !bayus;
			}
			if (bayus) {
				System.out.println("even");
			}
			else {
				System.out.println("odd");
			}
		}

	}
	private static int nChoose2 (int n) {
		return (n * (n-1)) / 2;
	}

}


//package Educational35;

//import FastScanner.Competitive;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class D {
        String INPUT = "4\n" +
                "1 2 4 3\n" +
                "4\n" +
                "1 1\n" +
                "1 4\n" +
                "1 4\n" +
                "2 3";

        void solve()
        {
                final int n = i();
                final int[] a = ia(n);
                int count = 0 ;
                for(int i = 0 ; i<n-1 ; i++)
                {
                        for(int j = i+1; j<n ; j++)
                        {
                                if(a[j]<a[i])
                                {
                                        count++;
                                }
                        }
                }
                final int q = i();
                for(int i = 0 ; i<q ; i++)
                {
                        final int l = i(), r=i();
                        final int mid = (r-l+1)/2;
                        if(mid%2==0)
                        {
                                out.println(count%2==0?"even":"odd");
                        }
                        else
                        {
                                count++;
                                out.println(count%2==0?"even":"odd");
                        }
                }

        }
        ///////////////////////////////////////
        void run() throws Exception{
                is = oj ? System.in: new ByteArrayInputStream(INPUT.getBytes());
                //is = System.in;
                out = new PrintWriter(System.out);
                int t = 1;
                while(t-->0)	solve();
                out.flush();
        }
        public static void main(String[] args)throws Exception {
                new D().run();
        }
        InputStream is;
        PrintWriter out;
        private byte[] inbuf = new byte[1024];
        public int lenbuf = 0, ptrbuf = 0;

        private int readByte()
        {
                if(lenbuf == -1)throw new InputMismatchException();
                if(ptrbuf >= lenbuf){
                        ptrbuf = 0;
                        try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
                        if(lenbuf <= 0)return -1;
                }
                return inbuf[ptrbuf++];
        }

        private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
        private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

        private double d() { return Double.parseDouble(s()); }
        private char c() { return (char)skip(); }

        private String s()
        {
                int b = skip();
                StringBuilder sb = new StringBuilder();
                while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
                        sb.appendCodePoint(b);
                        b = readByte();
                }
                return sb.toString();
        }

        private char[] sa(int n)
        {
                char[] buf = new char[n];
                int b = skip(), p = 0;
                while(p < n && !(isSpaceChar(b))){
                        buf[p++] = (char)b;
                        b = readByte();
                }
                return n == p ? buf : Arrays.copyOf(buf, p);
        }

        private char[][] nm(int n, int m)
        {
                char[][] map = new char[n][];
                for(int i = 0;i < n;i++)map[i] = sa(m);
                return map;
        }

        private int[] ia(int n)
        {
                int[] a = new int[n];
                for(int i = 0;i < n;i++)a[i] = i();
                return a;
        }

        private int i()
        {
                int num = 0, b;
                boolean minus = false;
                while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
                if(b == '-'){
                        minus = true;
                        b = readByte();
                }

                while(true){
                        if(b >= '0' && b <= '9'){
                                num = num * 10 + (b - '0');
                        }else{
                                return minus ? -num : num;
                        }
                        b = readByte();
                }
        }

        private long l()
        {
                long num = 0;
                int b;
                boolean minus = false;
                while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
                if(b == '-'){
                        minus = true;
                        b = readByte();
                }

                while(true){
                        if(b >= '0' && b <= '9'){
                                num = num * 10 + (b - '0');
                        }else{
                                return minus ? -num : num;
                        }
                        b = readByte();
                }
        }

        private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class P911D
{
	public static void main(String[] args)
	{
		FastScanner scan = new FastScanner();
		PrintWriter pw = new PrintWriter(System.out);
		int n = scan.nextInt();
		int[] arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = scan.nextInt();
		int inv = 0;
		for (int i = 0; i < n; i++)
		{
			for (int j = i+1; j < n; j++)
			{
				if (arr[i] > arr[j])
					inv++;
			}
		}
		inv &= 1;

		int[] cumul = new int[n+1];
		for (int i = 2; i < cumul.length; i++)
		{
			cumul[i] = cumul[i-1] + i-1;
		}
		int q = scan.nextInt();
		for (int i = 0; i < q; i++)
		{
			int a = scan.nextInt()-1;
			int b = scan.nextInt()-1;
			inv += cumul[b-a+1];
			inv &= 1;
			if (inv == 0)
				pw.println("even");
			else
				pw.println("odd");
		}
		pw.flush();
	}

	static class FastScanner
	{
		BufferedReader br;
		StringTokenizer st;

		public FastScanner()
		{
			try
			{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e)
			{
				e.printStackTrace();
			}
		}

		public String next()
		{
			if (st.hasMoreTokens())
				return st.nextToken();
			try
			{
				st = new StringTokenizer(br.readLine());
			} catch (Exception e)
			{
				e.printStackTrace();
			}
			return st.nextToken();
		}

		public int nextInt()
		{
			return Integer.parseInt(next());
		}

		public long nextLong()
		{
			return Long.parseLong(next());
		}

		public String nextLine()
		{
			String line = "";
			try
			{
				line = br.readLine();
			} catch (Exception e)
			{
				e.printStackTrace();
			}
			return line;
		}
	}
}


import java.util.*;
import java.io.*;
import java.math.*;
public class A{

    void solve(){
        int n=ni();
        int P[]=new int[n+1];
        for(int i=1;i<=n;i++) P[i]=ni();
        a=new int[n+1];
        BIT=new long[n+1];
        long cnt=0;

        long p=0;
        for(int i=n;i>=1;i--){
            p+=querry(P[i]);
            if(p>=M) p%=M;
            update(n,P[i],1);
        }
        int d=0;
        if(p%2==0) d=1;
        int m=ni();
        while(m-->0){
            int l=ni(),r=ni();
            long sz=r-l+1;
            sz=(sz*(sz-1))/2;
            if(d==1 && sz%2==0) d=1;
            else if(d==1 && sz%2!=0) d=0;
            else if(d==0 && sz%2==0) d=0;
            else if(d==0 && sz%2!=0) d=1;
            if(d==1) pw.println("even");
            else pw.println("odd");
        }
    }
    int a[];
    long BIT[];
    void update(int n,int x,int val){
        a[x]=val;
        for(;x<=n;x+=(x&-x)) BIT[x]+=val;
    }
    long querry(int x){
        long ans=0;
        for(;x>0;x-=(x&-x)) ans+=BIT[x];
        return ans;

    }

    static long d, x, y;
    static void extendedEuclid(long A, long B) {
        if(B == 0) {
            d = A;
            x = 1;
            y = 0;
        }
        else {
            extendedEuclid(B, A%B);
            long temp = x;
            x = y;
            y = temp - (A/B)*y;
        }
    }
    static long modInverse(long A, long M)
    {
        extendedEuclid(A,M);
        return (x%M+M)%M;
    }
    long M=(long)1e9+7;
    InputStream is;
    PrintWriter pw;
    String INPUT = "";
    void run() throws Exception {
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        pw = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        pw.flush();
        if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
    }

    public static void main(String[] args) throws Exception { new A().run(); }

    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte() {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n) {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private char[][] nm(int n, int m) {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }

    private int[] na(int n) {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }

    private int ni() {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private long nl() {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
}


import java.util.*;
import java.io.*;

public class P911d {

  private static void solve() {
    int n = nextInt();

    int[] a = new int[n];
    for (int i = 0; i < n; i++) {
      a[i] = nextInt();
    }

    int cnt = 0;
    for (int i = 0; i < n; i++) {
      for (int j = i + 1; j < n; j++) {
        if (a[i] > a[j]) {
          cnt++;
        }
      }
    }

    cnt %= 2;

    int m = nextInt();
    for (int i = 0; i < m; i++) {
      int l = nextInt();
      int r = nextInt();

      int size = r - l + 1;
      int sum = (size * (size - 1)) / 2;

      sum %= 2;

      cnt += sum;
      cnt %= 2;

      out.println(cnt == 0 ? "even" : "odd");
    }
  }

  private static void run() {
    br = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(System.out);

    solve();

    out.close();
  }

  private static StringTokenizer st;
  private static BufferedReader br;
  private static PrintWriter out;

  private static String next() {
    while (st == null || !st.hasMoreElements()) {
      String s;
      try {
        s = br.readLine();
      } catch (IOException e) {
        return null;
      }
      st = new StringTokenizer(s);
    }
    return st.nextToken();
  }

  private static int nextInt() {
    return Integer.parseInt(next());
  }

  private static long nextLong() {
    return Long.parseLong(next());
  }

  public static void main(String[] args) {
    run();
  }
}


//app.は全部けす

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

//流す前にfinalにする
public final class EcRound35DApplication {

	public static void main(String[] args) {

		Input input = new Input();
		input = SystemInput();
		List<String> resultList = run(input);
		for(String result:resultList){
			System.out.println(result);
		}

	}

	//流す前にstaticにする
	private static void tester(Integer no,List<Integer> inputList,List<String> answer) {
		Input input = new Input();
		input.setInput(inputList);
		List<String> result = run(input);

		if(result.equals(answer)) {
			System.out.println("No." + no + ":OK");
		}
		else {
			System.out.println("No." + no + ":failed");
			System.out.println("result:" + result);
			System.out.println("answer:" + answer);
		}
	}

	//流す前にstaticにする
	private static Input SystemInput() {
		Input input = new Input();
		Scanner sc = new Scanner(System.in);

		List<Integer> inputList = new ArrayList<Integer>();

		while(sc.hasNextInt()) {
			inputList.add(sc.nextInt());
		}

		input.setInput(inputList);
		sc.close();
		return input;
	}

	//流す前にstaticにする
	private static List<String> run(Input input) {
		List<String> result = new ArrayList<String>();

		List<Integer> permutation = input.getPermutationList();
		Integer count;

		count = inversion(permutation);

		for(Integer i = 0;i < input.getQueryNum();i++) {
			count = count + change(input.getQuery(i));

			result.add(evenOdd(count));
		}

		return result;
	}

	//カウントする
	private static Integer inversion(List<Integer>permutation) {
		String result = new String();
		Integer inversionCount = 0;

		for(Integer i = 0; i < permutation.size(); i++) {
			for(Integer j = i + 1; j < permutation.size(); j++) {
				if(permutation.get(i) > permutation.get(j)) {
					inversionCount++;
				}
			}
		}

		return inversionCount;

	}

	//交換時追加分カウント
	private static Integer change(Query query) {
		Integer result;

		result = query.getLength() * (query.getLength() - 1) / 2;

		return result;
	}

	//判定する
	private static String evenOdd(Integer i) {
		if(i % 2 == 0) {
			return "even";
		}

		else {
			return "odd";
		}
	}

	private static class Query{
		private Integer l;
		private Integer r;

		public void setQuery(Integer l,Integer r) {
			this.l = l;
			this.r = r;
		}

		public Integer getL() {
			return l;
		}
		public void setL(Integer l) {
			this.l = l;
		}
		public Integer getR() {
			return r;
		}
		public void setR(Integer r) {
			this.r = r;
		}
		public Integer getLength(){
			return r - l + 1;
		}

	}

	//流す前にstaticにする
	private static class Input{
		private Integer length;
		private List<Integer> permutationList = new ArrayList<Integer>();
		private Integer queryNum;
		private List<Query> queryList = new ArrayList<Query>();

		public void setInput(List<Integer> inputList) {
			this.length = inputList.get(0);

			setPermutationList(inputList.subList(1, length+1));

			this.queryNum = inputList.get(length+1);

			for(Integer j = length+2; j < inputList.size()-1; j = j + 2) {
				addQueryList(inputList.get(j),inputList.get(j+1));
			}

//			checkInput();

		}

		public void checkInput() {
			System.out.println("permutation length:" + permutationList.size());

			System.out.println("permutation:" + permutationList);

			System.out.println("query length:" + queryList.size());
			System.out.println("queries:");
			for(Integer i = 0;i < queryList.size();i++) {
				System.out.println(this.getQueryL(i) + " " + this.getQueryR(i));
			}

		}

		public Integer getLength() {
			return length;
		}

		public void setLength(Integer length) {
			this.length = length;
		}

		public List<Integer> getPermutationList() {
			return permutationList;
		}

		public void setPermutationList(List<Integer> permutationList) {
			this.permutationList = permutationList;
		}

		public Integer getPermutation(Integer i) {
			return permutationList.get(i);
		}

		public void addPermutationList(Integer newPermutation) {
			this.permutationList.add(newPermutation);
		}

		public Integer getQueryNum() {
			return queryNum;
		}

		public void setQueryNum(Integer queryNum) {
			this.queryNum = queryNum;
		}

		public Query getQuery(Integer i) {
			return queryList.get(i);
		}

		public Integer getQueryL(Integer i) {
			return queryList.get(i).getL();
		}

		public Integer getQueryR(Integer i) {
			return queryList.get(i).getR();
		}

		public List<Query> getQueryList() {
			return queryList;
		}

		public void setQueryList(List<Query> queryList) {
			this.queryList = queryList;
		}

		public void addQueryList(Query newQuery) {
			this.queryList.add(newQuery);
		}

		public void addQueryList(Integer l,Integer r) {
			Query newQuery = new Query();
			newQuery.setQuery(l, r);
			addQueryList(newQuery);
		}

	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            String[] response = {"even", "odd"};
            int n = in.nextInt();
            int[] arr = in.nextIntArray(0, n);
            int swaps = 0;
            for (int i = 0; i < n; i++) {
                for (int j = i + 1; j < n; j++) {
                    if (arr[i] > arr[j]) swaps = (swaps + 1) % 2;
                }
            }
            int m = in.nextInt();
            for (int i = 0; i < m; i++) {
                int l = in.nextInt(), r = in.nextInt(), combinaisons = ((r - l) * (r - l + 1)) / 2;
                if (combinaisons % 2 == 1) {
                    swaps ^= 1;
                }
                out.println(response[swaps]);
            }
        }

    }

    static class InputReader {
        private StringTokenizer tokenizer;
        private BufferedReader reader;

        public InputReader(InputStream inputStream) {
            reader = new BufferedReader(new InputStreamReader(inputStream));
        }

        private void fillTokenizer() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }

        public String next() {
            fillTokenizer();
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public int[] nextIntArray(int offset, int length) {
            int[] arr = new int[offset + length];
            for (int i = offset; i < offset + length; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

    }
}


import java.io.*;
import java.util.*;
import java.util.function.Consumer;

public class Solution {

    static MyScanner sc;
    private static PrintWriter out;
    static long M2 = 1_000_000_000L + 7;

    private static HashMap<Long, Long>[] mods;

    public static void main(String[] s) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();

//        stringBuilder.append("7 3\n" +
//                "1 5 2 6 3 7 4\n" +
//                "2 5 3\n" +
//                "4 4 1\n" +
//                "1 7 3");

//
//        Random r = new Random(5);
//        stringBuilder.append("100000 5000 ");
//        for (int i = 0; i < 100000; i++) {
//            stringBuilder.append(" " + (r.nextInt(2000000000) - 1000000000) + " ");
//
//        }
//        for (int k = 0; k < 5000; k++) {
//            stringBuilder.append(" 1 100000 777 ");
//        }
        if (stringBuilder.length() == 0) {
            sc = new MyScanner(System.in);
        } else {
            sc = new MyScanner(new BufferedReader(new StringReader(stringBuilder.toString())));
        }

        out = new PrintWriter(new OutputStreamWriter(System.out));

        initData();
        solve();

        out.flush();
    }

    private static void solve() throws IOException {
        int n = sc.nextInt();
        int[] data = sc.na(n);
        boolean ev = true;
        for (int t = 0; t < n - 1; t++) {
            for (int x = t + 1; x < n; x++) {
                if (data[t] > data[x]) {
                    ev = !ev;
                }
            }
        }
        int m = sc.nextInt();
        for (int i = 0; i < m; i++) {
            int dd = -sc.nextInt() + sc.nextInt();

            int dm = (dd + 1) * dd / 2;
            if (dm % 2 == 1) {
                ev = !ev;
            }
            out.println(ev ? "even" : "odd");
        }

    }

    private static void initData() {

    }

    private static boolean isset(long i, int k) {
        return (i & (1 << k)) > 0;
    }

    private static void solveT() throws IOException {
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    private static long gcd(long l, long l1) {
        if (l > l1) return gcd(l1, l);
        if (l == 0) return l1;
        return gcd(l1 % l, l);
    }

    private static long pow(long a, long b, long m) {
        if (b == 0) return 1;
        if (b == 1) return a;
        long pp = pow(a, b / 2, m);
        pp *= pp;
        pp %= m;
        return (pp * (b % 2 == 0 ? 1 : a)) % m;
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        MyScanner(BufferedReader br) {
            this.br = br;
        }

        public MyScanner(InputStream in) {
            this(new BufferedReader(new InputStreamReader(in)));
        }

        void findToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        String next() {
            findToken();
            return st.nextToken();
        }

        Integer[] nab(int n) {
            Integer[] k = new Integer[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        int[] na(int n) {
            int[] k = new int[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        long[] nl(int n) {
            long[] k = new long[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.nextLong();
            }
            return k;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        int fi() {
            String t = next();
            int cur = 0;
            boolean n = t.charAt(0) == '-';
            for (int a = n ? 1 : 0; a < t.length(); a++) {
                cur = cur * 10 + t.charAt(a) - '0';
            }
            return n ? -cur : cur;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

}


import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.*;
public class USACO {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(reader.readLine());
        StringTokenizer st = new StringTokenizer(reader.readLine()," ");
        int[] perm = new int[n];
        int count=0;
        for (int i=0;i<n;i++) {
            perm[i]=Integer.parseInt(st.nextToken());
            for (int j=0;j<i;j++) {
                if (perm[j]>perm[i]) {
                    count++;
                }
            }
        }
        count=count%2;
        int m = Integer.parseInt(reader.readLine());
        for (int i=0;i<m;i++) {
            StringTokenizer st2 = new StringTokenizer(reader.readLine()," ");
            int a = Integer.parseInt(st2.nextToken());
            int b = Integer.parseInt(st2.nextToken());
            if ((b-a+1)%4==2||(b-a+1)%4==3) {
                count++;
                count=count%2;
            }
            if(count%2==0) {
                System.out.println("even");
            } else {
                System.out.println("odd");
            }
        }
    }
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;

public class D {

    int N,M;
    int[] a,l,r;

    private void solve() {
        N = nextInt();

        a = new int[N];
        for(int i = 0;i < N;i++) {
            a[i] = nextInt();
        }

        M = nextInt();

        l = new int[M];
        r = new int[M];
        for(int i = 0;i < M;i++) {
            l[i] = nextInt();
            r[i] = nextInt();
        }

        int count = 0;
        for(int i = 0;i < N - 1;i++) {
            for(int j = i + 1;j < N;j++) if (a[i] > a[j]) {
                count++;
            }
        }

        for(int i = 0;i < M;i++) {
            count += (r[i] - l[i] + 1) * (r[i] - l[i]) / 2;
            count %= 2;
            out.println(count == 0 ? "even" : "odd");
        }
    }

    public static void main(String[] args) {
        out.flush();
        new D().solve();
        out.close();
    }

    /* Input */
    private static final InputStream in = System.in;
    private static final PrintWriter out = new PrintWriter(System.out);
    private final byte[] buffer = new byte[2048];
    private int p = 0;
    private int buflen = 0;

    private boolean hasNextByte() {
        if (p < buflen)
            return true;
        p = 0;
        try {
            buflen = in.read(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (buflen <= 0)
            return false;
        return true;
    }

    public boolean hasNext() {
        while (hasNextByte() && !isPrint(buffer[p])) {
            p++;
        }
        return hasNextByte();
    }

    private boolean isPrint(int ch) {
        if (ch >= '!' && ch <= '~')
            return true;
        return false;
    }

    private int nextByte() {
        if (!hasNextByte())
            return -1;
        return buffer[p++];
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = -1;
        while (isPrint((b = nextByte()))) {
            sb.appendCodePoint(b);
        }
        return sb.toString();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}


import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class D {
	public static void main(String[] args) throws Exception {
		new D().run();
	}
	int[] BIT;
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = f.nextInt();
		int[] arr = new int[n];
		BIT = new int[n+10];
		int inv = 0;
		for(int i = 0; i < n; i++) {
			arr[i] = f.nextInt();
			inv ^= (i-query(arr[i])) & 1;
			add(arr[i]);
		}
		int k = f.nextInt();
		while(k-->0) {
			int diff = -f.nextInt()+f.nextInt()+1;
			inv ^= (diff*(diff-1)/2) & 1;
			out.println(inv == 1 ? "odd" : "even");
		}
		out.flush();
	}

	public int query(int i) {
		i++;
		int res = 0;
		while(i > 0) {
			res += BIT[i];
			i -= i & -i;
		}
		return res;
	}
	public void add(int i) {
		i++;
		while(i < BIT.length) {
			BIT[i]++;
			i += i & -i;
		}
	}

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public FastScanner() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
        	return Long.parseLong(next());
        }
        public double nextDouble() {
        	return Double.parseDouble(next());
        }
        public String nextLine() {
        	try {
        		return reader.readLine();
        	} catch(IOException e) {
        		throw new RuntimeException(e);
        	}
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ShekharN
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int[] arr = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                arr[i] = in.nextInt();
            }
            int inversions = 0;
            for (int i = 1; i <= n; i++) {
                for (int j = i + 1; j <= n; j++) {
                    if (arr[i] > arr[j])
                        inversions++;
                }
            }
            inversions %= 2;
            int q = in.nextInt();
            for (int i = 0; i < q; i++) {
                int l = in.nextInt(), r = in.nextInt();
                int d = r - l + 1;
                d = d * (d - 1) / 2;
                if ((d & 1) == 1) inversions ^= 1;
                out.println((inversions & 1) == 1 ? "odd" : "even");
            }
        }

    }

    static class FastScanner {
        private BufferedReader br;
        private StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        public String nextString() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(nextString());
        }

    }
}


/*
 * Author Ayub Subhaniya
 * Institute DA-IICT
 */

import java.io.*;
import java.math.*;
import java.util.*;

public class A
{

	InputStream in;
	PrintWriter out;

	void solve()
	{
		int n=ni();
		int a[]=na(n);
		int INV=0;
		for (int i=0;i<n;i++)
			for (int j=i+1;j<n;j++)
				if (a[i]>a[j])
					INV++;
		boolean even=INV%2==0;
		int q=ni();
		while (q-->0)
		{
			int l=ni();
			int r=ni();
			int len=r-l+1;
			len=(len-1)*(len)/2;
			if (len%2==1)
				even=!even;
			if (even)
				out.println("even");
			else
				out.println("odd");
		}
	}

	int MAX = (int)1e5;
	long factorial[];
	void findfactorial()
	{
		factorial = new long[MAX + 1];
		factorial[0] = 1;
		for (int i = 1; i < MAX + 1; i++)
		{
			factorial[i] = mul(i,factorial[i - 1]);
		}
	}

	long mod=(long)1e9+7;
	long add(long a,long b)
	{
		long x=(a+b);
		while(x>=mod) x-=mod;
		return x;

	}

	long sub(long a,long b)
	{
		long x=(a-b);
		while(x<0) x+=mod;
		return x;

	}

	long mul(long a,long b)
	{
		a%=mod;
		b%=mod;
		long x=(a*b);
		return x%mod;

	}

	int max(int a,int b)
	{
		if(a>b)
			return a;
		else
			return b;
	}

	int min(int a,int b)
	{
		if(a>b)
			return b;
		else
			return a;
	}

	long max(long a,long b)
	{
		if(a>b)
			return a;
		else
			return b;

	}

	long min(long a,long b)
	{
		if(a>b)
			return b;
		else
			return a;

	}

	void run() throws Exception
	{
		String INPUT = "C:/Users/ayubs/Desktop/input.txt";
		in = oj ? System.in : new FileInputStream(INPUT);
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis() - s + "ms");

	}
	public static void main(String[] args) throws Exception
	{
		new A().run();
	}

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf)
		{
			ptrbuf = 0;
			try
			{
				lenbuf = in.read(inbuf);
			}
			catch (IOException e)
			{
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean inSpaceChar(int c)
	{
		return !(c >= 33 && c <= 126);
	}

	private int skip()
	{
		int b;
		while ((b = readByte()) != -1 && inSpaceChar(b))
			;
		return b;
	}

	private double nd()
	{
		return Double.parseDouble(ns());
	}

	private char nc()
	{
		return (char) skip();
	}

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(inSpaceChar(b)))
		{ // when nextLine, (inSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(inSpaceChar(b)))
		{
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}
			else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}
			else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

	private void tr(Object... o)
	{
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}

}


import java.util.Scanner;

public class D {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int[] a = new int[n];
		for(int i = 0; i < n; ++i) {
			a[i] = in.nextInt();
		}
		int ans = 0;
		for(int i = 0; i < n; ++i) {
			for(int j = i+1; j < n; ++j) {
				if(a[i] > a[j]) ans++;
			}
		}

		int m = in.nextInt();

		for(int i = 0; i < m; ++i) {
			int l = in.nextInt();
			int r = in.nextInt();

			int size = r-l + 1;

			int x = size * size - size;
			x = x >> 1;

			ans = ans^x;
			if(ans%2 == 0) System.out.println("even");
			else System.out.println("odd");

		}
	}

}


/*
Keep solving problems.
*/

import java.util.*;
import java.io.*;

public class CFA {
    BufferedReader br;
    PrintWriter out;
    StringTokenizer st;
    boolean eof;
    final long MOD = 1000L * 1000L * 1000L + 7;
    int[] dx = {0, -1, 0, 1};
    int[] dy = {1, 0, -1, 0};

    void solve() throws IOException {
        int n = nextInt();
        int[] arr = nextIntArr(n);
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (arr[i] > arr[j]) {
                    cnt++;
                }
            }
        }
        int m = nextInt();
        boolean[] vis = new boolean[n];
        for (int i = 0; i < m; i++) {
            int l = nextInt() - 1;
            int r = nextInt() - 1;
            int len = r - l + 1;
            if (len * (len - 1) / 2 % 2 != 0) {
                cnt++;
            }

            if (cnt % 2 != 0) {
                outln("odd");
            }
            else {
                outln("even");
            }
        }
    }

    void shuffle(int[] a) {
        int n = a.length;
        for(int i = 0; i < n; i++) {
            int r = i + (int) (Math.random() * (n - i));
            int tmp = a[i];
            a[i] = a[r];
            a[r] = tmp;
        }
    }

    long gcd(long a, long b) {
        while(a != 0 && b != 0) {
            long c = b;
            b = a % b;
            a = c;
        }
        return a + b;
    }

    private void outln(Object o) {
        out.println(o);
    }
    private void out(Object o) {
        out.print(o);
    }
    public CFA() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }
    public static void main(String[] args) throws IOException {
        new CFA();
    }

    public long[] nextLongArr(int n) throws IOException{
        long[] res = new long[n];
        for(int i = 0; i < n; i++)
            res[i] = nextLong();
        return res;
    }
    public int[] nextIntArr(int n) throws IOException {
        int[] res = new int[n];
        for(int i = 0; i < n; i++)
            res[i] = nextInt();
        return res;
    }
    public String nextToken() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                eof = true;
                return null;
            }
        }
        return st.nextToken();
    }
    public String nextString() {
        try {
            return br.readLine();
        } catch (IOException e) {
            eof = true;
            return null;
        }
    }
    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    public long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    public double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Liavontsi Brechka
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static
    @SuppressWarnings("Duplicates")
    class TaskD {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = in.nextIntArray(n);
            int m = in.nextInt();

            int count = 0;
            for (int i = 0; i < n; i++) {
                for (int j = i + 1; j < n; j++) {
                    if (a[i] > a[j]) count = (count + 1) % 2;
                }
            }

            StringBuilder res = new StringBuilder();

            int l, r;
            while (m-- > 0) {
                l = in.nextInt() - 1;
                r = in.nextInt() - 1;

                count = count ^ (((r - l + 1) * (r - l) / 2) % 2);
                res.append(count == 1 ? "odd" : "even").append('\n');
            }

            out.print(res);
        }

    }

    static class InputReader {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
        }

        public int[] nextIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; ++i) {
                array[i] = nextInt();
            }
            return array;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(readLine());
            }
            return tokenizer.nextToken();
        }

        public String readLine() {
            String line;
            try {
                line = reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return line;
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Wolfgang Beyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = in.readIntArray(n);

            long count = 0;
            for (int i = 1; i < n; i++) {
                for (int j = 0; j < i; j++) {
                    if (a[j] > a[i]) count++;
                }
            }
            boolean even = count % 2 == 0 ? true : false;

            int m = in.nextInt();
            for (int i = 0; i < m; i++) {
                int left = in.nextInt();
                int right = in.nextInt();
                int diff = right - left;
                if ((diff % 4 == 1) || (diff % 4 == 2)) {
                    even = !even;
                }
                if (even) {
                    out.println("even");
                } else {
                    out.println("odd");
                }
            }
        }

    }

    static class InputReader {
        private static BufferedReader in;
        private static StringTokenizer tok;

        public InputReader(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public int[] readIntArray(int n) {
            int[] ar = new int[n];
            for (int i = 0; i < n; i++) {
                ar[i] = nextInt();
            }
            return ar;
        }

        public String next() {
            try {
                while (tok == null || !tok.hasMoreTokens()) {
                    tok = new StringTokenizer(in.readLine());
                    //tok = new StringTokenizer(in.readLine(), ", \t\n\r\f"); //adds commas as delimeter
                }
            } catch (IOException ex) {
                System.err.println("An IOException was caught :" + ex.getMessage());
            }
            return tok.nextToken();
        }

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class D {

	public static void main(String[] args){
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = scan.nextInt();
		int[] a = new int[n+1];
		for(int i = 1; i <= n; i++) a[i] = scan.nextInt();
		BIT bit = new BIT(n);
		int p = 0;
		for(int i = 1; i <= n; i++) {
			p ^= bit.atOrAbove(a[i])&1;
			bit.add(a[i], 1);
		}
		int m = scan.nextInt();
		for(int i = 0; i < m; i++) {
			int l = scan.nextInt(), r = scan.nextInt();
			int s = r-l+1;
			int in = s*(s-1)/2;
			if((in&1) == 1) p ^= 1;
			out.println(p==0?"even":"odd");
		}
		out.close();
	}

	static class BIT {

		int[] a;
		int n;

		public BIT(int n) {
			this.n = n;
			a = new int[n+1];
		}

		public void add(int i, int val) {
			while(i <= n) {
				a[i] += val;
				i += i & -i;
			}
		}

		public int sum(int j)
		{
			int res = 0;
			for(int i = j; i >= 1; i -= (i & -i)) res += a[i];
			return res;
		}

		public int sum(int i, int j) {
			return sum(j)-sum(i-1);
		}
		public int atOrAbove(int index) {
			int sub = 0;
			if (index > 0) sub = sum(index-1);
			return sum(n) - sub;
		}
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class D_Edu_Round_35 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        int[] data = new int[n];
        for (int i = 0; i < n; i++) {
            data[i] = in.nextInt();
        }
        FT tree = new FT(n + 1);
        int result = 0;
        for (int i = n - 1; i >= 0; i--) {
            tree.update(data[i], 1);
            result += tree.get(data[i] - 1);
            result %= 2;
        }
        int q = in.nextInt();
        int[] tmp = new int[n];
        for (int i = 0; i < q; i++) {
            int l = in.nextInt() - 1;
            int r = in.nextInt() - 1;

            int total = r - l + 1;
            total = total * (total - 1) / 2;
            total %= 2;

            result += total;
            result %= 2;
            if (result % 2 == 0) {
                out.println("even");
            } else {
                out.println("odd");
            }
        }
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        int[] data;

        FT(int n) {
            data = new int[n];
        }

        public void update(int index, int value) {
            while (index < data.length) {
                data[index] += value;
                data[index] %= 2;
                index += (index & (-index));
            }
        }

        public int get(int index) {
            int result = 0;
            while (index > 0) {
                result += data[index];
                result %= 2;
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.*;
import java.util.*;

public class Codeforces911D {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] sp = br.readLine().split(" ");
		int n = Integer.parseInt(sp[0]);
		int[] a = new int[n];
		sp = br.readLine().split(" ");
		for (int i = 0; i < n; i++) {
			a[i] = Integer.parseInt(sp[i]);
		}
		int inversions = 0;
		for (int i = 0; i < n-1; i++) {
			for (int j = i+1; j < n; j++) {
				if (a[i] > a[j]) {
					inversions++;
				}
			}
		}
		inversions = inversions%2;

		sp = br.readLine().split(" ");
		int m = Integer.parseInt(sp[0]);
		for (int i = 0; i < m; i++) {
			sp = br.readLine().split(" ");
			int l = Integer.parseInt(sp[0]);
			int r = Integer.parseInt(sp[1]);
			if ((r-l+1)%4 == 2 || (r-l+1)%4 == 3) {
				inversions = 1-inversions;
			}
			if (inversions == 1) {
				System.out.println("odd");
			}
			else {
				System.out.println("even");
			}
		}
	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ankur
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int ar[] = in.nextIntArray(n);
            long dp[][] = new long[n][n];
            long ct = 0;
            for (int i = 0; i < n; i++) {

                for (int j = i + 1; j < n; j++) {
                    if (ar[i] > ar[j]) {
                        dp[i][j]++;
                        ct++;
                    }
                }
            }
            for (int i = n - 2; i >= 0; i--) {
                for (int j = i + 1; j < n; j++) {
                    dp[i][j] += dp[i + 1][j];
                }
            }
            int m = in.nextInt();
            for (int i = 0; i < m; i++) {
                int l = in.nextInt() - 1;
                int r = in.nextInt() - 1;
                long val = (r - l + 1);
                long estimated = (val * (val - 1)) / 2;
                long change = estimated - dp[l][r];
                //System.out.println(ct);
                ct = ct - dp[l][r];
                dp[l][r] = change;
                ct += dp[l][r];
                if (ct % 2 == 0) {
                    out.println("even");
                } else {
                    out.println("odd");
                }
               // System.out.println(ct);

            }

        }

    }

    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar;
        private int snumChars;

        public InputReader(InputStream st) {
            this.stream = st;
        }

        public int read() {
            //*-*------clare------

            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            return a;
        }

        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}


import java.util.Arrays;
import java.util.Scanner;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), sum = 0;
        int [] a = new int[n+1];
        for (int i = 1; i <= n; i++) {
            a[i] = in.nextInt();
        }
        for (int i = 1; i <= n; ++i)
            for (int j = i + 1; j <= n; ++j)
                sum += a[i] > a[j] ? 1 : 0;
        int m = in.nextInt();
        sum &= 1;
        for (int i = 1; i <= m; i++) {
            int l = in.nextInt(), r = in.nextInt();
            if (((r - l + 1) / 2) % 2 == 1)
                sum ^= 1;
            System.out.println(sum == 1 ? "odd" : "even");
        }
    }
}


import javafx.util.Pair;

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] arr = new int[n];
        int chet = 0;
        for (int i = 0; i < n; i++) {
            arr[i]=scanner.nextInt();
            for (int j = 0; j < i; j++) {
                if (arr[j]>arr[i]) chet^=1;
            }
        }
        n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            int l = scanner.nextInt();
            int r = scanner.nextInt();
            if ((((r-l+1)/2)&1)!=0){
                chet^=1;
            }
            if (chet==1){
                System.out.println("odd");
            }else{
                System.out.println("even");
            }
        }

    }

}


import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static class Reader
    {
        private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
        public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
        public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
        public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
        public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
        public int i(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
        public double d() throws IOException {return Double.parseDouble(s()) ;}
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
        public int[] arr(int n){int[] ret = new int[n];for (int i = 0; i < n; i++) {ret[i] = i();}return ret;}
    }

           //       |----|       /\      |    |   -----   |
           //       |   /       /  \     |    |     |     |
           //       |--/       /----\    |----|     |     |
           //       |   \     /      \   |    |     |     |
           //       |    \   /        \  |    |   -----   -------

    public static void main(String[] args)throws IOException
    {
        Reader sc=new Reader();
        PrintWriter out=new PrintWriter(System.out);
        int n=sc.i();
        int arr[]=sc.arr(n);
        int count=0;
        for(int i=0;i<n;i++)for(int j=i+1;j<n;j++)if(arr[j]<arr[i])count++;
        count%=2;
        int q=sc.i();
        while(q-->0)
        {
            int a=sc.i();
            int b=sc.i();
            long len=((long)(b-a+1)*(b-a))/2;
            if(len%2==1)count^=1;
            if(count==0)out.println("even");
            else out.println("odd");
        }
        out.flush();
    }
}


import java.util.*;
public class inversions {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] values = new int[N];
        for(int i=0;i<N;i++){
            values[i] = sc.nextInt();
        }
        int query = sc.nextInt();
        int[][] tasks = new int[query][2];
        for(int i=0;i<query;i++){
            tasks[i][0] = sc.nextInt();
            tasks[i][1] = sc.nextInt();
        }
        int startinversions = 0;
        for(int i=1;i<values.length;i++){
            for(int j=i-1;j>=0;j--){
                if(values[i]<values[j]){
                    startinversions++;
                }
            }
        }
        int value = startinversions%2;
        for(int[] task : tasks){
            int n = task[1]-task[0];
            if(n*(n+1)/2 % 2 != 0){
                value = (value+1)%2;
            }
            if(value==1){
                System.out.println("odd");
            }
            else{
                System.out.println("even");
            }
        }
    }
}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

public class lc1 implements Runnable{

	public void run() {

		InputReader s = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);

		int t = 1;

		while(t-- > 0) {

			int n = s.nextInt();

			int[] a = new int[n + 1];

			for(int i = 1; i <= n; i++)
				a[i] = s.nextInt();

			int curr = 0;

			for(int i = 1; i <= n; i++)
				for(int j = i + 1; j <= n; j++)
					if(a[i] > a[j])
						curr++;

			curr = curr % 2;

			int m = s.nextInt();

			while(m-- > 0) {

				int l = s.nextInt();
				int r = s.nextInt();

				int fact = (r - l) % 4;

				if(fact == 1 || fact == 2)
					curr = 1 - curr;

				if(curr % 2 == 0)
					w.println("even");
				else
					w.println("odd");
			}
		}

		w.close();
	}

	static class InputReader {

		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;
			do
			{
				if(c<'0'||c>'9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}

	public static void main(String args[]) throws Exception
	{
		new Thread(null, new lc1(),"lc1",1<<26).start();
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class D {

	public static void main(String[] args) throws IOException {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int inv=0;
		int []a=new int [n];
		for(int i=0;i<n;i++)
			a[i]=sc.nextInt();
		for(int j=0;j<n;j++)
			for(int i=j+1;i<n;i++)
				if(a[j]>a[i])
					inv=1-inv;

		int m=sc.nextInt();
		StringBuilder sb=new StringBuilder();
		while(m-->0)
		{
			int l=sc.nextInt();
			int r=sc.nextInt();
			int s=r-l+1;
			if(s*(s-1)/2%2==1)
				inv=1-inv;
			if(inv==1)
				sb.append("odd\n");
			else
				sb.append("even\n");
		}
		System.out.print(sb);

	}
	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if(x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for(int i = start; i < x.length(); i++)
				if(x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				}
				else
				{
					sb.append(x.charAt(i));
					if(dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg?-1:1);
		}

		public boolean ready() throws IOException {return br.ready();}

	}

}


import sun.reflect.generics.tree.Tree;

import java.io.*;
import java.math.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception{
        IO io = new IO(null,null);
        int n = io.getNextInt(),ans = 0;
        int [] A = new int[n];
        for (int i = 0;i < n;i++) {
            A[i] = io.getNextInt();
            for (int j = 0;j < i;j++)
                ans ^= (A[j] > A[i]) ? 1 : 0;
        }
        String [] word = {"even","odd"};
        int m = io.getNextInt();
        for (int i = 0;i < m;i++) {
            int l = io.getNextInt(),r = io.getNextInt();
            int len = r - l + 1;
            long tot = len*(len - 1L)/2;
            ans ^= tot & 1;
            io.println(word[ans]);
        }
        io.close();
    }
}

class IO{
    private BufferedReader br;
    private StringTokenizer st;
    private PrintWriter writer;
    private String inputFile,outputFile;

    public boolean hasMore() throws IOException{
        if(st != null && st.hasMoreTokens()) return true;
        if(br != null && br.ready()) return true;
        return false;
    }
    public String getNext() throws FileNotFoundException, IOException{
        while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

    public String getNextLine() throws FileNotFoundException, IOException{
        return br.readLine().trim();
    }

    public int getNextInt() throws FileNotFoundException, IOException{
        return Integer.parseInt(getNext());
    }
    public long getNextLong() throws FileNotFoundException, IOException{
        return Long.parseLong(getNext());
    }

    public void print(double x,int num_digits) throws  IOException{
        writer.printf("%." + num_digits + "f" ,x);
    }
    public void println(double x,int num_digits) throws  IOException{
        writer.printf("%." + num_digits + "f\n" ,x);
    }
    public void print(Object o) throws  IOException{
        writer.print(o.toString());
    }

    public void println(Object o) throws  IOException{
        writer.println(o.toString());
    }
    public IO(String x,String y) throws FileNotFoundException, IOException{
        inputFile = x;
        outputFile = y;
        if(x != null) br = new BufferedReader(new FileReader(inputFile));
        else br = new BufferedReader(new InputStreamReader(System.in));
        if(y != null) writer = new PrintWriter(new BufferedWriter(new FileWriter(outputFile)));
        else writer = new PrintWriter(new OutputStreamWriter(System.out));
    }

    protected void close() throws IOException{
        br.close();
        writer.close();
    }
    public void outputArr(Object [] A) throws IOException{
        int L = A.length;
        for (int i = 0;i < L;i++) {
            if(i > 0) writer.print(" ");
            writer.print(A[i]);
        }
        writer.print("\n");
    }
}


import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) throws Exception {
        MyReader reader = new MyReader(System.in);
//        MyReader reader = new MyReader(new FileInputStream("input.txt"));
        MyWriter writer = new MyWriter(System.out);
        new Solution().run(reader, writer);
        writer.close();
    }

    private void run(MyReader reader, MyWriter writer) throws IOException, InterruptedException {
        int n = reader.nextInt();
        int[] a = reader.nextIntArray(n);
        boolean b = false;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (a[i] > a[j]) {
                    b = !b;
                }
            }
        }
        int m = reader.nextInt();
        for (int i = 0; i < m; i++) {
            int l = reader.nextInt();
            int r = reader.nextInt();
            int d = r - l + 1;
            if (d * (d - 1) / 2 % 2 == 1) {
                b = !b;
            }
            writer.println(b ? "odd" : "even");
        }
    }

        static class MyReader {

            final BufferedInputStream in;
            final int bufSize = 1 << 16;
            final byte buf[] = new byte[bufSize];
            int i = bufSize;
            int k = bufSize;
            boolean end = false;
            final StringBuilder str = new StringBuilder();

            MyReader(InputStream in) {
                this.in = new BufferedInputStream(in, bufSize);
            }

            int nextInt() throws IOException {
                return (int) nextLong();
            }

            int[] nextIntArray(int n) throws IOException {
                int[] m = new int[n];
                for (int i = 0; i < n; i++) {
                    m[i] = nextInt();
                }
                return m;
            }

            int[][] nextIntMatrix(int n, int m) throws IOException {
                int[][] a = new int[n][0];
                for (int j = 0; j < n; j++) {
                    a[j] = nextIntArray(m);
                }
                return a;
            }

            long nextLong() throws IOException {
                int c;
                long x = 0;
                boolean sign = true;
                while ((c = nextChar()) <= 32) ;
                if (c == '-') {
                    sign = false;
                    c = nextChar();
                }
                if (c == '+') {
                    c = nextChar();
                }
                while (c >= '0') {
                    x = x * 10 + (c - '0');
                    c = nextChar();
                }
                return sign ? x : -x;
            }

            long[] nextLongArray(int n) throws IOException {
                long[] m = new long[n];
                for (int i = 0; i < n; i++) {
                    m[i] = nextLong();
                }
                return m;
            }

            int nextChar() throws IOException {
                if (i == k) {
                    k = in.read(buf, 0, bufSize);
                    i = 0;
                }
                return i >= k ? -1 : buf[i++];
            }

            String nextString() throws IOException {
                if (end) {
                    return null;
                }
                str.setLength(0);
                int c;
                while ((c = nextChar()) <= 32 && c != -1) ;
                if (c == -1) {
                    end = true;
                    return null;
                }
                while (c > 32) {
                    str.append((char) c);
                    c = nextChar();
                }
                return str.toString();
            }

            String nextLine() throws IOException {
                if (end) {
                    return null;
                }
                str.setLength(0);
                int c = nextChar();
                while (c != '\n' && c != '\r' && c != -1) {
                    str.append((char) c);
                    c = nextChar();
                }
                if (c == -1) {
                    end = true;
                    if (str.length() == 0) {
                        return null;
                    }
                }
                if (c == '\r') {
                    nextChar();
                }
                return str.toString();
            }

            char[] nextCharArray() throws IOException {
                return nextString().toCharArray();
            }

            char[][] nextCharMatrix(int n) throws IOException {
                char[][] a = new char[n][0];
                for (int i = 0; i < n; i++) {
                    a[i] = nextCharArray();
                }
                return a;
            }
        }

        static class MyWriter {

            final BufferedOutputStream out;
            final int bufSize = 1 << 16;
            final byte buf[] = new byte[bufSize];
            int i = 0;
            final byte c[] = new byte[30];
            static final String newLine = System.getProperty("line.separator");

            MyWriter(OutputStream out) {
                this.out = new BufferedOutputStream(out, bufSize);
            }

            void print(long x) throws IOException {
                int j = 0;
                if (i + 30 >= bufSize) {
                    flush();
                }
                if (x < 0) {
                    buf[i++] = (byte) ('-');
                    x = -x;
                }
                while (j == 0 || x != 0) {
                    c[j++] = (byte) (x % 10 + '0');
                    x /= 10;
                }
                while (j-- > 0)
                    buf[i++] = c[j];
            }

            void print(int[] m) throws IOException {
                for (int a : m) {
                    print(a);
                    print(' ');
                }
            }

            void print(long[] m) throws IOException {
                for (long a : m) {
                    print(a);
                    print(' ');
                }
            }

            void print(String s) throws IOException {
                for (int i = 0; i < s.length(); i++) {
                    print(s.charAt(i));
                }
            }

            void print(char x) throws IOException {
                if (i == bufSize) {
                    flush();
                }
                buf[i++] = (byte) x;
            }

            void print(char[] m) throws IOException {
                for (char c : m) {
                    print(c);
                }
            }

            void println(String s) throws IOException {
                print(s);
                println();
            }

            void println() throws IOException {
                print(newLine);
            }

            void flush() throws IOException {
                out.write(buf, 0, i);
                out.flush();
                i = 0;
            }

            void close() throws IOException {
                flush();
                out.close();
            }
        }
    }


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class D {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int n = nextInt();
		int[]a = new int[n+1];
		for (int i = 1; i <= n; i++) {
			a[i] = nextInt();
		}
		int inv = 0;
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j < i; j++) {
				if (a[j] > a[i])
					inv++;
			}
		}
		int m = nextInt();
		boolean odd = inv % 2==1;
		for (int i = 0; i < m; i++) {
			int left = nextInt();
			int right = nextInt();
			long k = right-left+1;
			if (k*(k-1)/2 % 2==1)
				odd = !odd;
			if (odd)
				pw.println("odd");
			else
				pw.println("even");
		}
		pw.close();
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class d {

	public static void main(String args[]) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		//BEGIN HERE
		int n = in.nextInt();
		int perm[] = new int[n];
		for(int i  = 0; i < n; i++) {
			perm[i] = in.nextInt();
		}
		int q = in.nextInt();

		int inv[] = new int[n];
		inv[0] = 0;
		for(int i = 1; i < n; i++) {
			inv[i] = inv[i-1];
			for(int j = i - 1; j >= 0; j--) {
				if(perm[i] < perm[j]) inv[i]++;
			}
		}
		boolean parity = inv[n-1] % 2 == 0;

		for(int i = 0; i < q; i++) {
			int l = in.nextInt() - 1;
			int r = in.nextInt() -1;
			if(l == r) {
				System.out.println(parity?"even":"odd");
				continue;
			}

			int s = r - l + 1;
			s = s * (s-1)/ 2;
			if(s % 2 != 0) {
				parity = !parity;
			}
			System.out.println(parity?"even":"odd");
		}
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(InputStream i) {
			br = new BufferedReader(new InputStreamReader(i));
			st = null;
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			if (st == null) {
				st = new StringTokenizer(br.readLine());
			}
			String line = st.nextToken("\n");
			st = null;
			return line;
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
	}

	public static class combinatorics {
		static long modInv(long a, long b) {
			return 1 < a ? b - modInv(b % a, a) * b / a : 1;
		}

		static long factorial[], mod;

		combinatorics(int n, long MOD) {
			mod = MOD;
			factorial = new long[n + 1];
			factorial[0] = 1;
			for (int i = 1; i <= n; i++) {
				factorial[i] = i * factorial[i - 1];
				factorial[i] %= mod;
			}
		}

		static long nCr(int n, int r) {
			if (r > n)
				return 0;
			return (factorial[n] * modInv((factorial[n - r] * factorial[r]) % mod, mod)) % mod;
		}
	}

	public static class DisjointSet {
		int p[], r[], s[];
		int numDisjoint;

		DisjointSet(int N) {
			numDisjoint = N;
			r = new int[N];
			s = new int[N];
			p = new int[N];
			for (int i = 0; i < N; i++)
				p[i] = i;
		}

		int findSet(int i) {
			return (p[i] == i) ? i : (p[i] = findSet(p[i]));
		}

		boolean isSameSet(int i, int j) {
			return findSet(i) == findSet(j);
		}

		void unionSet(int i, int j) {
			if (!isSameSet(i, j)) // if from different set
			{
				numDisjoint--;
				int x = findSet(i), y = findSet(j);
				if (r[x] > r[y]) {
					p[y] = x; // rank keeps the tree short
					s[x] += s[y];
				} else {
					p[x] = y;
					if (r[x] == r[y])
						r[y]++;
					s[y] += s[x];
				}
			}
		}

		int sizeOfSet(int i) {
			return s[findSet(i)];
		}
	};

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt();
            }
            int inv = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < i; j++) {
                    if (a[j] > a[i]) {
                        inv++;
                    }
                }
            }
            int m = in.nextInt();
            for (int i = 0; i < m; i++) {
                int l = in.nextInt();
                int r = in.nextInt();
                int s = (r - l + 1) * (r - l) / 2;
                inv = (inv + s) % 2;
                out.println(inv % 2 == 0 ? "even" : "odd");
            }
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public String next() {
            while (stt == null || !stt.hasMoreTokens()) {
                stt = new StringTokenizer(nextLine());
            }
            return stt.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}


/*
 * UMANG PANCHAL
 * DAIICT
 */
import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class Main
{

	static LinkedList<Integer> adj[];
	static ArrayList<Integer> adj1[];
	static int[] color,visited1;
	static boolean b[],visited[],possible;
	static int level[];
	static Map<Integer,HashSet<Integer>> s;
	static int totalnodes,colored;
	static int count[];
	static long sum[];
	static int nodes;
	static double ans=0;
	static long[] as=new long[10001];
	static long c1=0,c2=0;
	static int[] a,d,k;
	static int max=100000000;
	static long MOD = (long)1e9 + 7,sm=0,m=Long.MIN_VALUE;
	static boolean[] prime=new boolean[1000005];
	static int[] levl;
    static int[] eat;
    static int price[];
    static int size[],res[],par[];
    static int result=0;
	// --------------------My Code Starts Here----------------------

	public static void main(String[] args) throws IOException
	{
		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
		 int n=ni();
		 int[] a=na(n);
		 int ans=0;
		 for(int i=0;i<n;i++)
		 {
			 for(int j=i+1;j<n;j++)
			 {
				 if(a[j]<a[i])
					 ans++;
			 }
		 }
		 int m=ni();
		 ans=ans%2;
		 while(m-->0)
		 {
			 int l=ni(),r=ni();
			 int range=r-l+1;
			 range=range*(range-1)/2;
			 range=range%2;
			 ans=(ans+range)%2;
			 if(ans==1)
				 w.println("odd");
			 else
				 w.println("even");
		 }
       w.close();
    }

	public static long nCrModp(long n, long r, long p)
	{

	    long[] C=new long[(int)r+1];

	    C[0] = 1;

	    for (long i = 1; i <= n; i++)
	    {

	        for (long j = Math.min(i, r); j > 0; j--)

	            C[(int)j] = (C[(int)j] + C[(int)(j-1)])%p;
	    }
	    return C[(int)r];
	}
	public static long nCr(long n, long r)
	{
		long x=1;
		for(long i=n;i>=n-r+1;i--)
			x=((x)*(i));
		for(long i=r;i>=1;i--)
			x=((x)/(i));

		return x%MOD;
	}
	public static long nCrModpDP(long n, long r, long p)
	{

	    long[] C=new long[(int)r+1];

	    C[0] = 1;

	    for (long i = 1; i <= n; i++)
	    {
	        for (int j = (int)Math.min(i, r); j > 0; j--)
	           C[j] = (C[j] + C[j-1])%p;
	    }
	    return C[(int)r];
	}

	public static long nCrModpLucas(long n,long r, long p)
	{

	   if (r==0)
	      return 1;

	   long ni = n%p, ri = r%p;

	   return (nCrModpLucas(n/p,r/p, p) * nCrModpDP(ni,ri, p)) % p;
	}

	 public static void buildgraph(int n){
         adj=new LinkedList[n+1];
         visited=new boolean[n+1];
         levl=new int[n+1];
         par=new int[n+1];
         for(int i=0;i<=n;i++){
             adj[i]=new LinkedList<Integer>();

         }

     }
	public static int getSum(long BITree[], int index)
	{
	    int sum = 0;

	    while (index > 0)
	    {
	        sum += BITree[index];
	        index -= index & (-index);
	    }
	    return sum;
	}

	public static long[] updateBIT(long BITree[], int n, int index, int val)
	{
	    while (index <= n)
	    {
	       BITree[index] += val;
	       index += index & (-index);
	    }
	    return BITree;
	}

	public static boolean isPrime(int n)
	{
	    // Corner cases
	    if (n <= 1)  return false;
	    if (n <= 3)  return true;

	    // This is checked so that we can skip
	    // middle five numbers in below loop
	    if (n%2 == 0 || n%3 == 0)
	    	return false;

	    for (int i=5; i*i<=n; i=i+6)
	        if (n%i == 0 || n%(i+2) == 0)
	           return false;

	    return true;
	}

	// --------------------My Code Ends Here------------------------

	public static String ns()
	{
		return in.nextLine();
	}
	public static int ni()
	{
		return in.nextInt();
	}
	public static long nl()
	{
		return in.nextLong();
	}
	public static int[] na(int n)
	{
		a=new int[n];
		for(int i=0;i<n;i++)
		a[i]=ni();
		return a;
	}
	public static void sieveOfEratosthenes()
	    {
	       int n=prime.length;
	        for(int i=0;i<n;i++)
	            prime[i] = true;

	        for(int p = 2; p*p <=n; p++)
	        {
	            if(prime[p] == true)
	            {
	                for(int i = p*2; i <n; i += p)
	                    prime[i] = false;
	            }
	        }
	    }

	public static boolean printDivisors(long n)
    {
		long ans=0;
        for (int i=1; i<=Math.sqrt(n); i++)
        {
            if (n%i==0)
            {
                if (n/i == i)
                    ans++;
                else
                {
                	ans=ans+2;
                }
            }
            if(ans>3)
            	break;
        }
        if(ans==3)
        	return true;
        else
        	return false;
    }

  public static void dfs(int i)
  {
	  visited[i]=true;
	  for(int j:adj[i])
	  {
		  if(!visited[j])
			  {
			  dfs(j);
			  nodes++;
			  }
	  }

  }
  public static String rev(String s)
	{
		StringBuilder sb=new StringBuilder(s);
		sb.reverse();
		return sb.toString();
	}
	static long lcm(long a, long b)
	{
	    return a * (b / gcd(a, b));
	}
	static long gcd(long a, long b)
	{
	    while (b > 0)
	    {
	        long temp = b;
	        b = a % b; // % is remainder
	        a = temp;
	    }
	    return a;
	}
	static InputReader in;
	static PrintWriter w;
static class InputReader
{

private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;

public InputReader(InputStream stream)
{
  this.stream = stream;
}

public int snext()
{
  if (snumChars == -1)
    throw new InputMismatchException();
  if (curChar >= snumChars)
  {
    curChar = 0;
    try
    {
      snumChars = stream.read(buf);
    }
    catch (IOException e)
    {
      throw new InputMismatchException();
    }
    if (snumChars <= 0)
      return -1;
  }
  return buf[curChar++];
}

public int nextInt()
{
  int c = snext();
  while (isSpaceChar(c))
  {
    c = snext();
  }
  int sgn = 1;
  if (c == '-')
  {
    sgn = -1;
    c = snext();
  }
  int res = 0;
  do
  {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  }
  while (!isSpaceChar(c));
  return res * sgn;
}

public long nextLong()
{
  int c = snext();
  while (isSpaceChar(c))
  {
    c = snext();
  }
  int sgn = 1;
  if (c == '-')
  {
    sgn = -1;
    c = snext();
  }
  long res = 0;
  do
  {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  }
  while (!isSpaceChar(c));
  return res * sgn;
}
public String readString()
{
  int c = snext();
  while (isSpaceChar(c))
  {
    c = snext();
  }
  StringBuilder res = new StringBuilder();
  do
  {
    res.appendCodePoint(c);
    c = snext();
  }
  while (!isSpaceChar(c));
  return res.toString();
}

public String nextLine()
{
  int c = snext();
  while (isSpaceChar(c))
    c = snext();
  StringBuilder res = new StringBuilder();
  do
  {
    res.appendCodePoint(c);
    c = snext();
  }
  while (!isEndOfLine(c));
  return res.toString();
}

public boolean isSpaceChar(int c)
{
  if (filter != null)
    return filter.isSpaceChar(c);
  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

private boolean isEndOfLine(int c)
{
  return c == '\n' || c == '\r' || c == -1;
}

public interface SpaceCharFilter
{
  public boolean isSpaceChar(int ch);
}
}

}


import java.io.*;
import java.util.StringTokenizer;

public class D911 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        StringTokenizer st;

        int n = Integer.parseInt(br.readLine());
        st = new StringTokenizer(br.readLine());
        int[] num = new int[n];
        for (int i = 0; i < n; i++) {
            num[i] = Integer.parseInt(st.nextToken());
        }

        int count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (num[i] < num[j]) {
                    count++;
                }
            }
        }

        boolean ans = count % 2 == 0;
        for (int m = Integer.parseInt(br.readLine()); m-- > 0; ) {
            st = new StringTokenizer(br.readLine());
            int l = Integer.parseInt(st.nextToken());
            int r = Integer.parseInt(st.nextToken());
            if (((r - l + 1) / 2) % 2 != 0) {
                ans = !ans;
            }
            out.println(ans ? "even" : "odd");
        }
        out.close();
    }
}