#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroint-loops")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define int           int64_t
#define ull           unsigned long long
#define ld            long double
#define INF           (int)2e16

#define rng(i,a,b)    for(int i=int(a);i<int(b);i++)
#define gnr(i,a,b)    for(int i=int(b)-1;i>=int(a);i--)
#define per(i,b)      gnr(i,0,b)
#define rep(i,b)      rng(i,0,b)

#define endl          '\n'
#define yes           "YES\n"
#define no            "NO\n"

#define F             first
#define S             second

#define all(a)        a.begin(),a.end()
#define rall(a)       a.rbegin(),a.rend()
#define __sort(x)     sort(x.begin(), x.end())
#define __rsort(x)    sort(x.rbegin(), x.rend())
#define __lcm(a, b)   (int(a) * int(b) / (__gcd(int(a), int(b))))

#define out_1arr(a, ch123)   for(auto el_ : a) cout << el_ << ch123;
#define out_2arr(a, ch123)   for(auto row_ : a) {for(auto col_ : row_) cout << col_ << ch123; cout << endl;}

#define optimize()    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define multitest()   int ttt;cin >> ttt;rep(t_cnt, ttt)
using namespace std;
#ifdef LOCAL
mt19937 tw(9450189);
#else
mt19937 tw(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
uniform_int_distribution<int> ll_distr;
int rnd(int a, int b) { return ll_distr(tw) % (b - a + 1) + a; }

struct Node {
    int l, r, x, priority, size;
    int min;
    bool inv;

    Node(int _x = -1, int l = -1, int r = -1,
         int pr = rnd(1, 1000000000)): x(_x), priority(pr), l(l),
         r(r), size(1), min(_x), inv(false) {}
};

const int NMAX = 1e5 + 10;
vector<Node> t(NMAX);
int cur_new = 0, root = -1;

int get_size(int v) {
    if (v == -1)
        return 0;
    return t[v].size;
}

int get_min(int v) {
    if (v == -1)
        return INF;
    return t[v].min;
}

void update(int v) {
    if (v == -1) return;
    t[v].size = get_size(t[v].l) + get_size(t[v].r) + 1;
    t[v].min = min(min(get_min(t[v].l), get_min(t[v].r)), t[v].x);
}

void give(int v) {
    if (v != -1 && t[v].inv) {
        t[v].inv = false;
        swap(t[v].l, t[v].r);
        if (t[v].l != -1) {
            t[t[v].l].inv ^= 1;
        }
        if (t[v].r != -1) {
            t[t[v].r].inv ^= 1;
        }
    }
}

int merge(int l, int r) {
    give(l);
    give(r);
    if (l == -1) return r;
    if (r == -1) return l;
    if (t[l].priority < t[r].priority) {
        t[l].r = merge(t[l].r, r);
        update(l);
        return l;
    } else {
        t[r].l = merge(l, t[r].l);
        update(r);
        return r;
    }
}

void split(int v, int k, int &l, int &r) {
    give(v);
    if (v == -1)
        l = r = -1;
    else if (get_size(t[v].l) < k) {
        split(t[v].r, k - get_size(t[v].l) - 1, t[v].r, r);
        l = v;
    } else {
        split(t[v].l, k, l, t[v].l);
        r = v;
    }
    update(v);
}

int32_t main() {
    optimize();
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        t[cur_new++] = {x};
        root = merge(root, cur_new - 1);
    }
    while (m--) {
        int type, l, r;
        cin >> type >> l >> r;
        l--;
        int a, b, c;
        split(root, r, root, c);
        split(root, l, a, b);
        if (type == 2) {
            cout << get_min(b) << '\n';
        } else {
            t[b].inv ^= 1;
        }
        root = merge(a, b);
        root = merge(root, c);
    }
}