import java.io.*;
import java.util.*;

/**
 * The End of the World
 * @author vanb
 *
 * This is a simple recursive process, using knowledge of
 * the structure of the most optimal Towers of Hanoi solution.
 * The key fact: Moving a pyramid with n disks takes (2^n)-1 moves.
 */
public class theend
{
    public Scanner sc;
    public PrintStream ps;
        
    // Keep track of which peg every disk is on
    char disks[];
    
    /**
     * This is the number of moves remaining to solve ToH with n disks,
     * where we're trying to move from the source peg to the dest peg.
     * 
     * @param n Largest disk to move
     * @param source Source peg
     * @param dest Destination peg
     * @param other The 'Other' peg
     * @return The number of moves remaining
     */
    public long remaining( int n, char source, char dest, char other ) 
    { 
        long moves = 0;
        if( n>0 )
        {
            --n;  
            if( disks[n]==source )
            {
                // If the largest disk is on the source peg, then we've got
                // to finish moving the n-1 pyramid on top (that's the call to remaining()), 
                // then move this disk (1), then move the n-1 pyramid back.
                // That takes 2^n-1 (since we're 0-based - the smallest disk is disk 0)
                // So, that's a total of remaining() + 2^n moves. Note that we've got
                // to move the n-1 pyramid over to the other peg, so its source
                // is 'source' and its destination is 'other'
                moves = (1l<<n)+remaining( n, source, other, dest );   
            }
            else if( disks[n]==dest )
            {
                // If the largest disk is already at its destination, then we've
                // just got to finish moving the n-1 pyramid back on top. So,
                // we're moving the n-1 pyramid from the 'other' peg (that's its
                // source) to the destination peg 'dest'.
                moves = remaining( n, other, dest, source );   
            }
            else if( disks[n]==other )
            {
                // This can't happen in a properly formed input.
                System.err.println( "PANIC!! disk " + n + " is on the OTHER peg! other=" + other );
            }
            else
            {
                // This can't happen!!
                System.err.println( "PANIC!! disk " + n + " has a weird character! character=" + disks[n] );
            }
        }
        
        return moves;
    }
        
    /**
     * Do it!
     * 
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "theend.in" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "theend.out" ) );
                
        for(;;)
        {
            disks = sc.nextLine().toCharArray();
            if( disks[0]=='X' ) break;
            
            ps.println( remaining( disks.length, 'A', 'B', 'C' ) );
        } 
    }
    
    /**
     * Main is just a driver
     * 
     * @param args Ignored
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        new theend().doit();
    }

}