// Problem: P9057 [Ynoi2004] rpfrdtzls
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P9057
// Memory Limit: 512 MB
// Time Limit: 2500 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef __int128 lll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<ll, ll> pii;

namespace IO {
	const int maxn = 1 << 20;
	
    char ibuf[maxn], *iS, *iT, obuf[maxn], *oS = obuf;

	inline char gc() {
		return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, maxn, stdin), (iS == iT ? EOF : *iS++) : *iS++);
	}

	template<typename T = int>
	inline T read() {
		char c = gc();
		T x = 0;
		bool f = 0;
		while (c < '0' || c > '9') {
			f |= (c == '-');
			c = gc();
		}
		while (c >= '0' && c <= '9') {
			x = (x << 1) + (x << 3) + (c ^ 48);
			c = gc();
		}
		return f ? ~(x - 1) : x;
	}

	inline void flush() {
		fwrite(obuf, 1, oS - obuf, stdout);
		oS = obuf;
	}
	
	struct Flusher {
		~Flusher() {
			flush();
		}
	} AutoFlush;

	inline void pc(char ch) {
		if (oS == obuf + maxn) {
			flush();
		}
		*oS++ = ch;
	}

	template<typename T>
	inline void write(T x) {
		static char stk[64], *tp = stk;
		if (x < 0) {
			x = ~(x - 1);
			pc('-');
		}
		do {
			*tp++ = x % 10;
			x /= 10;
		} while (x);
		while (tp != stk) {
			pc((*--tp) | 48);
		}
	}
	
	template<typename T>
	inline void writesp(T x) {
		write(x);
		pc(' ');
	}
	
	template<typename T>
	inline void writeln(T x) {
		write(x);
		pc('\n');
	}
}

using IO::read;
using IO::write;
using IO::pc;
using IO::writesp;
using IO::writeln;

const int maxn = 500100;

ll n, m, K, f[maxn], g[maxn], h[maxn], b[maxn], c[maxn], ans[maxn], nt;
int pre[maxn], nxt[maxn];

struct List1 {
	int nxt[maxn << 1], hd[maxn], len;
	pii to[maxn << 1];
	
	inline void add(int x, pii y) {
		to[++len] = y;
		nxt[len] = hd[x];
		hd[x] = len;
	}
} L1, L2;

struct List2 {
	int to[maxn], nxt[maxn], len, hd[maxn];
	
	inline void add(int x, int y) {
		to[++len] = y;
		nxt[len] = hd[x];
		hd[x] = len;
	}
} L3;

struct que {
	ll op, l, r, x;
} a[maxn];

struct BIT1 {
	ll c[maxn];
	
	inline void update(ll x, ll d) {
		for (int i = x; i <= nt; i += (i & (-i))) {
			c[i] += d;
		}
	}
	
	inline void update(ll l, ll r, ll x) {
		if (l > r) {
			return;
		}
		update(l, x);
		update(r + 1, -x);
	}
	
	inline ll query(ll x) {
		ll res = 0;
		for (int i = x; i; i -= (i & (-i))) {
			res += c[i];
		}
		return res;
	}
} T1, T3, T4;

struct BIT2 {
	ll c[maxn];
	
	inline void update(ll x, ll d) {
		for (int i = x; i <= n; i += (i & (-i))) {
			c[i] += d;
		}
	}
	
	inline ll query(ll x) {
		ll res = 0;
		for (int i = x; i; i -= (i & (-i))) {
			res += c[i];
		}
		return res;
	}
	
	inline ll query(ll l, ll r) {
		return l > r ? 0 : query(r) - query(l - 1);
	}
} T2;

inline void update(int i, int k) {
	int t = k, y = 0;
	lll x = b[k];
	while (nxt[t] && x <= K) {
		t = nxt[t];
		x *= b[t];
		y += c[t] + 1;
	}
	f[k] += (i - g[k]) * h[k];
	g[k] = i;
	h[k] = y + 1;
	y += c[k] + 1;
	for (int p = pre[k]; p && t >= pre[k]; p = pre[p]) {
		x *= b[p];
		while (x / b[t] > K) {
			x /= b[t];
			y -= c[t] + 1;
			t = pre[t];
		}
		f[p] += (i - g[p]) * h[p];
		g[p] = i;
		h[p] = y + 1;
		y += c[p] + 1;
	}
}

