You already know that Valery's favorite sport is biathlon. Due to your help, he learned to shoot without missing, and his skills are unmatched at the shooting range. But now a smaller task is to be performed, he should learn to complete the path fastest.

The track's map is represented by a rectangle n × m in size divided into squares. Each square is marked with a lowercase Latin letter (which means the type of the plot), with the exception of the starting square (it is marked with a capital Latin letters S) and the terminating square (it is marked with a capital Latin letter T). The time of movement from one square to another is equal to 1 minute. The time of movement within the cell can be neglected. We can move from the cell only to side-adjacent ones, but it is forbidden to go beyond the map edges. Also the following restriction is imposed on the path: it is not allowed to visit more than k different types of squares (squares of one type can be visited an infinite number of times). Squares marked with S and T have no type, so they are not counted. But S must be visited exactly once — at the very beginning, and T must be visited exactly once — at the very end.

Your task is to find the path from the square S to the square T that takes minimum time. Among all shortest paths you should choose the lexicographically minimal one. When comparing paths you should lexicographically represent them as a sequence of characters, that is, of plot types.

Input

The first input line contains three integers n, m and k (1 ≤ n, m ≤ 50, n·m ≥ 2, 1 ≤ k ≤ 4). Then n lines contain the map. Each line has the length of exactly m characters and consists of lowercase Latin letters and characters S and T. It is guaranteed that the map contains exactly one character S and exactly one character T.

Pretest 12 is one of the maximal tests for this problem.

Output

If there is a path that satisfies the condition, print it as a sequence of letters — the plot types. Otherwise, print "-1" (without quotes). You shouldn't print the character S in the beginning and T in the end.

Note that this sequence may be empty. This case is present in pretests. You can just print nothing or print one "End of line"-character. Both will be accepted.

Examples

Input

5 3 2
Sba
ccc
aac
ccc
abT


Output

bcccc


Input

3 4 1
Sxyy
yxxx
yyyT


Output

xxxx


Input

1 3 3
TyS


Output

y


Input

1 4 1
SxyT


Output

-1
20 10 3
ebebccacdb
eeebccddeT
eadebecaac
adeeeaccbc
baccccdaed
deabceabba
dadbecbaaa
eacbbcedcb
aeeScdbbab
babaecaead
bacdbebeae
aacbadbeec
acddceecca
acaeaebaba
cdddeaaeae
eabddadade
ddddaeaeed
bccbaacadd
dccccbabdc
ecdaebeccc
 1 30 2
bmjcfldkloleiqqiTnmdjpaSckkijf
 15 15 3
cbbdccabdcbacbd
bcabdcacadacdbc
cbcddbbcdbddcad
ddcabdbbdcabbdc
aabadcccTcabdbb
cbacaaacaabdbbd
dbdcbSdabaadbdb
dbbaddcdddaadbb
bbddcdcbaccbbaa
adadadbdbbddccc
cddbbdaddcbbdcc
bbaadcdbbcaacca
adbdcdbbcbddbcd
cdadbcccddcdbda
cbcdaabdcabccbc
 10 8 2
bdcdcbfa
decffcce
dTffdacb
eeedcdbb
fdbbbcba
ddabfcda
abdbSeed
bdcdcffa
cadbaffa
fcccddad
 20 20 2
ddadfcdeTaeccbedeaec
acafdfdeaffdeabdcefe
abbcbefcdbbbcdebafef
fdafdcccbcdeeaedeffc
dfdaabdefdafabaabcef
febdcabacaaaabfacbbe
abfcaacadfdbfdbaaefd
dacceeccddccaccdbbce
cacebecabedbddfbfdad
dacbfcabbebfddcedffd
cfcdfacfadcfbcebebaa
ddfbebafaccbebeefbac
ebfaebacbbebdfcbcbea
dfbaebcfccacfeaccaad
edeedeceebcbfdbcdbbe
afaacccfbdecebfdabed
ddbdcedacedadeccaeec
ecbSeacbdcccbcedafef
cfdbeeffbeeafccfdddb
cefdbdfbabccfdaaadbf
 2 1 4
S
T
 3 5 2
SbcaT
acbab
acccb
 3 4 1
SbbT
aaaa
abba
 5 3 4
aaT
acc
bbb
bbc
cSb
 1 50 3
SaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaTaaaaaaaaaaa
 3 3 1
aaa
aaa
TSa
 6 6 3
pkhipk
mlfmak
aqmbae
dlbfSj
dpbjcr
aTbqbm
 3 4 1
Sbbb
aaaT
abbc
 5 5 1
caTbc
dccac
dacda
aacaS
cdcab
 1 40 1
faSfgfTcfadcdfagfbccbffbeaaebagbfcfcgdfd
 1 3 3
SaT
 1 10 2
baaSaaTacb
 20 20 2
