// zhenjiernanxie
#include <bits/stdc++.h>
using namespace std;

const int _ = 5e5 + 7, __ = 6e6 + 7;
int n, k, hd[_][2], cmdid[_];
const string CMDLIST[] = {"SLACKOFF", "MOVE", "SWAP", "TRIGGER",
                          "TOGGLETRIGGERREPLACE"};
int cmdname2id(string cmdname) {
  return find(CMDLIST, CMDLIST + 6, cmdname) - CMDLIST;
}

namespace sat {
vector<int> nxt[__];
int cntnode;
int newnode() { return cntnode += 2; }
void adde(int x, int y) {
  nxt[x].push_back(y);
  if (y != (x ^ 1)) nxt[y ^ 1].push_back(x ^ 1);
}

int dfn[__], low[__], bel[__], stk[__], top, cntscc, cntdfn;
bool in[__];
void tarjan(int x) {
  dfn[x] = low[x] = ++cntdfn;
  stk[++top] = x;
  in[x] = 1;
  for (auto t : nxt[x]) {
    if (!dfn[t])
      tarjan(t);
    else if (!in[t])
      continue;
    low[x] = min(low[x], low[t]);
  }
  if (dfn[x] == low[x]) {
    ++cntscc;
    do {
      int t = stk[top];
      in[t] = 0;
      bel[t] = cntscc;
    } while (stk[top--] != x);
  }
}

void solve() {
  for (int i = 0; i <= cntnode + 1; ++i)
    if (!dfn[i]) tarjan(i);
  for (int i = 0; i <= cntnode; i += 2) assert(bel[i] != bel[i ^ 1]);
}
bool qval(int x) { return bel[x] < bel[x ^ 1]; }
}  // namespace sat
using sat::newnode, sat::adde, sat::qval;

struct MainCmd {
  string cmdname;
  int h, z, replace_id, trgid;
  MainCmd() { h = z = replace_id = trgid = 0; }
  void inputandact();
  void output();
};

struct TrgHd {
  int v1, v2;
  string cmd_name;
  set<string> fail_cmd;
  bool v2_fail;
  // v1 = 1 => no trg; v2 = 1 => trg is not trg
  void toggle(TrgHd prev) {
    adde(prev.v1, v1 ^ 1);
    adde(prev.v1 ^ 1, v1);
  }
  void interact(TrgHd prev, string cmd, bool success) {
    bool fail = 0;
    if (!success) {
      fail_cmd.insert(cmd);
      adde(prev.v1 ^ 1, v2);
    } else {
      if (cmd_name.empty())
        cmd_name = cmd;
      else
        fail |= cmd_name != cmd;
      adde(prev.v1, v2);
    }
    fail |= fail_cmd.find(cmd_name) != fail_cmd.end() || fail_cmd.size() == 4;
    if (!v2_fail && fail) {
      adde(v2, v1);
      v2_fail = 1;
    }
  }
  void notrg() { adde(v1 ^ 1, v1); }

  void allocname() {
    if (cmd_name.empty())
      for (auto t : CMDLIST)
        if (t != "TRIGGER" && fail_cmd.find(t) == fail_cmd.end()) cmd_name = t;
  }
  void output() {
    allocname();
    if (!qval(v1))
      cout << "TRIGGER " << (qval(v2) ? cmd_name : "TRIGGER") << ": ";
  }
  string gettrgname() {
    allocname();
    return qval(v1) ? "SLACKOFF" : (qval(v2) ? cmd_name : "TRIGGER");
  }
} trg[_ * 3];
int cnttrg;

int newtrg() {
  int id = cnttrg++;
  trg[id].v1 = newnode();
  trg[id].v2 = newnode();
  return id;
}

struct Cmd {
  MainCmd main;
  int origin_trgid, trgid;
  int trgflip() {
    int ntrg = newtrg();
    trg[ntrg].toggle(trg[trgid]);
    return trgid = ntrg;
  }
  void notrg() { trg[trgid].notrg(); }
  void interact(Cmd prev, bool success) {
    trg[trgid].interact(trg[prev.trgid], prev.main.cmdname, success);
  }

  void output() {
    trg[origin_trgid].output();
    main.output();
  }
} cmd[_ * 2];
int cntcmd, prevcmd = -1, previd;

int newcmd() {
  int id = cntcmd++;
  cmd[id].origin_trgid = cmd[id].trgid = newtrg();
  return id;
}

void MainCmd::inputandact() {
  int id, side, id2, id3;
  cin >> cmdname >> id;
  int curcmd = cmdid[id];

  // trg Interaction between cmds
  if (prevcmd == -1 || hd[previd][1] != id) cmd[curcmd].notrg();
  if (prevcmd != -1 && hd[previd][1] != previd)
    cmd[cmdid[hd[previd][1]]].interact(cmd[prevcmd], hd[previd][1] == id);
  prevcmd = curcmd;
  previd = id;

  switch (cmdname2id(cmdname)) {
    case 0:
      break;  // SLACKOFF
    case 1:   // MOVE
      cin >> h >> id2;
      z = (id2 - hd[id][h] + n) % n;
      hd[id][h] = id2;
      break;
    case 2:  // SWAP
      cin >> id2 >> id3;
      swap(cmdid[id2], cmdid[id3]);
      break;
    case 4:  // TOGGLETRIGGERREPLACE
      cin >> id2;
      assert(hd[id][0] == id2 || hd[id][1] == id2);
      h = hd[id][0] != id2;
      trgid = cmd[cmdid[id2]].trgflip();
      cmdid[id] = replace_id = newcmd();
      break;
    default:
      assert(0);
  }
  cmd[curcmd].main = *this;
}

void MainCmd::output() {
  if (cmdname.empty()) cmdname = "SLACKOFF";
  cout << cmdname << ' ';
  switch (cmdname2id(cmdname)) {
    case 0:
      break;
    case 1:
      cout << h << ' ' << z;
      break;
    case 2:
      break;
    case 4:
      cout << h << ' ' << trg[trgid].gettrgname() << ' ';
      cmd[replace_id].output();
      break;
    default:
      assert(0);
  }
}

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> k;
  for (int i = 0; i < n; ++i) {
    cin >> hd[i][0] >> hd[i][1];
    cmdid[i] = newcmd();
  }
  for (int i = 0; i < k; ++i) MainCmd().inputandact();
  cmd[cmdid[hd[previd][1]]].interact(cmd[prevcmd], 0);
  sat::solve();
  for (int i = 0; i < n; ++i, cout << '\n') cmd[i].output();
  return 0;
}