import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.TreeSet;

/**
 * Solution to Prefix Free Code
 * 
 * @author vanb
 */
public class prefix_vanb
{
    private static BufferedReader br;
    private static PrintStream ps;
   
    /** The Modulo for the final answer */
    private static final int MOD = 1000000007;
    
    /** A counter for index numbers */
    private int nextindex = 0;
      
    /**
     * This is a node of a Word Tree. 
     * A Word Tree is a tree where every node represents a letter (except the root),
     * and a child of a node represents that that letter comes after the given letter in some word.
     * 
     * Suppose we've seen the words "cat" and "car" and "cur". The word tree would look like this:
     * 
     *        +
     *        |
     *        c
     *       / \
     *      a   u
     *     / \  |
     *    t   r r
     * 
     * @author vanb
     */
    private class Node
    {
        // Index will be -1 for internal nodes.
        // For leaf nodes, it'll be the index of the initial string in the sorted array.
        public int index = -1;
        
        // The child links are the 26 letters of the alphabet.
        public Node children[] = new Node[26];
        
        /**
         * Create a Node.
         * No parameters, we'll fill in the details later.
         */
        public Node()
        {
            Arrays.fill( children, null );
        }
        
        /**
         * Compute index numbers by traversing the tree.
         */
        public void traverse()
        {
            boolean kids = false;
            for( Node child : children ) if( child!=null )
            {
                child.traverse();
                kids = true;
            }
            
            /** No kids? Then this is a leaf, and must be the next initial string. */
            if( !kids ) index = nextindex++;
        }
    }
    
    /**
     * Fenwick Tree!
     * 
     * A Fenwick Tree is a data structure that efficiently keeps a list of numbers, with two operations:
     *     adjust: Change one of the numbers
     *     sum: Add up all of the numbers up to a given point.
     * Both operations are O(logn). Isn't that cool?
     * 
     * @author vanb
     */
    private class Fenwick
    {
        /** The tree */
        private int tree[];
        
        /**
         * Create a Fenwick tree.
         * 
         * @param size The size of your list
         */
        public Fenwick( int size )
        {
            tree = new int[size+1];
            reset();
        }
        
        /**
         * Start from scratch.
         */
        public void reset()
        {
            Arrays.fill( tree, 0 );
        }
        
        /**
         * Add a delta to list[i].
         * 
         * @param i Index
         * @param diff Value change
         */
        public void adjust( int i, int diff )
        {
            for( ; i<tree.length; i += (i&-i) )
            {
                tree[i] += diff;  
            }
        }
        
        /**
         * Get the sum of elements of your list from 1..i
         * 
         * @param i Element
         * @return Sum of list[1] + list[2] + ... + list[i]
         */
        public int sum( int i )
        {
            int result = 0;
            for( ; i>0; i -= (i&-i) )
            {
                result += tree[i];  
            }
            
            return result;
        }
    }

    /**
     * Do it!
     */
    private void doit() throws Exception
    {     
        String tokens[] = br.readLine().trim().split( "\\s+" );
        int n = Integer.parseInt( tokens[0] );
        int k = Integer.parseInt( tokens[1] );
        
        // Read the initial strings
        String initials[] = new String[n];
        for( int i=0; i<n; i++ ) initials[i] = br.readLine();
        
        // Put the initial strings into a word tree.
        // node.index is -1 for interior nodes, 
        // it's the index of the string in the sorted array for leaves
        Node root = new Node();
        for( int i=0; i<n; i++ )
        {
            String s = initials[i];
            Node node = root;
            for( int j=0; j<s.length(); j++ )
            {
                int p = (int)(s.charAt( j ) - 'a');
                if( node.children[p]==null ) node.children[p] = new Node();
                node = node.children[p];
            }
        }
        
        // Assign index numbers in alphabetical order
        root.traverse();
        
        // Read in the test string. It'll be easier to handle as an array.
        char testarray[] = br.readLine().toCharArray();
        
        // We need to figure out where this permutation lies in the list of permutations.
        // We can think of a permutations as a number in a permutation base. This is a bit different from a number base.
        //
        // Think of a base 10 number, like 3874. That's 3*10*10*10 + 8*10*10 + 7*10 + 4*1
        // At every digit, we have 10 options. 
        //
        // It's different in a factorial base. 
        // The number of options at each place goes down by 1, since we cannot use
        // any of the "digits" that we've already seen.
        // So, our "multiplier" will go down, for instance from 10*9*8 to 9*8 to 8, as we go down digits.
        //
        // The digits themselves are a little tricky, too. We need to know, not the digit, bit its order in
        // all remaining digits. So, if the fist digit is a 5, then, for the second digit,
        // 0 has value 0, 1=1, 2=2, 3=3, 4=4, 6=5 (we've used 5, so we can't use it again), 7=6, and so on. 
        // So, for any "digit", we need to know how many smaller "digits" have already been "used".
        
        // We'll use a Fenwick Tree to figure out how many smaller "digits" have already been "used".
        Fenwick fenwick = new Fenwick( n );
        
        // Find the index of each substring by looking in our word tree.
        // Record the "digit" 
        int j=0;
        int digit[] = new int[k];
        Node node = root;
        for( char ch : testarray )
        {
            // Traverse the tree
            node = node.children[(int)(ch-'a')];
            int index = node.index;
            
            // If we're at the end of an initial string...
            if( index>=0 )
            {
                // Record the "digit"
                digit[j++] = (index - fenwick.sum( index+1 ) ); 
                
                // We've seen this index, add it to the Fenwick Tree
                fenwick.adjust( index+1, 1 );
                
                // Start back at the root
                node = root;
            }
        }
        
        // Now, convert those "digits" into an answer.
        long answer = 1L;
        long multiplier = 1L;
        j = n-k+1;
        for( int i=k-1; i>=0; i-- )
        {
            answer += multiplier * digit[i];
            answer %= MOD;
            multiplier *= j++;
            multiplier %= MOD;
        }
        
        ps.println( answer );        
    }
    
    /**
     * main
     * 
     * @param args
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        br = new BufferedReader( new InputStreamReader( System.in ) );
        ps = System.out;
        
        new prefix_vanb().doit();
    }

}