Problem: Unknown pathogen

Dr. Hideyo discovered an unknown pathogen. This pathogen has a chain structure in which two types of bacteria called Akdamakin and Zendamakin are linked in a straight line. We want to detoxify this pathogen for humankind.

It is known that this pathogen weakens when the length is 2 or less and is detoxified by immunity. Dr. Hideyo can cut this pathogen anywhere to make two chains, the first half and the second half. You can also connect two chains into one chain.

However, it should be noted that chains with a large number of Akdamakin are extremely harmful. When the number of Akdamakins in a chain exceeds the number of Zendamakins, the Akdamakins begin to grow indefinitely at that moment. This is no exception for chains with a length of 2 or less, so you must carefully cut the chains.

Is it possible to make one chain harmless by making it 2 or less in length without making a chain that has more Akdamakins at any moment? Dr. Hideyo has instructed you, your assistant, to write a program to determine if detoxification is possible. Create a program that outputs the operation if detoxification is possible, and outputs that it is impossible if it is not possible. However, the number of steps for that operation does not have to be minimal.

Input / output example

Input example


6
oooxxxx
ooooxxx
oxxooxxo
ooxx
oo
ooo


Output example


-1
7
split 0 0
join 2 1
split 3 4
split 4 0
join 7 6
split 8 2
split 9 0
3
split 0 1
split 2 1
split 4 1
-1
0
1
split 0 0


For example, the second pathogen ooooxxx in the input example
split 0 0 creates o (1) and oooxxx (2). Here, the numbers in parentheses represent identification numbers.
join 2 1 creates oooxxxo (3) and 1 and 2 disappear.
split 3 4 gives oooxx (4) and xo (5). At this time, there is a chain of {oooxx (4), xo (5)}.
split 40 produces o (6) and ooxx (7). {xo (5), o (6), ooxx (7)}
ooxxo (8) can be created by join 7 6. {xo (5), ooxxo (8)}
split 8 2 produces oox (9) and xo (10). {xo (5), oox (9), xo (10)}
The split 90 results in {xo (5), xo (10), o (11), ox (12)} and ends.



input

The input is given in the following format.


Q
str1
str2
::
strQ


The number of pathogens Q (1 ≤ Q ≤ 300) is given on the first line. The following Q line is given a single string stri consisting of'o'(Zendamakin) and'x' (Akudamakin) representing the initial state of each pathogen. The length of the string stri is 1 or more and 100 or less.

output

For stri, if there is a column of disconnect / join operations that meets the requirements, the first row of output outputs an integer n representing the length of the operation column, and the following n rows contain the operation content 1 per row. Outputs each operation in order from the first operation.

The disconnect operation should be expressed in the following format.


split a p


a is an integer representing the identification number of the chain to be cut, and p is the position to cut the chain. As a result of this operation, chain a is cleaved immediately after the p-th (serial number starting with 0) fungus from the beginning. Of the two new chains, the first half is given the identification number m + 1 and the second half is given the identification number m + 2 (where m represents the highest identification number ever assigned. ). Also, the chain a disappears.

The join operation should be expressed in the following format.


join a b


a and b are integers representing the identification numbers of the chains to be joined. The result of this operation is a new chain with the beginning of chain b joined to the end of chain a. The newly created strand is given the identification number m + 1 (where m represents the highest identification number ever given). Also, the chains a and b disappear.

The first strand given as input is given the identification number 0.

As a result of the operation, if the chain is disassembled to meet the requirements of the problem, any operation is judged to be the correct answer. The length of the operation sequence does not necessarily have to be the shortest. However, the length of the operation sequence must be 20000 or less. Whenever a chain is decomposable in a dataset, it is guaranteed that there is an operating sequence that meets this condition.

If an invalid operation sequence is output, it is judged as an incorrect answer. The illegal operation sequence includes the following cases.

* If 0 ≤ p <(length of chain a) -1 is not satisfied in the split operation split a p.
* When the identification number of the chain to be the target of the cutting / joining operation has not been generated yet, or when it has disappeared because it has already been the target of another operation.
* In the join operation join a b, if a and b are equal.



If there is no disconnect / join operation column that satisfies the request, "-1" is output.

Example

Input

6
oooxxxx
ooooxxx
oxxooxxo
ooxx
oo
ooo


Output

-1
7
split 0 0
join 2 1
split 3 4
split 4 0
join 7 6
split 8 2
split 9 0
3
split 0 1
split 2 1
split 4 1
-1
0
1
split 0 0

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


enum Type{
	SPRIT,
	JOIN,
};

enum Ret{
	ALL_GOOD,
	OK,
	NOT,
	EVEN,
	SPECIAL,
};

struct Info{

	Info(Type arg_type,int arg_a,int arg_b){
		type = arg_type;
		a = arg_a;
		b = arg_b;
	}

	Type  type;
	int a,b;
};

struct Data{

	Data(){
		str = "";
		id = 0;
	}

	Data(string arg_str,int arg_id){
		str = arg_str;
		id = arg_id;
	}

	string str;
	int id;
};

Ret is_ok(string str){

	int num_good = 0,num_bad = 0;

	for(int i = 0; i < str.size(); i++){

		if(str[i] == 'o'){

			num_good++;
		}else{
			num_bad++;
		}
	}

	if(num_good < num_bad){

		return NOT;

	}else if(num_good > num_bad){

		if(num_good == str.size()){

			return ALL_GOOD;

		}else{

			return OK;
		}

	}else{ //num_good == num_bad

		//入力では、oxかxoのみから構成されていなければ不可

		for(int i = 0; i < str.size()-1; i += 2){

			if(str[i] == str[i+1]){

				return EVEN;
			}
		}

		return SPECIAL;
	}
	return NOT; //バグ
}

void func(){

	string str;
	cin >> str;

	Ret ret = is_ok(str);

	if(ret == NOT || ret == EVEN){

		printf("-1\n");
		return;

	}else if(ret == SPECIAL || ret == ALL_GOOD){

		printf("%d\n",(str.size()-1)/2);

		for(int i = 0; i < (str.size()-1)/2; i++){

			printf("split %d 1\n",2*i);
		}

		return;
	}

	queue<Data> Q;
	Q.push(Data(str,0));

	vector<Info> ANS;

	int last_id = 0;
	Ret ret2;

	while(!Q.empty()){

		Data tmp = Q.front();
		Q.pop();

		//printf("%s\n",tmp.str.c_str());

		ret = is_ok(tmp.str);

		if(ret == ALL_GOOD || ret == SPECIAL){ //2以下に切り出す

			for(int i = 0; i < (tmp.str.size()-1)/2; i++){

				if(i == 0){

					ANS.push_back(Info(SPRIT,tmp.id,1));

				}else{

					ANS.push_back(Info(SPRIT,last_id,1));
				}

				last_id += 2;
			}

			continue;
		}else if(ret == NOT){

			printf("-1\n");
			return;
		}

		if(tmp.str[0] == 'o'){

			if(tmp.str[1] == 'x'){  //左端を切り出す

				ANS.push_back(Info(SPRIT,tmp.id,1));
				last_id += 2;

				if(tmp.str.size()-2 > 2){
					Q.push(Data(tmp.str.substr(2),last_id));
				}

			}else if((tmp.str[tmp.str.size()-1] == 'o' && tmp.str[tmp.str.size()-2] == 'x') ||
					(tmp.str[tmp.str.size()-1] == 'x' && tmp.str[tmp.str.size()-2] == 'o')){ //右端を切り出す

				ANS.push_back(Info(SPRIT,tmp.id,tmp.str.size()-3));
				last_id += 2;
				if(tmp.str.size()-2 > 2){
					Q.push(Data(tmp.str.substr(0,tmp.str.size()-2),last_id-1));
				}

			}else{ //tmp_str[1] == 'o' //左端の'o'を右端にくっつける

				ANS.push_back(Info(SPRIT,tmp.id,0));
				ANS.push_back(Info(JOIN,last_id+2,last_id+1));
				last_id += 3;
				Q.push(Data(tmp.str.substr(1)+tmp.str[0],last_id));
			}

		}else if(tmp.str[tmp.str.size()-1] == 'o'){ //左端がxで右端がo

			if(tmp.str[tmp.str.size()-2] == 'x'){ //右端を切り出す

				ANS.push_back(Info(SPRIT,tmp.id,tmp.str.size()-3));
				last_id += 2;
				if(tmp.str.size()-2 > 2){
					Q.push(Data(tmp.str.substr(0,tmp.str.size()-2),last_id-1));
				}

			}else{ //tmp_str[tmp.str.size()-2] == 'o' //右端の'o'を左端にくっつける

				ANS.push_back(Info(SPRIT,tmp.id,tmp.str.size()-2));
				ANS.push_back(Info(JOIN,last_id+2,last_id+1));
				last_id += 3;
				Q.push(Data(tmp.str[tmp.str.size()-1]+tmp.str.substr(0,tmp.str.size()-1),last_id));
			}
		}else{ //★★xooo...ox

			//文字列を分割する(x単独も不可)

			int divide_point = -1;
			for(int mid = 0; mid < tmp.str.size()-1; mid++){

				ret = is_ok(tmp.str.substr(0,mid+1));
				ret2 = is_ok(tmp.str.substr(mid+1));

				if(ret == NOT || ret2 == NOT)continue;

				divide_point = mid;
				break;
			}
			if(divide_point == -1){

				printf("-1\n");
				return;
			}

			ANS.push_back(Info(SPRIT,tmp.id,divide_point));
			last_id += 2;


			if(ret == EVEN || ret2 == EVEN){ //★すぐにjoinする★

				ANS.push_back(Info(JOIN,last_id,last_id-1));
				Q.push(Data(tmp.str.substr(divide_point+1)+tmp.str.substr(0,divide_point+1),last_id+1));
				last_id++;
			}else{ //xxoooooxx

				if(divide_point >= 2){
					Q.push(Data(tmp.str.substr(0,divide_point+1),last_id-1));
				}

				if(tmp.str.size()-(divide_point+1) > 2){
					Q.push(Data(tmp.str.substr(divide_point+1),last_id));
				}
			}
		}
	}

	printf("%lld\n",ANS.size());

	for(int i = 0; i < ANS.size(); i++){

		if(ANS[i].type == SPRIT){

			printf("split %d %d\n",ANS[i].a,ANS[i].b);

		}else{

			printf("join %d %d\n",ANS[i].a,ANS[i].b);
		}
	}
}

int main(){

	int num_case;
	scanf("%d",&num_case);

	for(int loop = 0; loop < num_case; loop++){

		func();
	}

	return 0;
}