#include <iostream>
#include <vector>

using namespace std;

void print_evenness(bool is_even) {
    if (is_even)
        cout << "even" << endl;
    else
        cout << "odd" << endl;
}

void print_state(const vector<int>& group_even_count) {
    cout << "group n even" << endl;
    for (const auto &x: group_even_count) {
        cout << x << ",";
    }
    cout << endl;
}

int main() {
    size_t n_arguments, n_changes;
    cin >> n_arguments >> n_changes;
    vector<bool> num_evenness(n_arguments); // 1 if even else 0
    vector<int> group_even_count;
    vector<size_t> number_idx_to_group_idx;
    bool whole_expression_is_even = true;
    // read the expression from stdin
    size_t curr_number;
    char curr_operation;
    bool prev_was_addition = true;
    bool curr_evenness;
    for (size_t i = 0; i < n_arguments; ++i) {
        if (i != (n_arguments - 1)) {
            cin >> curr_number >> curr_operation;
        }
        else {
            cin >> curr_number;
        }
        curr_evenness = 1 - (curr_number % 2);
        num_evenness[i] = curr_evenness;
        if (prev_was_addition) {
            group_even_count.emplace_back(curr_evenness);
        } else {
            group_even_count.back() += curr_evenness;
        }
        number_idx_to_group_idx.emplace_back(group_even_count.size()-1);
        prev_was_addition = curr_operation != '*';
    }
    // calculate evenness of whole expression
    for (auto even_count: group_even_count) {
        // if odd number is encountered
        if (even_count == 0) {
            whole_expression_is_even = !whole_expression_is_even;
        }
    }

 /*   cout << "num evenness" << endl;
    for (const auto &x: num_evenness) {
        cout << x << ",";
    }
    cout << endl;

    print_state(group_even_count);*/

    // initial evenness
    print_evenness(whole_expression_is_even);
    // read changes
    size_t arg_idx;
    size_t new_num;
    for (size_t i=0; i < n_changes; ++i) {
        cin >> arg_idx >> new_num;
        --arg_idx;
        auto &curr_group_even_count = group_even_count[number_idx_to_group_idx[arg_idx]];
        bool group_was_even = curr_group_even_count > 0;
        bool arg_was_even = num_evenness[arg_idx];
        bool changed_arg_even = (new_num % 2) == 0;
        if (arg_was_even == changed_arg_even) {
            print_evenness(whole_expression_is_even);
            continue;
        }
        if (arg_was_even && !changed_arg_even) {
            --curr_group_even_count;
        } else if (!arg_was_even && changed_arg_even) {
            ++curr_group_even_count;
        }
        if (group_was_even != (curr_group_even_count > 0)){
            whole_expression_is_even = !whole_expression_is_even;
        }
        print_evenness(whole_expression_is_even);
    }
    return 0;
}