// Problem: P11367 [Ynoi2024] 魔法少女网站第二部
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P11367
// Memory Limit: 512 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define uint unsigned
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<ll, ll> pii;

namespace IO {
	const int maxn = 1 << 20;
	
    char ibuf[maxn], *iS, *iT, obuf[maxn], *oS = obuf;

	inline char gc() {
		return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, maxn, stdin), (iS == iT ? EOF : *iS++) : *iS++);
	}

	template<typename T = int>
	inline T read() {
		char c = gc();
		T x = 0;
		bool f = 0;
		while (c < '0' || c > '9') {
			f |= (c == '-');
			c = gc();
		}
		while (c >= '0' && c <= '9') {
			x = (x << 1) + (x << 3) + (c ^ 48);
			c = gc();
		}
		return f ? ~(x - 1) : x;
	}

	inline void flush() {
		fwrite(obuf, 1, oS - obuf, stdout);
		oS = obuf;
	}
	
	struct Flusher {
		~Flusher() {
			flush();
		}
	} AutoFlush;

	inline void pc(char ch) {
		if (oS == obuf + maxn) {
			flush();
		}
		*oS++ = ch;
	}

	template<typename T>
	inline void write(T x) {
		static char stk[64], *tp = stk;
		if (x < 0) {
			x = ~(x - 1);
			pc('-');
		}
		do {
			*tp++ = x % 10;
			x /= 10;
		} while (x);
		while (tp != stk) {
			pc((*--tp) | 48);
		}
	}
	
	template<typename T>
	inline void writesp(T x) {
		write(x);
		pc(' ');
	}
	
	template<typename T>
	inline void writeln(T x) {
		write(x);
		pc('\n');
	}
}

using IO::read;
using IO::write;
using IO::pc;
using IO::writesp;
using IO::writeln;

const int maxn = 2000100;
const int logn = 22;
const int inf = 0x3f3f3f3f;

int n, m, a[maxn], b[maxn], lsh[maxn], tot, f[logn][maxn];

struct node {
	int l, r;
} c[maxn];

ll ans[maxn];

inline int qmin(int l, int r) {
	if (l > r) {
		return inf;
	}
	int k = __lg(r - l + 1);
	return min(f[k][l], f[k][r - (1 << k) + 1]);
}

inline int qmax(int l, int r) {
	if (l > r) {
		return 0;
	}
	int k = __lg(r - l + 1);
	return max(f[k][l], f[k][r - (1 << k) + 1]);
}

struct List {
	int hd[maxn], len, val[maxn << 1], nxt[maxn << 1];
	
	inline void add(int x, int y) {
		val[++len] = y;
		nxt[len] = hd[x];
		hd[x] = len;
	}
} G;

namespace BIT {
	ll c[maxn];
	
	inline void update(int x, int d) {
		for (int i = x; i <= n; i += (i & (-i))) {
			c[i] += d;
		}
	}
	
	inline ll query(int x) {
		ll res = 0;
		for (int i = x; i; i -= (i & (-i))) {
			res += c[i];
		}
		return res;
	}
	
	inline ll query(int l, int r) {
		return query(r) - query(l - 1);
	}
	
	inline void clear(int x) {
		for (int i = x; i <= n; i += (i & (-i))) {
			c[i] = 0;
		}
	}
}

struct DS {
	int a[maxn], b[maxn], n;
	
	inline void init(int _n) {
		n = _n;
		for (int i = 0; i <= n; ++i) {
			a[i] = 0;
			b[i] = inf;
		}
	}
	
	inline void insert(int x) {
		for (int i = x; i <= n; i += (i & (-i))) {
			a[i] = max(a[i], x);
		}
		for (int i = x; i; i -= (i & (-i))) {
			b[i] = min(b[i], x);
		}
	}
	
	inline int prev(int x) {
		int res = 0;
		for (int i = x; i; i -= (i & (-i))) {
			res = max(res, a[i]);
		}
		return res;
	}
	
	inline int next(int x) {
		int res = inf;
		for (int i = x; i <= n; i += (i & (-i))) {
			res = min(res, b[i]);
		}
		return res;
	}
	
	inline void clear(int x) {
		for (int i = x; i <= n; i += (i & (-i))) {
			a[i] = 0;
		}
		for (int i = x; i; i -= (i & (-i))) {
			b[i] = inf;
		}
	}
} S;

