#ifdef LOCAL
class SS {
   int x[0];
};
extern "C" SS __sanitizer_print_stack_trace();
#define __last_state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
   }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
   ;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
   SS x {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
      __sanitizer_print_stack_trace()
#endif
#include <bits/stdc++.h>
#include <chrono>
#include <ext/pb_ds/assoc_container.hpp>
#include <math.h>
using namespace __gnu_pbds;
using namespace std;
#define endl "\n"
#define mp make_pair
#define st first
#define nd second
#define pii pair<int, int>
#define vi vector<int>
#define pb push_back
#define _upgrade ios_base::sync_with_stdio(0), cout.setf(ios::fixed), cout.precision(10), cin.tie(0), cout.tie(0);
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define fwd(i, a, b) for (int i = (a); i < (b); ++i)
#define trav(a, x) for (auto &a : x)
#define all(c) (c).begin(), (c).end()
#define sz(X) (int)((X).size())
typedef long double ld;
typedef unsigned long long ull;
typedef long long ll;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set; // find_by_order(x) <-returns x-th element   order_of_key(x) <- returns order of element x
// mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());uniform_int_distribution<int> distr(0, 1e9);auto my_rand = bind(distr, gen); // my_rand() zwraca teraz liczbe z przedzialu [a, b]
#ifdef LOCAL
ostream &operator<<(ostream &out, string str) {
   for (char c : str)
      out << c;
   return out;
}
template <class L, class R> ostream &operator<<(ostream &out, pair<L, R> p) { return out << "(" << p.st << ", " << p.nd << ")"; }
template <class L, class R, class S> ostream &operator<<(ostream &out, tuple<L, R, S> p) {
   auto &[a, b, c] = p;
   return out << "(" << a << ", " << b << ", " << c << ")";
}
template <class T> auto operator<<(ostream &out, T a) -> decltype(a.begin(), out) {
   out << '{';
   for (auto it = a.begin(); it != a.end(); it = next(it))
      out << (it != a.begin() ? ", " : "") << *it;
   return out << '}';
}
void dump() { cerr << "\n"; }
template <class T, class... Ts> void dump(T a, Ts... x) {
   cerr << a << ", ";
   dump(x...);
}
#define debug(...) cerr << "[" #__VA_ARGS__ "]: ", dump(__VA_ARGS__)
#else
#define debug(...) ;
#endif
const ll mod = 1e9 + 7;

ull mod_mul(ull a, ull b) { return a * b % mod; }
ull mod_pow(ull b, ull e) {
   ull ans = 1;
   for (; e; b = b * b % mod, e /= 2)
      if (e & 1)
         ans = ans * b % mod;
   return ans;
}
ull inv(ull a) { return mod_pow(a, mod - 2); }

typedef vector<array<int, 2>> graph;

graph build_graph(const vector<pii> &V) {
   int n = sz(V);
   graph G(n, {-1, -1});
   set<pair<int, int>> S;

   for (int i = n - 1; i >= 0; i--) {
      auto [l, r] = V[i];
      auto itr1 = S.upper_bound({l, 0});
      auto itr2 = S.upper_bound({r, 0});
      for (auto itr = itr1; itr != itr2; itr++) {
         auto [_, x] = *itr;
         G[x / 2][x & 1] = i;
      }
      S.erase(itr1, itr2);
      S.insert({l, 2 * i});
      S.insert({r, 2 * i + 1});
   }
   return G;
}

struct FT {
   vector<ll> s;
   FT(int n) : s(n) {}
   void update(int pos, ll dif) { // a[pos] += dif
      for (; pos < sz(s); pos |= pos + 1)
         s[pos] += dif;
   }
   ll query(int pos) { // sum of values in [0, pos)
      ll res = 0;
      for (; pos > 0; pos &= pos - 1)
         res += s[pos - 1];
      return res;
   }
};

vector<vi> build_parent(const graph &G) {
   int n = sz(G);
   vector<vi> res(n);
   vector<int> P(n);
   iota(all(P), 0);
   for (int i = n - 1; i >= 0; i--) {
      rep(j, 2) if (auto y = G[i][j]; y != -1) P[y] = max(P[y], P[i]);
      res[P[i]].push_back(i);
   }
   return res;
}
int brut(const graph &G) {
   int n = sz(G);
   vi cnt(n);
   vi vis(n);
   rep(i, n) {
      vis.assign(n, false);
      vector<int> Q(all(G[i]));
      while (sz(Q)) {
         auto x = Q.back();
         Q.pop_back();
         if (x == -1 or vis[x])
            continue;
         cnt[x]++;
         vis[x] = true;
         Q.insert(Q.end(), all(G[x]));
      }
   }
   ll res = 0;
   debug(cnt);
   rep(i, n) res += inv(cnt[i] + 1);
   return res % mod;
}

typedef array<int, 3> tpl;

int solve(const auto &V) {
   auto G = build_graph(V);
   auto P = build_parent(G);
   int n = sz(V);

   debug(G);
   debug(P);
   // L,R
   array<FT, 2> ft = {FT(2 * n + 3), FT(2 * n + 3)};
   vi cnt(n);
   vector<vector<tpl>> T(n);

   auto get = [&](pii T) {
      auto [p, q] = T;
      return ft[0].query(q) - ft[1].query(p);
   };

   for (int i = n - 1; i >= 0; i--) {
      for (auto y : P[i])
         cnt[y] -= get(V[y]);
      cnt[i] += get(V[i]);

      array<int, 2> przedzil = {V[i].st, V[i].nd};
      array<int, 2> A = {1, 1};
      for (auto [typ, x, val] : T[i]) {
         A[typ] += val;
         ft[typ].update(x, -val);
      }
      rep(i, 2) ft[i].update(przedzil[i], A[i]);
      rep(j, 2) if (auto y = G[i][j]; y != -1) T[y].push_back({j, przedzil[j], A[j]});
   }
   ll res = 0;
   debug(cnt);

   rep(i, n) res += inv(cnt[i] + 1);
   return res % mod;
}

vector<pii> gen_test(int n) {
   vector<int> X(2 * n);
   iota(all(X), 0ll);
   random_shuffle(all(X));
   vector<pii> res;
   rep(i, n) res.push_back(minmax(X[i * 2] + 1, X[2 * i + 1] + 1));
   return res;
}

int32_t main() {
   _upgrade;
   int n;
   cin >> n;

   vector<pii> V(n);
   for (auto &[a, b] : V)
      cin >> a >> b;
   {
      //    while (true) {
      //       auto V = gen_test(1000);
      //       debug(V);

      //   auto G = build_graph(V);
      //   debug(G.back());
      //   auto res1 = brut(G);
      auto res = solve(V);
      //   assert(res1 == res);
      cout << res << endl;
   }
}