import java.util.*;

/**
 * Use heuristics to guide the solution towards states that are closer to being solved.
 * Use rotations of one ring followed by either a rotation of a different ring or a "swap 3" sequence of moves
 * that swaps 3 beads in one outer ring for 3 beads in another outer ring.
 * 
 * This can sometimes get stuck in local minima, so perform a random additional move if we get stuck and repeat
 * until we arrive at the solved state. If the total number of moves exceeded the bound, then just try the 
 * whole thing again.
 *
 * @author Finn Lidbetter
 */

public class magicbeancube_finn {
   
    static int MOVES_MAX = 240;
    static int TOP = 0;
    static int LEFT = 1;
    static int RIGHT = 2;
    static int CENTER = 3;
    static Move[] trSwap3;
    static Move[] rlSwap3;
    static Move[] ltSwap3;
    static Move[][] swap3s;
    static Move[][] moves;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // state[0] is the Top
        // state[1] is the Left
        // state[2] is the Right
        char[][] state = new char[3][10];
        state[TOP] = sc.nextLine().strip().toCharArray();
        state[LEFT] = sc.nextLine().strip().toCharArray();
        state[RIGHT] = sc.nextLine().strip().toCharArray();
        
        moves = new Move[4][];
        moves[TOP] = new Move[9];
        moves[LEFT] = new Move[9];
        moves[RIGHT] = new Move[9];
        moves[CENTER] = new Move[2];
        moves[CENTER][0] = new Move(CENTER, 1);
        moves[CENTER][1] = new Move(CENTER, 2);
        for (int i=0; i<3; i++) {
            for (int j=1; j<=9; j++) {
                moves[i][j-1] = new Move(i, j);
            }
        }
        State curr = new State(state, null, 0);

        trSwap3 = new Move[]{moves[CENTER][0], moves[RIGHT][6], moves[CENTER][1], moves[RIGHT][2], moves[CENTER][0], moves[RIGHT][6], moves[CENTER][1]};
        rlSwap3 = new Move[]{moves[CENTER][0], moves[LEFT][6], moves[CENTER][1], moves[LEFT][2], moves[CENTER][0], moves[LEFT][6], moves[CENTER][1]};
        ltSwap3 = new Move[]{moves[CENTER][0], moves[TOP][6], moves[CENTER][1], moves[TOP][2], moves[CENTER][0], moves[TOP][6], moves[CENTER][1]};
        swap3s = new Move[3][];
        swap3s[0] = trSwap3;
        swap3s[1] = rlSwap3;
        swap3s[2] = ltSwap3;
        
        State result = search(curr);
        while (result.depth>MOVES_MAX) {
            result = search(curr);
        }
        System.out.println(result.depth);
        curr = result;
        Move[] solutionMoves = new Move[result.depth];
        while (curr.prevState!=null) {
            solutionMoves[curr.depth-1] = curr.prevMove;
            curr = curr.prevState;
        }
        char[] chrs = {'o', 'g', 'r', 'c'};
        for (Move move: solutionMoves) {
            System.out.printf("%s%d\n", chrs[move.ring], move.rotations);
        }
    }
    
    static State search(State curr) {
        State best = curr;
        int bestValue = best.evaluate();
        if (bestValue==0) {
            return best;
        }
        for (int j=0; j<4; j++) {
            for (int i=1; i<=9; i++) {
                if (j==CENTER && i>2) {
                    break;
                }
                State intermediate = curr.applyMove(moves[j][i-1]);
                int intermediateValue = intermediate.evaluate();
                if (intermediateValue<bestValue) {
                    best = intermediate;
                    bestValue = intermediateValue;
                }
                for (Move[] moves: swap3s) {
                    State other = intermediate.applyMoves(moves);
                    int otherValue = other.evaluate();
                    if (otherValue<bestValue) {
                        best = other;
                        bestValue = otherValue;
                    }
                }
                for (int k=0; k<4; k++) {
                    if (k==j) {
                        continue;
                    }
                    for (int l=1; l<=9; l++) {
                        if (k==CENTER &&l>2) {
                            break;
                        }
                        State other = intermediate.applyMove(moves[k][l-1]);
                        int otherValue = other.evaluate();
                        if (otherValue<bestValue) {
                            best = other;
                            bestValue = otherValue;
                        }
                    }
                }
            }
        }
        if (bestValue == curr.evaluate()) {
            int randomRing = (int)(Math.random()*4);
            int rotations = (int)(Math.random()*9) + 1;
            if (randomRing == CENTER) {
                rotations = (rotations%2)+1;
            }
            return search(curr.applyMove(new Move(randomRing, rotations)));
        }
        return search(best);
    }

    
    }
