import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Word Ladder
 * 
 * We'll use Best-First Search, also known as Dijkstra's algorithm,
 * to find the shortest path from the start word to the target word.
 * 
 * @author vanb
 */
public class ladder_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /** Distance between words (distance = # letters different) */
    public int dists[][];
    
    /** The words themselves, stored as char arrays */
    public char words[][];
    
    /**
     * A state in a Best-First Search
     * 
     * @author vanb
     */
    public class State implements Comparable<State>
    {
        /** The distance to get to this state (distance = # syteps ) */
        public int distance;
        
        /** Index of the word here */
        public int word;
        
        /** The word we added to get here (or "0" if no word added) */
        public String add;
        
        /** The state we came from. This isn't necessary, but it's useful for debugging. */
        public State from;
        
        /**
         * Create a State.
         * 
         * @param distance # of steps to get to this state
         * @param word Index of work
         * @param from State we came from
         * @param add Word we added (or "0")
         */
        public State( int distance, int word, State from, String add )
        {
            this.distance = distance;
            this.word = word;
            this.add = add;
            this.from = from;
        }

        @Override
        /**
         * Compare this State to another, first by distance, then by added word.
         * 
         * @param s Another State
         * @return Standard for compareTo
         */
        public int compareTo( State s )
        {
            int diff = distance - s.distance;
            if( diff==0 ) diff = add.compareTo( s.add );
            
            return diff;
        }
        
        /**
         * A Pretty String for debugging.
         * 
         * @return A pretty String
         */
        public String toString()
        {
            return "[" + distance + " " + new String(words[word]) + " <" + add + ">]"; 
        }
    }
           
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
          
        // Read in n, allocate arrays
        int n = sc.nextInt();
        dists = new int[n][n];
        words = new char[n][];
        
        // Read in the words in the dictionary
        for( int i=0; i<n; i++ )
        {
            String word = sc.next();
            words[i] = word.toCharArray();
            
            // Find distances to other words already read in.
            // Distance = # of letters different.
            // If distance=1, we can go from one word to the other.
            // If distance=2, we can go from one word to the other by adding a word.
            for( int j=0; j<i; j++ )
            {
                int count = 0;
                
                // We're only interested in words with distance 1 or 2 or 3. 
                // No need to go beyond 3.
                for( int k=0; k<words[i].length && count<3; k++ ) if(words[i][k]!=words[j][k] ) ++count;
                dists[i][j] = dists[j][i] = count;
            }
        }
                
        // Have we visited this word?
        // visited[0][i] is true if we've visited this word BEFORE adding a word
        // visited[1][i] is true if we've visited this word AFTER adding a word
        boolean visited[][] = new boolean[2][n];
        Arrays.fill( visited[0], false );
        Arrays.fill( visited[1], false );
        
        // Priority Queue for the BestFS
        PriorityQueue<State> pq = new PriorityQueue<State>();
        
        // The starting state - word 0, distance 0, no added word.
        pq.add( new State( 0, 0, null, "0" ) );
        
        // This is the default solution if we can't get there from here.
        State solution = new State( -1, 1, null, "0" );
        
        // BestFS! (Also known as Dijkstra's algorithm)
        while( !pq.isEmpty() )
        {
            State s = pq.poll();
            
            // Have we used our prerogative to add a word yet?
            int used = s.add.charAt( 0 ) == '0' ? 0 : 1;
            
            // If we've already visited this word, go to the next state.
            if( visited[used][s.word] ) continue;
            
            // Mark it as visited
            visited[used][s.word]= true; 
            
            // Have we gotten to the target word?
            // Are we done?
            if( s.word == 1 )
            {
                solution = s;
                break;
            }
            
            // Go through all the words to see where we can go next
            for( int i=0; i<n; i++ ) if( i!=s.word )
            {
                // If distance is one, we can go there without adding a word
                if( dists[i][s.word]==1 )
                {
                    if( !visited[used][i] ) pq.add( new State( s.distance+1, i, s, s.add ) );   
                }
                // Otherwise, if distance is 2, and we haven't added a word yet, 
                // we can go there by adding a word.
                else if( used==0 && dists[i][s.word]==2 && !visited[1][i] )
                {
                    // Build the new word. It's easy - look for the first
                    // letter where they differ, and use the smaller one.
                    // Then go to the second letter where they differ, and
                    // use the letter from the word you didn't use for the first letter.
                    char newword[] = new char[words[i].length];
                    boolean usei = false;
                    boolean uses = false;
                    for( int k=0; k<words[i].length; k++ )
                    {
                        // If the letters are the same, just copy.
                        if( words[i][k]==words[s.word][k] ) newword[k] = words[i][k];
                        // If we've already used s, use i now.
                        else if( usei ) newword[k] = words[i][k];
                        // If we've already used i, use s now.
                        else if( uses ) newword[k] = words[s.word][k];
                        // If i is smaller, use i now and s later.
                        else if( words[i][k]<words[s.word][k] )
                        {
                            newword[k] = words[i][k];
                            uses = true;
                        }
                        // if s is smaller, use s now and use i later.
                        else if( words[i][k]>words[s.word][k] )
                        {
                            newword[k] = words[s.word][k];
                            usei = true;
                        }
                    }
                    
                    // Add the new state!
                    pq.add( new State( s.distance+2, i, s, new String(newword)) );
                }
            }         
        }
        
        // Print the solution!
        ps.println( solution.add );
        ps.println( solution.distance ); 
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new ladder_vanb().doit();
    }   
}