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.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;


public class track {
    
static char[][] map;
static int k;
static int gr,gc;

public static void main(String[] args) {
    Scanner2 in = new Scanner2(System.in);
    int n = in.intNext();
    int m = in.intNext();
    k = in.intNext();
    map = new char[n][m];
    State start = null;
    for(int r = 0; r < n; ++r) {
        map[r] = in.stringNext().toCharArray();
        for(int c = 0; c < m; ++c) {
            if(map[r][c] == 'S') start = new State(r,c,0);
            if(map[r][c] == 'T') {gr=r;gc=c;}
        }
    }
    
    int res = aStar(start);
    if(res == INF) System.out.println(-1);
    else {
        for(int i = 1; i < path.size()-1; ++i) {
            State curr = path.get(i);
            System.out.print(map[curr.r][curr.c]);
        }
    }
}






static int[] dr = {0,1,0,-1};
static int[] dc = {-1,0,1,0};

public static class State {
    public final int r, c, used;
    
    public State(int r, int c, int used) {
        this.r = r;
        this.c = c;
        this.used = used;
    }
    
    @Override public boolean equals(Object o) {
        if(!(o instanceof State)) return false;
        State that = (State)o;
        return r == that.r && c == that.c && used == that.used;
    }
    
    @Override public int hashCode() {
        return 31*(31*r+c)+used;
    }
    
    public boolean isGoal() {
      return map[r][c] == 'T';
    }

    public void getSuccs(List<State> succs, List<Integer> costs) {  
        if(!isGoal()) {
            for(int i = 0; i < dr.length; ++i) {
                try {
                    int cr = r+dr[i];
                    int cc = c+dc[i];
                    int used2 = used;
                    if(map[cr][cc] != 'T') used2 = set(used,map[cr][cc]-'a');
                    if(Integer.bitCount(used2) <= k) {
                        succs.add(new State(cr,cc,used2));
                        costs.add(1);
                    }
                } catch (IndexOutOfBoundsException e){};
            }
            
            Collections.sort(succs,new Comparator<State>(){
                public int compare(State a, State b) {
                    return Integer.signum(map[a.r][a.c]-map[b.r][b.c]);
                }
            });
        }
    }
    
    @Override public String toString() {
         return r+" "+c+" "+used;
    }
    
    public int h() {
        return Math.abs(r-gr)+Math.abs(c-gc);
    }
}





    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
//Returns cost of shortest path from start to a goal state or INF if no such path exists.
static int INF = 1000000000;
static List<State> path = null;

public static int aStar(State start) {
  final Map<State, Integer> fScores = new HashMap<State, Integer>();
  Comparator<State> comp = new Comparator<State>() {
    public int compare(State v, State w) {
      Integer vFScore = fScores.get(v);
      Integer wFScore = fScores.get(w);
      if (wFScore == null || vFScore < wFScore) return -1;
      if (vFScore == null || vFScore > wFScore) return 1;
      return 0;
    }
  };

  Map<State, State> prev = new HashMap<State, State>();
  fScores.put(start, 0+start.h());
  Queue<State> unexpanded = new PriorityQueue<State>(100, comp);
  unexpanded.add(start);

  while (!unexpanded.isEmpty()) {
    State curr = unexpanded.poll();
    if (curr.isGoal()) {
      path = makePath(curr,prev);
      return fScores.get(curr)-curr.h();
    }
    List<State> succs = new ArrayList<State>();
    List<Integer> costs = new ArrayList<Integer>();
    curr.getSuccs(succs,costs);
    for (int i = 0; i < succs.size(); ++i) {
      State succ = succs.get(i);
      Integer currToSuccCost = costs.get(i);
      Integer succFScore = fScores.get(succ);
      Integer startToCurrCost = fScores.get(curr)-curr.h();
      int alt = startToCurrCost + currToSuccCost + succ.h();
      if (succFScore == null || alt < succFScore) {
        fScores.put(succ, alt);
        unexpanded.add(succ);
        prev.put(succ, curr);
      }
    }
  }
  return INF;
}

 
    
    
    
    
    
    
    
    public static List<State> makePath(State curr, Map<State,State> prev) {
        List<State> path = new LinkedList<State>();
        while(curr != null) {
            path.add(0,curr);
            curr = prev.get(curr);
        }
        return path;
    }
    
    
    
    

    public static int set(int x, int i) {
        assert i >= 0 && i <= 31;
        return x | (1 << i);
      }

}













//Negligible speed difference compared to manually reading from BufferedReader and calling parse functions.
class Scanner2 {
    private final BufferedReader reader;
    private StringTokenizer tokenizer = new StringTokenizer("");

    public Scanner2(InputStream is){reader=new BufferedReader(new InputStreamReader(is));}
    public Scanner2(File f)throws IOException{reader=new BufferedReader(new FileReader(f));}
    public Scanner2(String s){reader=new BufferedReader(new StringReader(s));}

    //Name of type comes first so auto-complete faster.
    public String stringNext() {
        try {
            while(!tokenizer.hasMoreTokens()) tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        } catch (IOException e) {throw new RuntimeException(e);}
    }
    public int intNext(){return Integer.parseInt(stringNext());}
    public long longNext(){return Long.parseLong(stringNext());}
    public double doubleNext(){return Double.parseDouble(stringNext());}
}