#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;  
}