// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

using LL = long long int;

#define incII(i, l, r) for(LL i = (l)    ; i <= (r); i++)

#define incIX(i, l, r) for(LL i = (l)    ; i <  (r); i++)

#define incXI(i, l, r) for(LL i = (l) + 1; i <= (r); i++)

#define incXX(i, l, r) for(LL i = (l) + 1; i <  (r); i++)

#define decII(i, l, r) for(LL i = (r)    ; i >= (l); i--)

#define decIX(i, l, r) for(LL i = (r) - 1; i >= (l); i--)

#define decXI(i, l, r) for(LL i = (r)    ; i >  (l); i--)

#define decXX(i, l, r) for(LL i = (r) - 1; i >  (l); i--)

#define inc(i, n)  incIX(i, 0, n)

#define dec(i, n)  decIX(i, 0, n)

#define inc1(i, n) incII(i, 1, n)

#define dec1(i, n) decII(i, 1, n)

auto inII = [](auto x, auto l, auto r) { return (l <= x && x <= r); };

auto inIX = [](auto x, auto l, auto r) { return (l <= x && x <  r); };

auto inXI = [](auto x, auto l, auto r) { return (l <  x && x <= r); };

auto inXX = [](auto x, auto l, auto r) { return (l <  x && x <  r); };

auto setmin   = [](auto & a, auto b) { return (b <  a ? a = b, true : false); };

auto setmax   = [](auto & a, auto b) { return (b >  a ? a = b, true : false); };

auto setmineq = [](auto & a, auto b) { return (b <= a ? a = b, true : false); };

auto setmaxeq = [](auto & a, auto b) { return (b >= a ? a = b, true : false); };

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define MT make_tuple

#define FI first

#define SE second

#define FR front()

#define BA back()

#define ALL(c) c.begin(), c.end()

#define RALL(c) c.rbegin(), c.rend()

#define RV(c) reverse(ALL(c))

#define SC static_cast

#define SI(c) SC<int>(c.size())

#define SL(c) SC<LL >(c.size())

#define RF(e, c) for(auto & e: c)

#define SF(c, ...) for(auto & [__VA_ARGS__]: c)

#define until(e) while(! (e))

#define if_not(e) if(! (e))

#define ef else if

#define UR assert(false)

auto * IS = & cin;

auto * OS = & cout;

array<string, 3> SEQ = { "", " ", "" };

// input

template<typename T> T in() { T a; (* IS) >> a; return a; }

// input: tuple

template<typename U, int I> void tin_([[maybe_unused]] U & t) { }

template<typename U, int I, typename A, typename ... B> void tin_(U & t) { (* IS) >> get<I>(t); tin_<U, I + 1, B ...>(t); }

template<typename ... T> auto tin() { tuple<T ...> t; tin_<tuple<T ...>, 0, T ...>(t); return t; }

// input: array

template<typename T, int N> auto ain() { array<T, N> a; inc(i, N) { (* IS) >> a[i]; } return a; }

// input: multi-dimensional vector

template<typename T> T vin() { T v; (* IS) >> v; return v; }

template<typename T, typename N, typename ... M> auto vin(N n, M ... m) {

	vector<decltype(vin<T, M ...>(m ...))> v(n); inc(i, n) { v[i] = vin<T, M ...>(m ...); } return v;

}

// input: multi-column (tuple<vector>)

template<typename U, int I> void colin_([[maybe_unused]] U & t) { }

template<typename U, int I, typename A, typename ... B> void colin_(U & t) {

	get<I>(t).PB(in<A>()); colin_<U, I + 1, B ...>(t);

}

template<typename ... T> auto colin(int n) {

	tuple<vector<T> ...> t; inc(i, n) { colin_<tuple<vector<T> ...>, 0, T ...>(t); } return t;

}

// output

void out_([[maybe_unused]] string s) { }

template<typename A> void out_([[maybe_unused]] string s, A && a) { (* OS) << a; }

template<typename A, typename ... B> void out_(string s, A && a, B && ... b) { (* OS) << a << s; out_(s, b ...); }

auto outF = [](auto x, auto y, auto z, auto ... a) { (* OS) << x; out_(y, a ...); (* OS) << z << flush; };

auto out  = [](auto ... a) { outF("", " " , "\n", a ...); };

auto outS = [](auto ... a) { outF("", " " , " " , a ...); };

auto outL = [](auto ... a) { outF("", "\n", "\n", a ...); };

auto outN = [](auto ... a) { outF("", ""  , ""  , a ...); };

// output: multi-dimensional vector

template<typename T> ostream & operator<<(ostream & os, vector<T> const & v) {

	os << SEQ[0]; inc(i, SI(v)) { os << (i == 0 ? "" : SEQ[1]) << v[i]; } return (os << SEQ[2]);

}