void solve() {
	n = read();
	m = read();
	K = read();
	nt = 1;
	for (int i = 1; i <= m; ++i) {
		a[i].op = read();
		a[i].l = read();
		a[i].r = read();
		if (a[i].op == 1) {
			a[i].x = read();
			L1.add(a[i].l, pii(a[i].x, ++nt));
			L3.add(a[i].r + 1, nt);
		} else {
			L2.add(a[i].l - 1, pii(nt, -i));
			L2.add(a[i].r, pii(nt, i));
		}
	}
	b[nt] = K + 1;
	set<int> S;
	S.insert(0);
	S.insert(nt);
	g[nt] = h[nt] = 1;
	for (int i = 1; i <= n; ++i) {
		for (int _ = L3.hd[i]; _; _ = L3.nxt[_]) {
			int j = L3.to[_];
			j = nt - j + 1;
			if (b[j] == 1) {
				T2.update(j, -1);
				int k = *S.lower_bound(j);
				--c[k];
				T3.update(pre[k] + 1, j, -1);
				T4.update(pre[k] + 1, j, -i);
				update(i, k);
			} else {
				int k = nxt[j];
				T1.update(pre[j] + 1, j, f[j] + (i - g[j]) * h[j]);
				T1.update(j + 1, k, f[k] + (i - g[k]) * h[k]);
				T3.update(pre[j] + 1, j, c[k]);
				T4.update(pre[j] + 1, j, c[k] * i);
				c[k] += c[j];
				f[j] = g[j] = h[j] = f[k] = g[k] = h[k] = b[j] = c[j] = 0;
				if (pre[j]) {
					nxt[pre[j]] = nxt[j];
				}
				if (nxt[j]) {
					pre[nxt[j]] = pre[j];
				}
				S.erase(j);
				update(i, k);
			}
			b[j] = 0;
		}
		for (int _ = L1.hd[i]; _; _ = L1.nxt[_]) {
			pii p = L1.to[_];
			p.scd = nt - p.scd + 1;
			int j = p.scd;
			b[j] = p.fst;
			if (p.fst == 1) {
				T2.update(j, 1);
				int k = *S.lower_bound(j);
				++c[k];
				T3.update(pre[k] + 1, j, 1);
				T4.update(pre[k] + 1, j, i);
				update(i, k);
			} else {
				auto it = S.insert(j).fst;
				pre[j] = *prev(it);
				nxt[j] = *next(it);
				T1.update(pre[j] + 1, nxt[j], f[nxt[j]] + (i - g[nxt[j]]) * h[nxt[j]]);
				f[nxt[j]] = g[nxt[j]] = h[nxt[j]] = 0;
				nxt[pre[j]] = pre[nxt[j]] = j;
				int k = nxt[j];
				c[j] = T2.query(pre[j] + 1, j);
				c[k] = T2.query(j + 1, k);
				T3.update(pre[j] + 1, j, -c[k]);
				T4.update(pre[j] + 1, j, -c[k] * i);
				update(i, k);
			}
		}
		for (int _ = L2.hd[i]; _; _ = L2.nxt[_]) {
			pii p = L2.to[_];
			int j = nt - p.fst + 1;
			ll res = T1.query(j) + T3.query(j) * (i + 1) - T4.query(j);
			int k = *S.lower_bound(j);
			res += f[k] + (i + 1 - g[k]) * h[k];
			if (p.scd > 0) {
				ans[p.scd] += res;
			} else {
				ans[-p.scd] += -res;
			}
		}
	}
	for (int i = 1; i <= m; ++i) {
		if (a[i].op == 2) {
			writeln(ans[i]);
		}
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}