class Move {
    int ring;
    int rotations;
    public Move(int ring, int rotations) {
        this.ring = ring;
        this.rotations = rotations;
    }
}   
class State {
    static int TOP = 0;
    static int LEFT = 1;
    static int RIGHT = 2;
    static int CENTER = 3;
    char[][] puzzle;
    Move prevMove;
    State prevState;
    int depth;
    public State(char[][] puzzle, Move prevMove, int depth) {
        this.puzzle = puzzle;
        this.prevMove = prevMove;
        this.depth = depth;
    }
    public void print() {
        System.out.println(new String(puzzle[0]));
        System.out.println(new String(puzzle[1]));
        System.out.println(new String(puzzle[2]));
    }

    public State applyMove(Move move) {
        State result;
        if (move.ring<=2) {
            result = new State(rotateOuter(puzzle, move.ring, move.rotations), move, depth+1);
        } else {
            result = new State(rotateCenter(puzzle, move.rotations), move, depth+1);
        }
        result.prevState = this;
        return result;
    }

    public State applyMoves(Move[] moves) {
        State curr = this;
        for (Move m: moves) {
            curr = curr.applyMove(m);
        }
        return curr;
    }

    static char[][] rotateOuter(char[][] state, int row, int beads) {
        char[][] copy = new char[3][10];
        for (int i=0; i<3; i++) {
            if (i==row) {
                continue;
            }
            for (int j=0; j<10; j++) {
                copy[i][j] = state[i][j];
            }
        }
        for (int i=0; i<10; i++) {
            copy[row][(i+beads)%10] = state[row][i];
        }
        return copy;
    }

    static char[][] rotateCenter(char[][] state, int rotations) {
        char[][] copy = new char[3][10];
        for (int i=0; i<3; i++) {
            for (int j=0; j<10; j++) {
                copy[i][j] = state[i][j];
            }
        }
        for (int i=0; i<3; i++) {
            for (int j=0; j<3; j++) {
                copy[(i-rotations+3)%3][j] = state[i][j];
            }
        }
        return copy;
    }
    public int evaluate() {
        int score = 0;
        score += alternations(puzzle[TOP]) + alternations(puzzle[LEFT]) + alternations(puzzle[RIGHT]);
        score += 2*singles(puzzle[TOP]) + 2*singles(puzzle[LEFT]) + 2*singles(puzzle[RIGHT]);
        score += doubles(puzzle[TOP]) + doubles(puzzle[LEFT]) + doubles(puzzle[RIGHT]);
        score += countMismatch(puzzle[TOP], 'o') + countMismatch(puzzle[LEFT], 'g') + countMismatch(puzzle[RIGHT], 'r');
        return score;
    }

    static int alternations(char[] seq) {
        int count = 0;
        for (int i=0; i<seq.length; i++) {
            if (seq[i]!=seq[(i+1)%seq.length]) {
                count++;
            }
        }
        return count;
    }

    static int singles(char[] seq) {
        int count = 0;
        for (int i=0; i<seq.length; i++) {
            if (seq[i]!=seq[(i+1)%seq.length] && seq[i]!=seq[(i-1+seq.length)%seq.length]) {
                count++;
            }
        }
        return count;
    }
    static int doubles(char[] seq) {
        int count = 0;
        for (int i=0; i<seq.length; i++) {
            if (seq[i]==seq[(i+1)%seq.length] && seq[i]!=seq[(i-1+seq.length)%seq.length] && seq[i]!=seq[(i+2)%seq.length]) {
                count++;
            }
        }
        return count;
    }

    static int countMismatch(char[] seq, char target) {
        int count = 0;
        for (char c: seq) {
            if (c!=target) {
                count++;
            }
        }
        return count;
    }

}