#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstdio>
#include <cstdint>
#include <set>
#include <map>
#include <deque>
#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <chrono>
#include <ctime>
#include <random>
using namespace std;
#define int long long
#define all(x) (x).begin(), (x).end()
#define rep(n) for (int rep_i = 0; rep_i < n; rep_i++)
#define cin(v) for (auto& e : v) cin >> e;
#define cout(v) for (auto e : v) cout << e << " "; cout << endl;
using ll = long long;
using ull = unsigned long long;
using db = double;
using i32 = int32_t;
using vi = vector <int>;
using vll = vector <ll>;
using pii = pair <int, int>;
using pll = pair <ll, ll>;
#define sq(x) ((x) * (x))
mt19937 rng(time(0));
int rand(int l, int r) {
	return (rng() % (r - l + 1)) + l;
}
void fastw() {
	ios_base::sync_with_stdio(0); cin.tie(0);
}

void solve();

signed main() {
#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin);
#endif
	fastw();
	solve();
}

const int md = 998244353;

int binpow(int a, int b) {
	int res = 1;
	while (b) {
		if (b & 1) {
			res = (res * a) % md;
		}
		a = (a * a) % md;
		b >>= 1;
	}

	return res;
}

void solve() {
	int n, q;
	cin >> n >> q;
	vector <int> a(n);
	cin(a);

	rep(q) {
		int t, x; cin >> t >> x;
		if (t == 1) {
			swap(a[x - 1], a[x]);
		}
		else {
			x--;
			set <pii> st;
			for (int i = 0; i < n; i++) {
				int j = i;
				while (j < n && a[i] == a[j]) {
					j++;
				}
				j--;
				st.insert({ i, j });
				//[cout << i << " " << j << end
				i = j;
			}
			vector <int> order;
			set <int> st2;
			for (int i = 0; i < n; i++) st2.insert(i);
			int cur = -1;
			while (1) {
				if (st.size() == 0) break;
				pii fir = *st.begin();
				if (cur == -1) {
					order.push_back(fir.first);
					st2.erase(fir.first);
					pair <int, int> nw = { fir.first + 1, fir.second };
					cur = a[fir.first];
					st.erase(st.begin());
					if (nw.first <= nw.second)
						st.insert(nw);
				}
				else {
					if (a[fir.first] != cur) {
						order.push_back(fir.first);
						st2.erase(fir.first);
						pair <int, int> nw = { fir.first + 1, fir.second };
						cur = a[fir.first];
						st.erase(st.begin());
						if (nw.first <= nw.second)
							st.insert(nw);
					}
					else {
						auto it = st.begin();
						while (it != st.end() && a[it->first] == cur) it++;
						if (it == st.end()) break;
						pii sec = *it;
						order.push_back(sec.first);
						st2.erase(sec.first);
						pair <int, int> nw = { sec.first + 1, sec.second };
						cur = a[sec.first];
						st.erase(st.find(sec));
						if (nw.first <= nw.second)
							st.insert(nw);
					}
				}
			}
			set <int> st3;
			for (auto e : st2) {
				order.push_back(e);
			}

			for (int i = 0; i < n; i++) {
				if (order[i] == x) {
					cout << i + 1 << endl;
				}
			}
		}
	}

	//int n, q; cin >> n >> q;
	//vector <int> p(n); cin(p);
	//vector <int> b(q); cin(b);
	//vector <int> orig = p;
	//auto get = [&](const vector<int>& A) {
	//	int r = 0;
	//	for (int i = 0; i < n; i++) {
	//		r += binpow(A[i], i + 1);
	//		r %= md;
	//	}
	//	return r;
	//};

	//auto _2 = [&](vector <int>& A) {
	//	for (int i = 0; i < n; i++) {
	//		A[i] = n - A[i] + 1;
	//	}
	//};

	//if (n <= 1000 && q <= 1000) {
	//	for (auto qr : b) {
	//		int r = 0;
	//		if (qr == 1) {
	//			reverse(all(p));
	//		}
	//		else if (qr == 2) {
	//			for (int i = 0; i < n; i++) {
	//				p[i] = n - p[i] + 1;
	//			}
	//		}
	//		else {
	//			vector <int> nw(n);
	//			for (int i = 0; i < n; i++) {
	//				nw[p[i] - 1] = i + 1;
	//			}
	//			p = nw;
	//		}
	//		for (int i = 0; i < n; i++) {
	//			r += binpow(p[i], i + 1);
	//			r %= md;
	//		}
	//		cout << r << " ";
	//	}
	//	cout << endl;
	//	//return;
	//}

	//if (*max_element(all(b)) == *min_element(all(b))) {
	//	int t = b[0];
	//	int st = 0;

	//	for (int i = 0; i < n; i++) {
	//		st += binpow(p[i], i + 1);
	//		st %= md;
	//	}

	//	int r = 0;
	//	if (t == 1) {
	//		reverse(all(p));
	//	}
	//	else if (t == 2) {
	//		for (int i = 0; i < n; i++) {
	//			p[i] = n - p[i] + 1;
	//		}
	//	}
	//	else {
	//		vector <int> nw(n);
	//		for (int i = 0; i < n; i++) {
	//			nw[p[i] - 1] = i + 1;
	//		}
	//		p = nw;
	//	}

	//	for (int i = 0; i < n; i++) {
	//		r += binpow(p[i], i + 1);
	//		r %= md;
	//	}

	//	int fl = 0;
	//	rep(q) {
	//		if (fl) {
	//			cout << st << " ";
	//		}
	//		else {
	//			cout << r << " ";
	//		}
	//		fl ^= 1;
	//	}
	//	return;
	//}

	//if (*max_element(all(b)) <= 2) {
	//	p = orig;
	//	reverse(all(p));
	//	int fir = get(p);
	//	//cout << fir << endl;
	//	vector <int> al = { fir };
	//	_2(p);
	//	int cur = get(p);
	//	int fl = 0;
	//	while (cur != fir) {
	//		al.push_back(cur);
	//		if (fl) {
	//			_2(p);
	//		}
	//		else {
	//			reverse(all(p));
	//		}
	//		cur = get(p);
	//		fl ^= 1;
	//	}
	//	
	//	p = orig;
	//	_2(p);
	//	fir = get(p);
	//	vector <int> al2 = { fir };
	//	reverse(all(p));
	//	cur = get(p);
	//	fl = 0;
	//	while (cur != fir) {
	//		al2.push_back(cur);
	//		if (fl) {
	//			reverse(all(p));
	//		}
	//		else {
	//			_2(p);
	//		}

	//		cur = get(p);
	//		fl ^= 1;
	//	}

	//	vector <int> ans(q);
	//	cout << endl;
	//	cout(al);
	//	cout(al2);
	//	cout << endl;
	//	int sus = 1;
	//	if (b[0] == 2) sus = 2;
	//	int last_1 = -1, last_2 = -1;
	//	int FIRST = get(orig);
	//	bool ok = 0, ok2 = 0, ok3 = 0;
	//	int F = 0;
	//	int S = 0;
	//	for (int i = 0; i < q; i++) {

	//		int qr = b[i];
	//		int kol = 0;
	//		int j = i;
	//		if (ok3) {
	//			if (sus == 1) sus = 2;
	//			else sus = 1;
	//		}
	//		while (j < q && b[j] == b[i]) {
	//			j++; kol++;
	//		}
	//		j--;
	//		if (qr == 1) {
	//			F += (j - i + 1);
	//		}
	//		else {
	//			S += (j - i + 1);
	//		}
	//		int st = 0;
	//		if (qr == 1) st = al[0];
	//		else st = al2[0];

	//		if (i != 0) {
	//			if (sus == 1) {
	//				st = find(all(al), ans[i - 1]) - al.begin();
	//				st++; st %= al.size();
	//				st = al[st];
	//			}
	//			else {
	//				st = find(all(al2), ans[i - 1]) - al2.begin();
	//				st++; st %= al2.size();
	//				st = al2[st];
	//			}
	//		}
	//		int st2 = FIRST;
	//		if (i != 0) {
	//			st2 = ans[i - 1];
	//		}

	//		fl = 1;

	//		if (ok) {
	//			if (qr == 1) {
	//				st = al[0];
	//			}
	//			else {
	//				st = al2[0];
	//			}

	//			st2 = FIRST;
	//		}

	//		if (ok2) {
	//			if (qr == 1) {
	//				if (last_1 != -1) {
	//					if (last_1 <= 0) {
	//						st = FIRST;
	//					}
	//					else {
	//						st = ans[last_1 - 1];
	//					}

	//					st2 = ans[last_1];
	//				}
	//				else {
	//					st = al[0];
	//					st2 = FIRST;
	//				}
	//			}
	//			else {
	//				if (last_2 != -1) {
	//					if (last_2 == 0) {
	//						st = FIRST;
	//					}
	//					else {
	//						st = ans[last_2 - 1];
	//					}

	//					st2 = ans[last_2];
	//				}
	//				else {
	//					st = al2[0];
	//					st2 = FIRST;
	//				}
	//			}
	//		}

	//		ans[i] = st;

	//		for (int k = i + 1; k <= j; k++) {
	//			if (fl) {
	//				ans[k] = st2;
	//			}
	//			else {
	//				ans[k] = st;
	//			}
	//			fl ^= 1;
	//		}

	//		if (qr == 1) last_1 = j;
	//		else last_2 = j;
	//		if (kol & 1) {
	//			i = j; ok = 0; ok2 = 0;
	//			if (qr == 1 && F & 1 ^ 1) {
	//				ok3 = 1;
	//				F = 0;
	//			}
	//			else if (qr == 2 && S & 1 ^ 1) {
	//				ok3 = 1;
	//				S = 0;
	//			}
	//			continue;
	//		}

	//		if (i == 0) {
	//			ok = 1;
	//		}
	//		else {
	//			ok = 0;
	//		}

	//		ok2 = 1;

	//		i = j;
	//		/*else {
	//			if (b[i] != b[i - 1]) {
	//				if (sus == 1) {
	//					int prev = ans[i - 1];
	//					int j = find(all(al), prev) - al.begin();
	//					j++; j %= al.size();
	//					ans[i] = al[j];
	//				}
	//				else {
	//					int prev = ans[i - 1];
	//					int j = find(all(al2), prev) - al2.begin();
	//					j++; j %= al2.size();
	//					ans[i] = al2[j];
	//				}
	//			}
	//		}*/
	//	}
	//	for (auto e : ans) {
	//		cout << e << " ";
	//	}
	//	cout << endl;
	//	return;
	//}

	// 3225 215 1175 303 3225 215
}