#include <bits/stdc++.h>
#pragma GCC optimize(3)
namespace IO {
char ibuf[1 << 21], *p1 = ibuf, *p2 = ibuf, obuf[1 << 21], *p = obuf;
struct outflush {
  ~outflush() {
    (void)(fwrite(::IO::obuf, 1, ::IO::p - ::IO::obuf, stdout), fflush(stdout),
           ::IO::p = ::IO::obuf);
  }
} flushout;
}  // namespace IO
namespace mystl {
inline int rec() {
  int ch;
  for (ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++);
       isspace(ch);
       ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++))
    ;
  return ch;
}
inline bool rei(char &c) {
  int ch;
  for (ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++);
       isspace(ch);
       ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++))
    ;
  if (ch == EOF) return false;
  c = ch;
  return true;
}
inline bool rei(char *s) {
  if (!rei(*s)) return false;
  int ch;
  while (*++s = ch = (::IO::p1 == ::IO::p2 &&
                              (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                          fread(::IO::ibuf, 1, 1 << 21, stdin),
                               ::IO::p1 == ::IO::p2)
                          ? EOF
                          : *::IO::p1++),
         ch != EOF && !isspace(ch))
    ;
  *s = 0;
  return true;
}
template <class T>
inline bool rei(T &x) {
  bool f = true;
  int ch;
  for (ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++);
       !isdigit(ch);
       ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++)) {
    if (ch == EOF) return false;
    f = ch != '-';
  }
  x = 0;
  if (f)
    while (isdigit(ch))
      x = x * 10 + (ch & 15),
      ch = (::IO::p1 == ::IO::p2 &&
                    (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                ? EOF
                : *::IO::p1++);
  else
    while (isdigit(ch))
      x = x * 10 - (ch & 15),
      ch = (::IO::p1 == ::IO::p2 &&
                    (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                ? EOF
                : *::IO::p1++);
  return true;
}
inline void pti(const char &c) {
  (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
       (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
   *::IO::p++ = c);
}
inline void pti(const char *s) {
  while (*s)
    (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
         (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
     *::IO::p++ = *s++);
}
template <class T>
inline void pti(T x) {
  char buf[sizeof(T) * 3], *p = buf + 1;
  if (x >= 0)
    *buf = (x % 10) | 48, x /= 10;
  else
    (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
         (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
     *::IO::p++ = '-'),
        *buf = (-(x % 10)) | 48, x = -(x / 10);
  while (x) *p++ = (x % 10) | 48, x /= 10;
  while (p != buf)
    (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
         (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
     *::IO::p++ = *--p);
}
template <class T>
inline void pri(const T &x) {
  pti(x), (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
               (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
           *::IO::p++ = ' ');
}
template <class T>
inline void prn(const T &x) {
  pti(x), (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
               (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
           *::IO::p++ = '\n');
}
template <class T, class... Args>
inline bool rei(T &&x, Args &&...args) {
  return rei(std::forward<T>(x)) ? rei(args...) : false;
}
template <class T, class... Args>
inline void pti(const T &x, const Args &...args) {
  pti(x), pti(args...);
}
template <class T, class... Args>
inline void pri(const T &x, const Args &...args) {
  pri(x), pri(args...);
}
template <class T, class... Args>
inline void prn(const T &x, const Args &...args) {
  pri(x), prn(args...);
}
template <class T1, class T2>
inline T1 &cmax(T1 &a, const T2 &b) {
  return a < b ? a = b : a;
}
template <class T1, class T2>
inline T1 &cmin(T1 &a, const T2 &b) {
  return a > b ? a = b : a;
}
template <class T>
inline T lowbit(const T &x) {
  return x & -x;
}
}  // namespace mystl
using namespace std;
using namespace mystl;
const int MAXN = 300005;
int n;
int a[MAXN];
int mx[MAXN], mn[MAXN];
int t[MAXN << 1];
long long ans;
void calc(int l, int r) {
  if (l == r) {
    return;
  }
  int mid = (l + r) >> 1;
  mx[mid] = mn[mid] = a[mid];
  mx[mid + 1] = mn[mid + 1] = a[mid + 1];
  for (int i = mid - 1, i_end = l; i >= i_end; --i) {
    mx[i] = max(a[i], mx[i + 1]);
    mn[i] = min(a[i], mn[i + 1]);
  }
  for (int i = mid + 2, i_end = r; i <= i_end; ++i) {
    mx[i] = max(a[i], mx[i - 1]);
    mn[i] = min(a[i], mn[i - 1]);
  }
  for (int i = mid, i_end = l; i >= i_end; --i) {
    int x = mx[i] - mn[i] + i;
    if (x > mid && x <= r && mx[x] < mx[i] && mn[x] > mn[i]) {
      ++ans;
    }
  }
  for (int i = mid + 1, i_end = r; i <= i_end; ++i) {
    int x = i - mx[i] + mn[i];
    if (x <= mid && x >= l && mx[x] < mx[i] && mn[x] > mn[i]) {
      ++ans;
    }
  }
  int j = mid + 1;
  int k = mid + 1;
  for (int i = mid, i_end = l; i >= i_end; --i) {
    while (j <= r && mn[j] > mn[i]) {
      ++t[mx[j] - j + n];
      ++j;
    }
    while (k < j && mx[k] < mx[i]) {
      --t[mx[k] - k + n];
      ++k;
    }
    ans += t[mn[i] - i + n];
  }
  while (k < j) {
    --t[mx[k] - k + n];
    ++k;
  }
  j = mid;
  k = mid;
  for (int i = mid + 1, i_end = r; i <= i_end; ++i) {
    while (j >= l && mn[j] > mn[i]) {
      ++t[mx[j] + j];
      --j;
    }
    while (k > j && mx[k] < mx[i]) {
      --t[mx[k] + k];
      --k;
    }
    ans += t[mn[i] + i];
  }
  while (k > j) {
    --t[mx[k] + k];
    --k;
  }
  calc(l, mid);
  calc(mid + 1, r);
}
signed main() {
  rei(n);
  for (int i = 1, i_end = n, x, y; i <= i_end; ++i) {
    rei(x, y);
    a[x] = y;
  }
  calc(1, n);
  prn(ans + n);
  return 0;
}
