import java.io.PrintStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Solution to Letter Wheels
 */
public class wheels
{

    /** The input. */
    private static Scanner sc;

    /** The output. */
    private static PrintStream ps;

    /**
     * Do it.
     */
    private void doit()
    {
        // Read the strings
        char s1[] = sc.next().toCharArray();
        char s2[] = sc.next().toCharArray();
        String s3 = sc.next();
        
        // This will be useful later on when we see how to rotate wheel 3
        String s3s3 = s3+s3;
        
        // We can get n from the strings
        int n = s1.length;
        
        // ok[k] is true if we can rotate wheel 2 (left) by k and have mismatches at every position
        boolean ok[] = new boolean[n];
        Arrays.fill( ok, true );
        for( int i=0; i<n; i++ ) for( int j=0; j<n; j++ ) if( s1[i]==s2[j] ) ok[(j-i+n)%n] = false;
              
        int best = Integer.MAX_VALUE;
        char t[] = new char[n];
        for( int k=0; k<n; k++ ) if( ok[k] && (k<best || n-k<best) )
        {
            // Here's a target substring we'll look for in wheel 3
            for( int i=0; i<n; i++ )
            {
                // t[i] is whichever letter s1[i] and s2[i+k] aren't
                t[i] = (char)('A'+ ( ( (s1[i]-'A') + (s2[(i+k)%n]-'A') ) ^ 3 ) );
            }
            String target = new String(t);
            
            // See if we can find the target in s3s3. If we find it at p, that means that
            // if we rotate wheel 3 (left) by p, then we'll have mismatches at every position
            int p = s3s3.indexOf( target );
            if( p>=0 )
            {
                // We can always hold one of the wheels still
                // What if it's wheel 1?
                // We rotated wheel 2 by k and wheel 3 by p
                // if we rotated it left by x, then that's the same as rotating right by n-x
                // So, wee need to take the smaller of x and n-x
                int answer1 = Math.min( k, n-k ) + Math.min( p,  n-p  );
                if( answer1<best ) best = answer1;
                
                // What if it's wheel 2? 
                // Wheel 1 then moves by k (in the other direction)
                // Wheel 3 moves by p-k
                int p2 = (p-k+n)%n;
                int answer2 = Math.min( k, n-k ) + Math.min( p2,  n-p2  );
                if( answer2<best ) best = answer2;            
                
                // What if it's wheel 3?
                // Wheel 2 then moves by p (in the other direction)
                // Wheel 1 moves by k-p
                int k3 = (k-p+n)%n;
                int answer3 = Math.min( k3, n-k3 ) + Math.min( p,  n-p  );
                if( answer3<best ) best = answer3;            
            }
        }
        
        ps.println( best>n ? -1 : best );
    }

    /**
     * The main method.
     *
     * @param args the arguments (unused)
     */
    public static void main( String[] args )
    {
        sc = new Scanner( System.in );
        ps = System.out;
        new wheels().doit();
    }

}