baaaaaaaaaaaaaaaaaaa
bfffffffacfffffffffa
bgggggggaccgggggggga
bhhhhhhhaccchhhhhhha
biiiiiiiacccciiiiiia
bjjjjjjjacccccjjjjja
bkkkkkkkacccccckkkka
blllllllacccccccllla
bbbbbbbbSccccccccmma
bddddddddddcccccccna
bodddddddcccccccccca
bppddddddddTaaaaaaaa
bqqqdddddddbqqqqqqqa
brrrrddddddbrrrrrrra
bsssssdddddbsssssssa
bttttttddddbttttttta
buuuuuuudddbuuuuuuua
bvvvvvvvvddbvvvvvvva
bwwwwwwwwwdbwwwwwwwa
bbbbbbbbbbbbbbbbbbbb
 10 10 2
baaaaaaaaa
bffacffffa
bggaccggga
bbbSccchha
bdddddccia
bjddccccca
bkkdddTaaa
blllddblla
bmmmmdbmma
bbbbbbbbbb
 15 3 4
llv
ttT
hbo
ogc
kfe
gli
fbx
kfp
spm
cxc
ndw
Soa
pfh
edr
xmv
 3 4 2
Sbbb
aabT
abbc
 5 10 4
aaaaaaaaaa
aaaaaTaaaa
aaaaaaaSaa
aaaaaaaaaa
aaaaaaaaaa
 10 20 3
baaaaaaaaaaaaaaaaaaa
bfffffffacfffffffffa
bgggggggaccgggggggga
bbbbbbbbSccchhhhhhha
biiiiidddddcciiiiiia
bjjjjjjddcccccjjjjja
bkkkkkkkdddTaaaaaaaa
bllllllllddbllllllla
bmmmmmmmmmdbmmmmmmma
bbbbbbbbbbbbbbbbbbbb
 1 2 4
ST
 20 10 4
baaaaaaaaa
bffacffffa
bggaccggga
bhhaccchha
biiaccccia
bjjaccccca
bkkakkkkka
bllallllla
bbbSmmmmma
bnnnnnnnna
booooooooa
bpppppTaaa
bqqqqqbqqa
brrrrrbrra
bdddddbssa
btddddbtta
buudddbuua
bvvvddbvva
bwwwwdbwwa
bbbbbbbbbb
 15 10 4
sejwprqjku
pnjsiopxft
rsplgvwixq
endglkchxl
ftihbbexgh
sxtxbbavge
jcdkusfnmr
skgsqvflia
kcxmcxjpae
amaiwcfile
njgjSunmwd
ldxvahgreu
ecmrajbjuT
naioqigols
pbwrmxkltj
 4 5 3
abaaa
babaT
Sabba
aaaaa
 1 2 1
ST
 2 1 1
S
T
 1 20 3
acbccbbddbffScTadffd

bbbcccaccaac
 -1
 aaca
 bbbbee
 -1
 aacccaa
 bb
 bbbc
 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 cbqb
 aaa
 -1
 -1
 a
 aa
 ccccc
 ccccc
 -1
 aab
 aa
 ccccc
 mmmno
 aajbju
 aaba
 c

import java.util.*;
import java.io.*;
import java.math.*;

public class Solution {
    int n, m, k;
    char[][] map;
    
    int stI, stJ, fnI, fnJ;
    
    int bestLen = 10000;
    String bestP = null;
    
    boolean[] can;
    
    final int[] dx = new int[] {1, -1, 0, 0};
    final int[] dy = new int[] {0, 0, 1, -1};
    
    boolean[][] pass;
    int[][] len;
    
    int[] qI, qJ;
    
    class Pair implements Comparable<Pair> {
        int vi, vj;
        char let;
        int next;
        public Pair(int vi, int vj, char let, int next) {
            this.vi = vi;
            this.vj = vj;
            this.let = let;
            this.next = next;
        }
        public int compareTo(Pair other) {
            if (this.let != other.let)
                return this.let - other.let;
            else
                return this.next - other.next;
        }
    }
    
