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

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <bitset>
#include <string>
#include <numeric>
#include <functional>
#include <iterator>
#include <typeinfo>
#include <utility>
#include <memory>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <cstddef>
#include <complex>
#include <ctime>
#include <cassert>
using namespace std;

typedef long long int53;
static inline int Rint()
{
	struct X{ int dig[256]; X(){
	for(int i = '0'; i <= '9'; ++i) dig[i] = 1; dig['-'] = 1;
	}};
	static 	X fuck;int s = 1, v = 0, c;
	for (;!fuck.dig[c = getchar()];);
	if (c == '-') s = 0; else if (fuck.dig[c]) v = c ^ 48;
	for (;fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48));
	return s ? v : -v;
}
typedef vector<int> vi;
typedef vi::iterator ivi;
typedef map<int, int> mii;
typedef mii::iterator imii;
typedef set<int> si;
typedef si::iterator isi;

#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define sz(x) ((int)x.size())
#define rep(i, s, e) for (int i = (s); i < (e); ++i)
#define foreach(itr, c) for(__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); ++itr)
int n, m, k;
char mat[53][53];
int sx, sy, ex, ey;
int ok(int x, int y){return x >= 0 && x < n && y >= 0 && y < m;}
int have[256];
int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
char ans[2500*2];
int la;
char tans[2500*2];
int lt;
int dist[53][53];
int prev[53][53][2];
void solve(int flag)
{
	queue<int> q;
	q.push(ex), q.push(ey);
	prev[ex][ey][0] = ex;
	prev[ex][ey][1] = ey;
	memset(dist, -1, sizeof dist);
	dist[ex][ey] = 0;
	while (!q.empty())
	{
		int cx = q.front(); q.pop();
		int cy = q.front(); q.pop();
		if (cx == sx && cy == sy) break;
		for (int i = 0; i < 4; ++i)
		{
			int nx = cx + dir[i][0];
			int ny = cy + dir[i][1];
			if (!ok(nx, ny)) continue;
			if (!(nx == sx && ny == sy) && ((1 << mat[nx][ny]) & flag) == 0) continue;
			if (dist[nx][ny] != -1)
			{
				if (dist[cx][cy] + 1 > dist[nx][ny]) continue;
				if (dist[cx][cy] + 1 == dist[nx][ny])
				{
					int c = prev[nx][ny][0];
					int d = prev[nx][ny][1];
					if (mat[cx][cy] < mat[c][d])
					prev[nx][ny][0] = cx, prev[nx][ny][1] = cy;
				}
				else
				{
					//never reach this branch
					//assert(0);
					dist[nx][ny] = dist[cx][cy] + 1;
					prev[nx][ny][0] = cx,prev[nx][ny][1] = cy;
				}
			}
			else
			{
				dist[nx][ny] = dist[cx][cy] + 1;
				prev[nx][ny][0] = cx,prev[nx][ny][1] = cy;
				q.push(nx), q.push(ny);
			}
		}
	}
	if (dist[sx][sy] == -1) return;
	int x = sx, y = sy;
	lt = 0;
	//cerr << dist[sx][sy] << endl;
	//cerr << la << " " << flag << " " << dist[sx][sy] << endl;
	//rep(i, 0, n) {rep(j, 0, m) cerr << prev[i][j][0] << "," << prev[i][j][1] << "\t";cerr<<endl;}
	while (x != ex || y != ey)
	{
		
		int c = prev[x][y][0];
		int d = prev[x][y][1];
		if (c == ex && d == ey) break;
		tans[lt++] = mat[c][d] + 'a';
		x = c, y = d;//cerr << x << " " << y << " " << " " << sx << " " << sy << " " << ex << " " << ey << endl;
		//cerr << lt << endl;
	}
	//puts(tans);
	//puts("\n");
	tans[lt] = 0;
	if (lt < la || lt == la && strcmp(tans, ans) < 0)
	{
		la = lt;
		strcpy(ans, tans);
	}
}

int comb(int curr, int used, int flag)
{
	if (used <= k)
	{
		if (used >= 1) solve(flag);
	}
	for (int i = curr; i < 26; ++i) if (have[i] && used + 1 <= k)
	{
		comb(i+1, used+1, flag | 1 << i);
	}
}
int main()
{
	scanf("%d%d%d", &n, &m, &k);
	rep(i, 0, n) scanf("%s", mat[i]);
	rep(i, 0, n) rep(j, 0, m)
	{
		if (mat[i][j] == 'S') sx = i, sy = j, mat[i][j] = 27;
		if (mat[i][j] == 'T') ex = i, ey = j, mat[i][j] = 28;
	}
	rep(i, 0, 4)
	{
		int nx = sx + dir[i][0];
		int ny = sy + dir[i][1];
		if (nx == ex && ny == ey)
		{
			puts("");
			return 0;
		}
	}
	memset(have, 0, sizeof have);
	rep(i, 0, n) rep(j, 0, m) if (mat[i][j] >= 'a' && mat[i][j] <= 'z')
	mat[i][j] -= 'a', ++have[mat[i][j]];
	la = 20000000;
	comb(0, 0, 0);
	if (la == 20000000) {puts("-1");return 0;}
	puts(ans);
	return 0;
}
