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

#define _CRT_SECURE_NO_WARNINGS
#ifdef ONLINE_JUDGE
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <limits>
#include <utility>
#include <cstdlib>
#include <cstdio>
#include <cstdarg>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstring>
#endif
// #include "local.h"

#define len(C)                  int((C).size())
#define for_(I, M, N)           for(int I = int(M), CNT_##I = int(N); I < CNT_##I; ++I)
#define rep(I, N)               for_(I, 0, N)
#define elems(XS)               (XS).begin(), (XS).end()

using namespace std;	
template <typename S, typename T> void fill_(S& buf, T x){fill(reinterpret_cast<T*>(&buf), reinterpret_cast<T*>(&buf) + sizeof(buf) / sizeof(T), x);}
template <typename T, int N> inline int countof(const T (&)[N]){return N;}
template <typename T> inline vector<T>& operator +=(vector<T>& ret, const T& x){ret.push_back(x);return ret;}

#define PAIR(y, x)      ((y) << 16 | (x) & 0xFFFF)
#define Y(v)            ((v) >> 16 & 0xFFFF)
#define X(v)            ((v)       & 0xFFFF)

const int S = 51;
int N, M, K;
int start, goal;
int best = INT_MAX;
char orginalBoard[S][S];
char board[S][S];
string ret;
int xs[] = { 0, -1, 1, 0};
int ys[] = {-1,  0, 0, 1};

inline void clear()
{
    memset(board, '#', sizeof(board));
}

int findPos(const char c)
{
    rep(n, N) rep(m, M) if(orginalBoard[n][m] == c)
        return PAIR(n, m);
    return -1;
}

template <typename T> class Releaser
{
    T* m_p;
public:
    Releaser(T* p) : m_p(p){};
    ~Releaser(){delete m_p;}
};

inline bool inRange(const int y, const int x)
{
    return board[y][x] != '#' && 0 <= y && y < N && 0 <= x && x < M;
}

inline void bfs()
{
    struct State{
        int pos;
        int cost;
        string route;
        State(int pos, int cost) : pos(pos), cost(cost){}
        State(int pos, int cost, const string route, char add) : pos(pos), cost(cost), route(route){this->route.push_back(add);}
    };

    queue<State*> qs;
    map<int, string> check;

    qs.push(new State(start, 0));

    while(!qs.empty()){
        State* p = qs.front(); qs.pop();

        {
            Releaser<State> dummy(p);

            if(check.count(p->pos)){
                if(check[p->pos] <= p->route)
                    continue;
            }

            check[p->pos] = p->route;

            if(p->cost > best)
                continue;

            if(p->pos == start && p->cost != 0)
                continue;

            if(p->pos == goal){
                best = p->cost;
                ret = ret.empty() ? p->route : min(ret, p->route);
                continue;
            }

            rep(i, countof(xs)){
                const int y = Y(p->pos) + ys[i], x = X(p->pos) + xs[i];

                if(!inRange(y, x))
                    continue;

                const char c = board[y][x];

                qs.push(new State(PAIR(y, x), p->cost + 1, p->route, c));
            }
        }
    }
}

void dfs(const unsigned int acc, const char next, const int k)
{
    if(k == 0){
        const char candidates[4] = {acc & 0xFF, (acc >> 8) & 0xFF, (acc >> 24) & 0xFF, (acc >> 16) & 0xFF};

        clear();
        rep(n, N) rep(m, M) rep(k, K) if(orginalBoard[n][m] == candidates[k])
            board[n][m] = candidates[k];

        board[Y(goal)][X(goal)] = 'T';

        return bfs();
    }

    for(char c = next; c <= 'z'; ++c)
        dfs((acc << 8) + c, c + 1, k - 1);
}

int main(int argc, char* argv[])
{
    cin >> N >> M >> K;

    string s;

    rep(i, N){
        cin >> s;
        rep(j, M) orginalBoard[i][j] = s[j];
    }

    start = findPos('S');
    goal  = findPos('T');

    dfs(0, 'a', K);

    if(ret.empty())
        cout << -1 << endl;
    else
        cout << ret.substr(0, len(ret) - 1) << endl;

    return 0;
}
