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

#pragma GCC optimize("Ofast")
#pragma GCC target("avx2")

using ll = long long;
using LL = long long;

const int SLACKOFF = 1;
const int MOVE = 2;
const int SWAP = 3;
const int MIRROR = 4;
const int REPLACE = 5;
const int ACTIVATE = 6;
const int TRIGGER = 7;

struct Command;
struct Robot;

vector<Command> pool(5000005);
int getnew() {
	static int C = 0;
	return ++C;
}

vector<Robot> robot;

void action(int rid, int cid);

int n, m, k;

void print(int type, int id1 = 0, int id2 = 0, int side = 0) {
	static int count = 0;
	if (type == SLACKOFF) cout << "Robot " << id1 << " slacks off.\n";
	else if (type == MOVE) cout << "Robot " << id1 << " moves its " << (side ? "right" : "left") << " hand towards Robot " << id2 << ".\n";
	else if (type == SWAP) cout << "Robot " << id1 << " swaps a line of command with Robot " << id2 << ".\n";
	else if (type == MIRROR) cout << "Robot " << id1 << " modifies a line of command of Robot " << id2 << ".\n";
	else if (type == REPLACE) cout << "Robot " << id1 << " replaces a line of command of Robot " << id2 << ".\n"; 
	else if (type == ACTIVATE) cout << "Robot " << id1 << " activates Robot " << id2 << ".\n";
	
	if (++count == k) {
		exit(0);
	}
}

struct Command {
	int type = 0;
	int h = 0;
	int x = 0;
	int y = 0;
	int z = 0;
	int cmdname = 0;
	int subcommand = -1;

	void input() {
		string s;
		cin >> s;
		const string cmd = "_LOWIECR";
		type = cmd.find_first_of(s[1]);

		if (type == SLACKOFF) {
			// empty
		}
		else if (type == MOVE) {
			cin >> h >> z;
		}
		else if (type == SWAP) {
			cin >> h >> x >> y;
		}
		else if (type == MIRROR) {
			cin >> h >> x;
		}
		else if (type == REPLACE) {
			cin >> h >> x;
			subcommand = getnew();
			pool[subcommand].input();
		}
		else if (type == ACTIVATE) {
			cin >> h;
		}
		else if (type == TRIGGER) {
			string s;
			cin >> s;
			cmdname = cmd.find_first_of(s[1]);
			subcommand = getnew();
			pool[subcommand].input();
		}
	}
};

struct Robot {
	int id;
	int hand[2];
	vector<int> commands;

	int triggerCount = 0;

	void input() {
		cin >> hand[0] >> hand[1];

		triggerCount = 0;
		commands.resize(m + 1);
		for (int i = 1; i <= m; i++) {
			commands[i] = getnew();
			pool[commands[i]].input();

			if (pool[commands[i]].type == TRIGGER) ++triggerCount;
		}
	}

	void run() {
		if (triggerCount == m) return;
		for (int i = 1; i <= m; i++) {
			if (pool[commands[i]].type == TRIGGER) continue;
			int type = pool[commands[i]].type;
			action(id, commands[i]);
			if (hand[1] != id) robot[hand[1]].trigger(type, false);
		}
	}

	void trigger(int cmdname, bool trigger) {
		if (triggerCount == 0) return;
		for (int i = 1; i <= m; i++) {
			if (pool[commands[i]].type == TRIGGER && pool[commands[i]].cmdname == TRIGGER && trigger) {
				int type = pool[pool[commands[i]].subcommand].type;
				action(id, pool[commands[i]].subcommand);
				if (hand[1] != id) robot[hand[1]].trigger(type, true);
				return;
			}
			else if (pool[commands[i]].type == TRIGGER && pool[commands[i]].cmdname == cmdname) {
				int type = pool[pool[commands[i]].subcommand].type;
				action(id, pool[commands[i]].subcommand);
				if (hand[1] != id) robot[hand[1]].trigger(type, true);
				return;
			}
		}
	}
};

void action(int rid, int cid) {
	Command C = pool[cid];
	Robot& R = robot[rid];
	if (C.type == SLACKOFF) {
		print(SLACKOFF, rid);
	}
	else if (C.type == MOVE) {
		(R.hand[C.h] += C.z) %= n;
		print(MOVE, rid, R.hand[C.h], C.h);
	}
	else if (C.type == SWAP) {
		Robot& R2 = robot[R.hand[C.h]];
		if (pool[R.commands[C.y]].type == TRIGGER) --R.triggerCount;
		if (pool[R2.commands[C.x]].type == TRIGGER) --R2.triggerCount;
		swap(R.commands[C.y], R2.commands[C.x]);
		if (pool[R.commands[C.y]].type == TRIGGER) ++R.triggerCount;
		if (pool[R2.commands[C.x]].type == TRIGGER) ++R2.triggerCount;
		print(SWAP, rid, R.hand[C.h]);
	}
	else if (C.type == MIRROR) {
		Robot& R2 = robot[R.hand[C.h]];
		if (pool[R2.commands[C.x]].type == TRIGGER) {
			int nid = getnew();
			pool[nid] = pool[R2.commands[C.x]];
			int nid2 = getnew();
			pool[nid2] = pool[pool[R2.commands[C.x]].subcommand];
			pool[nid2].h ^= 1;

			pool[nid].subcommand = nid2;

			R2.commands[C.x] = nid;
		}
		else {
			int nid = getnew();
			pool[nid] = pool[R2.commands[C.x]];
			pool[nid].h ^= 1;

			R2.commands[C.x] = nid;
		}
		print(MIRROR, rid, R.hand[C.h]);
	}
	else if (C.type == REPLACE) {
		Robot& R2 = robot[R.hand[C.h]];
		if (pool[R2.commands[C.x]].type == TRIGGER) --R2.triggerCount;
		R2.commands[C.x] = C.subcommand;
		if (pool[R2.commands[C.x]].type == TRIGGER) ++R2.triggerCount;
		print(REPLACE, rid, R.hand[C.h]);
	}
	else if (C.type == ACTIVATE) {
		print(ACTIVATE, rid, R.hand[C.h]);
		Robot& R2 = robot[R.hand[C.h]];
		R2.run();
	}
}

void solve(int TC) {
	cin >> n >> m >> k;
	robot.resize(n);
	for (int i = 0; i < n; i++) {
		robot[i].id = i;
		robot[i].input();
	}

	while (true) {
		for (int i = 0; i < n; i++) {
			robot[i].run();
		}
	}
}

int32_t main() {
	cin.tie(0)->sync_with_stdio(0);
	cout << fixed << setprecision(10);

	int t = 1;
	// cin >> t;

	for (int i = 1; i <= t; i++) {
		solve(i);
	}
}