// May this submission get accepted!

#pragma GCC optimize ("O3")
#pragma GCC target ("tune=native")
#pragma GCC target ("avx")

#include <bits/stdc++.h>

// 汎用マクロ
#define ALL_OF(x) (x).begin(), (x).end()
#define REP(i,n) for (long long i=0, i##_len=(n); i<i##_len; i++)
#define RANGE(i,is,ie) for (long long i=(is), i##_end=(ie); i<=i##_end; i++)
#define DSRNG(i,is,ie) for (long long i=(is), i##_end=(ie); i>=i##_end; i--)
#define UNIQUE(v) { sort((v).begin(), (v).end()); (v).erase(unique((v).begin(), (v).end()), (v).end()); }
template<class T> bool chmax(T &a, const T &b) {if (a < b) {a = b; return true;} return false; }
template<class T> bool chmin(T &a, const T &b) {if (a > b) {a = b; return true;} return false; }
#define INF 0x7FFFFFFF
#define LINF 0x7FFFFFFFFFFFFFFFLL
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
#define DUMP(q) cerr << "[DEBUG] " #q ": " << (q) << " at " __FILE__ ":" << __LINE__ << endl
#define DUMPALL(q) { cerr << "[DEBUG] " #q ": ["; REP(i, (q).size()) { cerr << (q)[i] << (i == i_len-1 ? "" : ", "); } cerr << "] at " __FILE__ ":" << __LINE__ << endl; }
template<class T> T gcd(const T &a, const T &b) { return a < b ? gcd(b, a) : b ? gcd(b, a % b) : a; }
template<class T> T lcm(const T &a, const T &b) { return a / gcd(a, b) * b; }

// gcc拡張マクロ
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll

// エイリアス
#define DANCE_ long
#define ROBOT_ unsigned
#define HUMAN_ signed
#define CHOKUDAI_ const
using  ll = DANCE_ HUMAN_ DANCE_;
using ull = DANCE_ ROBOT_ DANCE_;
using cll = DANCE_ DANCE_ CHOKUDAI_;
using  ld = long double;
using namespace std;

// モジュール
// 遅延評価セグ木 (T が値の型, U が値を変更する型, IT が T の単位元で IU が U の単位元)
template <class T, class U, T& IT, U& IU>
struct lazy_segtree {
    
    ll n;
    vector<T>    node;
    vector<U>    lazy;
    vector<bool> fall;
    
    // 演算; applyしてからjoinするのとjoinしてからapplyするのとが同じになる必要あり
    function<T(T,T)>      join_t; // 値同士のjoin
    function<T(T,U)>     apply_u; // 操作を値に適用する
    function<U(U,U)>      join_u; // 操作をjoinする
    function<U(U,ll)> multiply_u; // 操作をn回やる操作を作る（nは2べきで呼ばれる）
    function<U(U)>        half_u; // 操作の半分の操作を作る（Uは2べきのはず）
    
    // コンストラクタ
    lazy_segtree(const vector<T> &v, function<T(T,T)> _join_t, function<T(T,U)> _apply_u, function<U(U,U)> _join_u, function<U(U,ll)> _multiply_u, function<U(U)> _half_u): join_t(_join_t), apply_u(_apply_u), join_u(_join_u), multiply_u(_multiply_u), half_u(_half_u) {
        ll sz = (ll)v.size();
        n = 1; while (n < sz) n *= 2;
        node.resize(n * 2 - 1, IT);
        lazy.resize(n * 2 - 1, IU);
        fall.resize(n * 2 - 1, false);
        for (ll i = 0; i < sz; i++) node[n-1 + i] = v[i];
        for (ll i = n-2; i--; )  node[i] = join_t(node[i*2+1], node[i*2+2]);
    }
    
    // [l, r) を見ており, k を遅延評価
    inline void eval(ll k, ll l, ll r) {
        if (!fall[k]) return;
        node[k] = apply_u(node[k], lazy[k]);
        if (r-l > 1) { // 子があるなら伝播
            lazy[k*2+1] = join_u(lazy[k*2+1], half_u(lazy[k]));
            lazy[k*2+2] = join_u(lazy[k*2+2], half_u(lazy[k]));
            fall[k*2+1] = fall[k*2+2] = true;
        }
        lazy[k] = IU;
        fall[k] = false;
    }
    
    // 区間 [a, b) に x を適用（但し, [l, r)を見て今kをいじっている）
    void apply(ll a, ll b, U x, ll k = 0, ll l = 0, ll r = -1) {
        if (r < 0) r = n; // デフォルト値には定数しか入れられない
        eval(k, l, r);
        if (b <= l || r <= a) return; // セグフォ防止
        if (a <= l && r <= b) {
            lazy[k] = join_u(lazy[k], multiply_u(x, r - l));
            fall[k] = true;
            eval(k, l, r);
        } else {
            apply(a, b, x, k*2+1, l, (l+r)/2);
            apply(a, b, x, k*2+2, (l+r)/2, r);
            node[k] = join_t(node[k*2+1], node[k*2+2]);
        }
    }
    
    // 区間 [a, b) の操作後の値を求める
    T fetch(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
        if (r < 0) r = n; // デフォルト値には定数しか入れられない
        if (b <= l || r <= a) return IT; // セグフォ防止
        eval(k, l, r);
        if (a <= l && r <= b) return node[k];
        T vl = fetch(a, b, k*2+1, l, (l+r)/2);
        T vr = fetch(a, b, k*2+2, (l+r)/2, r);
        return join_t(vl, vr);
    }
    
};

// Range Minimum Query + Index
pair<ll, ll> x(INF, -1);

using pl4 = pair<ll, ll>;
struct rmq_pair : lazy_segtree<pl4, pl4, x, x> {
    rmq_pair (const vector<pl4> &v) : lazy_segtree<pl4, pl4, x, x>(v,
        [&](pl4 x, pl4 y) -> pl4 { return x.first < y.first ? x : y; },
        [](pl4 x, pl4 y) -> pl4 { return y; },
        [](pl4 x, pl4 y) -> pl4 { return x.first < y.first ? x : y; },
        [](pl4 x, ll y) -> pl4 { return x; },
        [](pl4 x) -> pl4 { return x; }) {}
};

// 処理内容
int main() {
    
    ll n, q; cin >> n >> q;
    vector<pair<ll, ll>> a(n);
    REP(i, n) {
        cin >> a[i].first;
        a[i].second = i+1;
    }

    rmq_pair rmq(a);

    REP(t, q) {
        ll qr, i, j;
        cin >> qr >> i >> j;
        if (qr == 1) {
            ll ai = rmq.fetch(i-1, i).first;
            ll aj = rmq.fetch(j-1, j).first;
            rmq.apply(i-1, i, pair<ll, ll>(aj, i));
            rmq.apply(j-1, j, pair<ll, ll>(ai, j));
        } else {
            pair<ll, ll> ans = rmq.fetch(i, j+1);
            cout << ans.second << endl;
        }
        
    }
    
}