codeparrot/codecomplex huggingface dataset:
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic


import javafx.util.Pair;

import java.util.*;

import static java.lang.Math.floor;
import static java.lang.Math.min;

public class Main {

    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {

        int n = scanInt();
        List<Integer> a = scanList(n);
        int m = scanInt();
        List<Integer> left = new ArrayList<>();
        List<Integer> right = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            left.add(scanInt());
            right.add(scanInt());
        }

        String even = "even";
        String odd = "odd";

        int inversions = 0;
        for (int i = 0; i < a.size(); i++) {
            for (int j = i; j < a.size(); j++) {
                if (a.get(i) > a.get(j)) {
                    ++inversions;
                }
            }
        }

        inversions = inversions % 2;
        for (int i = 0; i < m; i++) {
            inversions = (inversions + (right.get(i) - left.get(i) + 1) / 2 % 2) % 2;
            println(inversions % 2 == 0 ? even : odd);
        }


    }

    private static Integer get(int digit, List<Integer> numbers) {
        Integer toReturn = null;
        for (Integer number : numbers
                ) {
            if (number <= digit) {
                toReturn = number;
                break;
            }
        }
        return toReturn;

    }

    private static List<Integer> toList(char[] chars) {
        List<Integer> integers = new ArrayList<>();
        for (int i = 0; i < chars.length; i++) {
            integers.add(Integer.parseInt(String.valueOf(chars[i])));
        }
        return integers;
    }

    private static List<Pair<Integer, Integer>> scanPairs(int amount) {
        List<Pair<Integer, Integer>> list = new ArrayList<>();
        for (int i = 0; i < amount; i++) {
            list.add(new Pair<>(scanInt(), scanInt()));
        }
        return list;
    }

    private static int[] scanArray(int length) {
        int array[] = new int[length];
        for (int i = 0; i < length; i++) {
            array[i] = scanner.nextInt();
        }
        return array;
    }

    private static List<Integer> scanList(int length) {
        List<Integer> integers = new ArrayList<>();
        for (int i = 0; i < length; i++) {
            integers.add(scanner.nextInt());
        }
        return integers;
    }

    public static String scanString() {
        return scanner.next();
    }

    private static int scanInt() {
        return scanner.nextInt();
    }

    private static void println(int n) {
        System.out.println(n);
    }

    private static void print(int n) {
        System.out.print(n);
    }

    private static void println(String s) {
        System.out.println(s);
    }

    private static void print(String s) {
        System.out.print(s);
    }

    private static void print(int a[]) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;


public class Main {
    static int bit[];
    static int array[];
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        bit = new int[1505];
        array = new int[n + 1];
        StringTokenizer st = new StringTokenizer(br.readLine());
        for(int i = 1;i <= n;i++)
            array[i] = Integer.parseInt(st.nextToken());
        long ans = 0;
        for(int i = n;i >= 1;i--){
            ans += read(array[i]);
            update(array[i]);
        }
        long val = (ans & 1) + 1000_000;
        int m = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        for(int i = 1;i <= m;i++){
            st = new StringTokenizer(br.readLine());
            int l = Integer.parseInt(st.nextToken());
            int r = Integer.parseInt(st.nextToken());
            long temp = (r - l + 1);
            temp = temp*(temp - 1) / 2;
            if((temp & 1) == 1)--val;
            if((val & 1) == 1)sb.append("odd");
            else sb.append("even");
            sb.append('\n');
        }
        System.out.print(sb);
    }
    static int update(int idx){
        int sum = 0;
        while(idx < 1501){
            bit[idx] += 1;
            idx += idx & (-idx);
        }
        return sum;
    }
    static int read(int idx){
        int sum = 0;
        while(idx > 0){
            sum += bit[idx];
            idx -= idx & (-idx);
        }
        return sum;
    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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[] ar = new int[n];
            for (int i = 0; i < n; i++) {
                ar[i] = in.nextInt();
            }
            long ninv = 0;
            for (int i = 0; i < n - 1; i++) {
                for (int j = i + 1; j < n; j++) {
                    if (ar[i] > ar[j])
                        ninv++;
                }
            }
            int m = in.nextInt();
            for (int i = 0; i < m; i++) {
                int l = in.nextInt();
                int r = in.nextInt();

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

                ninv += s;

                if (ninv % 2 == 0)
                    out.println("even");
                else
                    out.println("odd");
            }
        }

    }

    static class InputReader {
        StringTokenizer st;
        BufferedReader br;

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

        public String next() {
            if (st == null || !st.hasMoreTokens()) {
                String nextLine = null;
                try {
                    nextLine = br.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                if (nextLine == null)
                    return null;
                st = new StringTokenizer(nextLine);
            }
            return st.nextToken();
        }

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

    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.*;
import java.util.*;

public class Main {
    
    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        int n = Reader.nextInt();
        int[] arr = new int[n];
        int initial = 0;
        for (int i = 0; i < n; i++) arr[i] = Reader.nextInt();

        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) if (arr[i] > arr[j]) initial++;
        }

        int m = Reader.nextInt();
        boolean parity = initial % 2 == 0;
//        System.out.println(parity ? "even": "odd");
        for (int i = 0; i < m; i++) {
            int l = Reader.nextInt();
            int r = Reader.nextInt();
            int elems = r - l + 1;
            boolean change = (elems/2) % 2 == 0;
            parity = parity == change;
            System.out.println(parity ? "even": "odd");
        }
    }
}