void dfs(int l, int r, vector<int> Q) {
	if (l == r || Q.empty()) {
		return;
	}
	int mid = (l + r) >> 1;
	G.len = tot = 0;
	for (int i = l; i <= r; ++i) {
		G.hd[i] = 0;
		lsh[++tot] = a[i];
	}
	// sort(lsh + 1, lsh + tot + 1);
	for (int i = l; i <= r; ++i) {
		// a[i] = lower_bound(lsh + 1, lsh + tot + 1, a[i]) - lsh;
		b[a[i]] = i;
	}
	vector<int> L, R;
	for (int i : Q) {
		if (c[i].r <= mid) {
			L.pb(i);
		} else if (c[i].l > mid) {
			R.pb(i);
		} else {
			G.add(c[i].l, i);
			G.add(c[i].r, i);
		}
	}
	// ll s = 0;
	// int mn = inf, mx = 0;
	// for (int i = 1; i <= tot; ++i) {
		// f[0][i] = inf;
	// }
	// for (int i = mid + 1; i <= r; ++i) {
		// f[0][a[i]] = i;
	// }
	// for (int j = 1; (1 << j) <= tot; ++j) {
		// for (int i = 1; i + (1 << j) - 1 <= tot; ++i) {
			// f[j][i] = min(f[j - 1][i], f[j - 1][i + (1 << (j - 1))]);
		// }
	// }
	// S.init(tot);
	// for (int i = mid; i >= l; --i) {
		// mn = min(mn, a[i]);
		// mx = max(mx, a[i]);
		// int j = S.prev(a[i]), k = S.next(a[i]);
		// S.insert(a[i]);
		// if (j) {
			// s += abs(i - b[j]);
			// int t = qmin(j + 1, a[i] - 1);
			// if (t <= r) {
				// BIT::update(t, (mid - max(i, b[j])) * 2);
			// }
		// }
		// if (k <= n) {
			// s += abs(i - b[k]);
			// int t = qmin(a[i] + 1, k - 1);
			// if (t <= r) {
				// BIT::update(t, (mid - max(i, b[k])) * 2);
			// }
		// }
		// if (j && k <= n) {
			// s -= abs(b[j] - b[k]);
			// int t = qmin(j + 1, k - 1);
			// if (t <= r) {
				// BIT::update(t, -(mid - max(b[j], b[k])) * 2);
			// }
		// }
		// for (int _ = G.hd[i]; _; _ = G.nxt[_]) {
			// int j = G.val[_];
			// ans[j] += s + BIT::query(mid + 1, c[j].r);
			// if (qmin(mx + 1, tot) <= c[j].r) {
				// ans[j] += mid - b[mx];
			// }
			// if (qmin(1, mn - 1) <= c[j].r) {
				// ans[j] += mid - b[mn];
			// }
		// }
	// }
	// for (int i = mid + 1; i <= r; ++i) {
		// BIT::clear(i);
	// }
	// s = mx = 0;
	// mn = inf;
	// for (int i = 1; i <= tot; ++i) {
		// f[0][i] = 0;
	// }
	// for (int i = l; i <= mid; ++i) {
		// f[0][a[i]] = i;
	// }
	// for (int j = 1; (1 << j) <= tot; ++j) {
		// for (int i = 1; i + (1 << j) - 1 <= tot; ++i) {
			// f[j][i] = max(f[j - 1][i], f[j - 1][i + (1 << (j - 1))]);
		// }
	// }
	// S.init(tot);
	// for (int i = mid + 1; i <= r; ++i) {
		// mn = min(mn, a[i]);
		// mx = max(mx, a[i]);
		// int j = S.prev(a[i]), k = S.next(a[i]);
		// S.insert(a[i]);
		// if (j) {
			// s += abs(i - b[j]);
			// int t = qmax(j + 1, a[i] - 1);
			// if (t >= l) {
				// BIT::update(t, (min(i, b[j]) - mid) * 2);
			// }
		// }
		// if (k <= n) {
			// s += abs(i - b[k]);
			// int t = qmax(a[i] + 1, k - 1);
			// if (t >= l) {
				// BIT::update(t, (min(i, b[k]) - mid) * 2);
			// }
		// }
		// if (j && k <= n) {
			// s -= abs(b[j] - b[k]);
			// int t = qmax(j + 1, k - 1);
			// if (t >= l) {
				// BIT::update(t, -(min(b[j], b[k]) - mid) * 2);
			// }
		// }
		// for (int _ = G.hd[i]; _; _ = G.nxt[_]) {
			// int j = G.val[_];
			// ans[j] += s + BIT::query(c[j].l, mid);
			// if (qmax(mx + 1, tot) >= c[j].l) {
				// ans[j] += b[mx] - mid;
			// }
			// if (qmax(1, mn - 1) >= c[j].l) {
				// ans[j] += b[mn] - mid;
			// }
		// }
	// }
	// for (int i = l; i <= mid; ++i) {
		// BIT::clear(i);
	// }
	dfs(l, mid, L);
	dfs(mid + 1, r, R);
}

void solve() {
	mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
	n = m = 2000000;
	for (int i = 1; i <= n; ++i) {
		a[i] = i;
	}
	shuffle(a + 1, a + n + 1, rnd);
	vector<int> Q;
	for (int i = 1; i <= m; ++i) {
		c[i].l = rnd() % n + 1;
		c[i].r = rnd() % n + 1;
		if (c[i].l > c[i].r) {
			swap(c[i].l, c[i].r);
		}
		if (c[i].l != c[i].r) {
			Q.pb(i);
		}
	}
	dfs(1, n, Q);
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}