#include<iostream>
#include<cstdio>
#include<string>
#include<cassert>
#include<vector>
#include<queue>
using namespace std;
static const int DEAD = -1;
static const int EVEN = 0;
static const int GOOD = 1;
static const int OVER = 2;

int gID;
vector<string> ops;

string itoa(int x){
  char s[20];
  sprintf(s, "%d", x);
  return string(s);
}

class Gen{
public:
  string str;
  int id;
  Gen(string s="", int i=0):str(s), id(i){}

  int getState(){
    assert( str.size() > 0 );
    int o = 0, x = 0;
    for ( int i = 0; i < str.size(); i++ ){
      if ( str[i] == 'o' ) o++;
      else if ( str[i] == 'x' ) x++;
      else assert(false);
    }
    if ( x == 0 ){
      assert( o > 0 );
      return GOOD;
    } else if ( x == o ) return EVEN;
    else if ( o > x ) return OVER;
    else return DEAD;
  }
  int length(){ return (int)str.size(); }

  pair<Gen, Gen> split(int pos){
    assert( 0 <= pos && pos < length()-1);
    ops.push_back("split " + itoa(id) + " " + itoa(pos) );
    Gen l = Gen(str.substr(0, pos+1), gID++);
    Gen r = Gen(str.substr(pos+1), gID++ );
    return make_pair(l, r);
  }

  Gen join(Gen g){
    ops.push_back("join " + itoa(id) + " " + itoa(g.id));
    string s = str + g.str;
    return Gen(s, gID++);
  }

  bool startsWith(string s){
    if ( str.size() < s.size() ) return false;
    return str.substr(0, 2) == s;
  }

  bool endsWith(string s){
    if ( str.size() < s.size() ) return false;
    return str.substr(str.size()-2) == s;
  }

};

typedef pair<Gen, Gen> Gen2;

bool solveEven(Gen g){
  assert( g.length()%2 == 0 && g.length() > 0 );
  for ( int i = 0; i < g.length(); i+=2 ){
    if ( !(g.str.substr(i, 2) == "ox" || g.str.substr(i, 2) == "xo" ) ){
      return false;
    }
  }
  while( g.length() > 2 ){
    Gen2 w = g.split(1);
    g = w.second;
  }
  return true;
}

void solveEvens(queue<Gen> evens, Gen good){
  while( !evens.empty() ){
    Gen even = evens.front(); evens.pop();
    assert( even.getState() == EVEN );
    if ( even.length() <= 2 ) continue;
    Gen tmp;
    
    while( even.length() > 2 ){
      assert( good.str == "o" );
      while( even.length() >= 4 && (even.startsWith("xo") || even.startsWith("ox"))){
	Gen2 w = even.split(1);
	even = w.second;
      }
      while( even.length() >= 4 && (even.endsWith("xo") || even.endsWith("ox"))){
	Gen2 w = even.split(even.length()-3);
	even = w.first;
      }
      if ( even.length() == 2 ) break;

      if ( even.startsWith("oo") && even.endsWith("xx") ){
	tmp = even.join(good);
	Gen2 w = tmp.split(tmp.length()-3);
	Gen2 y = w.first.split(0);
	good = y.first;
	even = y.second;
      } else if ( even.startsWith("xx") && even.endsWith("oo") ){
	tmp = good.join(even);
	Gen2 w = tmp.split(1);
	Gen2 y = w.second.split(w.second.length()-2);
	even = y.first;
	good = y.second;
      } else if ( even.startsWith("oo") && even.endsWith("oo") ){
	tmp = even.join(good);
	Gen2 w = tmp.split(0);
	tmp = w.second.join(w.first);
	Gen2 y = tmp.split(0);
	good = y.first;
	even = y.second;
      } else if ( even.startsWith("xx") && even.endsWith("xx") ){
	int f = 0;
	int c = 0;
	for ( c = 0; ; c++ ){
	  if ( even.str[c]  == 'x' ) f--;
	  else f++;
	  if ( f == 0 ) break;
	}
	Gen2 w = even.split(c);
	assert( w.first.length() >= 2 && w.first.getState() == EVEN );
	assert( w.second.length() >= 2 && w.second.getState() == EVEN );
	evens.push(w.first);
	evens.push(w.second);
	even = Gen("", -1);
      } else {
	cout << even.str << endl;
	assert( false );
      }
    }
  }
}

void solveOver(Gen g){
  queue<Gen> evens;
  Gen good;

  while(1){
    if ( g.getState() == GOOD ){
      good = g;
      break;
    }

    for ( int i = 0, f = 0; i < g.str.size(); i++ ){
      if ( g.str[i] == 'o' ){
	f++;
	if ( f == 0 ) {
	  Gen2 w = g.split(i);
	  evens.push(w.first);
	  g = w.second;
	  f = 0;
	  break;
	}
      } else if ( g.str[i] == 'x' ){
	f--;
	if ( f >= 0 ){
	  while(f--){
	    Gen2 w = g.split(0);
	    assert( w.first.str[0] == 'o');
	    g = w.second.join(w.first);
	    i--;
	  }
	  Gen2 w = g.split(i);
	  evens.push(w.first);
	  g = w.second;
	  break;
	}
      }   
    }
  }
  assert( good.getState() == GOOD );

  while( good.length() > 1 ){
    Gen2 w = good.split(0);
    good = w.second;
  }

  solveEvens(evens, good);
}

void solve(string str){
  gID = 0;
  ops.clear();
  Gen g = Gen(str, gID++);
  if ( g.getState() == DEAD ){
    cout << -1 << endl;
    return;
  } else if ( g.getState() == EVEN ){
    if ( !solveEven(g) ){
      cout << -1 << endl;
      return;
    }
  } else if ( g.getState() == GOOD || g.getState() == OVER ){
    solveOver(g);
  }

  cout << ops.size() << endl;
  for ( int i = 0; i < ops.size(); i++ ) cout << ops[i] << endl;
}

int main(){
  int tcase; cin >> tcase;
  for ( int i = 0; i < tcase; i++ ){
    string g; cin >> g;
    solve(g);
  }
  return 0;
}



Measured memory_bytes: 3300