Problem: Problem

Kotatsu turtle is a turtle with a kotatsu shell.


As soon as Kotatsu was pokita (getting up), he was trapped in a stage divided into grid-like sections. There is only one exit on this stage. The parcel is either a road, a fence or a bomb, and the kotatsu can move up, down, left and right to enter the parcel of the road or bomb. It cannot be moved diagonally. In addition, the fence section cannot be passed. The road section extends infinitely outside the stage, but it cannot be passed because there is a crocodile, the natural enemy of the turtle.

Kotatsu wants to go home (sleep) quickly, so I decided to head to the exit of this stage.

The kotatsu turtle, which can freely manipulate the infrared rays of the kotatsu, has the ability to turn eight sections around it into a road at the same time. However, if the 8 sections and one of the sections where you are located are bomb sections, the kotatsu will burn up when you explode, and you will not even be able to use the famous SNS "Kametta", so you will activate the ability. I can't do that.

<image>

An example is illustrated. The section where the illustration is not placed and the section where the kotatsu is placed are the sections of the road. The eight compartments around the kotatsu are the orange compartments. In the figure on the left, the 8 compartments around the kotatsu and the compartment where you are are not included in the bomb compartment, so you can activate the ability. However, in the figure on the right, the ability cannot be activated because the bomb compartment is included in either the surrounding 8 compartments or the compartment where you are.

The cost to move is $ A $ for each parcel move, and the cost to activate the ability is $ B $ each time. Please note that it is not the cost per wall turned into a road. The starting point and the exit of the stage are roads. Output the minimum sum of the cost of moving from the starting point to the exit of the stage and the cost of activating the ability. However, if you cannot reach the exit of the stage, output "INF" instead.

Constraints

The input satisfies the following conditions.

* $ 1 \ le H, W, A, B \ le 1000 $
* $ 3 \ le H + W $
* $ c_ {i, j} \ in $ {'s','g','.','#','*'}
*'s' and'g' appear once each

Input

The input is given in the following format.


$ H $ $ W $ $ A $ $ B $
$ c_ {1,1} \ cdots c_ {1, W} $
$ \ vdots $
$ c_ {H, 1} \ cdots c_ {H, W} $


The input consists of $ H + 1 $ lines.
On the $ 1 $ line, there are an integer $ H $ that represents the vertical length, an integer $ W $ that represents the left and right length, an integer $ A $ that represents the cost to move, and an integer $ B $ that represents the cost to activate the ability. Each is given with a blank delimiter.
The $ H $ line from the $ 2 $ line is given the state $ c_ {i, j} $ in each section of the stage where the kotatsu is confined.
$ c_ {i, j} $ consists of one of's','g','.','#','*', Each, and the partition $ (i, j) $ is in the following state. Represents that.
's': Indicates that the section is the starting point.
'g': Indicates that the parcel is the exit of the stage.
'.': Indicates that the section is a road.
'#': Indicates that the section is a fence.
'*': Indicates that the parcel is a bomb.

Output

Output the minimum sum of the cost of moving from the starting point to the exit of the stage and the cost of activating the ability. However, if you cannot reach the exit of the stage, output "INF" instead.

Examples

Input

4 4 1 1
g#..
#...
.*..
...s


Output

7


Input

4 4 1 1
g#..
...
.*..
...s


Output

7


Input

4 4 1 1
g#..
*..
....
...s


Output

INF


Input

2 4 1 1
g
s###


Output

6


Input

3 3 1 10
g..
.
s..


Output

6


Input

3 3 10 1
g..
.
s..


Output

21

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
using namespace std;
const int MOD = 1000000007LL;
const int INF = MOD;
int di[8] = {0, -1, -1, -1, 0, 1, 1, 1};
int dj[8] = {1, 1, 0, -1, -1, -1, 0, 1};

vector<int> dijk(int s, int v, vector<vector<pair<int, int> > > adjlist){
    
    priority_queue <pair<int, int> > wait;
    vector<int> result(v, INF);

    //スタート地点を追加
    result[s] = 0;
    wait.push(make_pair(0, s));

    //ダイクストラ本体
    while(!wait.empty()){    //waitが空になるまで

        int nowpoint = wait.top().second;
        int nowcost = -wait.top().first;
        wait.pop();

        if(result[nowpoint] < nowcost) continue;

        //今いる頂点と隣接しているすべての頂点をなめる
        for(int i = 0; i < adjlist[nowpoint].size(); i++){

            int nextpoint = adjlist[nowpoint][i].second;
            int nextcost = nowcost + adjlist[nowpoint][i].first;
            //現時点より安く到達できそうであれば、結果を更新して優先度付きキューに格納
            if(result[nextpoint] > nextcost){
                result[nextpoint] = nextcost;
                wait.push(make_pair(-nextcost, nextpoint));
            }
        }
    }
    
    return result;         //結果列を返す
}

signed main(){
    
    int h, w, a, b; cin >> h >> w >> a >> b;
    vector<vector<char> > G(h + 2, vector<char> (w + 2, 'x'));
    
    int si, sj, gi, gj;
    for(int i = 1; i <= h; i++){
        for(int j = 1; j <= w; j++){
            cin >> G[i][j];
            if(G[i][j] == 's'){
                si = i;
                sj = j;
                G[i][j] = '.';
            }

            if(G[i][j] == 'g'){
                gi = i;
                gj = j;
                G[i][j] = '.';
            }
        }
    }

    int GridtoGraph[1010][1010];
    int num = 0;
    for(int i = 0; i <= h + 1; i++){
        for(int j = 0; j <= w + 1; j++){
            GridtoGraph[i][j] = num;
            num++;
        }
    }

    //first := コスト　second := 行先   
    vector<vector<pair<int, int> > > adjlist(num); 
    int s = GridtoGraph[si][sj];   
    int g = GridtoGraph[gi][gj];
    
    for(int i = 1; i <= h; i++){
        for(int j = 1; j <= w; j++){
            int cur = GridtoGraph[i][j];
            
            bool isExist = false;   //爆弾が周りにあるか
            if(G[i][j] == '*') isExist = true;
            for(int h = 0; h < 8; h++){
                int ni = i + di[h];
                int nj = j + dj[h];
                if(G[ni][nj] == '*') isExist = true;
            }

            for(int h = 0; h < 8; h++){
                int ni = i + di[h];
                int nj = j + dj[h];
                if(G[ni][nj] == 'x') continue;

                //この時点で '.' '*' '#' の三通り

                int nxt = GridtoGraph[ni][nj];
                if(h % 2 == 0){
                    //上下左右の移動
                    if(G[ni][nj] == '#'){
                        if(isExist) continue;
                        adjlist[cur].push_back({a + b, nxt});
                    }else{
                        adjlist[cur].push_back({a, nxt});                        
                    }

                }else{
                    //斜め移動
                    int subi1 = i + di[h - 1];
                    int subj1 = j + dj[h - 1];
                    int subi2 = i + di[(h + 1) % 8];
                    int subj2 = j + dj[(h + 1) % 8];                    
                    
                    if(G[ni][nj] == '#' || G[subi1][subj1] == '#' || G[subi2][subj2] == '#'){
                        if(isExist) continue;
                        adjlist[cur].push_back({2 * a + b, nxt});                        
                    }else{
                        adjlist[cur].push_back({2 * a, nxt});
                    }
                }
            }
        }
    }

    vector<int> result(num);
    result = dijk(s, num, adjlist);
    int ans = result[g];
    if(ans == INF) cout << "INF" << endl;
    else cout << ans << endl;
    return 0;
}