#include <bits/stdc++.h>
using namespace std;

using i64 = long long;

constexpr int P = 1e9 + 7;
struct mint {
  int v;
  mint(i64 x = 0) : v(x % P) {x < 0 ? x += P : 0;}
  int val() const {return v;}
  mint operator-() const {return -v;}
  mint &operator+=(const mint &b) {
    v += b.v - P, v += v >> 31 & P;
    return *this;
  }
  mint &operator-=(const mint &b) {
    v -= b.v, v += v >> 31 & P;
    return *this;
  }
  mint &operator*=(const mint &b) {
    v = i64(v) * b.v % P;
    return *this;
  }
  mint &operator/=(const mint &b) {return *this *= b.inv();}
  mint pow(int n) const {
    mint c = 1, a = *this;
    for (; n; a *= a, n /= 2) if (n % 2) c *= a;
    return c;
  }
  mint inv() const {return this->pow(P - 2);}
  friend mint operator+(mint a, const mint &b) {return a += b;}
  friend mint operator-(mint a, const mint &b) {return a -= b;}
  friend mint operator*(mint a, const mint &b) {return a *= b;}
  friend mint operator/(mint a, const mint &b) {return a /= b;}
  friend ostream &operator<<(ostream &os, const mint &a) {
    return os << a.val();
  }
};

constexpr int N = 2e5 + 5;
mint sum1[4 * N], sum2[4 * N], tag1[4 * N], tag2[4 * N];

#define ls (2 * i)
#define rs (2 * i + 1)
void upd(int i) {
  sum1[i] = sum1[ls] + sum1[rs];
  sum2[i] = sum2[ls] + sum2[rs];
}
void push1(int i, mint v) {
  sum1[i] *= v;
  tag1[i] *= v;
}
void push2(int i, mint v) {
  sum2[i] *= v;
  tag2[i] *= v;
}
void down(int i) {
  if (tag1[i].val() != 1) {
    push1(ls, tag1[i]);
    push1(rs, tag1[i]);
    tag1[i] = 1;
  }
  if (tag2[i].val() != 1) {
    push2(ls, tag2[i]);
    push2(rs, tag2[i]);
    tag2[i] = 1;
  }
}
void build(int i, int l, int r) {
  tag1[i] = tag2[i] = 1;
  sum1[i] = sum2[i] = 0;
  if (l == r) {
    return;
  }
  int mid = (l + r) / 2;
  build(ls, l, mid);
  build(rs, mid + 1, r);
  upd(i);
}
void modify(int i, int l, int r, int x, mint v1, mint v2) {
  if (l == r) {
    sum1[i] = v1;
    sum2[i] = v2;
    return;
  }
  down(i);
  int mid = (l + r) / 2;
  if (x <= mid)
    modify(ls, l, mid, x, v1, v2);
  else
    modify(rs, mid + 1, r, x, v1, v2);
  upd(i);
}
void range(int i, int l, int r, int ql, int qr, mint v1, mint v2) {
  if (ql > r || qr < l) return;
  if (ql <= l && qr >= r) return push1(i, v1), push2(i, v2);
  down(i);
  int mid = (l + r) / 2;
  range(ls, l, mid, ql, qr, v1, v2);
  range(rs, mid + 1, r, ql, qr, v1, v2);
  upd(i);
}
mint query1(int i, int l, int r, int ql, int qr) {
  if (ql > r || qr < l) return 0;
  if (ql <= l && qr >= r) return sum1[i];
  down(i);
  int mid = (l + r) / 2;
  mint res = 0;
  if (ql <= mid)
    res += query1(ls, l, mid, ql, qr);
  if (qr > mid)
    res += query1(rs, mid + 1, r, ql, qr);
  return res;
}
mint query2(int i, int l, int r, int ql, int qr) {
  if (ql > r || qr < l) return 0;
  if (ql <= l && qr >= r) return sum2[i];
  down(i);
  int mid = (l + r) / 2;
  mint res = 0;
  if (ql <= mid)
    res += query2(ls, l, mid, ql, qr);
  if (qr > mid)
    res += query2(rs, mid + 1, r, ql, qr);
  return res;
}

struct BIT {
  int n;
  vector<int> a;
  BIT(int n = 0) : n(n), a(n + 1) {}
  void modify(int x, int v) {
    for (int i = x + 1; i <= n; i += i & -i) {
      a[i] += v;
    }
  }
  int query(int x) {
    int res = 0;
    for (int i = x + 1; i > 0; i -= i & -i) {
      res += a[i];
    }
    return res;
  }
};

int main() {
  cin.tie(0)->sync_with_stdio(0);
  int n;
  cin >> n;
  vector<int> a(n), b(n);
  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    --x, --y;
    a[x] = y;
    b[x] = n - y - 1;
  }
  vector<mint> pw2(n + 1);
  pw2[0] = 1;
  for (int i = 1; i <= n; i++) {
    pw2[i] = pw2[i - 1] * 2;
  }
  mint iv2 = mint(2).inv();
  mint ans = 0;
  for (int i = 0; i < n - 1; i++) {
    ans += pw2[i] * (pw2[n - i - 1] - 1) * 4;
  }
  auto solve = [&](auto a) {
    build(1, 0, n - 1);
    BIT A(n), B(n);
    for (int i = 0; i < n; i++) {
      B.modify(a[i], 1);
    }
    mint res = 0;
    for (int i = 0; i < n - 1; i++) {
      B.modify(a[i], -1);
      range(1, 0, n - 1, 0, a[i] - 1, iv2, 1);
      modify(1, 0, n - 1, a[i], pw2[A.query(a[i]) + n - i - 1 - B.query(a[i])],
          pw2[A.query(a[i])]);
      res += query1(1, 0, n - 1, a[i], n - 1);
      res -= query2(1, 0, n - 1, a[i], n - 1);
      A.modify(a[i], 1);
      range(1, 0, n - 1, a[i] + 1, n - 1, 2, 2);
    }
    return res * 2;
  };
  ans -= solve(a) + solve(b);
  cout << ans << "\n";
  return 0;
}