codeparrot/codecomplex huggingface dataset:
// 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;


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());
        }

    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author EndUser
 */
public class E35PD {
    public static void main(String[] args) throws IOException {
        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 count = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                if (a[i] > a[j]) {
                    count++;
                }
            }            
        }
        
        boolean isEven = (count % 2 == 0);
        
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        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 numOfConn = (size - 1) * size / 2;
            if (numOfConn % 2 == 1) {
                isEven = !isEven;
            }
            if (isEven) {
                out.write("even");
                out.newLine();
            } else {
                out.write("odd");
                out.newLine();
            }
        }
        out.close();
    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic

import java.util.*;

public class Main {
    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();
    	long no=0;
    	for(int i=0; i<n-1; i++)
    	{
    		for(int j=i+1; j<n; j++)
    		{
    			if(a[i]>a[j])
    				no++;
    		}
    	}
   // 	System.out.println(no);
    	no%=2;
    	int m=in.nextInt();
    	int te;
    	String te2="odd",te1="even";
    	for(int i=0; i<m; i++)
    	{
    		te=in.nextInt()-in.nextInt();
    		te=-te+1;
    //		System.out.println(te);
    		if((te*(te-1)/2)%2==0)
    		{
    //			System.out.println("HOLA"+no);
    			if(no==0)
    				System.out.println("even");
    			else
    				System.out.println("odd");
    		}
    		else
    		{
    			no=(no+1)%2;
    			if(no==0)
    				System.out.println("even");
    			else
    				System.out.println("odd");
    		}
    	}
    	
    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;


public class CE35D {
	public static void main(String[] args) throws NumberFormatException, IOException {
		//Scanner sc = new Scanner(System.in);
		BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
		
		int n = Integer.parseInt(sc.readLine());
		String[] t = sc.readLine().split(" ");
		int[] list = new int[n];
		for(int x=0; x<n; x++){
			list[x] = Integer.parseInt(t[x]);
		}
		
		boolean even = true;
		
		int[] indList = new int[n+1];
		
		
		for(int x=0; x<n; x++){
			indList[list[x]] = x;
		}
		
		for(int x=1; x<=n; x++){
			int theIndex = indList[x];
			int other = list[x-1];
			if(theIndex != x-1){
				even = !even;

				list[x-1] = x;
				list[theIndex] = other;
				
				indList[x] = x-1;
				indList[other] = theIndex;
			}
		}
		
		//System.out.println(even);
		
		int numQ = Integer.parseInt(sc.readLine());
		for(int x=0; x<numQ; x++){
			String[] dir = sc.readLine().split(" ");
			int l = Integer.parseInt(dir[0]);
			int r = Integer.parseInt(dir[1]);
			int diff = r - l + 1;
			if(diff%4 > 1){
				even = !even;
			}
			if(even){
				System.out.println("even");
			}
			else{
				System.out.println("odd");
			}
		}
	}
}

/*
int n = Integer.parseInt(sc.nextLine());
String[] t = sc.nextLine().split(" ");
int[] list = new int[n];
for(int x=0; x<n; x++){
	list[x] = Integer.parseInt(t[x]);
}
		
String[] dir = sc.nextLine().split(" ");
int a = Integer.parseInt(dir[0]);
int b = Integer.parseInt(dir[1]);
int c = Integer.parseInt(dir[2]);
int d = Integer.parseInt(dir[3]);
int e = Integer.parseInt(dir[4]);

int n = Integer.parseInt(sc.nextLine());
*/
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {

	final static int mod = 1_000_000_007;

	public static void main(String[] args) throws Exception {

		STDIN scan = new STDIN();
		PrintWriter pw = new PrintWriter(System.out);
		
		int n = scan.nextInt();
		boolean even = true;
		int[] a = new int[n];
		for(int i = 0; i < n; i++) {
			a[i] = scan.nextInt();
			for(int j = 0; j < i; j++)
				if(a[i] < a[j]) even = !even;
		}
		int q = scan.nextInt();
		while(q-- > 0) {
			int l = scan.nextInt(), r = scan.nextInt();
			int len = r - l + 1;
			int permutations = len * (len - 1) / 2;
			if(permutations % 2 != 0) even = !even;
			pw.println(even ? "even" : "odd");
		}
		
		pw.flush();
	}
		
	static class STDIN {
		BufferedReader br;
		StringTokenizer st;

		public STDIN() {
			br = new BufferedReader(new InputStreamReader(System.in));
			st = null;
		}

		boolean hasNext() throws Exception {
			if (!st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.hasMoreTokens();
		}

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

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

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

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

		String nextLine() throws Exception {
			return br.readLine();
		}
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.util.Scanner;

public class D2 {
	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int array[] =new int[n];
		for(int i=0; i<=n-1; i++) {
			array[i] = sc.nextInt();
		}
		int m = sc.nextInt();
		int result = count(array);
		for(int i=1; i<=m; i++) {
			int a = sc.nextInt();
			int b = sc.nextInt();
			result += (b-a)*(b-a+1)/2;
			result=result%2;
			if(result%2==1)
				System.out.println("odd");
			else
				System.out.println("even");
		}
	}
	
	public static int count(int[] arr) {
		int[] array = arr.clone();
		return sort(array,0,array.length-1);
	}
	
	public static int sort(int[] arr, int i, int j) {
		if(i>=j) return 0;
		int mid = (i+j)/2;
		int a = sort(arr,i,mid);
		int b = sort(arr,mid+1,j);
		int addition = 0;
		int r1 = mid+1;
		int[] tmp = new int[arr.length];
		int tIndex = i;
        int cIndex=i;
		while(i<=mid&&r1<=j) {
			if (arr[i] <= arr[r1]) 
                tmp[tIndex++] = arr[i++];
            else {
                      tmp[tIndex++] = arr[r1++];
                      addition+=mid+1-i;
            }
		}
		while (i <=mid) {
            tmp[tIndex++] = arr[i++];
        }
        while ( r1 <= j ) {
            tmp[tIndex++] = arr[r1++];
        }
        while(cIndex<=j){
            arr[cIndex]=tmp[cIndex];
            cIndex++;
        }
        return a+b+addition;
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic

import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;

/**
 */
public class Main911D {
	public static void main(String[] args) {
		run(System.in, System.out);
	}

	public static void run(InputStream in, PrintStream out) {

		try (Scanner sc = new Scanner(in)) {
			int n = sc.nextInt();
			int[] t = new int[n];
			int inv = 0;
			for (int i = 0; i < n; i++) {
				t[i] = sc.nextInt();
				for (int j = 0; j < i; j++) {
					if (t[j] > t[i]) inv++;
				}
			}

			inv = inv % 2;
			int m = sc.nextInt();
			for (int i = 0; i < m; i++) {
				int a = sc.nextInt();
				int b = sc.nextInt();
				int s = b - a + 1;
				inv = (inv + s * (s - 1) / 2) % 2;
				out.println(inv == 0 ? "even" : "odd");

			}

		}
	}

}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic

import java.util.Scanner;

public class inversion__count {

	public static void main(String[] args) {
	
		Scanner s = new Scanner(System.in);
		
		int n=s.nextInt();
		
		int[] a = new int[n+1];
		
		for(int i=1;i<=n;i++){
			a[i]=s.nextInt();
		}
		
		int m=s.nextInt();
		int count=0;
		
		for(int i=1;i<=n;i++){
			for(int j=i+1;j<=n;j++){
				if(a[i]>a[j]){
					count++;
				}
			}
		}
		
		if(count%2==0){
			count=0;
		}else{
			count=1;
		}
		
		//System.out.println(count);
		for(int i=0;i<m;i++){
			int l=s.nextInt();
			int r=s.nextInt();
			
			if(l==r){
				if((count&1)==1){
					System.out.println("odd");
				}else{
					System.out.println("even");
				}
				continue;
			}
			
			 int d=r-l+1;
			 int segcount = 0;
			 
			
			 
			int  temp =   (d*(d-1))/2; 
			 
			 if((temp&1)==1 && (count&1)==1){
				 count=0;
				 System.out.println("even");
			 }else if((temp&1)==1 && (count&1)==0){
				 count=1;
				 System.out.println("odd");
			 }else{
				 if((count&1)==1){
					 System.out.println("odd");
				}else{
					System.out.println("even");
				}
			 }
		}
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.* ;
import java.util.* ;
import java.text.* ;
import java.math.* ;
import static java.lang.Math.min ;
import static java.lang.Math.max ;
public class Codeshefcode{
	public static void main(String[] args) throws IOException{
		// Solver Machine = new Solver() ;
		// Machine.Solve() ;
		// Machine.Finish() ;
		new Thread(null,new Runnable(){
			public void run(){
				Solver Machine = new Solver() ;
				try{
					Machine.Solve() ;
					Machine.Finish() ;
				}catch(Exception e){
					e.printStackTrace() ;
					System.out.flush() ;
					System.exit(-1) ;
				}catch(Error e){
					e.printStackTrace() ;
					System.out.flush() ;
					System.exit(-1) ;
				}
			}
		},"Solver",1l<<27).start() ;
	}
}
class Mod{
	static long mod=1000000007 ;
	static long d(long a,long b){ return (a*MI(b))%mod ; }
	static long m(long a,long b){ return (a*b)%mod ; }
	static private long MI(long a){ return pow(a,mod-2) ; }
	static long pow(long a,long b){
		if(b<0) return pow(MI(a),-b) ;
		long val=a ; long ans=1 ;
		while(b!=0){
			if((b&1)==1) ans = (ans*val)%mod ; 
			val = (val*val)%mod ; 
			b/=2 ;
		}
		return ans ;
	}	
}
class pair implements Comparable<pair>{
	int x ; int y ;  
	pair(int x,int y){ this.x=x ; this.y=y ;} 
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
class Solver{
	Reader ip = new Reader(System.in) ;	  
	PrintWriter op = new PrintWriter(System.out) ;
	public void Solve() throws IOException{
		int n = ip.i() ;
		int a[] = new int[n] ;
		for(int i=0 ; i<n ; i++) a[i] = ip.i() ;
		int num=0 ;
		for(int i=0 ; i<n ; i++)
			for(int j=(i+1) ; j<n ; j++)
				if(a[i]>a[j])
					num++ ;
		num%=2 ;
		int m = ip.i() ;
		while(m--!=0){
			int l = ip.i() ;
			int r = ip.i() ;
			int d = (r-l+1) ;
			int mod = d%4 ;
			int bit ;
			if(mod<=1) bit=0 ; else bit=1 ;
			num+=bit ;
			num%=2 ;
			pln(num==1 ? "odd" : "even") ;
		}
	}
	void Finish(){
		op.flush();
		op.close();
	}
	void p(Object o){
		op.print(o) ;
	}
	void pln(Object o){
		op.println(o) ;
	}		
}
class mylist extends ArrayList<Integer>{}
class myset extends TreeSet<Integer>{}
class mystack extends Stack<Integer>{}
class mymap extends TreeMap<Long,Integer>{}
class Reader {
	BufferedReader reader;
	StringTokenizer tokenizer;
	Reader(InputStream input) {
		reader = new BufferedReader(
					new InputStreamReader(input) );
		tokenizer = new StringTokenizer("") ;
	}
	String s() throws IOException {
		while (!tokenizer.hasMoreTokens()){
			tokenizer = new StringTokenizer(
			reader.readLine()) ;
		}
		return tokenizer.nextToken();
	}
	int i() throws IOException {
		return Integer.parseInt(s()) ;
	}
	long l() throws IOException{
		return Long.parseLong(s()) ;
	}
	double d() throws IOException {
		return Double.parseDouble(s()) ;
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
//package codeforces.Educational35;

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

public class D
{
	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		
		int inv = 0;
		int n = sc.nextInt();
		int[] arr = new int[n];
		for (int i = 0; i < arr.length; i++)
			arr[i] = sc.nextInt();
		
		for (int i = 0; i < arr.length; i++)
			for (int j = i+1; j < arr.length; j++)
				if(arr[i] > arr[j])
					inv++;
		
		
		boolean odd = (inv%2)!=0;
		int q = sc.nextInt();
		for (int i = 0; i < q; i++)
		{
			int l = sc.nextInt();
			int r = sc.nextInt();
			int sz = r-l+1;
			int tot = (sz*(sz-1))/2;
			if(tot%2 != 0)
				odd = !odd;
			if(odd)
				pw.println("odd");
			else
				pw.println("even");
		}
		
		pw.flush();
		pw.close();
	}
	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String s) throws FileNotFoundException
		{
			br = new BufferedReader(new FileReader(new File((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();
		}
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.util.*;
import java.io.*;
import java.math.BigInteger;

public class D {
	FastScanner in;
	PrintWriter out;
	boolean systemIO = true;

	public void solve() {
		int n = in.nextInt();
		int[] a = new int[n];
		for (int i = 0; i < a.length; i++) {
			a[i] = in.nextInt();
		}
		int x = 0;
		for (int i = 0; i < a.length; i++) {
			for (int j = i + 1; j < a.length; j++) {
				if (a[i] > a[j]) {
					x++;
				}
			}
		}
		boolean ans = x % 2 == 0;
		int m = in.nextInt();
		for (int i = 0; i < m; i++) {
			int len = -in.nextInt() + in.nextInt();
			len = len * (len + 1) / 2;
			if (len % 2 == 1) {
				ans = !ans;
			}
			if (ans) {
				out.println("even");
			} else {
				out.println("odd");
			}
		}
	}

	public void run() {
		try {
			if (systemIO) {
				in = new FastScanner(System.in);
				out = new PrintWriter(System.out);
			} else {
				in = new FastScanner(new File("segments.in"));
				out = new PrintWriter(new File("segments.out"));
			}
			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

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

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

	}

	// AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
	public static void main(String[] arg) {
		new D().run();
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic


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 solve(FastScanner fs) {	
		int n=fs.nextInt();
		int[] a=fs.readArray(n);
		boolean even=((countInversions(a)&1)==0);
		int q=fs.nextInt();
		for (int i=0; i<q; i++) {
			int start=fs.nextInt();
			int end=fs.nextInt();
			int diff=end-start;
			boolean evenChange=(diff+1)/2%2==0;
			even^=!evenChange;
			System.out.println(even?"even":"odd");
		}
	}
	
	private static int countInversions(int[] a) {
		int c=0;
		for (int i=0; i<a.length; i++) {
			for (int j=i+1; j<a.length; j++)
				if (a[j]<a[i])
					c++;
		}
		return c;
	}

	
	
	
	
	public static void main(String[] args) throws NumberFormatException, IOException {
		FastScanner scanner = new FastScanner(System.in);
		solve(scanner);
	}
	

	private static class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
		}
		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}
		int nextInt() {
			return Integer.parseInt(next());
		}
		long nextLong() {
			return Long.parseLong(next());
		}
		double nextDouble() {
			return Double.parseDouble(next());
		}
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++)
				a[i]=nextInt();
			return a;
		}
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
// discussed with rainboy
import java.io.*;
import java.util.*;

public class CF911D {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		int n = Integer.parseInt(br.readLine());
		StringTokenizer st = new StringTokenizer(br.readLine());
		int[] aa = new int[n];
		for (int i = 0; i < n; i++)
			aa[i] = Integer.parseInt(st.nextToken());
		boolean odd = false;
		for (int i = 0; i < n; i++)
			for (int j = i + 1; j < n; j++)
				if (aa[i] > aa[j])
					odd = !odd;
		int m = Integer.parseInt(br.readLine());
		while (m-- > 0) {
			st = new StringTokenizer(br.readLine());
			int l = Integer.parseInt(st.nextToken());
			int r = Integer.parseInt(st.nextToken());
			int k = r - l + 1;
			if ((long) k * (k - 1) / 2 % 2 != 0)
				odd = !odd;
			pw.println(odd ? "odd" : "even");
		}
		pw.close();
	}
}