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

class worms_judge
{
    public Scanner sc;
    public PrintStream ps;

    public String toString()
    {
        return "worms_judge";
    }

    // Class to hold a rule: A->BC
    public class Rule
    {
        // Actually, index -> a b
        // where index, a and b are integers
        public int index, a, b;

        public Rule( char chs[] )
        {
            // Convert from chars to ints
            index = (int)(chs[0]-'A');
            a = (int)(chs[1]-'A');
            b = (int)(chs[2]-'A');
        }

        public String toString()
        {
            return ""+(char)(index+'A')+"->"+(char)(a+'A')+(char)(b+'A');
        }
    };

    // memo[][] is for memoization - memo[i][j][c] will remember the best (shortest)
    // number of days to produce the subsequence from i to j in the original worm,
    // if you start from char c (represented as an int).
    int memo[][][];

    // For each cell, remember a list of rules that say what that cell can grow into
    LinkedList<Rule> rules[];

    // The characters of the original worm
    char worm[];

    // Compute the least number of days it would take to generate the
    // subsequence of the original worm from lo to hi, if you started
    // with cell ch.
    public int fastest( int ch, int lo, int hi )
    {
        // Look at the memo field to see if we've already computed this
        // -1 is used as a flag that it hasn't been computed yet.
        if( memo[lo][hi][ch]<0 )
        {
            // Start out with something unreasonably big
            int best = 10000;

            // if lo==hi, then we're talking about a single cell.
            if( lo==hi )
            {
                // If this spot in the worm matches that cell, then it takes 0 days.
                // Otherwise, you can't get there. Use an unreasonably large number.
                best = (worm[lo]==(char)(ch+'A')) ? 0 : 10000;
            }
            else
            {
                // If lo!=hi, then we've got to apply a rule.
                // So, go through all the rules that start with ch
                for( Rule rule : rules[ch] )
                {
                    // We've got to split the subsequence into two smaller subsequences.
                    // If the rule is X->AB, then the first subsequence has to be generated by A,
                    // and the second by B. 
                    //
                    // Start by going through all the possible split points. (Split between i and i+1)
                    for( int i=lo; i<hi; i++ )
                    {
                        // Depth is 1 day for applying this rule, plus the max of the left and right children.
                        int depth = 1 + Math.max( fastest( rule.a, lo, i  ), fastest( rule.b, i+1, hi ) );
                        if( depth<best ) best = depth;
                    }
                }
            }
            
            // Remember the best
            memo[lo][hi][ch] = best;
        }

        // Return the best
        return memo[lo][hi][ch];
    }

    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;

        for(;;)
        {
            // Read n, break if done
            int n = sc.nextInt();
            if( n==0 ) break;

            // Build the rules
            rules = new LinkedList[20];
            for( int i=0; i<20; i++ )
            {
                rules[i] = new LinkedList<Rule>();
            }

            // Read the rules
            for( int i=0; i<n; i++ )
            {
                char letters[] = sc.next().toUpperCase().toCharArray();
                Rule rule = new Rule( letters );
                rules[rule.index].add( rule );
            }

            // Read the target worm.
            // Compute some useful stuff from it - its length, and an array of chars
            String target = sc.next().toUpperCase();
            int len = target.length();
            worm = target.toCharArray();

            // Build and initialize the memoization array.
            // Start with all -1's, which is a flag that this value hasn't been computed yet.
            memo = new int[len][len][20];
            for( int i=0; i<len; i++ )
            {
                for( int j=0; j<len; j++ )
                { 
                    Arrays.fill( memo[i][j], -1 );
                }
            }

            // Go through all possible starting cells, find the smallest number of days.
            int min = 10000;
            for( int i=0; i<20; i++  )
            {
                min = Math.min( min, fastest( i, 0, len-1 ) );
            }

            // Print the result if one was found, -1 if not.
            ps.println( min < 10000 ? min : -1 );
        }
    }

	public static void main(String[] args) throws Exception
	{
		new worms_judge().doit();
	}
}