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

//#include <atcoder/all>

using namespace std;

//using namespace atcoder;

#define ll long long

#define FOR(i, a, b) for(int i=(a);i<(b);++i)

#define rep(i, n) FOR(i, 0, n)

#define rep1(i, n) FOR(i, 1, n+1)

#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)

#define whole(x) (x).begin(),(x).end()

#define rwhole(x) (x).rbegin(), (x).rend()

#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())

#define P pair<int, int>

#define debug(var) cerr << "[" << #var << "] " << var << endl

template<typename T1, typename T2>

bool chmax(T1 &a,T2 b){if(a<b){a=b;return true;}else return false;}

template<typename T1, typename T2>

bool chmin(T1 &a,T2 b){if(a>b){a=b;return true;}else return false;}

#define vi vector<int>

#define vl vector<ll>

#define pb push_back

#define eb emplace_back

#define fi first

#define se second

#define pr(s) cout << (s) << '\n'

const ll mod = 1000000007;

const int dx[] = {-1,0,1,0};

const int dy[] = {0,-1,0,1};

const int INF = 1001001001;

const ll INFll = 1E+18;



namespace internal {



// @param n `0 <= n`

// @return minimum non-negative `x` s.t. `n <= 2**x`

int ceil_pow2(int n) {

    int x = 0;

    while ((1U << x) < (unsigned int)(n)) x++;

    return x;

}



// @param n `1 <= n`

// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`

int bsf(unsigned int n) {

#ifdef _MSC_VER

    unsigned long index;

    _BitScanForward(&index, n);

    return index;

#else

    return __builtin_ctz(n);

#endif

}



}  // namespace internal



template <class S,

          S (*op)(S, S),

          S (*e)(),

          class F,

          S (*mapping)(F, S),

          F (*composition)(F, F),

          F (*id)()>

struct lazy_segtree {

  public:

    lazy_segtree() : lazy_segtree(0) {}

    lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}

    lazy_segtree(const std::vector<S>& v) : _n(int(v.size())) {

        log = internal::ceil_pow2(_n);

        size = 1 << log;

        d = std::vector<S>(2 * size, e());

        lz = std::vector<F>(size, id());

        for (int i = 0; i < _n; i++) d[size + i] = v[i];

        for (int i = size - 1; i >= 1; i--) {

            update(i);

        }

    }



    void set(int p, S x) {

        assert(0 <= p && p < _n);

        p += size;

        for (int i = log; i >= 1; i--) push(p >> i);

        d[p] = x;

        for (int i = 1; i <= log; i++) update(p >> i);

    }



    S get(int p) {

        assert(0 <= p && p < _n);

        p += size;

        for (int i = log; i >= 1; i--) push(p >> i);

        return d[p];

    }



    S prod(int l, int r) {

        assert(0 <= l && l <= r && r <= _n);

        if (l == r) return e();



        l += size;

        r += size;



        for (int i = log; i >= 1; i--) {

            if (((l >> i) << i) != l) push(l >> i);

            if (((r >> i) << i) != r) push(r >> i);

        }



        S sml = e(), smr = e();

        while (l < r) {

            if (l & 1) sml = op(sml, d[l++]);

            if (r & 1) smr = op(d[--r], smr);

            l >>= 1;

            r >>= 1;

        }



        return op(sml, smr);

    }



    S all_prod() { return d[1]; }



    void apply(int p, F f) {

        assert(0 <= p && p < _n);

        p += size;

        for (int i = log; i >= 1; i--) push(p >> i);

        d[p] = mapping(f, d[p]);

        for (int i = 1; i <= log; i++) update(p >> i);

    }

    void apply(int l, int r, F f) {

        assert(0 <= l && l <= r && r <= _n);

        if (l == r) return;



        l += size;

        r += size;



        for (int i = log; i >= 1; i--) {

            if (((l >> i) << i) != l) push(l >> i);

            if (((r >> i) << i) != r) push((r - 1) >> i);

        }



        {

            int l2 = l, r2 = r;

            while (l < r) {

                if (l & 1) all_apply(l++, f);

                if (r & 1) all_apply(--r, f);

                l >>= 1;

                r >>= 1;

            }

            l = l2;

            r = r2;

        }



        for (int i = 1; i <= log; i++) {

            if (((l >> i) << i) != l) update(l >> i);

            if (((r >> i) << i) != r) update((r - 1) >> i);

        }

    }



    template <bool (*g)(S)> int max_right(int l) {

        return max_right(l, [](S x) { return g(x); });

    }

    template <class G> int max_right(int l, G g) {

        assert(0 <= l && l <= _n);

        assert(g(e()));

        if (l == _n) return _n;

        l += size;

        for (int i = log; i >= 1; i--) push(l >> i);

        S sm = e();

        do {

            while (l % 2 == 0) l >>= 1;

            if (!g(op(sm, d[l]))) {

                while (l < size) {

                    push(l);

                    l = (2 * l);

                    if (g(op(sm, d[l]))) {

                        sm = op(sm, d[l]);

                        l++;

                    }

                }

                return l - size;

            }

            sm = op(sm, d[l]);

            l++;

        } while ((l & -l) != l);

        return _n;

    }



    template <bool (*g)(S)> int min_left(int r) {

        return min_left(r, [](S x) { return g(x); });

    }

    template <class G> int min_left(int r, G g) {

        assert(0 <= r && r <= _n);

        assert(g(e()));

        if (r == 0) return 0;

        r += size;

        for (int i = log; i >= 1; i--) push((r - 1) >> i);

        S sm = e();

        do {

            r--;

            while (r > 1 && (r % 2)) r >>= 1;

            if (!g(op(d[r], sm))) {

                while (r < size) {

                    push(r);

                    r = (2 * r + 1);

                    if (g(op(d[r], sm))) {

                        sm = op(d[r], sm);

                        r--;

                    }

                }

                return r + 1 - size;

            }

            sm = op(d[r], sm);

        } while ((r & -r) != r);

        return 0;

    }



  private:

    int _n, size, log;

    std::vector<S> d;

    std::vector<F> lz;



    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }

    void all_apply(int k, F f) {

        d[k] = mapping(f, d[k]);

        if (k < size) lz[k] = composition(f, lz[k]);

    }

    void push(int k) {

        all_apply(2 * k, lz[k]);

        all_apply(2 * k + 1, lz[k]);

        lz[k] = id();

    }

};



