#include <cstdio>
#include <cassert>
#include <algorithm>

#define maxN 2048
#define INFI 0x3f3f3f3f

using namespace std;

struct skl {
	int sum;
	int right;

	void update();
};

int N, M;
int dia[maxN];
int lst[maxN][2];

skl pool[2 * maxN * maxN];
int pool_head = 0;

inline void skl::update() {
	sum = (this + 1)->sum;
	if (right != INFI) sum += pool[right].sum;
}

/*
void recursive_print(skl* lista) {
	if (lista == NULL) return;

	static int level = -1;
	++level;

	printf("%3d ", lista->sum);
	recursive_print(lista->left);

	printf("\n    ");
	for (int i = 0; i < level; ++i)
		printf("    ");
	recursive_print(lista->right);

	--level;
}

int recursive_check(skl* lista) {
	if (lista->end - lista->begin == 1)
		return lista->sum;

	assert(lista->sum == recursive_check(lista->left) +
			             recursive_check(lista->right));
	return lista->sum;
}

void print(skl* lista, const char* name) {
	printf("=============================\n");
	printf("%s:\n", name);

	recursive_print(lista);
	printf("\n");
	recursive_check(lista);

	printf("*****************************\n");
}

#define print(lista) print(lista, #lista)
*/

int query_count = 0;

int create(int* line, int begin, int end, int limit) {
	++query_count;

	if (begin >= limit) return INFI;
	const int node = pool_head++;

	if (end - begin != 1) {
		const int mid = (begin + end) / 2;

		create(line, begin, mid, limit);                   // left
		pool[node].right = create(line, mid, end, limit);  // right
		pool[node].update();
	} else {
		pool[node].right = INFI;
		pool[node].sum = line[begin];
	}

	return node;
}

int query(int lista, int count) {
	int sum = 0;
	int begin = 0;
	int end = N;

	while (lista != INFI) {
		++query_count;

		const int mid = (begin + end) / 2;
		if (begin >= count) break;

		if (mid <= count) {
			if (end - begin > 1)
				sum += pool[lista+1].sum;

			begin = mid;
			lista = pool[lista].right;
		} else {
			end = mid;
			++lista;
		}
	}

	return sum;
}

void mix(int first, int second, int begin, int end, int count) {
	++query_count;

	// assert(first->begin == second->begin);
	// assert(first->end == second->end);

	if (end <= count) {
		// intervalul e in partea stanga a liniei
		return;
	}

	const int mid = (begin + end) / 2;

	if (mid >= count) {
		// partea dreapta trebuie intershimbata
		mix(first + 1, second + 1, begin, mid, count);
		swap(pool[first].right, pool[second].right);
	} else {
		mix(pool[first].right, pool[second].right, mid, end, count);
	}

	// facem update la suma
	pool[first].update();
	pool[second].update();
}

void recursive_print_square(int lista, int begin, int end, bool dir) {
	if (lista == INFI) return;

	if (end - begin == 1) {
		printf("%d ", pool[lista].sum);
		return;
	} else {
		const int mid = (begin + end) / 2;

		if (dir) {
			recursive_print_square(pool[lista].right, mid, end, dir);
			recursive_print_square(lista + 1, begin, mid, dir);
		} else {
			recursive_print_square(lista + 1, begin, mid, dir);
			recursive_print_square(pool[lista].right, mid, end, dir);
		}
	}
}

void print_square() {
	for (int i = 0; i < N; ++i) {
		if (i != 0)
			recursive_print_square(lst[i][0], 0, N, true);

		printf("%d ", dia[i]);

		if (i != N-1)
			recursive_print_square(lst[i][1], 0, N, false);

		printf("\n");
	}
}

int main() {
	freopen("eprubeta.in", "rt", stdin);
	freopen("eprubeta.out", "wt", stdout);

	scanf("%d %d", &N, &M);

	int X, A, B;
	scanf("%d %d %d", &X, &A, &B);

	for (int i = 0; i < N; ++i) {
		int line[maxN];
		for (int j = 0; j < N; ++j)
			line[j] = ((i + A) * (j + B) / 4) % X;

		dia[i] = line[i];
		lst[i][0] = lst[i][1] = INFI;

		// creem prima lista (stanga)
		if (i != 0) {
			int temp[maxN] = { 0 };
			copy(line, line + i, temp);
			reverse(temp, temp + i);

			lst[i][0] = create(temp, 0, N, i);
		}

		// creem a doua lista (dreapta)
		if (i != N-1) {
			int temp[maxN] = { 0 };
			copy(line + i + 1, line + N, temp);

			lst[i][1] = create(temp, 0, N, N - i - 1);
		}
	}

	fprintf(stderr, "pool_head = %d\n", pool_head);

	for (int i = 0; i < M; ++i) {
		int o, a, b;
		scanf("%d %d %d", &o, &a, &b);

		// verificam conditiile
		assert(0 <= a && a < N);
		assert(0 <= b && b < N);
		assert(o == 1 || o == 2);
		assert(a <= b);

		// executam operatiile
		if (o == 1) {
			int l = b-a+1;
			for (int j = 0; j < l-1; ++j) {
				mix(lst[a+j][1], lst[b-j][0], 0, N, l-j-1);
				swap(lst[a+j][1], lst[b-j][0]);
			}

			reverse(dia + a, dia + b + 1);
		} else {
			// interogare
			int sum = 0;

			for (int j = a; j <= b; ++j) {
				sum += dia[j];

				if (j > a) sum += query(lst[j][0], j - a);
				if (j < b) sum += query(lst[j][1], b - j);
			}

			printf("%d\n", sum);
		}
	}

	fprintf(stderr, "qc = %d\n", query_count);

	unsigned int result = 0;
	for (int i = 0; i < N; ++i) {
		unsigned int sum = 0;

		sum += dia[i];
		if (i != 0) sum += pool[lst[i][0]].sum;
		if (i != N-1) sum += pool[lst[i][1]].sum;

		result += sum * sum * (i + 1);
	}
	printf("%u\n", result);

	return 0;
}