#include <algorithm>
#include <cstdint>
#include <iostream>
#define EVAL(x) cout << #x " = " << x << "\n"

namespace {
using std::cin;
using std::cout;
using std::int64_t;

const int kP = 1.0e9 + 7;

namespace mod {
inline int Mod(int x) { return x >= kP ? x - kP : x; }
inline void Add(int &x, int y) { x = Mod(x + y); }
}  // namespace mod

const int kMaxN = 5.0e5 + 5;
int n, m;
int lt_bound[kMaxN], gt_bound[kMaxN];
int f[kMaxN][26];

class Fenwick {
 public:
  void Modify(int x, int val);
  int Max(int x);

 private:
  int max_[kMaxN];
};

void Fenwick::Modify(int x, int val) {
  x = n - x;
  while (x <= n) max_[x] = val, x += x & -x;
}

int Fenwick::Max(int x) {
  x = n - x;
  int ans = 0;
  while (x) ans = std::max(ans, max_[x]), x &= x - 1;
  return ans;
}

Fenwick lt_tree, gt_tree;
}  // namespace

int main() {
  cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  cin >> n >> m;

  while (m--) {
    int a, b;
    cin >> a >> b;

    if (a < b) {
      gt_bound[a] = std::max(gt_bound[a], b - 1);
    } else {
      lt_bound[b] = std::max(lt_bound[b], a - 1);
    }
  }

  std::fill_n(f[0], 26, 1);
  int ans = 26;

  for (int i = 1; i <= n - 1; ++i) {
    gt_tree.Modify(gt_bound[i], i);
    int j = gt_tree.Max(i);

    for (int k = j; k < i; ++k) {
      for (int prev_c = 0; prev_c < 26; ++prev_c) {
        for (int c = prev_c + 1; c < 26; ++c) mod::Add(f[i][c], f[k][prev_c]);
      }
    }

    lt_tree.Modify(lt_bound[i], i);
    j = lt_tree.Max(i);

    for (int k = j; k < i; ++k) {
      for (int prev_c = 0; prev_c < 26; ++prev_c) {
        for (int c = 0; c < prev_c; ++c) mod::Add(f[i][c], f[k][prev_c]);
      }
    }

    for (int c = 0; c < 26; ++c) mod::Add(ans, f[i][c]);
  }

  cout << ans << "\n";
  return 0;
}