Problem: The Kingdom of Aqua Canora Mystica is a very affluent and peaceful country, but around the kingdom, there are many evil monsters that kill people. So the king gave an order to you to kill the master monster.

You came to the dungeon where the monster lived. The dungeon consists of a grid of square cells. You explored the dungeon moving up, down, left and right. You finally found, fought against, and killed the monster.

Now, you are going to get out of the dungeon and return home. However, you found strange carpets and big rocks are placed in the dungeon, which were not there until you killed the monster. They are caused by the final magic the monster cast just before its death! Every rock occupies one whole cell, and you cannot go through that cell. Also, each carpet covers exactly one cell. Each rock is labeled by an uppercase letter and each carpet by a lowercase. Some of the rocks and carpets may have the same label.

While going around in the dungeon, you observed the following behaviors. When you enter into the cell covered by a carpet, all the rocks labeled with the corresponding letter (e.g., the rocks with ‘A’ for the carpets with ‘a’) disappear. After the disappearance, you can enter the cells where the rocks disappeared, but if you enter the same carpet cell again or another carpet cell with the same label, the rocks revive and prevent your entrance again. After the revival, you have to move on the corresponding carpet cell again in order to have those rocks disappear again.

Can you exit from the dungeon? If you can, how quickly can you exit? Your task is to write a program that determines whether you can exit the dungeon, and computes the minimum required time.



Input

The input consists of some data sets.

Each data set begins with a line containing two integers, W and H (3 ≤ W, H ≤ 30). In each of the following H lines, there are W characters, describing the map of the dungeon as W × H grid of square cells. Each character is one of the following:

* ‘@’ denoting your current position,
* ‘<’ denoting the exit of the dungeon,
* A lowercase letter denoting a cell covered by a carpet with the label of that letter,
* An uppercase letter denoting a cell occupied by a rock with the label of that letter,
* ‘#’ denoting a wall, and
* ‘.’ denoting an empty cell.



Every dungeon is surrounded by wall cells (‘#’), and has exactly one ‘@’ cell and one ‘<’ cell. There can be up to eight distinct uppercase labels for the rocks and eight distinct lowercase labels for the carpets.

You can move to one of adjacent cells (up, down, left, or right) in one second. You cannot move to wall cells or the rock cells.

A line containing two zeros indicates the end of the input, and should not be processed.

Output

For each data set, output the minimum time required to move from the ‘@’ cell to the ‘<’ cell, in seconds, in one line. If you cannot exit, output -1.

Examples

Input

8 3
########
#<A.@.a#
########
8 3
########
#<AaAa@#
########
8 4
########
#<EeEe@#
#FG.e#.#
########
8 8
########
#mmm@ZZ#
#mAAAbZ#
#mABBBZ#
#mABCCd#
#aABCDD#
#ZZcCD<#
########
0 0


Output

7
-1
7
27


Input

8 3

<A.@.a#

8 3

<AaAa@#

8 4

<EeEe@#
FG.e#.#

8 8

mmm@ZZ#
mAAAbZ#
mABBBZ#
mABCCd#
aABCDD#
ZZcCD<#

0 0


Output

7
-1
7
27

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

using namespace std;

#define LOG(...) fprintf(stderr,__VA_ARGS__)
//#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))

typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};

char field[30][30];

struct P {
    int x, y;
    int cnt;
    int pressed;
};

int main() {
    int w, h;
    while (cin >> w >> h, w|h) {
        int x, y, gx, gy;
        map<tuple<int, int, int>, bool> G;
        map<int, int> id;
        REP(i, h) {
            REP(j, w) {
                cin >> field[i][j];
                switch (field[i][j]) {
                case '@':
                    field[i][j] = '.';
                    x = j;
                    y = i;
                    break;
                case '<':
                    field[i][j] = '.';
                    gx = j;
                    gy = i;
                    break;
                case '#':
                    break;
                default: {
                    char c = tolower(field[i][j]);
                    if (!EXIST(id, c)) {
                        id[c] = id.size();
                    }
                }
                }
            }
        }
        REP(i, h) {
            REP(j, w) {
                char c = field[i][j];
                if ('a' <= c && c <= 'z') {
                    field[i][j] = id[c] + 'a';
                } else if ('A' <= c && c <= 'Z') {
                    field[i][j] = id[c+0x20] + 'A';
                }
            }
        }
//        REP(i, h) {
//            REP(j, w) {
//                char c = field[i][j];
//                LOG("%c", c);
//            }
//            LOG("\n");
//        }

        queue<P> que;
        que.push({x, y, 0, 0});
        while (!que.empty()) {
            P p = que.front(); que.pop();
            int x = p.x, y = p.y;

            if (x == gx && y == gy) {
                cout << p.cnt << endl;
                goto NEXT;
            }

            REP(i, 4) {
                int sx = x + dx[i], sy = y + dy[i];
                if (field[sy][sx] == '#') {
                    continue;
                } else if (field[sy][sx] == '.') {
                    tuple<int, int, int> k = make_tuple(sx, sy, p.pressed);
                    if (!EXIST(G, k)) {
                        G[k] = true;
                        que.push({sx, sy, p.cnt+1, p.pressed});
                    }
                } else if ('a' <= field[sy][sx] && field[sy][sx] <= 'z') {
                    int pressed = p.pressed ^ (1 << (field[sy][sx] - 'a'));
                    tuple<int, int, int> k = make_tuple(sx, sy, pressed);
                    if (!EXIST(G, k)) {
                        G[k] = true;
                        que.push({sx, sy, p.cnt+1, pressed});
                    }
                } else if ((1 << (field[sy][sx] - 'A')) & p.pressed) {
                    tuple<int, int, int> k = make_tuple(sx, sy, p.pressed);
                    if (!EXIST(G, k)) {
                        G[k] = true;
                        que.push({sx, sy, p.cnt+1, p.pressed});
                    }
                }
            }
        }
        cout << -1 << endl;
NEXT: {}
    }
}