#include <bits/stdc++.h>
#define sum(u) (tr[u].cnt[0]+tr[u].cnt[1])
#define ls(u) tr[u].ls
#define rs(u) tr[u].rs
#define N 500005
#define M 30
#define mod 1000000007
using namespace std;
typedef long long ll;

int n, m, rt, tot, rec[2];

struct Seg { int ls, rs, cnt[2]; } tr[N*2];

struct Pnt { int u, l, r; };
vector <Pnt> vec;

struct Lim { int l, r, tg; } p[N];
vector <int> lim[N];

int f[N][M], g[N][M], pr[2][N][M], sumg[N][M], sump[2][N][M];
ll ans;

void buildST (int &u, int l, int r)
{
    if (!u) { u=++tot; }
    if (l==r) { return; }
    int md=(l+r)/2;
    buildST(ls(u), l, md);
    buildST(rs(u), md+1, r);
}
void add (int u, int l, int r, int id, int tg, int num)
{
    if (l==r) { tr[u].cnt[tg]+=num; return; }
    int md=(l+r)/2;
    if (id<=md) { add(ls(u), l, md, id, tg, num); }
    else { add(rs(u), md+1, r, id, tg, num); }
    tr[u].cnt[tg]=tr[ls(u)].cnt[tg]+tr[rs(u)].cnt[tg];
}

void dfs (int u, int l, int r, int ql, int qr)
{
    if (l>qr || r<ql) { return; }
    if (ql<=l && r<=qr) { vec.push_back((Pnt){ u, l, r }); return; }
    int md=(l+r)/2;
    dfs(ls(u), l, md, ql, qr);
    dfs(rs(u), md+1, r, ql, qr);
}

int qry0 (int u, int l, int r)
{
    if (l==r) { rec[0]=(tr[u].cnt[0]!=0); rec[1]=(tr[u].cnt[1]!=0); return l; }
    int md=(l+r)/2;
    if (sum(rs(u))) { return qry0(rs(u), md+1, r); }
    else { return qry0(ls(u), l, md); }
}
int find0 (int ql, int qr)
{
    vec.clear();
    dfs(rt, 1, n, ql, qr);
    for (int i=vec.size()-1; i>=0; i--) {
        int u=vec[i].u, l=vec[i].l, r=vec[i].r;
        if (sum(u)!=0) { return qry0(u, l, r); }
    }
    return 0;
}

int qry1 (int u, int l, int r, int tg)
{
    if (l==r) { return l; }
    int md=(l+r)/2;
    if (tr[rs(u)].cnt[tg]) { return qry1(rs(u), md+1, r, tg); }
    else { return qry1(ls(u), l, md, tg); }
}
int find1 (int ql, int qr, int tg)
{
    vec.clear();
    dfs(rt, 1, n, ql, qr);
    for (int i=vec.size()-1; i>=0; i--) {
        int u=vec[i].u, l=vec[i].l, r=vec[i].r;
        if (tr[u].cnt[tg^1]) { return qry1(u, l, r, tg^1); }
    }
    return 0;
}

int cal (int i)
{
    for (int j=2; j<=26; j++) { pr[1][i][j]=(pr[1][i][j-1]+f[i][j-1])%mod; }
    ll tmp=(pr[1][i][26]+f[i][26])%mod;
    for (int j=25; j>=1; j--) { pr[0][i][j]=(pr[0][i][j+1]+f[i][j+1])%mod; }
    for (int j=1; j<=26; j++) { g[i][j]=(tmp-f[i][j])%mod; }

    for (int j=1; j<=26; j++) { sump[0][i][j]=((i ? sump[0][i-1][j] : 0)+pr[0][i][j])%mod; }
    for (int j=1; j<=26; j++) { sump[1][i][j]=((i ? sump[1][i-1][j] : 0)+pr[1][i][j])%mod; }
    for (int j=1; j<=26; j++) { sumg[i][j]=((i ? sumg[i-1][j] : 0)+g[i][j])%mod; }

    return tmp;
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d %d", &n, &m);
    buildST(rt, 1, n);
    for (int i=1; i<=m; i++) {
        int u, v; scanf("%d %d", &u, &v);
        if (u<v) { p[i]=(Lim){ u, v, 0 }; }
        else { p[i]=(Lim){ v, u, 1 }; }
        lim[p[i].r].push_back(i);
        add(rt, 1, n, p[i].l, p[i].tg, 1);
    }

    for (int i=1; i<=26; i++) { f[0][i]=1; }
    ans+=cal(0); ans%=mod;
    for (int i=1; i<=n; i++) {
        for (int j=0; j<(int)lim[i].size(); j++) {
            int id=lim[i][j];
            add(rt, 1, n, p[id].l, p[id].tg, -1);
        }
        for (int j=1; j<=26; j++) {
            int pos0=find0(1, i);
            if (!pos0) { f[i][j]+=sumg[i-1][j]; f[i][j]%=mod; continue; }
            else { f[i][j]+=sumg[i-1][j]-sumg[pos0-1][j]; f[i][j]%=mod; }

            if (rec[0] && rec[1]) { continue; }

            bool cur=(rec[0] ? 0 : 1);
            int pos1=find1(1, i, cur);
            if (!pos1) { f[i][j]+=sump[cur][pos0-1][j]; f[i][j]%=mod; }
            else { f[i][j]+=sump[cur][pos0-1][j]-sump[cur][pos1-1][j]; f[i][j]%=mod; }
        }

        if (i<n) { ans+=cal(i); ans%=mod; }
    }
    ans=(ans+mod)%mod;

    printf("%lld\n", ans);

    return 0;
}