/**
 * Reader class based on the article at "https://www.cpe.ku.ac.th/~jim/java-io.html"
 * */
class Reader{
    private static BufferedReader reader;
    private static StringTokenizer tokenizer;
    static void init(InputStream inputStream){
        reader = new BufferedReader(new InputStreamReader(inputStream));
        tokenizer = new StringTokenizer("");
    }
    static String next() throws IOException {
        String read;
        while (!tokenizer.hasMoreTokens()){
            read = reader.readLine();
            if (read == null || read.equals(""))
                return "-1";
            tokenizer = new StringTokenizer(read);
        }

        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException{
        return Integer.parseInt(next());
    }

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

    //Get a whole line.
//    static String line() throws IOException{
//        return reader.readLine();
//    }
//
//    static double nextDouble() throws IOException{return Double.parseDouble(next());}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.*;
import java.util.*;

public class utkarsh{
	BufferedReader br;
	PrintWriter out;

	int game(int s, int mid, int e, int[] a){
		int i, j, n, m;
		n = mid - s + 1;
		m = e - mid;
		int b[] = new int[n];
		int c[] = new int[m];
		for(i = 0; i < n; i++)	b[i] = a[s + i];
		for(j = 0; j < m; j++)	c[j] = a[mid + 1 + j];
		i = j = 0;
		int ans = 0;
		for(int k = s; k <= e; k++){
			if(i == n){
				a[k] = c[j++];
			}else if(j == m){
				a[k] = b[i++];
			}else{
				if(b[i] < c[j]){
					a[k] = b[i++];
				}else{
					a[k] = c[j++];
					ans += n - i;
				}
			}
		}
		return ans;
	}

	int play(int s, int e, int[] a){
		if(s >= e)	return 0;
		int m = (s + e) >> 1;
		return play(s, m, a) + play(m+1, e, a) + game(s, m, e, a);
	}

	void solve(){
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		
		int i, j, k, l, r, n;
		n = ni();
		int a[] = new int[n];
		int d[] = new int[n];
		for(i = 0; i < n; i++) {
			a[i] = ni();
			d[i] = a[i];
		}
		int ans = (play(0, n-1, d) & 1);

		int q = ni();
		while(q-- > 0){
			l = ni();	r = ni();
			ans ^= ((r - l + 1) * (r - l) / 2);
			//out.println(ans);
			if((ans & 1) > 0)	out.println("odd");
			else				out.println("even");
		}

		out.flush();
	}

	int ni(){
		return Integer.parseInt(ns());
	}

	String ip[];
	int len, sz;

	String ns(){
		if(len >= sz){
			try{
				ip = br.readLine().split(" ");
				len = 0;
				sz = ip.length;
			}catch(IOException e){
				throw new InputMismatchException();
			}
			if(sz <= 0)	return "-1";
		}
		return ip[len++];
	}

	public static void main(String[] args){	new utkarsh().solve();	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class D911 {

	public static long total = 0;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		ArrayList<Integer> temp = new ArrayList<>();
		int[] ar = new int[n];
		int[] memo = new int[n];
		for (int i = 0; i < n; i++) {
			int t = in.nextInt();
			int index = -1*Collections.binarySearch(temp, t)-1;
			temp.add(index, t);
			ar[i] = t;
			memo[i] = i - index;
			total += memo[i];
		}
		int m = in.nextInt();
		for (int i = 0; i < m; i++) {
//			int a = in.nextInt() - 1, b = in.nextInt() - 1;
//			query(ar, memo, in.nextInt() - 1, in.nextInt() - 1);
			total += (-1*(in.nextInt() - 1 - in.nextInt() + 1) + 1) / 2;
			System.out.println(total%2 == 0 ? "even" : "odd");
		}
	}
	
	public static void query(int[] ar, int[] memo, int a, int b) {
		if (a >= b) {
			return;
		}
		if (ar[a] < ar[b]) {
			memo[a]++;
			total++;
		} else {
			memo[b]--;
			total--;
		}
		int t = ar[a];
		ar[b] = ar[a];
		ar[b] = t;
		t = memo[a];
		memo[b] = memo[a];
		memo[b] = t;
		query(ar, memo, a + 1, b - 1);
	}
	
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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;
      long sum = ((long)size * (size - 1)) / 2;

      sum %= 2;

      cnt += sum;
      cnt %= 2;

      System.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();
  }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*; 
import java.util.*;
import java.util.regex.*;

/*
		  br = new BufferedReader(new FileReader("input.txt"));
		  pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
		  br = new BufferedReader(new InputStreamReader(System.in));
		  pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
	private static BufferedReader br;
	private static StringTokenizer st;
	private 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 qq = 1;
		int qq = Integer.MAX_VALUE;
		//int qq = readInt();
		for(int casenum = 1; casenum <= qq; casenum++)	{
			int n = readInt();
			int[] l = new int[n];
			for(int i = 0; i < n; i++) {
				l[i] = readInt();
			}
			int ret = 0;
			for(int i = 0; i < n; i++) {
				for(int j = i+1; j < n; j++) {
					if(l[i] > l[j]) {
						ret++;
					}
				}
			}
			int qqq = readInt();
			while(qqq-- > 0) {
				int a = readInt();
				int b = readInt();
				int d = b-a;
				ret ^= d*(d+1)/2;
				pw.println(ret%2 == 0 ? "even" : "odd");
			}
		}
		exitImmediately();
	}

	private static void exitImmediately() {
		pw.close();
		System.exit(0);
	}

	private static long readLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	private static double readDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	private static int readInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	private static String nextLine() throws IOException  {
		String s = br.readLine();
		if(s == null) {
			exitImmediately();
		}
		st = null;
		return s;
	}

	private static String nextToken() throws IOException  {
		while(st == null || !st.hasMoreTokens())  {
			st = new StringTokenizer(nextLine().trim());
		}
		return st.nextToken();
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.*;
import java.util.*;

public class Mainn {

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

		public InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public InputReader(InputStream stream) {
			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 char nextChar() {
			return next().charAt(0);
		}

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

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

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

		public int[] nextIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			return arr;
		}

		public Integer[] nextIntegerArr(int n) {
			Integer[] arr = new Integer[n];
			for (int i = 0; i < n; i++) {
				arr[i] = new Integer(this.nextInt());
			}
			return arr;
		}

		public int[][] next2DIntArr(int n, int m) {
			int[][] arr = new int[n][m];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < m; j++) {
					arr[i][j] = this.nextInt();
				}
			}
			return arr;
		}

		public int[] nextSortedIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			Arrays.sort(arr);
			return arr;
		}

		public long[] nextLongArr(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextLong();
			}
			return arr;
		}

		public char[] nextCharArr(int n) {
			char[] arr = new char[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextChar();
			}
			return arr;
		}
	}

	public static InputReader scn = new InputReader();
	public static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {
		// InputStream inputStream = System.in; // Useful when taking input other than
		// console eg file handling // check ctor of inputReader
		// To print in file use this:- out = new PrintWriter("destination of file
		// including extension");

		int n = scn.nextInt(), inv = 0;
		int[] arr = scn.nextIntArr(n);
		for(int i = 0; i < n; i++) {
			for(int j = i + 1; j < n; j++) {
				if(arr[i] > arr[j]) {
					inv++;
				}
			}
		}
		
		int ans = inv % 2;
		
		int m = scn.nextInt();
		while(m-- > 0) {
			int l = scn.nextInt(), r = scn.nextInt();
			
			int change = ((r - l + 1) / 2) % 2;
			
			if(change == 1) {
				ans = 1 - ans;
			}
			
			if(ans == 0) {
				out.println("even");
			} else {
				out.println("odd");
			}
		}
		
		out.close();
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.StringTokenizer;

public class D {
	
	public static class BIT {
		int[] dat;
		
		public BIT(int n){
			dat = new int[n + 1];
		}
		
		public void add(int k, int a){ // k : 0-indexed
			for(int i = k + 1; i < dat.length; i += i & -i){
				dat[i] += a;	
			}
		}
		
		public int sum(int s, int t){ // [s, t)
			if(s > 0) return sum(0, t) - sum(0, s);
			
			int ret = 0;
			for(int i = t; i > 0; i -= i & -i) {
				ret += dat[i];
			}
			return ret;
		}
	}
	
	public static void main(String[] args) {
		try (final Scanner sc = new Scanner(System.in)) {
			final int N = sc.nextInt();
			int[] array = new int[N];
			for(int i = 0; i < N; i++){
				array[i] = sc.nextInt() - 1;
			}
			
			long inv = 0;
			BIT bit = new BIT(N);
			for(int i = 0; i < N; i++){
				inv += bit.sum(array[i], N);
				bit.add(array[i], 1);
			}
			//System.out.println(inv);
			
			int mod2 = (int)(inv % 2);
			final int M = sc.nextInt();
			for(int i = 0; i < M; i++){
				final int l = sc.nextInt() - 1;
				final int r = sc.nextInt() - 1;
				
				final long size = (r - l) + 1;
				if(size > 1){
					//System.out.println(size + " " + ((size * (size - 1) / 2)));
					if((size * (size - 1) / 2) % 2 == 1){
						mod2 = 1 - mod2;
					}
				}
				
				System.out.println((mod2 == 0) ? "even" : "odd");
			}
		}
	}
	
	public static class Scanner implements Closeable {
		private BufferedReader br;
		private StringTokenizer tok;

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

		private void getLine() {
			try {
				while (!hasNext()) {
					tok = new StringTokenizer(br.readLine());
				}
			} catch (IOException e) { /* ignore */
			}
		}

		private boolean hasNext() {
			return tok != null && tok.hasMoreTokens();
		}

		public String next() {
			getLine();
			return tok.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}
		
		public long nextLong() {
			return Long.parseLong(next());
		}

		public void close() {
			try {
				br.close();
			} catch (IOException e) { /* ignore */
			}
		}
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int l, r, sum = 0;
            int[] a = new int[n+5];
            for (int i = 0; i < n; i++) a[i] = in.nextInt();
            for (int i = 0; i < n; i++)
                for (int j = i+1; j < n; j++)
                    if (a[i] > a[j]) sum++;
            int q = in.nextInt();
            while (q-- > 0){
                l = in.nextInt();
                r = in.nextInt();
                sum += (r-l+1)/2;
                if (sum % 2 == 1) out.println("odd");
                else out.println("even");
            }
        }

    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 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());
        }

    }
}