#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


constexpr char STR[][5] = {"copy", "swap", "roll", "fuse"};
enum { COPY, SWAP, ROLL, FUSE };

vector<int> solve(const string &S) {
  const int N = S.size();
  vector<int> ms;
  for (int i = 0, j = 0; i < N; i = j) {
    for (; j < N && S[i] == S[j]; ++j) {}
    ms.push_back(j - i);
  }
  const int msLen = ms.size();
  vector<int> ops;
  auto oper = [&](int op) -> void {
    if (ops.size() && ops.back() == SWAP && op == SWAP) {
      ops.pop_back();
    } else {
      ops.push_back(op);
    }
  };
  if (S[0] == 'a') oper(SWAP);
  if (msLen >= 2) {
    for (int j = 0; j < msLen - 2; ++j) {
      if (ms[j] == 1) {
        /*
          b a
          b a a
          a a b
        */
        oper(COPY);
        oper(ROLL);
      } else {
        /*
          b a
          b a a
          b a a a
          b a a a a
          b a a aa
          b a aaa
          b aaa a
          aaa a b
        */
        for (int x = 0; x < ms[j]; ++x) oper(COPY);
        for (int x = 1; x < ms[j]; ++x) oper(FUSE);
        oper(SWAP);
        oper(ROLL);
      }
    }
    /*
      b a
      b a a
      b a a a
      b a aa
      b aaa
      aaa b
    */
    for (int x = 1; x < ms[msLen - 2]; ++x) oper(COPY);
    for (int x = 1; x < ms[msLen - 2]; ++x) oper(FUSE);
    oper(SWAP);
  }
  for (int x = 1; x < ms[msLen - 1]; ++x) oper(COPY);
  for (int x = 1; x < ms[msLen - 1]; ++x) oper(FUSE);
  for (int j = msLen - 1; --j >= 0; ) oper(FUSE);
  return ops;
}

void stress() {
  for (int n = 1; n <= 16; ++n) {
    int mx = 0;
    for (int p = 0; p < 1 << n; ++p) {
      string s(n, '?');
      for (int i = 0; i < n; ++i) s[i] = 'a' + (p >> (n-1-i) & 1);
      const auto ops = solve(s);
// cerr<<s<<": "<<ops<<endl;
      vector<string> stack{"a", "b"};
      for (const int op : ops) {
        switch (op) {
          case COPY: {
            assert(stack.size() >= 1);
            stack.push_back(stack.end()[-1]);
          } break;
          case SWAP: {
            assert(stack.size() >= 2);
            swap(stack.end()[-2], stack.end()[-1]);
          } break;
          case ROLL: {
            assert(stack.size() >= 3);
            rotate(stack.end() - 3, stack.end() - 2, stack.end());
          } break;
          case FUSE: {
            assert(stack.size() >= 2);
            stack.end()[-2] += stack.end()[-1];
            stack.pop_back();
          } break;
          default: assert(false);
        }
// cerr<<"  "<<stack<<endl;
      }
      assert(stack.end()[-1] == s);
      assert((int)ops.size() <= 3 * n);
      chmax(mx, (int)ops.size());
    }
    cerr << "DONE n = " << n << ": mx = " << mx << endl;
  }
}


char S[100'010];

int main() {
  // stress(); return 0;
  
  for (; ~scanf("%s", S); ) {
    const auto ops = solve(S);
    printf("%d\n", (int)ops.size());
    for (const int op : ops) {
      puts(STR[op]);
    }
  }
  return 0;
}