    void go(int pos, int taken) {
        if (taken > k)
            return;
        
        if (pos == 26) {
            for (int i=0; i < n; i++) {
                Arrays.fill(len[i], -1);
                Arrays.fill(pass[i], false);
            }
            
            pass[stI][stJ] = true;
            pass[fnI][fnJ] = true;
            for (int i=0; i < n; i++)
                for (int j=0; j < m; j++)
                    if (map[i][j] >= 'a' && map[i][j] <= 'z' && can[map[i][j]-'a'])
                        pass[i][j] = true;
            
            int qBeg = 0, qEnd = 0;
            qI[qBeg] = fnI;
            qJ[qBeg++] = fnJ;
            len[fnI][fnJ] = 0;
            while (qEnd < qBeg) {
                int curI = qI[qEnd], curJ = qJ[qEnd++];
                for (int i=0; i < 4; i++) {
                    int nextI = curI + dx[i];
                    int nextJ = curJ + dy[i];
                    if (nextI >= 0 && nextI < n && nextJ >= 0 && nextJ < m &&
                            pass[nextI][nextJ] && len[nextI][nextJ] == -1) {
                        len[nextI][nextJ] = len[curI][curJ] + 1;
                        qI[qBeg] = nextI;
                        qJ[qBeg++] = nextJ;
                    }
                }
            }

            if (len[stI][stJ] == -1 || len[stI][stJ] > bestLen)
                return;
            
            int L = len[stI][stJ];
            int[] sz = new int[L+1];
            for (int i=0; i<n; i++)
                for (int j=0; j<m; j++)
                    if (len[i][j] != -1 && len[i][j] <= L)
                        sz[len[i][j]]++;
            
            int[][] layerI = new int[L+1][];
            int[][] layerJ = new int[L+1][];
            int[] p = new int[L+1];
            for (int i=0; i<=L; i++) {
                layerI[i] = new int[sz[i]];
                layerJ[i] = new int[sz[i]];
            }
            for (int i=0; i<n; i++)
                for (int j=0; j<m; j++)
                    if (len[i][j] != -1 && len[i][j] <= L) {
                        layerI[len[i][j]][p[len[i][j]]] = i;
                        layerJ[len[i][j]][p[len[i][j]]++] = j;
                    }
            
            int[][] pathId = new int[n][m];
            pathId[fnI][fnJ] = 0;
            
            int curPathId = 1;
            
            for (int X=1; X <= L; X++) {
                char[] let = new char[sz[X]];
                int[] next = new int[sz[X]];
                Pair[] pp = new Pair[sz[X]];
                for (int i=0; i < sz[X]; i++) {
                    int curI = layerI[X][i];
                    int curJ = layerJ[X][i];
                    let[i] = map[curI][curJ];
                    next[i] = 1000000;
                    for (int j=0; j < 4; j++) {
                        int nextI = curI + dx[j];
                        int nextJ = curJ + dy[j];
                        if (nextI >= 0 && nextI < n && nextJ >= 0 && nextJ < m && len[nextI][nextJ] == X-1)
                            next[i] = Math.min(next[i], pathId[nextI][nextJ]);
                    }
                    pp[i] = new Pair(curI, curJ, let[i], next[i]);
                }
                Arrays.sort(pp);
                for (int i=0; i < sz[X]; i++)
                    pathId[pp[i].vi][pp[i].vj] = curPathId++; 
            }
            
            StringBuilder sb = new StringBuilder();
            
            int curI = stI, curJ = stJ;
            while (curI != fnI || curJ != fnJ) {
                int minId = 10000, bestDI = -1, bestDJ = -1;
                sb.append(map[curI][curJ]);
                for (int i=0; i < 4; i++) {
                    int nextI = curI + dx[i];
                    int nextJ = curJ + dy[i];
                    if (nextI >= 0 && nextI < n && nextJ >= 0 && nextJ < m && len[nextI][nextJ] == len[curI][curJ] - 1) {
                        if (pathId[nextI][nextJ] < minId) {
                            minId = pathId[nextI][nextJ];
                            bestDI = dx[i];
                            bestDJ = dy[i];
                        }
                    }
                }
                curI += bestDI;
                curJ += bestDJ;
            }
            
            String path = sb.toString();
            
//          for (int i=0; i < n; i++) {
//              for (int j=0; j < m; j++)
//                  System.out.print(pathId[i][j] + " ");
//              System.out.println();
//          }
            
            if (L < bestLen) {
                bestLen = L;
                bestP = path;
            } else if (path.compareTo(bestP) < 0) {
                bestP = path;
            }
            
            return;
        }
        
        go(pos+1, taken);
        can[pos] = true;
        go(pos+1, taken+1);
        can[pos] = false;
    }
    
    public void go() throws Exception {
        Scanner sc = new Scanner(new InputStreamReader(System.in));
        n = sc.nextInt();
        m = sc.nextInt();
        k = sc.nextInt();
        map = new char[n][m];
        for (int i=0; i<n; i++) {
            String s = sc.next();
            for (int j=0; j<m; j++)
                map[i][j] = s.charAt(j);
        }
        sc.close();
        
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++) {
                if (map[i][j] == 'S') {
                    stI = i; stJ = j;
                }
                if (map[i][j] == 'T') {
                    fnI = i; fnJ = j;
                }
            }
        
        can = new boolean[26];
        len = new int[n][m];
        qI = new int[n*m];
        qJ = new int[n*m];
        pass = new boolean[n][m];
        go(0, 0);
        
        if (bestLen == 10000)
            System.out.println(-1);
        else
            System.out.println(bestP.substring(1));
    }
    
    public static void main(String[] args) throws Exception {
        (new Solution()).go();
    }
}
