#include <bits/stdc++.h>
using namespace std;
namespace {
using Integer = long long;
template <class T, class S>
istream& operator>>(istream& is, pair<T, S>& p) {
  return is >> p.first >> p.second;
}
template <class T>
istream& operator>>(istream& is, vector<T>& vec) {
  for (T& val : vec) is >> val;
  return is;
}
template <class T>
istream& operator,(istream& is, T& val) {
  return is >> val;
}
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& p) {
  return os << p.first << " " << p.second;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  for (size_t i = 0; i < vec.size(); i++)
    os << vec[i] << (i == vec.size() - 1 ? "" : " ");
  return os;
}
template <class T>
ostream& operator,(ostream& os, const T& val) {
  return os << " " << val;
}
template <class H>
void print(const H& head) {
  cout << head;
}
template <class H, class... T>
void print(const H& head, const T&... tail) {
  cout << head << " ";
  print(tail...);
}
template <class... T>
void println(const T&... values) {
  print(values...);
  cout << endl;
}
template <class H>
void eprint(const H& head) {
  cerr << head;
}
template <class H, class... T>
void eprint(const H& head, const T&... tail) {
  cerr << head << " ";
  eprint(tail...);
}
template <class... T>
void eprintln(const T&... values) {
  eprint(values...);
  cerr << endl;
}
class range {
  Integer start_, end_, step_;

 public:
  struct range_iterator {
    Integer val, step_;
    range_iterator(Integer v, Integer step) : val(v), step_(step) {}
    Integer operator*() { return val; }
    void operator++() { val += step_; }
    bool operator!=(range_iterator& x) {
      return step_ > 0 ? val < x.val : val > x.val;
    }
  };
  range(Integer len) : start_(0), end_(len), step_(1) {}
  range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
  range(Integer start, Integer end, Integer step)
      : start_(start), end_(end), step_(step) {}
  range_iterator begin() { return range_iterator(start_, step_); }
  range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char* str, size_t size) {
  return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
  return k == 0    ? z
         : k == 1  ? z * x
         : (k & 1) ? my_pow(x * x, k >> 1, z * x)
                   : my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
  return k == 0    ? z % M
         : k == 1  ? z * x % M
         : (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
                   : my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
  return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; }
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
               chrono::steady_clock::now().time_since_epoch())
               .count());
template <class T>
string join(const vector<T>& v, const string& sep) {
  stringstream ss;
  for (size_t i = 0; i < v.size(); i++) {
    if (i > 0) ss << sep;
    ss << v[i];
  }
  return ss.str();
}
inline string operator*(string s, int k) {
  string ret;
  while (k) {
    if (k & 1) ret += s;
    s += s;
    k >>= 1;
  }
  return ret;
}
}  // namespace
constexpr long long mod = 9_ten + 7;
template <class T>
vector<T> compress(vector<T> a) {
  auto b = a;
  sort(b.begin(), b.end());
  b.erase(unique(b.begin(), b.end()), b.end());
  for (int i = 0; i < a.size(); i++) {
    a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
  }
  return a;
}
template <class Value = int>
class SegmentTree {
  int n;
  vector<Value> V;
  Value DEFAULT_VALUE;
  static Value default_evaluate(Value a, Value b) { return a + b; }
  function<Value(Value, Value)> evaluate;
  Value RangeEvaluation(int a, int b, int at, int l, int r) {
    if (r <= a || b <= l) return DEFAULT_VALUE;
    if (a <= l && r <= b)
      return V[at];
    else {
      Value val_left = RangeEvaluation(a, b, at * 2 + 1, l, (l + r) / 2);
      Value val_right = RangeEvaluation(a, b, at * 2 + 2, (l + r) / 2, r);
      return evaluate(val_left, val_right);
    }
  }

 public:
  SegmentTree(int size, Value DEFAULT = 0,
              function<Value(Value, Value)> eval = default_evaluate) {
    DEFAULT_VALUE = DEFAULT;
    evaluate = eval;
    n = 1;
    while (n < size) n <<= 1;
    V = vector<Value>(2 * n - 1, DEFAULT_VALUE);
  }
  void update(int at, Value new_val) {
    at += n - 1;
    V[at] = new_val;
    while (at > 0) {
      at = (at - 1) / 2;
      V[at] = evaluate(V[at * 2 + 1], V[at * 2 + 2]);
    }
  }
  Value RangeEvaluation(int l, int r) {
    if (l >= r) return DEFAULT_VALUE;
    if (l >= n) return DEFAULT_VALUE;
    return RangeEvaluation(l, r, 0, 0, n);
  }
};
int main() {
  int n;
  cin >> n;
  vector<pair<int, int>> p(n);
  cin >> p;
  {
    vector<int> x(n);
    for (int i = 0; i < n; i++) {
      x[i] = p[i].first;
    }
    x = compress(x);
    for (int i = 0; i < n; i++) {
      p[i].first = x[i];
    }
  }
  SegmentTree<int> seg(n + 10);
  vector<int> y(n);
  iota(y.begin(), y.end(), 0);
  sort(y.begin(), y.end(), [&](int i, int j) {
    if (p[i].second == p[j].second) return p[i].first < p[j].first;
    return p[i].second < p[j].second;
  });
  long long ans = 0;
  map<int, int> z;
  for (int i = 0; i < n; i++) {
    int x = p[i].first;
    z[x]++;
  }
  for (auto& p : z) {
    seg.update(p.first, 1);
  }
  for (int i = 0; i < n; i++) {
    ans += (long long)(z.size() + 1) * (long long)(z.size()) / 2;
    int yi = y[i];
    {
      int x = p[yi].first;
      long long s = seg.RangeEvaluation(0, x);
      ans -= (s + 1) * s / 2;
    }
    int j = i;
    while (j + 1 < n && p[y[j + 1]].second == p[yi].second) {
      j++;
    }
    {
      int x = p[y[j]].first;
      long long s = seg.RangeEvaluation(x + 1, n + 10);
      ans -= (s + 1) * s / 2;
    }
    for (int jj = i + 1; jj <= j; jj++) {
      int yj = y[jj];
      int yk = y[jj - 1];
      int xj = p[yj].first;
      int xk = p[yk].first;
      if (xj == xk) continue;
      long long s = seg.RangeEvaluation(xk + 1, xj);
      ans -= (s + 1) * s / 2;
    }
    for (int jj = i; jj <= j; jj++) {
      int yj = y[jj];
      int x = p[yj].first;
      z[x]--;
      if (z[x] == 0) {
        z.erase(x);
        seg.update(x, 0);
      }
    }
    i = j;
  }
  println(ans);
  return 0;
}