template<typename T> void vout_(T && v) { (* OS) << v; }

template<typename T, typename A, typename ... B> void vout_(T && v, A a, B ... b) {

	inc(i, SI(v)) { (* OS) << (i == 0 ? "" : a); vout_(v[i], b ...); }

}

template<typename T, typename A, typename ... B> void vout (T && v, A a, B ... b) { vout_(v, a, b ...); (* OS) << a << flush; }

template<typename T, typename A, typename ... B> void voutN(T && v, A a, B ... b) { vout_(v, a, b ...); (* OS)      << flush; }



// ---- ----



template<typename T> class SegmentTree {

private:

	int n, s;

	vector<T> a;

	function<T(T &, T &)> f;

	T e;

	bool ok;

	void shift(int & p) {

		assert(inIX(p, 0, n));

		p += s;

	}

public:

	SegmentTree() { n = 0; }

	SegmentTree(int nn, function<T(T &, T &)> ff, T ee) { init(nn, ff, ee); }

	void init(int nn, function<T(T &, T &)> ff, T ee) {

		n = nn;

		f = ff;

		e = ee;

		s = 1;

		while(s < n) { s *= 2; }

		a = vector<T>(2 * s, e);

		ok = true;

	}

	void apply(int p, function<void(T &)> g) {

		shift(p);

		g(a[p]);

		while(p > 1) {

			p /= 2;

			a[p] = f(a[2 * p], a[2 * p + 1]);

		}

	}

	T fold_IX(int l, int r) {

		assert(ok);

		assert(inII(l, 0, n)); l += s;

		assert(inII(r, 0, n)); r += s; r--;

		T x = e, y = e;

		while(l <= r) {

			if(l % 2 == 1) { x = f(x, a[l]); l++; }

			if(r % 2 == 0) { y = f(a[r], y); r--; }

			l /= 2;

			r /= 2;

		}

		return f(x, y);

	}

	T fold_II(int l, int r) { return fold_IX(l + 0, r + 1); }

	T fold_XI(int l, int r) { return fold_IX(l + 1, r + 1); }

	T fold_XX(int l, int r) { return fold_IX(l + 1, r + 0); }

	const T & operator[](int p) {

		shift(p);

		return a[p];

	}

	T & ref(int p) {

		shift(p);

		ok = false;

		return a[p];

	}

	void calc() {

		dec(i, s) { a[i] = f(a[2 * i], a[2 * i + 1]); }

		ok = true;

	}

};

#define OP(s) [&](auto & A, auto & B) { return s; }

#define AP(s) [&](auto & A) { s; }



// ----



