import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

public class Expressions {

    static Scanner sc = new Scanner(System.in);

    static boolean[] isOdd;
    static ArrayList<ArrayList<Integer>> pSequence = new ArrayList<>();
    static HashMap<Integer, Boolean> dynMap = new HashMap<>();
    static int changedIndex = -1;

    static int[] seqIndex;



    public static void main(String[] args) {

        int num = sc.nextInt();
        int changes = sc.nextInt();


        isOdd = new boolean[num];
        seqIndex = new int[num];
        sc.nextLine();
        String[] expr = sc.nextLine().split(" ");

        int curSeq = 0;
        pSequence.add(new ArrayList<>());
        isOdd[0] = isOdd(Integer.parseInt(expr[0]));
        pSequence.get(curSeq).add(0);
        seqIndex[0] = 0;


        for (int i = 1; i < num; i++) {
            int mapping = 2 * i;

            String znam = expr[mapping - 1];
            isOdd[i] = isOdd(Integer.parseInt(expr[mapping]));

            if (znam.equals("+") || znam.equals("-")) {
                pSequence.add(new ArrayList<>());
                curSeq++;
            }

            pSequence.get(curSeq).add(i);
            seqIndex[i] = curSeq;

        }


        System.out.println(evaluate() ? "odd" : "even");

        for (int i = 0; i < changes; i++) {
            changedIndex = -1;
            int index = sc.nextInt() - 1;
            int nValue = sc.nextInt();
            boolean odd = isOdd(nValue);
            isOdd[index] = odd;
            changedIndex = seqIndex[index];
            System.out.println(evaluate() ? "odd" : "even");

        }
    }


    public static boolean isOdd(int num) {
        return num % 2 == 1;
    }


    public static boolean evaluate() {

        boolean result = false;
        int index = 0;
        for (int i = 0; i < pSequence.size(); i++) {
            boolean innerResult;
            if (changedIndex == -1 || changedIndex == i) {
                innerResult = isOdd[index++];
                for (int j = 1; j < pSequence.get(i).size(); j++) {
                    boolean second = isOdd[index++];
                    innerResult = innerResult && second;

                }
                dynMap.put(i, innerResult);
            } else {
                index += pSequence.get(i).size();
                innerResult = dynMap.get(i);
            }
            result = (result && !innerResult) || (!result && innerResult);
        }
        return result;
    }

}