codeparrot/codecomplex huggingface dataset:
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class D911{

	void solve()
	{
		int n = ni();
		int[] a = ia(n);
		int Q = ni();
		String[] ans = {"even", "odd"};
		int cur = merge(a, 0, n - 1) % 2;
		while(Q-->0)
		{
			int l = ni(), r = ni();
			cur ^= (r - l + 1) / 2 % 2;
			out.println(ans[cur]);
		}
		
	}
	
	int merge(int[] a, int l, int r)
	{
		if(l >= r)
			return 0;
		int mid = l + r >> 1;
		int v1 = merge(a, l, mid);
		int v2 = merge(a, mid + 1, r);
		
		int[] rep = new int[r-l+1];
		int ptr0 = 0, ptr1 = l, ptr2 = mid + 1;
		
		long len = mid-l+1;
		int ret = 0;
		while(ptr1<=mid && ptr2<=r)
		{
			if(a[ptr1] <= a[ptr2])
			{
				len--;
				rep[ptr0++] = a[ptr1++];
			}
			else
			{
				ret += len;
				rep[ptr0++] = a[ptr2++]; 
			}
		}
		
		while(ptr1 <= mid)
			rep[ptr0++] = a[ptr1++];
		while(ptr2 <= r)
			rep[ptr0++] = a[ptr2++];
		
		for(int i=0;i<ptr0;i++)
			a[l+i] = rep[i];
		
		return v1 + v2 + ret;
	}
	
	public static void main(String[] args){new D911().run();}
	
	private byte[] bufferArray = new byte[1024];
	private int bufLength = 0;
	private int bufCurrent = 0;
	InputStream inputStream;
	PrintWriter out;
	
	public void run()
	{
		inputStream = System.in;
		out = new PrintWriter(System.out);
		solve();
		out.flush();
	}
	
	int nextByte()
	{
		if(bufLength == -1)
			throw new InputMismatchException();
		if(bufCurrent >= bufLength)
		{
			bufCurrent = 0;
			try
			{bufLength = inputStream.read(bufferArray);}
			catch(IOException e)
			{ throw new InputMismatchException();}
			if(bufLength <= 0)
				return -1;
		}
		return bufferArray[bufCurrent++];
	}
	
	boolean isSpaceChar(int x)	{return (x < 33 || x > 126);}
	
	boolean isDigit(int x)	{return (x >= '0' && x <= '9');}
	
	int nextNonSpace()
	{
		int x;
		while((x=nextByte()) != -1 && isSpaceChar(x));
		return x;
	}
	
	int ni()
	{
		long ans = nl();
		if (ans >= Integer.MIN_VALUE && ans <= Integer.MAX_VALUE)
			return (int)ans;
		throw new InputMismatchException();
	}
	
	long nl()
	{
		long ans = 0;
		boolean neg = false;
		int x = nextNonSpace();
		if(x == '-') 
		{
			neg = true;
			x = nextByte();
		}
		while(!isSpaceChar(x))
		{
			if(isDigit(x))
			{
				ans = ans * 10 + x -'0';
				x = nextByte();
			}
			else
				throw new InputMismatchException();
		}
		return neg ? -ans : ans;
	}
	
	String ns()
	{
		StringBuilder sb = new StringBuilder();
		int x = nextNonSpace();
		while(!isSpaceChar(x))
		{
			sb.append((char)x);
			x = nextByte();
		}
		return sb.toString();
	}
	
	char nc()	{ return (char)nextNonSpace();}
	
	double nd()	{ return (double)Double.parseDouble(ns()); }
	
	char[] ca()	{ return ns().toCharArray();}
	
	char[][] ca(int n)
	{
		char[][] ans = new char[n][];
		for(int i=0;i<n;i++)
			ans[i] = ca();
		return ans;
	}
	
	int[] ia(int n)
	{
		int[] ans = new int[n];
		for(int i=0;i<n;i++)
			ans[i] = ni();
		return ans;
	}
	
	void db(Object... o) {System.out.println(Arrays.deepToString(o));}
	
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic

import java.util.Scanner;

public class Main {

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

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

public class d {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		
		int size = in.nextInt();
		
		int[] vals = new int[size];
		long[] cum = new long[size];
		for(int i=0; i<size; i++){
			vals[i] = in.nextInt();
			
			int c = 0;
			for(int j=0; j<i; j++)
				if(vals[j] > vals[i]) c++;
			
			if(i != 0) cum[i] = cum[i-1]+c;
			else cum[i] = c;
		}
		
		long tot = cum[size-1];
		int q = in.nextInt();

		int[] nv = new int[size];
		for(int i=0; i<q; i++)
		{
			int l = in.nextInt()-1;
			int r = in.nextInt()-1;
			int n = (r-l);
			
			long add = (n*(n+1))/2 - (cum[r] - cum[l]);
			tot = tot - (cum[r] - cum[l]) + add;
			
			if(tot%2 == 0)
				System.out.println("even");
			else
				System.out.println("odd");
			
//			for(int j=0; j<=r-l; j++)
//				nv[l+j] = vals[r-j];
//			
//			for(int j=0; j<=r-l; j++)
//				vals[l+j] = nv[l+j];
			
		}
	}
}
/*
3
1 2 3
2
1 2
2 3

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

*/
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
import java.io.*;
import java.util.*;
public class DD {
	public static void main(String[] args)throws Throwable {
		MyScanner sc=new MyScanner();
		PrintWriter pw=new PrintWriter(System.out);
		
		int n=sc.nextInt();
		int [] a=new int [n];
		for(int i=0;i<n;i++)
			a[i]=sc.nextInt();
		int c=0;
		for(int i=0;i<n;i++)
			for(int j=i+1;j<n;j++)
				if(a[i]>a[j])
					c^=1;
		int m=sc.nextInt();
		while(m-->0){
			int l=sc.nextInt()-1;
			int r=sc.nextInt()-1;
			int d=r-l+1;
			d=d*(d-1)/2;
			c^=(d%2);
			pw.println(c==0? "even" : "odd");
		}
		
		pw.flush();
		pw.close();
	}
	
	static class MyScanner {
		BufferedReader br;
		StringTokenizer st;
		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.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;}
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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();
	}
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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;
	}

}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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;
		}
	}
}
// 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;
      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();
  }
}
// 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.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;
        }

    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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");
            }
        }
    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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());
    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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);
        	}
        }


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

    }
}
// Problem: 911_D. Inversion Counting
// Time complexity: quadratic
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");
			
		}
	}
	
	

}