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

template<class Abel> struct STLP{//[0,STLP.n)
    vector<Abel> dat,lazy_val;
    vector<bool> lazy;
    long long n;
    Abel unity;

    STLP(long long n_origin, Abel SUM_UNITY){
        unity=SUM_UNITY;
        long long i=0;
        while(n_origin>(1<<i)) i++;
        n = (1<<i);
        dat.resize(2*n -1);
        lazy_val.resize(2*n-1);
        lazy.resize(2*n-1);
        for(i=0; i< 2*n -1; i++){
            dat[i]=1000000000000;
            lazy_val[i]=SUM_UNITY;
            lazy[i]=0;
        }
    }

    void eval(long long k, long long l, long long r){
        if(lazy[k]==1){
            dat[k]=lazy_val[k];
            if(r-l>1){
                lazy[k*2+1]=1;
                lazy[k*2+2]=1;
                lazy_val[k*2+1]=lazy_val[k];
                lazy_val[k*2+2]=lazy_val[k];
            }
            lazy[k]=0;
            lazy_val[k]=unity;
        }
    }

    void update_range(Abel x, long long a, long long b, long long k, long long l, long long r){//[a,b)
        eval(k,l,r);
        if(r<=a||b<=l) return;
        if(a<=l&&r<=b){
            lazy[k]=1;
            lazy_val[k]=x;
            eval(k,l,r);
            return;
        }
        update_range(x,a,b,k*2+1, l, (l+r)/2);
        update_range(x,a,b,k*2+2, (l+r)/2, r);
        dat[k]=min(dat[k*2+1],dat[k*2+2]);
        return;
    }

    Abel min_range(long long a, long long b, long long k, long long l, long long r){//[a,b)
        eval(k,l,r);
        if(r<=a||b<=l) return 1000000000000;
        if(a<=l&&r<=b) return dat[k];
        Abel vl=min_range(a,b,k*2 +1, l, (l+r)/2);
        Abel vr=min_range(a,b,k*2 +2, (l+r)/2, r);
        return min(vl,vr);
    }

    long long STLP_lower_bound(Abel val, long long a, long long b){//[a,b)
        long long a_origin=a, b_origin=b;
        long long M;
        while(a<b-1){
            M=(a+b)/2;
            if(min_range(a_origin,M+1,0,0,n)==val&&min_range(a_origin,M,0,0,n)==val){
                b=M;
            }else if(min_range(a_origin,M+1,0,0,n)>val){
                b=M;
            }else{
                a=M;
            }
        }
        return a;
    }
};

int main(){
    long long N,Q;
    cin >> N >> Q;
    long long i,j;
    long long basho;
    STLP<long long> STLProw((N-2LL),0LL), STLPcol((N-2LL),0LL);
    long long ans=(N-2)*(N-2);
    long long num, x;
    long long minrow=N-2, mincol=N-2;
    STLProw.update_range(0,0,N-2,0,0,STLProw.n);
    STLPcol.update_range(0,0,N-2,0,0,STLPcol.n);
    for(i=1; i<=Q; i++){
        cin >> num >> x;
        x-=2;
        if(num==1){
            if(x<mincol){
                ans-=minrow;
                STLPcol.update_range(minrow,x,mincol,0,0,STLProw.n);
                mincol=x;
            }else{
                ans-=STLPcol.min_range(x,x+1,0,0,STLPcol.n);
            }
        }else{
            if(x<minrow){
                ans-=mincol;
                STLProw.update_range(mincol,x,minrow,0,0,STLPcol.n);
                minrow=x;
            }else{
                ans-=STLProw.min_range(x,x+1,0,0,STLProw.n);
            }
        }
    }
    cout << ans << endl;
    system("pause");
    return 0;
}

Measured memory_bytes: 19876