/**
 * 论文题 :
 * ·首先，找到一个特殊的拓扑序。像一般的拓扑排序那样，每次删去一个入度为0的点并加到拓扑序中。
 * 	但此处，如果有多个入度为 0 的点，设 N(v) 为v的入边被删除的时间的集合。
 * 	我们将每个 N(v) 中的元素降序排列后寻找字典序最小的 N(v) （换句话说，尽可能早地被减小入度的 v ），
 * 	并在这一轮中选择 v.
 * ·然后，逆着拓扑序反着求答案。每次取两个在拓扑序中最靠后的，出度为 0 的点删去，并加到答案的前端。
*/

#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
#include <queue>
using namespace std;
using PII = pair <int, int>;
const int N = 1e5 + 10;
const int inf = 1e9;

inline int R() {
	int x = 0; char c = getchar(); while (!isdigit(c)) c = getchar();
	while (isdigit(c)) x = x * 10 + c - '0', c = getchar(); return x;
}

int n;

struct BIT {
	int b[N];
	void upd(int x, int v) {while (x) {b[x] = max(b[x], v); x &= x - 1;}}
	int qry(int x) {int res = 0; while (x <= n) {res = max(res, b[x]); x += x & -x;} return res;}
} bit;

struct SegInSeg {
	struct Node {int mx, ls, rs;} t[N * 700]; int tot;
		#define mid (l + r >> 1)
		#define lrt (t[rt].ls)
		#define rrt (t[rt].rs)
		int Rt[N << 2];
		void upd_(int p, int v, int l, int r, int &rt) {
			if (!rt) rt = ++tot;
			if (l == r) {t[rt].mx = v; return ;}
			if (p <= mid) upd_(p, v, l, mid, lrt);
			else upd_(p, v, mid + 1, r, rrt);
			t[rt].mx = max(t[lrt].mx, t[rrt].mx);
		}
		void upd_(int p, int v, int rt) {upd_(p, v, 1, n, Rt[rt]);}

		int qry_(int ll, int rr, int l, int r, int rt) {
			if (!rt) return 0;
			if (ll <= l && r <= rr) return t[rt].mx;
			if (rr <= mid) return qry_(ll, rr, l, mid, lrt);
			if (mid < ll) return qry_(ll, rr, mid + 1, r, rrt);
			return max(qry_(ll, rr, l, mid, lrt), qry_(ll, rr, mid + 1, r, rrt));
		}
		int qry_(int l, int r, int rt) {return qry_(l, r, 1, n, Rt[rt]);}
		#undef mid
		#undef lrt
		#undef rrt
	#define mid (l + r >> 1)
	#define lrt (rt << 1)
	#define rrt (rt << 1 | 1)
	void upd(int x, int y, int v, int l = 1, int r = n, int rt = 1) {
		upd_(y, v, rt);
		if (l == r) return ;
		if (x <= mid) upd(x, y, v, l, mid, lrt);
		else upd(x, y, v, mid + 1, r, rrt);
	}

	int qry(int xl, int xr, int yl, int yr, int l = 1, int r = n, int rt = 1) {
		if (xl > xr || yl > yr) return 0;
		if (xl <= l && r <= xr) return qry_(yl, yr, rt);
		if (xr <= mid) return qry(xl, xr, yl, yr, l, mid, lrt);
		if (mid < xl) return qry(xl, xr, yl, yr, mid + 1, r, rrt);
		return max(qry(xl, xr, yl, yr, l, mid, lrt), qry(xl, xr, yl, yr, mid + 1, r, rrt));
	}
	#undef mid
	#undef lrt
	#undef rrt
} sis;

int h[N], a[N], b[N];
int level[N];

vector <PII> ans;
priority_queue <int> q;

struct Seg {
	struct Node {int mn; bool vis, tag;} t[N << 2];
	#define mid (l + r >> 1)
	#define lrt (rt << 1)
	#define rrt (rt << 1 | 1)

	void build(int l = 1, int r = n, int rt = 1) {
		if (l == r) {t[rt].mn = h[l]; return ;}
		build(l, mid, lrt); build(mid + 1, r, rrt);
		t[rt].mn = min(t[lrt].mn, t[rrt].mn);
	}

	/**
	 * @brief: 找 h[x] 前的第一个大于等于 h[x] 的数
	*/
	int prv(int x, int l = 1, int r = n, int rt = 1) {
		if (t[rt].mn >= h[x]) return 0;
		if (l == r) return l;
		if (x <= mid) return prv(x, l, mid, lrt);
		int res = prv(x, mid + 1, r, rrt);
		if (!res) res = prv(x, l, mid, lrt);
		return res;
	}

	// ---

	void pushdown(int rt) {
		if (t[rt].tag) {
			t[lrt].vis = t[rrt].vis = 0;
			t[lrt].tag = t[rrt].tag = 1;
			t[rt].tag = 0;
		}
	}

	/**
	 * @brief: 删除区间的 vis 标记
	*/
	void undo(int ll, int rr, int l = 1, int r = n, int rt = 1) {
		t[rt].vis = 0;
		if (ll <= l && r <= rr) {t[rt].tag = 1; return ;}
		pushdown(rt);
		if (ll <= mid) undo(ll, rr, l, mid, lrt);
		if (mid < rr) undo(ll, rr, mid + 1, r, rrt);
	}

	// 同下
	void erase(int x, int l, int r, int rt) {
		if (l == r) {t[rt].mn = inf; return ;}
		if (x <= mid) erase(x, l, mid, lrt);
		else erase(x, mid + 1, r, rrt);
		t[rt].mn = min(t[lrt].mn, t[rrt].mn);
	}
	/**
	 * @brief: 从序列中删除 h[x] (体现为 h[x] 置 inf), 并删除 (prv(x), x] 的标记 (使之可搜索)
	*/
	void erase(int x) {undo(prv(x) + 1, x); erase(x, 1, n, 1);}

	// 同下
	void search(vector <int> &res, int rmn, int l, int r, int rt) {
		if (t[rt].mn >= rmn || t[rt].vis) return ;
		t[rt].vis = 1;
		if (l == r) {res.push_back(l); return ;}
		pushdown(rt);
		search(res, rmn, mid + 1, r, rrt);
		search(res, min(rmn, t[rrt].mn), l, mid, lrt);
	}
	/**
	 * @brief: 查询后缀最小值
	*/
	vector <int> search() {vector <int> res; search(res, inf, 1, n, 1); return res;}

	#undef mid
	#undef lrt
	#undef rrt
} seg;

int main() {
	n = R();
	for (int i = 1; i <= n; ++i) {
		h[i] = R();
		level[i] = bit.qry(h[i] + 1);
		bit.upd(h[i], level[i] + 1);
		a[i] = i;
	}
	sort(a + 1, a + n + 1, [](int x, int y) {
		return level[x] < level[y];
	});
	for (int l = 1, r; l <= n; l = r + 1) {
		r = l;
		while (r < n && level[r + 1] == level[l]) ++r;
		sort(a + l, a + r + 1, [](int x, int y) {
			bool flag = 0;
			if (x > y) swap(x, y), flag = 1;
			int X = sis.qry(1, x - 1, h[x] + 1, h[y]), Y = sis.qry(x + 1, y - 1, h[y] + 1, n);
			return X ^ Y ? (X < Y) ^ flag : 0;
		});
		for (int i = l; i <= r; ++i) sis.upd(a[i], h[a[i]], i);
	}
	for (int i = 1; i <= n; ++i)
		b[a[i]] = i;
	seg.build();
	while (1) {
		auto res = seg.search();
		for (auto i : res) q.push(b[i]);
		if (q.empty()) break;
		int x = q.top(); q.pop(); seg.erase(a[x]);
		int y = x;
		if (!q.empty()) y = q.top(), q.pop(), seg.erase(a[y]);
		ans.push_back({h[a[x]], h[a[y]]});
	}
	reverse(ans.begin(), ans.end());
	printf("%d\n", ans.size());
	for (auto i : ans)
		printf("%d %d\n", i.first, i.second);
	return 0;
}