#include <stdio.h>
#include <algorithm>

static const int maxn = (1 << 17); // smallest power of 2 not less than 10^5
int coords[maxn];
int array[maxn];

typedef struct node {
    node *l, *r;
    int sum;
} *Node;

node buffer[maxn * 50];
Node ver[maxn];

Node allocate(int number = 1)
{
    static Node freep = buffer;
    Node res = freep;
    freep += number;
    return res;
}

Node update(Node v, int vl, int vr, int x)
{
    if (vl == x && vr == x + 1) {
        Node u = allocate();
        *u = *v;
        u->sum = 1;
        return u;
    }
    Node u = allocate();
    *u = *v;
    int m = (vl + vr) / 2;
    if (x < m)
        u->l = update(u->l, vl, m, x);
    else

        u->r = update(u->r, m, vr, x);
    ++u->sum;
    return u;
}


std::pair<int, bool> find_nth(Node u, Node v, int vl, int vr, int k)
{
    int sum = v->sum - u->sum;
    if (vr - vl == 1) {
        if (k == sum)
            return std::make_pair(vl, false);
    }
    if (sum < k)
        return std::make_pair(vr, true);
    if (vr - vl == 1)
        return std::make_pair(vl, false);
    std::pair<int, bool> p = find_nth(u->l, v->l, vl, (vl + vr) / 2, k);
    if (!p.second)
        return p;
    return find_nth(u->r, v->r, (vl + vr) / 2, vr, k - v->l->sum + u->l->sum);
}

int main()
{
    int n, m;
    FILE *in = stdin;
    FILE *out = stdout;
    fscanf(in, "%d%d", &n, &m);
    for (int i = 0; i < n; ++i)
        fscanf(in, "%d", &array[i]);
    std::copy(array, array + n, coords);
    std::sort(coords, coords + n);
    for (int i = 0; i < n; ++i)
        array[i] = std::lower_bound(coords, coords + n, array[i]) - coords;
    allocate(2 * maxn - 1);
    for (int i = maxn - 2; i >= 0; --i)  {
        buffer[i].l = &buffer[2 * i + 1];
        buffer[i].r = &buffer[2 * i + 2];
    }
    ver[0] = buffer;
    for (int i = 0; i < n; ++i)
        ver[i + 1] = update(ver[i], 0, maxn, array[i]);

    for (int i = 0; i < m; ++i) {
        int l, r, k;
        fscanf(in, "%d%d%d", &l, &r, &k);
        --l;
        fprintf(out, "%d\n", coords[find_nth(ver[l], ver[r], 0, maxn, k).first]);
    }
    return 0;
}