//  ↘ ⬇ ⬇ ⬇ ⬇ ⬇ ↙
//  ➡ @roadfromroi ⬅
//  ↗ ⬆ ⬆ ⬆ ⬆ ⬆ ↖
#include <iostream>
#include "vector"
#include "algorithm"
#include "numeric"
#include "climits"
#include "iomanip"
#include "bitset"
#include "cmath"
#include "map"
#include "deque"
#include "array"
#include "set"
#define all(x) x.begin(), x.end()
using namespace std;
#include "floppy.h"
struct segtree {
    int sz;
    vector<pair<int, int>> tree;
    void init(vector<int> a) {
        sz = 1;
        while (sz < a.size())
            sz *= 2;
        tree.assign(sz * 2, {});
        for (int i = 0; i < a.size(); ++i) {
            tree[i + sz] = {a[i], i};
        }
        for (int i = sz-1; i >= 1; --i) {
            tree[i] = max(tree[i * 2], tree[i * 2 + 1]);
        }
    }
    int getseg(int l, int r) {
        l += sz;
        r += sz;
        pair<int, int> res ={-1,-1};
        while (l <= r) {
            if (l % 2 == 1) {
                res = max(res, tree[l]);l++;
            }
            if (r % 2 == 0) {
                res = max(res, tree[r]);r--;
            }
            l /= 2;r /= 2;
        }
        return res.second;
    }
};
void mrg(deque<int> &a, deque<int> &b) {
    if (a.size() > b.size()) {
        while (!b.empty()) {
            a.push_back(b.front());
            b.pop_front();
        }
    } else {
        while (!a.empty()) {
            b.push_front(a.back());
            a.pop_back();
        }
        swap(a, b);
    }
}
segtree sg;
void beba(int l, int r, string &boba) {
    if (l > r) {
        return;
    }
    int mx = sg.getseg(l, r);
    //cout << l << ' ' << r << "->" << mx << endl;
    beba(l, mx-1, boba);
    boba += '0';
    beba(mx+1, r, boba);
    boba += '1';
    return;
}
void read_array(int subtask_id, const std::vector<int> &v) {
    sg.init(v);
    string bits;
    beba(0, v.size() - 1, bits);
    save_to_floppy(bits);
}
vector<int> mytree;
vector<vector<int>> prfsm;
vector<int> actual;
void recareca(int l, int r, int myn, int myg) {
    if (l >= r)
        return;
    int eba = upper_bound(all(prfsm[myg]), r) - prfsm[myg].begin() - 1;
    if (eba == -1)
        return;
    int vl = prfsm[myg][eba];
    if (vl > r)
        exit(1);
    if (vl < l)
        return;
    mytree[actual[vl]] = myn;
    recareca(l, vl-1, myn-1, myg);
    recareca(vl+1, r-1, myn-1, myg+1);
}
std::vector<int> solve_queries(int subtask_id, int N,
                               const std::string &bits,
                               const std::vector<int> &a, const std::vector<int> &b) {
    prfsm.assign(bits.size() + 1, {});
    prfsm[0].push_back(0);
    mytree.assign(N, {});
    int sm = 0;
    int reac = 0;
    actual.assign(bits.size()+1, {});
    for (int i = 0; i < bits.size(); ++i) {
        if (bits[i] == '0') {
            //cout << "(";
            sm++;
            reac++;
        }else {
            //cout << ")";
            sm--;
        }
        actual[i + 1] = reac;
       // cout << i+1 << ' ' << sm << ' ';
        prfsm[sm].push_back(i+1);
        //cout << prfsm[sm].back() << endl;
        //cerr << sm << ' ' << i + 1 << endl;
    }
    recareca(0, bits.size() - 1, N, 0);
    sg.init(mytree);
    vector<int> res;
    for (int i = 0; i < a.size(); ++i) {
        res.push_back(sg.getseg(a[i], b[i]));
    }
    return res;
}

#ifdef __APPLE__

#define NMAX 100000
#define MMAX 100000

int subtask_id, N, M;
std::vector<int> v, sorted_v;
std::vector<int> a, b;
std::vector<int> correct_answers;

// Print score to stdout and exit.
void score_and_exit(const double pts, const char *verdict) {
    fprintf(stderr, "%s", verdict);
    fprintf(stdout, "%f", pts);
    exit(0);
}

// Contestant sent too many bits.
void too_many_bits() {
    score_and_exit(0, "Too many stored bits!");
}

// Contestant did not send any bits.
void misformatted_stored_bits() {
    score_and_exit(0, "Misformatted stored bits or save_to_floppy not called!");
}

// Contestant did not call the answer function.
void answer_not_provided() {
    score_and_exit(0, "Answer not provided!");
}

// Contestant sent a wrong answer.
void wrong_answer() {
    score_and_exit(0, "Wrong answer to query!");
}

// Contestant sent a correct answer.
void correct_answer() {
    score_and_exit(1, "OK!");
}

void read_test() {
    assert(scanf("%d", &subtask_id) == 1);
    assert(scanf("%d%d", &N, &M) == 2);
    assert(1 <= N && N <= NMAX);
    assert(0 <= M && M <= MMAX);
    v.resize(N);
    for (int i = 0; i < N; ++i) {
        v[i] = i * 2;
        //assert(scanf("%d", &v[i]) == 1);
    }

    // Check all values are distinct.
    sorted_v.resize(N);
    for (int i = 0; i < N; ++i) {
        sorted_v[i] = v[i];
    }
    std::sort(sorted_v.begin(), sorted_v.end());
    for (int i = 0; i + 1 < N; ++i) {
        assert(sorted_v[i] < sorted_v[i + 1]);
    }

    a.resize(M);
    b.resize(M);
    correct_answers.resize(M);
    for (int i = 0; i < M; ++i) {
        assert(scanf("%d%d%d", &a[i], &b[i], &correct_answers[i]) == 3);
        assert(0 <= a[i] && a[i] <= correct_answers[i] &&
               correct_answers[i] <= b[i] && b[i] < N);
    }
}

void save_to_floppy(const std::string &bits) {
    std::vector<int> contestant_answers = solve_queries(subtask_id, N, bits, a, b);
    for (int i = 0; i < M; ++i) {
        if (contestant_answers[i] != correct_answers[i]) {
            wrong_answer();
        }
    }
    correct_answer();
    exit(0);
}

int main(int argc, char **argv) {
    // Read input data.
    read_test();

    // Send subtask_id, v.
    read_array(subtask_id, v);

    answer_not_provided();
    return 0;
}
#endif
/*
2
4 1
40 20 30 10
0 0 0
 */