#include <bits/stdc++.h>
#define endl '\n'
using namespace std;

const int INF = 1e9 + 7;
const int MAX_N = 1e5 + 5;

//-------------------------------------------------

struct WaveletTree {
	private:
		struct Node;
		void BuildTree(Node *node, int low, int high);
		int FindKth(Node *node, int le, int ri, int k);

		Node *root;

	public:
		WaveletTree(const vector< int > &numbers);
		int FindKth(int le, int ri, int k);
		void Build(const vector< int > &v);
};

struct WaveletTree::Node {
	vector< int > a, b;
	Node *left, *right;	

	Node();
};

WaveletTree::Node::Node() : left(nullptr), right(nullptr) {
	a.clear();
	b.clear();
}

WaveletTree::WaveletTree(const vector< int > &numbers) {
	Build(numbers);
}

void WaveletTree::BuildTree(Node *node, int low, int high) {
	node -> b.push_back(0);

	if(node -> a.size() == 1 || low == high) {
		return;
	}

	int mid = (low + high) / 2, cntSmallerOrEqual = 0;

	node -> left = new Node();
	node -> right = new Node();

	node -> left -> a.push_back(INF);
	node -> right -> a.push_back(INF);

	for(int num : node -> a) {
		if(num == INF) {
			continue;
		}

		if(num <= mid) {
			node -> left -> a.push_back(num);
			cntSmallerOrEqual++;
		}
		else {
			node -> right -> a.push_back(num);
		}

		node -> b.push_back(cntSmallerOrEqual);
	}

	BuildTree(node -> left, low, mid);
	BuildTree(node -> right, mid + 1, high);
}

void WaveletTree::Build(const vector< int > &v) {
	int maxNum = -INF, minNum = INF;

	root = new Node();
	root -> a.push_back(INF);

	for(int num : v) {
		root -> a.push_back(num);

		minNum = min(minNum, num);
		maxNum = max(maxNum, num);
	}

	BuildTree(root, minNum, maxNum);
}

int WaveletTree::FindKth(Node *node, int le, int ri, int k) {
	if(le == ri) {
		return node -> a[le];
	}

	int goingLeft = node -> b[ri] - node -> b[le - 1];

	if(goingLeft >= k) {
		return FindKth(node -> left, node -> b[le - 1] + 1, node -> b[ri], k);
	}
	else {
		int newLe = le - node -> b[le - 1];
		int newRi = ri - node -> b[ri];
		int newK = k - goingLeft;

		return FindKth(node -> right, newLe, newRi, newK);
	}
}

int WaveletTree::FindKth(int le, int ri, int k) {
	return FindKth(root, le, ri, k);
}

//-------------------------------------------------

int fromNewToOld[MAX_N];

void Compress(vector< int > &v) {
	vector< int > numbers = v;
	sort(numbers.begin(), numbers.end());

	for(int i = 0; i < v.size(); i++) {
		int oldValue = v[i];
		v[i] = lower_bound(numbers.begin(), numbers.end(), oldValue) - numbers.begin() + 1;

		fromNewToOld[v[i]] = oldValue;
	}
}

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int n, m;
	cin >> n >> m;

	vector< int > v(n);
	for(int i = 0; i < n; i++) {
		cin >> v[i];
	}

	Compress(v);

	WaveletTree waveletTree = WaveletTree(v);

	for(int i = 0; i < m; i++) {
		int le, ri, k;
		cin >> le >> ri >> k;

		cout << fromNewToOld[waveletTree.FindKth(le, ri, k)] << endl;
	}

	return 0;
}