//#include <iostream>
//using namespace std;
#include <stdio.h>
#include <string.h>

typedef struct QuadNode{
    char color;
    QuadNode* parent;
    QuadNode* children;
    int childrenCnt;
}QuadNode;

class QuadTree{
public:
    QuadTree() : rootNode(0), currentNode(0), size(0){
    }
    void Insert(char color){
        if(size == 0){
            QuadNode* newNode = new QuadNode;
            newNode->color = color;
            newNode->children= new QuadNode[4];
            newNode->childrenCnt=0;
            newNode->parent=0;

            rootNode = newNode;
            currentNode = rootNode;
            size++;
            return ;
        }
        QuadNode* newNode = new QuadNode;
        newNode->color = color;
        newNode->children = new QuadNode[4];
        newNode->childrenCnt=0;
        newNode->parent=0;

        if(currentNode->color != 'x')
            return ;
        if(isFull())
            return ;
        currentNode->children[currentNode->childrenCnt] = (*newNode);
        currentNode->children[currentNode->childrenCnt].parent = currentNode;
        currentNode->childrenCnt++;
    }
    void UpLayer(){
        if(currentNode->parent != 0)
            currentNode = currentNode->parent;
    }
    void DownLayer(int childIndex){
        if(currentNode->childrenCnt >= childIndex)
            currentNode = &(currentNode->children[childIndex]);
    }
    void ChildSwap(){
        if(currentNode->color == 'x' && (currentNode->childrenCnt == 4)){
            QuadNode tempNode;
            tempNode = currentNode->children[0];
            currentNode->children[0] = currentNode->children[2];
            currentNode->children[2] = tempNode;
            tempNode = currentNode->children[1];
            currentNode->children[1] = currentNode->children[3];
            currentNode->children[3] = tempNode;
        }
    }
    void SwapPreorder(QuadNode& node){
        currentNode = &node;
        ChildSwap();
        for(int i=0; i<node.childrenCnt; i++){
            SwapPreorder(node.children[i]);
        }
    }
    void PrintPreorder(QuadNode& node, char buff[1000], int& buffCnt){
        currentNode = &node;
        buff[buffCnt] = node.color;
        buffCnt++;
        for(int i=0; i<node.childrenCnt; i++){
            PrintPreorder(node.children[i], buff, buffCnt);
        }
    }
    void CurrentToRoot(){
        currentNode = rootNode;
    }
    QuadNode& GetRootNode(){
        return (*rootNode);
    }
    bool isFull(){
        if(currentNode->childrenCnt == 4)
            return true;
        return false;
    }
    int GetChildrenCount(){
        return currentNode->childrenCnt;
    }
    int Count(){
        return size;
    }
private:
    QuadNode* rootNode;
    QuadNode* currentNode;
    int size;
};

int main(void){
    int C=0, caseCnt=0;
    char resultSet[50][1001] = {0, };
    int i=0;
    scanf("%d", &C);
    getchar();
    while(caseCnt<C){
        char picStr[1001] = {0, };
        int picStrCnt=0;
        QuadTree quadTree;
        char strBuff[1001] = {0, };
        int buffCnt=0;

        while(1){
            char ch = getchar();
            if(ch == 10)
                break;
            picStr[picStrCnt] = ch;
            picStrCnt++;
        }
        quadTree.Insert(picStr[0]);
        for(i=1; i<picStrCnt; i++){
            if(picStr[i]=='x'){
                quadTree.Insert(picStr[i]);
                quadTree.DownLayer(quadTree.GetChildrenCount()-1);
                continue;
            }
            quadTree.Insert(picStr[i]);
            if(quadTree.GetChildrenCount()==4){
                quadTree.UpLayer();
            }
        }
        quadTree.SwapPreorder(quadTree.GetRootNode());
        quadTree.CurrentToRoot();
        quadTree.PrintPreorder(quadTree.GetRootNode(), strBuff, buffCnt);

        strcpy(resultSet[caseCnt], strBuff);
        caseCnt++;
    }
    for(i=0; i<caseCnt; i++){
        printf("%s\n", resultSet[i]);
    }
    return 0;
}