#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <array>
#include <bitset>

long long mod = 1e9 + 7;
class Mint
{
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a)
  {
    x = a % mod;
    while (x < 0)
    {
      x += mod;
    }
  };
  Mint &operator+=(const Mint &a)
  {
    x += a.x;
    x %= mod;
    return *this;
  }
  Mint &operator-=(const Mint &a)
  {
    x += (mod - a.x);
    x %= mod;
    return *this;
  }
  Mint &operator*=(const Mint &a)
  {
    x *= a.x;
    x %= mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const
  {
    if (n == 0)
      return Mint(1);
    Mint y = pow(n >> 1); // pow(n/2)を計算する
    y *= y;
    if (n % 2 == 1)
      y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const
  {
    return a.pow(mod - 2);
  }

  Mint &operator/=(const Mint &a)
  {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator+(Mint &a) const
  {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator-(Mint &a) const
  {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator*(Mint &a) const
  {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator/(Mint &a) const
  {
    Mint y(*this);
    y /= a;
    return y.x;
  }
};
  // nCk @mod を計算する
Mint nCk(Mint &n, const long long k)
{
  Mint y = Mint(1);
  Mint iy = Mint(1);
  Mint one = Mint(1);
  // 割り算の演算は時間がかかるので最後に1度だけ行うようにすること
  for (Mint i(0); (i.x) < k; i.x++)
  {
    y *= (n - i);
    iy *= (i + one);
  }
  return y / iy;
}

// nPk @mod を計算する
Mint nPk(Mint &n, long long k)
{
  Mint y(1);
  for (Mint i(0); (i.x) < k; i.x++)
  {
    y *= (n - i);
  }
  return y;
}

class UnionFind
{
private:
  int n;
  std::vector<int> parent;

public:
  UnionFind(int num) : n(num)
  {
    parent = std::vector<int>(n);
    for (int i = 0; i < n; i++)
    {
      parent[i] = i;
    }
  }
  int GetRoot(int i)
  {
    int n = i;
    while (parent[n] != n)
    {
      n = parent[n];
    }
    parent[i] = n;
    return n;
  }

  bool SameGroup(int n, int m)
  {
    n = this->GetRoot(n);
    m = this->GetRoot(m);
    return n == m;
  }

  bool Unite(int n, int m)
  {
    n = this->GetRoot(n);
    m = this->GetRoot(m);
    if (n == m)
      return false;
    parent[n] = m;
    return true;
  }
};

int getgcd(int a, int b)
{
  int max = std::max(a, b);
  int min = std::min(a, b);
  if (min == 0)
    return max;
  return getgcd(min, max % min);
}

//Mint nCk_pascar[1004][1004];
// nの値までのnCkをパスカルの三角形から求めておく
/*void Calc_nCk_pascar(int n){
  for (int i=0; i<=n; i++) {
    for (int j=0; j<=i; j++) {
      if (j==0 || j==i) nCk_pascar[i][j] = Mint(1);
      else nCk_pascar[i][j] = nCk_pascar[i-1][j-1] + nCk_pascar[i-1][j];
    }
  }
  return;
}*/

long long nCk_pascar[1004][1004];
// nの値までのnCkをパスカルの三角形から求めておく
void Calc_nCk_pascar(int n){
  for (int i=0; i<=n; i++) {
    for (int j=0; j<=i; j++) {
      if (j==0 || j==i) nCk_pascar[i][j] = 1;
      else nCk_pascar[i][j] = nCk_pascar[i-1][j-1] + nCk_pascar[i-1][j];
    }
  }
  return;
}

Mint mynCk(int n, int k)
{
  if (2 * k > n)
    return mynCk(n, n - k);
  Mint retval(1);
  Mint iretval(1);
  for (int i = 0; i < k; i++)
  {
    retval *= Mint(n - i);
  }
  for (int i = 1; i <= k; i++)
  {
    iretval *= Mint(i);
  }
  return retval / iretval;
}

int tateyoko[2][800000];
int leaf = 1;
int N;
void init() {
  while(leaf<N) {
    leaf *= 2;
  }
  for (int i=0; i<800000; i++) {
    tateyoko[0][i] = N-1;
    tateyoko[1][i] = N-1;
  }
  //printf("leaf=%d, depth=%d\n", leaf, depth);
  return;
}

void print(int k){
  for (int i=0; i<N; i++) {
    printf("tateyoko[%d][%d]=%d\n",k,i+leaf,tateyoko[k][i+leaf]);
  }
}

void update(int n, int v, int k) {
  n += leaf;
  tateyoko[k][n] = std::min(tateyoko[k][n], v);
  // printf("iunput tateyoko[%d][%d]=%d\n",k,n,v);
  n /= 2;
  while(n>0) {
    tateyoko[k][n] = std::min(tateyoko[k][2*n], tateyoko[k][2*n+1]);
    n /= 2;
  }
  return;
} 

int getmin(int v, int min, int max, int L, int R, int k){
  if (max<L || R<min) {
    // printf("v=%d, L=%d, R=%d, neglect\n", v, L, R);
    return 1001001001;
  } else if (min<=L && R<=max) {
    // printf("return tateyoko[%d]=%d\n",v,tateyoko[k][v]);
    return tateyoko[k][v];
  } else {
    // printf("v=%d, split. L=%d, R=%d\n", v, L, R);
    return std::min(getmin(v*2, min, max, L, (L+R)/2, k),
                    getmin(v*2+1, min, max, (L+R)/2+1, R, k));
  }
}

// n以上のノードの最小値を取得
int getmin(int n, int k){
  // printf("getmin(1,%d,%d,%d,%d) called\n", n, N-1, 0, N-1);
  return getmin(1, n,leaf-1, 0, leaf-1, k);
}

int main()
{
  int Q;
  std::cin >> N >> Q;
  std::vector<int > which(Q), pos(Q);
  for (int i=0; i<Q; i++) {
    std::cin >> which[i] >> pos[i];
    which[i]--;
    pos[i]--;
  }
  init();
  long long ans = (long long)(N-2)*(N-2);
  for (int i=0; i<Q; i++) {
    int hit = getmin(pos[i], which[i]);
    // printf("hit=%d\n", hit);
    // printf("getmin(%d, %d)=%d\n",pos[i],which[i], hit);
    ans -= hit - 1;
    update(hit, pos[i], 1-which[i]);

    //print(which[i]);
    //print(1-which[i]);
  }
  std::cout << ans << std::endl;
  return 0;
}

Measured memory_bytes: 10764