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

#include <bits/stdc++.h>

int ri() {
	int n;
	scanf("%d", &n);
	return n;
}
int64_t rs64() {
	int64_t n;
	scanf("%" SCNd64, &n);
	return n;
}
#define INF 1000000000000000000
struct SegTree {
	struct Node {
		int64_t sum = 0;
		int64_t min = INF;
		int min_cnt = 1;
		int64_t min2 = INF;
		int64_t max = -INF;
		int max_cnt = 1;
		int64_t max2 = -INF;
		int64_t add = 0;
		int64_t chmin = INF;
		int64_t chmax = -INF;
		int l;
		int r;
		Node () = default;
		Node (int64_t n) : sum(n), min(n), max(n) {}
	};
	int n;
	std::vector<Node> nodes;
	SegTree (const std::vector<int64_t> &a) {
		for (n = 1; n < (int) a.size(); n <<= 1);
		nodes.resize(n << 1);
		for (int i = 0; i < (int) a.size(); i++) nodes[i + n] = Node(a[i]);
		for (int i = 0; i < n; i++) nodes[i + n].l = i, nodes[i + n].r = i + 1;
		for (int i = n; --i; ) fetch(i);
	}
	void fetch(int i) {
		Node &node = nodes[i];
		const Node &l = nodes[i << 1];
		const Node &r = nodes[i << 1 | 1];
		node.sum = l.sum + r.sum;
		if (l.min < r.min) node.min = l.min, node.min_cnt = l.min_cnt, node.min2 = std::min(l.min2, r.min);
		else if (l.min > r.min) node.min = r.min, node.min_cnt = r.min_cnt, node.min2 = std::min(l.min, r.min2);
		else node.min = l.min, node.min_cnt = l.min_cnt + r.min_cnt, node.min2 = std::min(l.min2, r.min2);
		if (l.max > r.max) node.max = l.max, node.max_cnt = l.max_cnt, node.max2 = std::max(l.max2, r.max);
		else if (l.max < r.max) node.max = r.max, node.max_cnt = r.max_cnt, node.max2 = std::max(l.max, r.max2);
		else node.max = l.max, node.max_cnt = l.max_cnt + r.max_cnt, node.max2 = std::max(l.max2, r.max2);
		node.l = l.l;
		node.r = r.r;
	}
	void flush(int i) {
		Node &node = nodes[i];
		if (node.add) {
			node.sum += (node.r - node.l) * node.add;
			node.min += node.add;
			node.max += node.add;
			if (node.min2 != INF) node.min2 += node.add;
			if (node.max2 != -INF) node.max2 += node.add;
			if (i < n) {
				nodes[i << 1].add += node.add;
				nodes[i << 1 | 1].add += node.add;
				if (nodes[i << 1].chmin != INF) nodes[i << 1].chmin += node.add;
				if (nodes[i << 1 | 1].chmin != INF) nodes[i << 1 | 1].chmin += node.add;
				if (nodes[i << 1].chmax != -INF) nodes[i << 1].chmax += node.add;
				if (nodes[i << 1 | 1].chmax != -INF) nodes[i << 1 | 1].chmax += node.add;
			}
			node.add = 0;
		}
		if (node.chmin != INF) {
			if (i < n) {
				nodes[i << 1].chmin = std::min(nodes[i << 1].chmin, node.chmin);
				nodes[i << 1 | 1].chmin = std::min(nodes[i << 1 | 1].chmin, node.chmin);
				nodes[i << 1].chmax = std::min(nodes[i << 1].chmax, node.chmin);
				nodes[i << 1 | 1].chmax = std::min(nodes[i << 1 | 1].chmax, node.chmin);
			}
			if (node.chmin < node.max2) {
				flush(i << 1);
				flush(i << 1 | 1);
				fetch(i);
			} else if (node.chmin < node.max) {
				node.sum -= (node.max - node.chmin) * node.max_cnt;
				if (node.min == node.max) node.min = node.chmin;
				else node.min2 = std::min(node.min2, node.chmin);
				node.max = node.chmin;
			}
			node.chmin = INF;
		}
		if (node.chmax != -INF) {
			if (i < n) {
				nodes[i << 1].chmax = std::max(nodes[i << 1].chmax, node.chmax);
				nodes[i << 1 | 1].chmax = std::max(nodes[i << 1 | 1].chmax, node.chmax);
			}
			if (node.chmax > node.min2) {
				flush(i << 1);
				flush(i << 1 | 1);
				fetch(i);
			} else if (node.chmax > node.min) {
				node.sum += (node.chmax - node.min) * node.min_cnt;
				if (node.max == node.min) node.max = node.chmax;
				else node.max2 = std::max(node.max2, node.chmax);
				node.min = node.chmax;
			}
			node.chmax = -INF;
		}
	}
	template<class T> void update(int l, int r, const T &func, int node_id) {
		Node &node = nodes[node_id];
		flush(node_id);
		if (r <= node.l || l >= node.r) return;
		if (l <= node.l && r >= node.r) {
			func(node);
			flush(node_id);
		} else {
			update(l, r, func, node_id << 1);
			update(l, r, func, node_id << 1 | 1);
			fetch(node_id);
		}
	}
	void add(int l, int r, int64_t val) {
		update(l, r, [&] (Node &node) { node.add = val; }, 1);
	}
	void chmin(int l, int r, int64_t val) {
		update(l, r, [&] (Node &node) { node.chmin = val; }, 1);
	}
	void chmax(int l, int r, int64_t val) {
		update(l, r, [&] (Node &node) { node.chmax = val; }, 1);
	}
	int64_t sum(int l, int r, int node_id = 1) {
		Node &node = nodes[node_id];
		flush(node_id);
		if (r <= node.l || l >= node.r) return 0;
		if (l <= node.l && r >= node.r) return node.sum;
		int64_t res =
			sum(l, r, node_id << 1) +
			sum(l, r, node_id << 1 | 1);
		fetch(node_id);
		return res;
	}
};

int main(){
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	ll n,q; cin >> n >> q;
	ll res=(n-2)*(n-2);
	vector<int64_t> v(n,n),vv(n,n);
	SegTree seg1(v),seg2(vv);
	while(q--){
		int t,x; cin >> t >> x;
		if(x==1)continue;
		if(t==1){
			int a=seg1.sum(x,x+1);
			res-=a-2;
			seg2.chmin(0,a,x);
		}
		else{
			int a=seg2.sum(x,x+1);
			res-=a-2;
			seg1.chmin(0,a,x);
		}
	} 
	cout << res << endl;
}

Measured memory_bytes: 96404