//#pragma GCC optimize("Ofast")
//#pragma GCC optimize ("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#pragma warning(disable:4786)
#pragma warning(disable:4996)
#include <bits/stdc++.h>
#include  <random>
#include <chrono>
#include <unordered_set>
using namespace std;

#define MEM(a, b) memset(a, (b), sizeof(a))
#define CLR(a) memset(a, 0, sizeof(a))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(X) ( (X) > 0 ? (X) : ( -(X) ) )
#define S(X) ( (X) * (X) )
#define SZ(V) (int )V.size()
#define FORN(i, n) for(int i = 0; i < n; i++)
#define FORAB(i, a, b) for(int i = a; i <= b; i++)
#define ALL(V) V.begin(), V.end()
#define IN(A, B, C)  ((B) <= (A) && (A) <= (C))
#define AIN(A, B, C) assert(IN(A, B, C))

string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto& x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void dbg_out() { cerr << endl; }
template<typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) { cerr << ' ' << to_string(H); dbg_out(T...); }
#ifdef LOCAL
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...) 0
#endif

typedef long long int LL;
//typedef __int128 LLL;
//typedef long long LLL;


typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LL, int> PLI;
typedef pair<double, double> PDD;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PLL> VPL;
typedef vector<PII> VP;
typedef vector<double> VD;
typedef vector<vector<int>> VVI;
typedef vector<vector<LL>> VVL;
typedef vector<string> VS;
typedef long double ld;
typedef unsigned long long ULL;

//#define MAXN 1000
//#define MAXN2 MAXN*MAXN

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// mt19937 rng(10);
// shuffle(V.begin(), V.end(), rng);
// int u = rng();
// int u = uniform_int_distribution<long long>(L, R)(rng);
// double u = uniform_real_distribution<float>(L, R)(rng);

// int dr[] = {-1, 0, 1, 0, 1, 1, -1, -1};
// int dc[] = {0, 1, 0, -1, 1, -1, 1, -1};

const LL MOD = 1000000007;
//const LL MOD = 998244353;
// const LL INF = 2000000000000000001LL; //2e18 + 1

//typedef long long LL;
//typedef unsigned long long ULL;

int l[500005], r[500005];
int lft[500005], rgt[500005];
int n;

LL msk[500005];
int sz[500005];

int inv[500005];
LL allOne;
int allO;

int BitCount(LL msk) {
    return __builtin_popcountll(msk);
    //LL a = msk & allOne;
    //LL b = (msk >> 64) & allOne;
    //return __builtin_popcountll(a) + __builtin_popcountll(b);
    /*int ret = 0;
    FORN(i, 64) {
        if ((msk >> i) & 1) ret++;
    }
    return ret;*/
}

void solve(int ks) {
    vector<PII> events;

    //n = 500000;
    scanf("%d", &n);
    FORAB(i, 1, n) {
        //l[i] = i;
        //r[i] = n + i;
        scanf("%d %d", &l[i], &r[i]);
        events.push_back({ l[i], i });
        events.push_back({ r[i], -i });
    }
    sort(ALL(events));

    set<int> S;
    auto FindWho = [&S](int id) {
        if (S.empty()) return 0;
        auto iS = S.upper_bound(id);
        if (iS == S.begin()) return 0;
        iS--;
        return *iS;
    };
    for (auto& p : events) {
        int id = ABS(p.second);
        if (p.second < 0) S.erase(id);
        int who = FindWho(id);
        if (p.second > 0) {
            lft[id] = who;
            S.insert(id);
        }
        else {
            rgt[id] = who;
        }
    }

    int l = 1, r = 64;
    while (true) {
        r = MIN(r, n);
        // [l, r]
        for (int i = r; i >= 1; i--) {
            sz[i] += BitCount(msk[i]);
            if (l <= i) {
                msk[i] |= 1LL << (i - l);
            }
            msk[lft[i]] |= msk[i];
            msk[rgt[i]] |= msk[i];
            msk[i] = 0;
        }
        l += 64; 
        r += 64;
        if (l > n) break;
    }

    LL ans = 0;
    FORAB(i, 1, n) {
        ans = (ans + inv[sz[i] + 1]);
        if (ans >= MOD) ans -= MOD;
    }
    printf("%lld\n", ans);
}

void gen() {
    inv[1] = 1;
    for (int i = 2; i < 500003; ++i) {
        inv[i] = (MOD - (MOD / i) * inv[MOD % i] % MOD) % MOD;
    }
    FORN(i, 64) allOne |= (1LL << i);
    FORN(i, 32) allO |= (1LL << i);

}

int main() {
    // ios_base::sync_with_stdio(false);
    // cin.tie(nullptr);

    double start_time = clock();
#ifdef LOCAL
    freopen("C:\\Home\\Contest\\sample.in", "r", stdin);
    //freopen("C:\\Home\\Contest\\0.out", "w", stdout);
#endif

    gen();

    if (0) {
        int T;
        scanf("%d", &T);
        for (int ks = 1; ks <= T; ks++) {
            solve(ks);
            if (ks % 100 == 0) fprintf(stderr, "%d done\n", ks);
            //double end_time = clock();
            //fprintf(stderr, "Time = %lf\n", (end_time - start_time) / CLOCKS_PER_SEC);
        }
    }
    else {
        solve(1);
    }

    double end_time = clock();
    fprintf(stderr, "Time = %lf\n", (end_time - start_time) / CLOCKS_PER_SEC);
    return 0;
}