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 ArrayList<int[]> evenOdds = new ArrayList<>();
    static HashMap<Integer, Boolean> dyn = new HashMap<>();
    static int changedIndex = -1;
    static int[] mainEvenOdds = new int[2];

    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<>());
        evenOdds.add(new int[2]);
        isOdd[0] = isOdd(Integer.parseInt(expr[0]));
        pSequence.get(curSeq).add(0);
        seqIndex[0] = 0;
        evenOdds.get(curSeq)[isOdd[0] ? 1 : 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<>());
                evenOdds.add(new int[2]);
                curSeq++;
            }

            evenOdds.get(curSeq)[isOdd[i] ? 1 : 0]++;
            pSequence.get(curSeq).add(i);
            seqIndex[i] = curSeq;

        }

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

        for (int i = 0; i < changes; i++) {
            changedIndex = -1;
            int index = sc.nextInt() - 1;
            int nValue = sc.nextInt();
            boolean odd = isOdd(nValue);
            boolean old = isOdd[index];
            isOdd[index] = odd;
            int seq = seqIndex[index];
            if (old != odd) {
                if (odd) {
                    evenOdds.get(seq)[0]--;
                    evenOdds.get(seq)[1]++;
                } else {
                    evenOdds.get(seq)[0]++;
                    evenOdds.get(seq)[1]--;
                }
            }

            changedIndex = seqIndex[index];
            System.out.println(evaluate(false) ? "odd" : "even");

        }
    }


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


    public static boolean evaluate(boolean first) {
        if (first) {
            for (int i = 0; i < pSequence.size(); i++) {
                boolean odd = evenOdds.get(i)[0] == 0;
                mainEvenOdds[odd ? 1 : 0]++;
                dyn.put(i, odd);
            }
        } else {
            boolean last = dyn.get(changedIndex);
            boolean odd = evenOdds.get(changedIndex)[0] == 0;
            if (last != odd) {
                if (odd) {
                    mainEvenOdds[0]--;
                    mainEvenOdds[1]++;
                } else {
                    mainEvenOdds[0]++;
                    mainEvenOdds[1]--;
                }
            }
            dyn.put(changedIndex, odd);
        }
        return mainEvenOdds[1] % 2 == 1;
    }

}