int main() {

	auto [n, Q] = tin<LL, int>();

	n -= 2;

	vector<SegmentTree<LL>> v(2, SegmentTree<LL>(n + 1, OP(A + B), 0));

	inc(k, 2) { v[k].apply(0, AP(A = n)); }

	LL ans = n * n;

	inc(q, Q) {

		auto [t, x] = tin<int, LL>();

		t--; x -= 2;

		ans -= v[1 - t].fold_II(0, x);

		if(x < v[t][0]) {

			LL p = v[1 - t][0];

			LL w = x - v[t][0];

			v[t].apply(0, AP(A += w));

			v[t].apply(p, AP(A -= w));

		}

	}

	out(ans);

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

using LL = long long int;

#define incII(i, l, r) for(LL i = (l)    ; i <= (r); i++)

#define incIX(i, l, r) for(LL i = (l)    ; i <  (r); i++)

#define incXI(i, l, r) for(LL i = (l) + 1; i <= (r); i++)

#define incXX(i, l, r) for(LL i = (l) + 1; i <  (r); i++)

#define decII(i, l, r) for(LL i = (r)    ; i >= (l); i--)

#define decIX(i, l, r) for(LL i = (r) - 1; i >= (l); i--)

#define decXI(i, l, r) for(LL i = (r)    ; i >  (l); i--)

#define decXX(i, l, r) for(LL i = (r) - 1; i >  (l); i--)

#define inc(i, n)  incIX(i, 0, n)

#define dec(i, n)  decIX(i, 0, n)

#define inc1(i, n) incII(i, 1, n)

#define dec1(i, n) decII(i, 1, n)

auto inII = [](auto x, auto l, auto r) { return (l <= x && x <= r); };

auto inIX = [](auto x, auto l, auto r) { return (l <= x && x <  r); };

auto inXI = [](auto x, auto l, auto r) { return (l <  x && x <= r); };

auto inXX = [](auto x, auto l, auto r) { return (l <  x && x <  r); };

auto setmin   = [](auto & a, auto b) { return (b <  a ? a = b, true : false); };

auto setmax   = [](auto & a, auto b) { return (b >  a ? a = b, true : false); };

auto setmineq = [](auto & a, auto b) { return (b <= a ? a = b, true : false); };

auto setmaxeq = [](auto & a, auto b) { return (b >= a ? a = b, true : false); };

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define MT make_tuple

#define FI first

#define SE second

#define FR front()

#define BA back()

#define ALL(c) c.begin(), c.end()

#define RALL(c) c.rbegin(), c.rend()

#define RV(c) reverse(ALL(c))

#define SC static_cast

#define SI(c) SC<int>(c.size())

#define SL(c) SC<LL >(c.size())

#define RF(e, c) for(auto & e: c)

#define SF(c, ...) for(auto & [__VA_ARGS__]: c)

#define until(e) while(! (e))

#define if_not(e) if(! (e))

#define ef else if

#define UR assert(false)

auto * IS = & cin;

auto * OS = & cout;

array<string, 3> SEQ = { "", " ", "" };

// input

template<typename T> T in() { T a; (* IS) >> a; return a; }

// input: tuple

template<typename U, int I> void tin_([[maybe_unused]] U & t) { }

template<typename U, int I, typename A, typename ... B> void tin_(U & t) { (* IS) >> get<I>(t); tin_<U, I + 1, B ...>(t); }

template<typename ... T> auto tin() { tuple<T ...> t; tin_<tuple<T ...>, 0, T ...>(t); return t; }

// input: array

template<typename T, int N> auto ain() { array<T, N> a; inc(i, N) { (* IS) >> a[i]; } return a; }

// input: multi-dimensional vector

template<typename T> T vin() { T v; (* IS) >> v; return v; }

template<typename T, typename N, typename ... M> auto vin(N n, M ... m) {

	vector<decltype(vin<T, M ...>(m ...))> v(n); inc(i, n) { v[i] = vin<T, M ...>(m ...); } return v;

}

// input: multi-column (tuple<vector>)

template<typename U, int I> void colin_([[maybe_unused]] U & t) { }

template<typename U, int I, typename A, typename ... B> void colin_(U & t) {

	get<I>(t).PB(in<A>()); colin_<U, I + 1, B ...>(t);

}

template<typename ... T> auto colin(int n) {

	tuple<vector<T> ...> t; inc(i, n) { colin_<tuple<vector<T> ...>, 0, T ...>(t); } return t;

}

// output

void out_([[maybe_unused]] string s) { }

template<typename A> void out_([[maybe_unused]] string s, A && a) { (* OS) << a; }

template<typename A, typename ... B> void out_(string s, A && a, B && ... b) { (* OS) << a << s; out_(s, b ...); }

auto outF = [](auto x, auto y, auto z, auto ... a) { (* OS) << x; out_(y, a ...); (* OS) << z << flush; };

auto out  = [](auto ... a) { outF("", " " , "\n", a ...); };

auto outS = [](auto ... a) { outF("", " " , " " , a ...); };

auto outL = [](auto ... a) { outF("", "\n", "\n", a ...); };

auto outN = [](auto ... a) { outF("", ""  , ""  , a ...); };

// output: multi-dimensional vector

template<typename T> ostream & operator<<(ostream & os, vector<T> const & v) {

	os << SEQ[0]; inc(i, SI(v)) { os << (i == 0 ? "" : SEQ[1]) << v[i]; } return (os << SEQ[2]);

}

template<typename T> void vout_(T && v) { (* OS) << v; }

template<typename T, typename A, typename ... B> void vout_(T && v, A a, B ... b) {

	inc(i, SI(v)) { (* OS) << (i == 0 ? "" : a); vout_(v[i], b ...); }

}

template<typename T, typename A, typename ... B> void vout (T && v, A a, B ... b) { vout_(v, a, b ...); (* OS) << a << flush; }

template<typename T, typename A, typename ... B> void voutN(T && v, A a, B ... b) { vout_(v, a, b ...); (* OS)      << flush; }



// ---- ----



// make vector

template<typename T> T MV(T v) { return v; }

template<typename T, typename ... U> auto MV(T v, int a, U ... b) { return vector<decltype(MV(v, b ...))>(a, MV(v, b ...)); }



int main() {

	auto [n, Q] = tin<LL, int>();

	n -= 2;

	auto v = MV(n, 2, n);

	auto w = MV(n, 2);

	LL ans = n * n;

	inc(q, Q) {

		auto [t, x] = tin<int, int>();

		t--; x -= 2;

		ans -= (x < w[t] ? w[1 - t] : v[1 - t][x]);

		if(x < w[t]) {

			incIX(i, x, w[t]) { v[1 - t][i] = w[1 - t]; }

			w[t] = x;

		}

	}

	out(ans);

}


// Fastest known solution for this problem: