#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (b); i >= (a); i--)
#define SZ(x) ((int)x.size())
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define st first
#define nd second
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
auto &operator<<(auto &o, pair<auto, auto> p) {
    return o << "(" << p.st << ", " << p.nd << ")";
}
auto operator<<(auto &o, auto x)->decltype(end(x), o) {
    o << "{"; int i=0; for(auto e: x) o << ", " + 2*!i++ << e;
    return o << "}";
}
#define deb(x...) cerr << "[" #x "]: ", [](auto...$) { ((cerr<<$<<"; "),...) << endl; }(x)

struct zwykleDrzewo{
    int roz;
    vector<int> tree;

    void init(int n){
        tree.clear();
        roz = 1;
        while(roz <= n) roz *= 2;
        roz *= 2;
        tree.resize(roz, 0);
    }

    void add(int pos, int delta){
        pos += roz / 2;
        while(pos >= 1){
            tree[pos] += delta;
            pos /= 2;
        }
    }

    int sum(int lo, int hi){
        if(lo > hi) return 0;
        lo += roz / 2; hi += roz / 2;
        int ans = tree[lo];
        if(hi != lo) ans += tree[hi];
        while(lo / 2 != hi / 2){
            if(!(lo & 1)) ans += tree[lo ^ 1];
            if(hi & 1) ans += tree[hi ^ 1];
            lo /= 2; hi /= 2;
        }
        return ans;
    }

    int lastLit(int lo, int hi, int u, int a, int b){
        if(lo == a && b == hi){
            if(lo + 1 == hi){
                if(tree[u]) return u - roz / 2;
                return -1;
            }
            if(tree[u] == 0) return -1;
            int mid = (lo + hi) / 2;
            if(tree[u * 2 + 1]) return lastLit(mid, hi, u * 2 + 1, max(a, mid), b);
            return lastLit(lo, mid, u * 2, a, min(b, mid));
        }
        if(b <= a) return -1;
        int mid = (lo + hi) / 2;
        auto R = lastLit(mid, hi, u * 2 + 1, max(a, mid), b);
        if(R != -1) return R;
        return lastLit(lo, mid, u * 2, a, min(b, mid));
    }

    int ostatni(int lo, int hi){
        return lastLit(0, roz / 2, 1, lo, hi + 1);
    }
};

struct secik{
    int roz;
    vector<int> tree;

    void init(int n){
        tree.clear();
        roz = 1;
        while(roz <= n) roz *= 2;
        roz *= 2;
        tree.resize(roz, 0);
    }

    void add(int pos, int delta){
        pos += roz / 2;
        while(pos >= 1){
            tree[pos] += delta;
            pos /= 2;
        }
    }

    int firstLit(int lo, int hi, int u, int a, int b){
        if(lo == a && b == hi){
            if(lo + 1 == hi){
                if(tree[u]) return u - roz / 2;
                return -1;
            }
            if(tree[u] == 0) return -1;
            int mid = (lo + hi) / 2;
            if(tree[u * 2]) return firstLit(lo, mid, u * 2, a, min(b, mid));
            return firstLit(mid, hi, u * 2 + 1, max(a, mid), b);
        }
        if(b <= a) return -1;
        int mid = (lo + hi) / 2;
        auto L = firstLit(lo, mid, u * 2, a, min(b, mid));
        if(L != -1) return L;
        return firstLit(mid, hi, u * 2 + 1, max(a, mid), b);
    }

    int lowerbound(int from){
        return firstLit(0, roz / 2, 1, from, roz / 2);
    }

};

const int nax = 1e6 + 5;
const int mod = 1e9 + 7;
int l[nax];
int r[nax];
int n;

int leftEdge[nax];
int rightEdge[nax];

int naLewo[nax];
int naPrawo[nax];

ll pp(ll a, ll b){
    ll ans = 1;
    while(b){
        if(b & 1){
            ans *= a;
            ans %= mod;
        }
        a *= a;
        a %= mod;
        b /= 2;
    }
    return ans;
}

ll inv(ll a){
    return pp(a, mod - 2);
}

struct segtree{
    vector<int> tree;
    int roz;

    void init(int n){
        tree.clear();
        roz = 1;
        while(roz <= n) roz *= 2;
        roz *= 2;
        tree.resize(roz, 0);
    }

    void add(int pos, int delta){
        pos += roz / 2;
        while(pos >= 1){
            tree[pos] += delta;
            pos /= 2;
        }
    }

    int sum(int lo, int hi){
        if(lo > hi) return 0;
        lo += roz / 2; hi += roz / 2;
        int ans = tree[lo];
        if(hi != lo) ans += tree[hi];
        while(lo / 2 != hi / 2){
            if(!(lo & 1)) ans += tree[lo ^ 1];
            if(hi & 1) ans += tree[hi ^ 1];
            lo /= 2; hi /= 2;
        }
        return ans;
    }
};

vector<int> sons[nax];
int pre[nax];
int post[nax];
int sz[nax];
int timer;
int nxt[nax];
int whopre[nax];
int parent[nax];

void dfs_sz(int v){
    sz[v] = 1;
    for(auto &u : sons[v]){
        dfs_sz(u);
        parent[u] = v;
        sz[v] += sz[u];
        if(sz[u] > sz[sons[v][0]]){
            swap(u, sons[v][0]);
        }
    }
}

void dfs_hld(int v){
    pre[v] = ++timer;
    for(auto u : sons[v]){
        nxt[u] = (u == sons[v][0] ? nxt[v] : u);
        dfs_hld(u);
    }
    post[v] = ++timer;
}

zwykleDrzewo drzewo;

int lastlit(int v){
    while(true){
        int gora = nxt[v];
        if(drzewo.sum(pre[gora], pre[v]) == 0){
            v = parent[gora];
            continue;
        }
        int prePos = drzewo.ostatni(pre[gora], pre[v]);
        return whopre[prePos];
    }
    assert(false);
}

void change(int v, int delta){
    drzewo.add(pre[v], delta);
}

vector<int> adj[nax];
int limit[nax];

void dfs(int v, int p){
    change(v, +1);
    for(int s : adj[v]){
        if(s == p) continue;
        limit[s] = lastlit(s);
        dfs(s, v);
    }
    change(v, -1);
}

int rightPrefsum[nax];
int leftPrefsum[nax];

pii typek[nax];

void solve(){
    cin >> n;
    rep(i, 1, n) cin >> l[i] >> r[i];
    l[n + 1] = 0;
    r[n + 1] = n * 2 + 1;
    n += 1;
    // 0 ... 2 * n - 1
    rep(i, 0, nax - 1) leftEdge[i] = rightEdge[i] = -1;
    secik poczatki;
    poczatki.init(n + 5);
    segtree konce;
    konce.init(n + 5);
    rep(i, 1, n){
        typek[l[i]] = mp(i, +1);
        typek[r[i]] = mp(i, -1);
    }
    
    rep(i, 0, n * 2 - 1){
        auto [id, op] = typek[i];
        if(op == +1){
            int dokad = poczatki.lowerbound(id);
            if(dokad != -1){
                leftEdge[id] = dokad;
            }
            poczatki.add(id, +1);
            if(leftEdge[id] != -1){
                int low = id;
                int high = leftEdge[id];
                naLewo[id] = konce.sum(low, high);
            }
        }
        else{
            poczatki.add(id, -1);
            konce.add(id, +1);
        }
    }
    
    poczatki.init(n + 5);
    konce.init(n + 5);

    per(i, 0, n * 2 - 1){
        auto [id, op] = typek[i];
        if(op == -1){
            int dokad = poczatki.lowerbound(id);
            if(dokad != -1){
                rightEdge[id] = dokad;
            }
            poczatki.add(id, +1);
            if(rightEdge[id] != -1){
                int low = id;
                int high = rightEdge[id];
                naPrawo[id] = konce.sum(low, high);
            }
        }
        else{
            poczatki.add(id, -1);
            konce.add(id, +1);
        }
    }

    rep(i, 1, n - 1){
        int ja = i;
        int upward = rightEdge[i];
        sons[upward].pb(ja);
    }
    
    rep(i, 1, n - 1){
        int ja = i;
        int on = leftEdge[i];
        adj[ja].pb(on);
        adj[on].pb(ja);
    }

    dfs_sz(n);
    nxt[n] = n;
    dfs_hld(n);
    rep(i, 1, n) whopre[pre[i]] = i;
    drzewo.init(n * 2 + 77);
    dfs(n, n);

    per(i, 1, n - 1){
        rightPrefsum[i] = naPrawo[i] + rightPrefsum[rightEdge[i]];
        leftPrefsum[i] = naLewo[i] + leftPrefsum[leftEdge[i]];
    }

    ll ans = 0;
    rep(i, 1, n - 1){
        int skipped = i - 1;
        skipped += leftPrefsum[i] - leftPrefsum[limit[i]];
        skipped += rightPrefsum[i] - rightPrefsum[limit[i]];
        skipped += (n - limit[i] + 1);
        int visited = n - skipped;
        ans += inv(visited);
        ans %= mod;
    }
    cout << ans << "\n";
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int tt = 1;
    // cin >> tt;
    rep(te, 1, tt) solve();
    return 0;
}