In the year 29XX, the government of a small country somewhere on the earth introduced a law restricting first names of the people only to traditional names in their culture, in order to preserve their cultural uniqueness. The linguists of the country specifies a set of rules once every year, and only names conforming to the rules are allowed in that year. In addition, the law also requires each person to use a name of a specific length calculated from one's birth date because otherwise too many people would use the same very popular names. Since the legislation of that law, the common task of the parents of new babies is to find the name that comes first in the alphabetical order among the legitimate names of the given length because names earlier in the alphabetical order have various benefits in their culture.

Legitimate names are the strings consisting of only lowercase letters that can be obtained by repeatedly applying the rule set to the initial string "S", a string consisting only of a single uppercase S.

Applying the rule set to a string is to choose one of the rules and apply it to the string. Each of the rules has the form A -> α, where A is an uppercase letter and α is a string of lowercase and/or uppercase letters. Applying such a rule to a string is to replace an occurrence of the letter A in the string to the string α. That is, when the string has the form "βAγ", where β and γ are arbitrary (possibly empty) strings of letters, applying the rule rewrites it into the string "βαγ". If there are two or more occurrences of A in the original string, an arbitrary one of them can be chosen for the replacement.

Below is an example set of rules.


S -> aAB  (1)
A ->      (2)
A -> Aa   (3)
B -> AbbA (4)


Applying the rule (1) to "S", "aAB" is obtained. Applying (2) to it results in "aB", as A is replaced by an empty string. Then, the rule (4) can be used to make it "aAbbA". Applying (3) to the first occurrence of A makes it "aAabbA". Applying the rule (2) to the A at the end results in "aAabb". Finally, applying the rule (2) again to the remaining A results in "aabb". As no uppercase letter remains in this string, "aabb" is a legitimate name.

We denote such a rewriting process as follows.


(1)     (2)    (4)       (3)        (2)       (2)
S --> aAB --> aB --> aAbbA --> aAabbA --> aAabb --> aabb


Linguists of the country may sometimes define a ridiculous rule set such as follows.


S -> sA (1)
A -> aS (2)
B -> b  (3)


The only possible rewriting sequence with this rule set is:


(1)    (2)     (1)      (2)
S --> sA --> saS --> sasA --> ...


which will never terminate. No legitimate names exist in this case. Also, the rule (3) can never be used, as its left hand side, B, does not appear anywhere else.

It may happen that no rules are supplied for some uppercase letters appearing in the rewriting steps. In its extreme case, even S might have no rules for it in the set, in which case there are no legitimate names, of course. Poor nameless babies, sigh!

Now your job is to write a program that finds the name earliest in the alphabetical order among the legitimate names of the given length conforming to the given set of rules.



Input

The input is a sequence of datasets, followed by a line containing two zeros separated by a space representing the end of the input. Each dataset starts with a line including two integers n and l separated by a space, where n (1 ≤ n ≤ 50) is the number of rules and l (0 ≤ l ≤ 20) is the required length of the name. After that line, n lines each representing a rule follow. Each of these lines starts with one of uppercase letters, A to Z, followed by the character "=" (instead of "->") and then followed by the right hand side of the rule which is a string of letters A to Z and a to z. The length of the string does not exceed 10 and may be zero. There appears no space in the lines representing the rules.

Output

The output consists of the lines showing the answer to each dataset in the same order as the input. Each line is a string of lowercase letters, a to z, which is the first legitimate name conforming to the rules and the length given in the corresponding input dataset. When the given set of rules has no conforming string of the given length, the corresponding line in the output should show a single hyphen, "-". No other characters should be included in the output.

Example

Input

4 3
A=a
A=
S=ASb
S=Ab
2 5
S=aSb
S=
1 5
S=S
1 0
S=S
1 0
A=
2 0
A=
S=AA
4 5
A=aB
A=b
B=SA
S=A
4 20
S=AAAAAAAAAA
A=aA
A=bA
A=
0 0


Output

abb
-
-
-
-

aabbb
aaaaaaaaaaaaaaaaaaaa
#include <string.h>
#include <ctype.h>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
inline void cmin(string &a, const string& b) { if (a > b) a = b; }
inline void cmin(string &a, const string& b, const string& c) {
    if (a.size() == 0) return ;
    if (b.size() && b[0] == '|') return ;
    if (c.size() && c[0] == '|') return ;
    if (a.size() != b.size() + c.size()) {
        a = b+c;
        return ;
    }
    else {
        int y = 0;
        rep (i, b.size()) {
            if (b[i] < a[i]) { y = -1; break; }
            if (b[i] > a[i]) { y = 1; break; }
        }
        if (y == 0) rep (i, c.size()) {
            if (c[i] < a[b.size()+i]) { y = -1; break; }
            if (c[i] > a[b.size()+i]) { y = 1; break; }
        }
        if (y < 0) {
            rep (i, b.size()) a[i] = b[i];
            rep (i, c.size()) a[b.size()+i] = c[i];
        }
    }
}
 
int n, L;
char from[64];
string to[64];
 
int has[32][24];
string dp[32][24], sub[2][24];
int minL[32], maxL[32];
 
string solve() {
    memset(has, 0, sizeof(has));
    rep (i, 32) rep (j, 24) dp[i][j] = '-';
    rep (i, 32) minL[i] = 1<<20;
    rep (i, 32) maxL[i] = -(1<<20);
    rep (LL, L+1) {
        for (;;) {
            bool update = false;
            rep (k, n) {
                int minE = 0, maxE = 0;
                rep (i, to[k].size()) {
                    if (islower(to[k][i])) minE++, maxE++;
                    else {
                        const int t = to[k][i] - 'A';
                        minE += minL[t];
                        maxE += maxL[t];
                    }
                }
                if (LL < minE || maxE < LL) continue;
                int cur = 0, nxt = 1;
                rep (i, 24) sub[cur][i] = '|';
                sub[cur][0] = "";
                rep (i, to[k].size()) {
                    rep (j, 24) sub[nxt][j] = '|';
                    if (islower(to[k][i])) {
                        rep (x, LL) cmin(sub[nxt][x+1], sub[cur][x]+to[k][i]);
                    }
                    else {
                        const int t = to[k][i] - 'A';
                        rep (j, LL+1) if (has[t][j]) rep (x, LL-j+1) {
                            cmin(sub[nxt][x+j], sub[cur][x], dp[t][j]);
                        }
                    }
                    swap(cur, nxt);
                }
                const int f = from[k] - 'A';
                if (sub[cur][LL] != "|") {
                    if (!has[f][LL] || dp[f][LL] > sub[cur][LL]) {
                        minL[f] = min(minL[f], LL);
                        maxL[f] = max(maxL[f], LL);
                        has[f][LL] = true;
                        update = true;
                        dp[f][LL] = sub[cur][LL];
                    }
                }
            }
            if (!update) break;
        }
    }
    return dp['S'-'A'][L];
}

int main() {
    for (;;) {
        cin >> n >> L;
        if (n == 0) return 0;
        string buf;
        rep (i, n) {
            cin >> buf;
            from[i] = buf[0];
            to[i] = buf.substr(2);
        }
        cout << solve() << endl;
    }
}