#include <iostream>
#include <vector>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <algorithm>

using namespace std;

const long long INF = 1e10;

struct Treap {
	long long x;
	long long y;
	long long cnt;
	long long minn;
	long long summ;
	long long maxn;
	bool rvrs;
	Treap* leftp;
	Treap* rightp;
};

void push(Treap* Treap) {
	if (Treap == NULL) {
		return;
	}

	if (Treap->rvrs) {
		Treap->rvrs = false;

		if (Treap->leftp != NULL) {
			Treap->leftp->rvrs ^= true;
		}

		if (Treap->rightp != NULL) {
			Treap->rightp->rvrs ^= true;
		}

		auto a = Treap->leftp;
		auto b = Treap->rightp;

		Treap->leftp = b;
		Treap->rightp = a;
	}
}

long long cnt(Treap* Treap) {
	if (Treap == NULL) {
		return 0;
	}
	else {
		return Treap->cnt;
	}
}

long long minn(Treap* Treap) {
	if (Treap == NULL) {
		return INF;
	}
	else {
		return Treap->minn;
	}
}

long long maxn(Treap* Treap) {
	if (Treap == NULL) {
		return 0;
	}
	else {
		return Treap->maxn;
	}
}

long long summ(Treap* Treap) {
	if (Treap == NULL) {
		return 0;
	}
	else {
		return Treap->summ;
	}
}

void upd_cnt(Treap* Treap) {
	if (Treap != NULL) Treap->cnt = 1 + cnt(Treap->rightp) + cnt(Treap->leftp);
}

void upd_minn(Treap* Treap) {
	if (Treap != NULL) Treap->minn = min(min(minn(Treap->rightp), minn(Treap->leftp)), Treap->x);
}

void upd_summ(Treap* Treap) {
	if (Treap != NULL) Treap->summ = summ(Treap->rightp) + summ(Treap->leftp) + Treap->x;
}

void upd_maxn(Treap* Treap) {
	if (Treap != NULL) Treap->maxn = max(max(maxn(Treap->rightp),maxn(Treap->leftp)),Treap->x);
}


void recalc(Treap* Treap) {
	upd_cnt(Treap);
	upd_minn(Treap);
	upd_summ(Treap);
	upd_maxn(Treap);
}

pair<Treap*, Treap*> split(Treap* root, long long x, long long summ = 0) {
	push(root);
	if (root == NULL) {
		return{ NULL, NULL };
	}

	long long id = summ + cnt(root->leftp);

	if (id < x) {
		auto res = split(root->rightp, x, id + 1);
		root->rightp = res.first;
		recalc(root);
		return{ root, res.second };
	}
	else {
		auto res = split(root->leftp, x, summ);
		root->leftp = res.second;
		recalc(root);
		return{ res.first, root };
	}
}

Treap* Merge(Treap* l, Treap* r) {
	push(l);
	push(r);
	if (l == NULL) {
		return r;
	}
	if (r == NULL) {
		return l;
	}
	if (l->y > r->y) {
		l->rightp = Merge(l->rightp, r);
		recalc(l);
		return l;
	}
	else {
		r->leftp = Merge(l, r->leftp);
		recalc(r);
		return r;
	}
}

Treap* Insert(Treap* root, long long value, long long x) {
	auto spl = split(root, x);
	Treap* nw = new Treap({ value, rand(), 1, value, false, NULL, NULL });
	auto a = Merge(Merge(spl.first, nw), spl.second);
	recalc(a);
	return a;
}

Treap* Insert_mass(Treap* root, Treap* nedw, long long x) {
	auto spl = split(root, x);
	auto a = Merge(Merge(spl.first, nedw), spl.second);
	recalc(a);
	return a;
}

Treap* del(Treap* root, long long l, long long r) {
	auto spl1 = split(root, l);
	auto spl2 = split(spl1.second, r + 1);
	auto a = Merge(spl1.first, spl2.second);
	return a;
}

pair<Treap*, Treap*> get_range(Treap* root, long long l, long long r) {
	auto spl1 = split(root, l);
	auto spl2 = split(spl1.second, r - l);
	auto a = Merge(spl1.first, spl2.second);
	auto b = spl2.first;
	return{ a, b };
}

long long get_min(Treap* root, long long l, long long r) {
	auto spl1 = split(root, l);
	auto spl2 = split(spl1.second, r - l);
	long long ans = minn(spl2.first);
	root = Merge(spl1.first, Merge(spl2.first, spl2.second));
	return ans;
}

long long get_sum(Treap* root, long long l, long long r) {
	auto spl1 = split(root, l);
	auto spl2 = split(spl1.second, r - l);
	long long ans = summ(spl2.first);
	root = Merge(spl1.first, Merge(spl2.first, spl2.second));
	return ans;
}

long long get_max(Treap* root, long long l, long long r) {
	auto spl1 = split(root, l);
	auto spl2 = split(spl1.second, r - l);
	long long ans = maxn(spl2.first);
	root = Merge(spl1.first, Merge(spl2.first, spl2.second));
	return ans;
}

void RVRS(Treap* root, long long l, long long r) {
	auto spl1 = split(root, l);
	auto spl2 = split(spl1.second, r - l);
	spl2.first->rvrs ^= true;
	root = Merge(spl1.first, Merge(spl2.first, spl2.second));
}

long long get(Treap* root, long long x, long long summ) {
	if (root == NULL) {
		return INF;
	}

	long long id = summ + cnt(root->leftp);

	if (id == x) {
		return root->x;
	}
	else {
		return (id < x) ? get(root->rightp, x, id + 1) : get(root->leftp, x, id + 1);
	}
}

void print_dek(Treap* root) {
	if (root == NULL) {
		return;
	}

	print_dek(root->leftp);
	cout << root->x << ' ';
	print_dek(root->rightp);
}

int main() {
	srand(2);

	long long n, m, cur, l, r;
	Treap* root = NULL;

	cin >> n >> m;

	for (int i = 0; i < n; ++i) {
		cin >> cur;
		root = Insert(root, cur, i);
	}
	for (int i = 0; i < m; ++i) {
		cin >> cur >> l >> r;
		l--;
		if (cur == 2) {
			RVRS(root, l, r);
		}
		else {
			cout << get_sum(root, l, r) << " " << get_min(root, l, r) << " " << get_max(root, l, r) <<  endl;
		}
	}

	return 0;
}