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

typedef pair <int, int> pii;
typedef long long ll;

const int N = 2e5 + 105;

struct atom {
	int n, t;
	atom (int a = 0, int b = 0) : n(a), t(b) {}
	bool operator < (const atom &A) const {	
		if (n != A.n) return n < A.n;
		return t > A.t;
	}
};

multiset < pair <atom, int> > all;
vector <int> a[N];
vector <atom> b[N];
vector <int> vec[N];
atom mx[N], mn[N];
int id[N], seq[N], now[N], len;
int n, d, l; ll ans, sum;

bool cmp(int i, int j) {
	return mx[i] < mx[j];
}

int val[N];
int calc(atom x) {
	if (x.n >= 2) return len - 1;
	return len - val[x.t];
}

const int B = 450;

int s1[N], s2[N];

void add(int x, int y) {
	s1[x] += y;
	s2[x / B] += y;
}

int query(int x) {
	int ans = 0;
	x = min(x, l);
	for (int i = 0; i <= x / B - 1; i++) ans += s2[i];
	for (int i = x / B * B; i <= x; i++) ans += s1[i];
	return ans;
}

int main() {

#ifdef xay5421
	freopen("a.in","r",stdin);
#endif
	scanf("%d%d%d", &n, &d, &l); l += 20;
	for (int i = 1; i <= n; i++) {
		int id, t;
		scanf("%d%d", &id, &t);
		a[id].push_back(t);
	}
	for (int i = 1; i <= d; i++) {
		if (a[i].size()) {
			vector <pii> seg[20];
			seq[++len] = a[i].back() + (a[i].size() - 1) * 20; id[len] = i; mx[i] = atom(0, 0); mn[i] = atom(1, seq[len]);
			if ((int)a[i].size() >= 2) b[i].push_back(atom(2, a[i][(int)a[i].size() - 2] + a[i].back() + (a[i].size() - 2) * 20));
			int cnt = 0;
			for (auto j : a[i]) {
				// b[i].push_back(atom(1, j + cnt * 20)); ++cnt;
				seg[j % 20].emplace_back(j, j + cnt * 20); ++cnt;
				if (mx[i].n <= 5) {
					++mx[i].n;
					mx[i].t += j;
				}
			}
			for (int j = 0; j < 20; j++) {
				int now = 0, x = j;
				while (now < (int)seg[j].size() && x <= l) {
					if (seg[j][now].second < x) ++now;
					else {
						x = max(x, seg[j][now].first);
						if (x > l) break;
						b[i].push_back(atom(1, x));
						x += 20;
					}
				}
			}
			stable_sort(b[i].begin(), b[i].end());
			reverse(b[i].begin(), b[i].end());
			all.insert(make_pair(b[i][0], i));
			if (b[i][0].n == 1) add(b[i][0].t, 1);
		}
	}
	sort(id + 1, id + len + 1, cmp);
	sort(seq + 1, seq + len + 1);
	for (int i = 0, j = 1; i <= l; i++) {
        while (j <= len && seq[j] < i) ++j;
		val[i] = j;
	}
	for (int i = 1; i <= d; i++) {
		if (b[i].size()) sum += calc(b[i][0]);
	}
	// fprintf(stderr, "sum = %lld, len = %d\n", sum, len);
	int flag = 0, ff = 0, SZ = 0;
	for (int _ = len; _ >= 1; _--) {
		int i = id[_];
		// fprintf(stderr, "i = %d\n", i);
		if (!flag) {
			while (all.size()) {
				auto it = --all.end();
				if (mx[i] < it -> first) {
					// fprintf(stderr, "it -> second = %d\n", it -> second);
					++now[it -> second];
					sum -= calc(it -> first);
					// fprintf(stderr, "calc({%d, %d}} = %d\n", (it -> first).n, (it -> first).t, calc(it -> first));
					if ((it -> first).n == 1) add((it -> first).t, -1);
					if (now[it -> second] < (int)b[it -> second].size()) {
						all.insert(make_pair(b[it -> second][now[it -> second]], it -> second));
						sum += calc(b[it -> second][now[it -> second]]);
						// fprintf(stderr, "calc({%d, %d}) = %d\n", b[it -> second][now[it -> second]].n, b[it -> second][now[it -> second]].t, calc(b[it -> second][now[it -> second]]));
						if (b[it -> second][now[it -> second]].n == 1) add(b[it -> second][now[it -> second]].t, 1);
					}
					all.erase(it);
				} else break;
			}
		} else {
			while (ff < mx[i].t) {
				for (auto j : vec[ff]) {
					sum -= calc(b[j][now[j]]);
					// assert(b[j][now[j]].n == 1);
					if (b[j][now[j]].n == 1) add(b[j][now[j]].t, -1);
					++now[j];
					if (now[j] < (int)b[j].size()) {
						vec[b[j][now[j]].t].push_back(j);
						// fprintf(stderr, "ff = %d, b[j][now[j]].t = %d\n", ff, b[j][now[j]].t);
						assert(b[j][now[j]].t > ff);
						sum += calc(b[j][now[j]]);
						add(b[j][now[j]].t, 1);
					} else --SZ;
				}
				++ff;
			}
		}
		if (mx[i].n == 1 && !flag) {
			flag = 1; SZ = all.size();
			for (auto j : all) {
				int id = j.second;
				// assert(j.first.n == 1);
				// assert(b[id][now[id]].n == 1);
				vec[b[id][now[id]].t].push_back(id);
			}
		}
		// fprintf(stderr, "sum = %d\n", sum);
		ans += sum - calc(b[i][now[i]]);
		ans -= ((!flag ? all.size() : SZ) - 1 - query(l) + query(mn[i].t));
		// fprintf(stderr, "ans = %lld\n", ans);
	}
	printf("%lld\n", ans);
	return 0;
}