There is an infinite sequence consisting of all positive integers in the increasing order: p = {1, 2, 3, ...}. We performed n swap operations with this sequence. A swap(a, b) is an operation of swapping the elements of the sequence on positions a and b. Your task is to find the number of inversions in the resulting sequence, i.e. the number of such index pairs (i, j), that i < j and pi > pj.

Input

The first line contains a single integer n (1 ≤ n ≤ 105) — the number of swap operations applied to the sequence.

Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109, ai ≠ bi) — the arguments of the swap operation.

Output

Print a single integer — the number of inversions in the resulting sequence.

Examples

Input

2
4 2
1 4


Output

4


Input

3
1 6
3 4
2 5


Output

15

Note

In the first sample the sequence is being modified as follows: <image>. It has 4 inversions formed by index pairs (1, 4), (2, 3), (2, 4) and (3, 4).
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll llinf = (1ll << 61) - 1;
const double eps = 1e-6, ldeps = 1e-9;
struct Dbg {
  static constexpr auto &os = cout;
  template <class C>
  static auto dud(C *x) -> decltype(os << *x, 0);
  template <class C>
  static char dud(...);
  template <class C>
  typename enable_if<sizeof dud<C>(0) != 1, Dbg &>::type operator<<(
      const C &x) {
    os << x;
    return *this;
  }
  template <class C>
  Dbg &dump(C b, C e) {
    *this << "\n[";
    int cur = 0;
    for (C i = b; i != e and cur < 26; i++, cur++)
      *this << ", " + 2 * (i == b) << *i;
    return *this << ']';
  }
  template <class C>
  typename enable_if<sizeof dud<C>(0) == 1, Dbg &>::type operator<<(
      const C &x) {
    return dump(begin(x), end(x));
  }
  template <class C, size_t X>
  typename enable_if<sizeof(C) != 1, Dbg &>::type operator<<(C (&x)[X]) {
    return dump(begin(x), end(x));
  }
  template <class B, class C>
  Dbg &operator<<(const pair<B, C> &x) {
    return *this << '{' << x.first << ", " << x.second << '}';
  }
  template <class C, size_t Y>
  struct TP {
    void operator()(Dbg &os, const C &t) {
      TP<C, Y - 1>()(os, t);
      os << ", " << get<Y - 1>(t);
    }
  };
  template <class C>
  struct TP<C, 1> {
    void operator()(Dbg &os, const C &t) { os << get<0>(t); }
  };
  template <class... C>
  Dbg &operator<<(const tuple<C...> &t) {
    os << '{', TP<decltype(t), sizeof...(C)>()(*this, t);
    return *this << '}';
  }
  Dbg &operator<<(ostream &(*x)(std::ostream &)) {
    os << x;
    return *this;
  }
} dbg;
void err(istringstream *iss) { delete iss; }
template <class C, class... Args>
void err(istringstream *iss, const C &val, const Args &...args) {
  string name;
  *iss >> name;
  if (name.back() == ',') name.pop_back();
  dbg << name << " = " << val << "; ", err(iss, args...);
}
int n, K, T, Q, cn;
const int inf = 1000000007, mxn = 200005;
int a[mxn];
ll inv1[21], inv2[21];
ll mergeSort(int l, int r, int x) {
  if (l >= r) return 0;
  int mid = (l + r) >> 1;
  ll invCnt = mergeSort(l, mid, x - 1) + mergeSort(mid + 1, r, x - 1);
  for (int i = l, j = mid + 1; i <= mid || j <= r;) {
    if (j > r || (i <= mid && a[i] <= a[j]))
      i++;
    else
      j++, invCnt += mid - i + 1, inv1[x] += mid - i + 1;
  }
  for (int i = l, j = mid + 1; i <= mid || j <= r;) {
    if (j > r || (i <= mid && a[i] < a[j]))
      i++, inv2[x] += r - j + 1;
    else
      j++;
  }
  inplace_merge(a + l, a + mid + 1, a + r + 1);
  return invCnt;
}
map<int, int> m;
vector<int> v;
int occ(int x, int y) {
  return x > y ? 0
               : int(upper_bound(begin(v), end(v), y) -
                     lower_bound(begin(v), end(v), x));
}
signed main() {
  ios::sync_with_stdio(0);
  cin.tie(NULL);
  cout.precision(11);
  cin >> n;
  for (int i = 0; i < n; i++) {
    int a, b;
    cin >> a >> b;
    if (!m[a]) m[a] = a;
    if (!m[b]) m[b] = b;
    swap(m[a], m[b]);
  }
  n = 0;
  ll inv = 0;
  v.resize(int(m.size()));
  for (auto &i : m) {
    v[n] = i.first, a[n++] = i.second;
  }
  inv += mergeSort(0, n - 1, 20);
  for (auto &i : m) {
    if (i.first == i.second) continue;
    int x = min(i.first, i.second), y = max(i.first, i.second);
    inv += max(0, y - 1 - (x + 1) + 1) - occ(x + 1, y - 1);
  }
  cout << inv << '\n';
}
