#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <algorithm>
#include <functional>
#include <iterator>
#include <locale>
#include <memory>
#include <stdexcept>
#include <utility>
#include <string>
#include <fstream>
#include <ios>
#include <iostream>
#include <iosfwd>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <streambuf>
#include <complex>
#include <numeric>
#include <valarray>
#include <exception>
#include <limits>
#include <new>
#include <typeinfo>
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <climits>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdlib>
#include <cstddef>
#include <cstdarg>
#include <ctime>
#include <cstdio>
#include <cstring>
#include <cwchar>
#include <cwctype>
using namespace std;
static const double EPS = 1e-8;
static const double PI = 4.0 * atan(1.0);
static const double PI2 = 8.0 * atan(1.0);
typedef long long ll;
typedef unsigned long long ull;

#define ALL(c) (c).begin(), (c).end()
#define CLEAR(v) memset(v,0,sizeof(v))
#define MP(a,b) make_pair((a),(b))
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define ABS(a) ((a)>0?(a):-(a))
template<class T> T MIN(const T& a, const T& b) { return a < b ? a : b; }
template<class T> T MAX(const T& a, const T& b) { return a > b ? a : b; }
template<class T> void MIN_UPDATE(T& a, const T& b) { if (a > b) a = b; }
template<class T> void MAX_UPDATE(T& a, const T& b) { if (a < b) a = b; }

int N;
bool rowReversed;
bool columnReversed;
bool reflected;
vector<int> rowToRaw;
vector<int> columnToRaw;
map<pair<int, int>, int> matrix;
ll A, B, C;

int& at(int row, int column) {
	if (rowReversed) {
		row = N - row - 1;
	}
	if (columnReversed) {
		column = N - column - 1;
	}

	row = rowToRaw[row];
	column = columnToRaw[column];

	if (reflected) {
		swap(row, column);
	}

	if (!matrix.count(MP(row, column))) {
		matrix[MP(row, column)] = (A * (row + 1) + B * (column + 1)) % C;
	}
	return matrix[MP(row, column)];
}

void write(int r, int c, int x) {
	at(r, c) = x;
}

void copy(int r1, int c1, int r2, int c2) {
	at(r2, c2) = at(r1, c1);
}

void swapRow(int r1, int r2) {
	if (rowReversed) {
		r1 = N - r1 - 1;
		r2 = N - r2 - 1;
	}
	swap(rowToRaw[r1], rowToRaw[r2]);
}

void swapColumn(int c1, int c2) {
	if (columnReversed) {
		c1 = N - c1 - 1;
		c2 = N - c2 - 1;
	}
	swap(columnToRaw[c1], columnToRaw[c2]);
}

void reflect() {
	swap(rowReversed, columnReversed);
	swap(rowToRaw, columnToRaw);
	reflected = !reflected;
}

void reflectHorizontal() {
	rowReversed = !rowReversed;
}

void reflectVertical() {
	columnReversed = !columnReversed;
}

void rotateLeft() {
	reflect();
	reflectHorizontal();
}

void rotateRight() {
	reflect();
	reflectVertical();
}

void output(int r, int c) {
	cout << at(r, c) << endl;
}

void debug() {
	cout << "---" << endl;
	REP(r, N) {
		REP(c, N) {
			cout << at(r, c) << " ";
		}
		cout << endl;
	}
	cout << "---" << endl;
}

int main() {
	std::ios::sync_with_stdio(false);

	int Q, D, E, F, G;
	while (cin >> N >> Q >> A >> B >> C >> D >> E >> F >> G) {
		matrix.clear();

		rowReversed = false;
		columnReversed = false;
		reflected = false;
		rowToRaw.clear();
		columnToRaw.clear();
		REP(i, N) {
			rowToRaw.push_back(i);
			columnToRaw.push_back(i);
		}

		REP(q, Q) {
			string command;
			cin >> command;

			if (command == "WR") {
				int r, c, x;
				cin >> r >> c >> x;
				--r;
				--c;
				write(r, c, x);

			} else if (command == "CP") {
				int r1, c1, r2, c2;
				cin >> r1 >> c1 >> r2 >> c2;
				--r1;
				--c1;
				--r2;
				--c2;
				copy(r1, c1, r2, c2);

			} else if (command == "SR") {
				int r1, r2;
				cin >> r1 >> r2;
				--r1;
				--r2;
				swapRow(r1, r2);

			} else if (command == "SC") {
				int c1, c2;
				cin >> c1 >> c2;
				--c1;
				--c2;
				swapColumn(c1, c2);

			} else if (command == "RL") {
				rotateLeft();

			} else if (command == "RR") {
				rotateRight();

			} else if (command == "RH") {
				reflectHorizontal();

			} else if (command == "RV") {
				reflectVertical();

			}

			//debug();
		}

		ll h = 314159265;
		for (int r = D; r <= E; ++r) {
			for (int c = F; c <= G; ++c) {
				h = (31 * h + at(r - 1, c - 1)) % 1000000007;
			}
		}
		cout << h << endl;
	}
}