using S = ll;

S op(S a, S b) {

    return a<b;

}

S e() {

    return INFll;

}

using F = ll;

S mapping(F a, S b) {

    return min(a, b);

}

F composition (F a, F b) {

    return min(a, b);

}

F id() {

    return INFll;

}



int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    

    ll n, q;

    cin >> n >> q;

    ll ans = (n-2)*(n-2);

    vector<ll> z1(n-1, n-1);

    vector<ll> z2(n-1, n-1);

    z1[0] = 0;

    z2[0] = 0;

    lazy_segtree<S, op, e, F, mapping, composition, id> seg1(z1);

    lazy_segtree<S, op, e, F, mapping, composition, id> seg2(z2);

    

    rep(i, q) {

        int id, x;

        cin >> id >> x;

        x--;

        if (id==1) {

            ll z = seg2.get(x);

            ans -= (z-1);

            seg2.set(x, 0LL);

            seg1.apply(1, z, x);

        }

        if (id==2) {

            ll z = seg1.get(x);

            ans -= (z-1);

            seg1.set(x, 0LL);

            seg2.apply(1, z, x);

        }

    }

    

    pr(ans);

    return 0;

}


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

//#include <atcoder/all>

using namespace std;

//using namespace atcoder;

#define ll long long

#define FOR(i, a, b) for(int i=(a);i<(b);++i)

#define rep(i, n) FOR(i, 0, n)

#define rep1(i, n) FOR(i, 1, n+1)

#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)

#define whole(x) (x).begin(),(x).end()

#define rwhole(x) (x).rbegin(), (x).rend()

#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())

#define P pair<int, int>

#define debug(var) cerr << "[" << #var << "] " << var << endl

template<typename T1, typename T2>

bool chmax(T1 &a,T2 b){if(a<b){a=b;return true;}else return false;}

template<typename T1, typename T2>

bool chmin(T1 &a,T2 b){if(a>b){a=b;return true;}else return false;}

#define vi vector<int>

#define vl vector<ll>

#define pb push_back

#define eb emplace_back

#define fi first

#define se second

#define pr(s) cout << (s) << '\n'

const ll mod = 1000000007;

const int dx[] = {-1,0,1,0};

const int dy[] = {0,-1,0,1};

const int INF = 1001001001;

const ll INFll = 1E+18;





int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    

    int n, q;

    cin >> n >> q;

    ll ans = (ll)(n-2)*(n-2);

    int nx = n-1;

    int ny = n-1;

    vector<int> ix(n-1, -1);

    vector<int> iy(n-1, -1);

    rep(qi, q) {

        int id, x;

        cin >> id >> x;

        x--;

        if (id==1) {

            if (x<ny) {

                for (int i=x; i<ny; i++) {

                    iy[i] = nx;

                }

            }

            ans -= iy[x] - 1;

            chmin(ny, x);

        }

        if (id==2) {

            if (x<nx) {

                for (int i=x; i<nx; i++) {

                    ix[i] = ny;

                }

            }

            ans -= ix[x] - 1;

            chmin(nx, x);

        }

    }

    

    

    pr(ans);

    return 0;

}


// Fastest known solution for this problem: