//高知能系Vtuberの高井茅乃です。
//Twitter: https://twitter.com/takaichino
//YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

#define INF INT_MAX
#define LLINF LLONG_MAX
#define REP(i,n) for(int i=0;i<n;i++)
#define REP1(i,n) for(int i=1;i<=n;i++)
#define MODA 1000000007
#define MODB  998244353 

template <typename T>
std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
    for (T& x: vec) { is >> x; }
    return is;
}

//ei1333さんのGitHubから https://ei1333.github.io/luzhiled/
//SegmentTree(n, f, M1):= サイズ n の初期化。ここで f は2つの区間の要素をマージする二項演算, M1はモノイドの単位元である。
	//1-originであることに注意されたし。
	//例: llで区間の最大値を取るセグ木: SegmentTree<ll> st(n, [](int a, int b){return max(a, b);}, LLINF) st;
//set(k, x):= k 番目の要素に xを代入する。
//build():= セグメント木を構築する。
//query(a, b):= 区間 [a,b)に対して二項演算した結果を返す。
//update(k, x):= k 番目の要素を xに変更する。
//operator[k] := k番目の要素を返す。
//find_first(a, check) := [a,x) が check を満たす最初の要素位置 xを返す。
	//例: Y = f[a, x)が初めてZを超すときのxを返す
	//st.find_first<function < bool(ll) > >(i, [](ll Y){if(Y>Z)return true; else return false;});
//find_last(b, check) := [x,b) が check を満たす最後の要素位置 x を返す。
//初期化の例:SegmentTree< int > seg(N, [](int a, int b) { return min(a, b); }, INT_MAX);
template< typename Monoid >
struct SegmentTree {
	using F = function< Monoid(Monoid, Monoid) >;

	int sz;
	vector< Monoid > seg;

	const F f;
	const Monoid M1;

	SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
		sz = 1;
		while(sz < n) sz <<= 1;
		seg.assign(2 * sz, M1);
	}

	void set(int k, const Monoid &x) {
		seg[k + sz] = x;
	}

	void build() {
		for(int k = sz - 1; k > 0; k--) {
			seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
		}
	}

	void update(int k, const Monoid &x) {
		k += sz;
		seg[k] = x;
		while(k >>= 1) {
			seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
		}
	}

	Monoid query(int a, int b) {
		Monoid L = M1, R = M1;
		for(a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
			if(a & 1) L = f(L, seg[a++]);
			if(b & 1) R = f(seg[--b], R);
		}
		return f(L, R);
	}

	Monoid operator[](const int &k) const {
		return seg[k + sz];
	}

	template< typename C >
	int find_subtree(int a, const C &check, Monoid &M, bool type) {
		while(a < sz) {
			Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]);
			if(check(nxt)) a = 2 * a + type;
			else M = nxt, a = 2 * a + 1 - type;
		}
		return a - sz;
	}


	template< typename C >
	int find_first(int a, const C &check) {
		Monoid L = M1;
		if(a <= 0) {
			if(check(f(L, seg[1]))) return find_subtree(1, check, L, false);
			return -1;
		}
		int b = sz;
		for(a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
			if(a & 1) {
				Monoid nxt = f(L, seg[a]);
				if(check(nxt)) return find_subtree(a, check, L, false);
				L = nxt;
				++a;
			}
		}
		return -1;
	}

	template< typename C >
	int find_last(int b, const C &check) {
		Monoid R = M1;
		if(b >= sz) {
			if(check(f(seg[1], R))) return find_subtree(1, check, R, true);
			return -1;
		}
		int a = sz;
		for(b += sz; a < b; a >>= 1, b >>= 1) {
			if(b & 1) {
				Monoid nxt = f(seg[--b], R);
				if(check(nxt)) return find_subtree(b, check, R, true);
				R = nxt;
			}
		}
		return -1;
	}
};

int main() {
	ll ans = 0;
	ll tmp;
	ll n; cin >> n;
	ll q; cin >> q;
	ans = (n-2)*(n-2);
	SegmentTree<ll> st1(n, [](int a, int b){return min(a, b);}, n-2);
	SegmentTree<ll> st2(n, [](int a, int b){return min(a, b);}, n-2);
	st1.build();
	st2.build();
	int x, y;
	REP(i, q){
		cin >> x >> y;
		y--;
		if(x == 1){
			tmp = st1.query(y, n);
			ans -= tmp;
			if(st2[tmp+1] > y-1) st2.update(tmp+1, y-1);
		} 
		else {
			tmp = st2.query(y, n);
			ans -= tmp;
			if(st1[tmp+1] > y-1) st1.update(tmp+1, y-1);
		} 
		//cout << tmp <<endl;
	}

	cout << ans << endl;
}

Measured memory_bytes: 11420