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;

typedef long long ll;
typedef long double Double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

namespace sub {
    template<typename T>
    constexpr typename std::enable_if<std::is_integral<T>::value, T>::type
    inf_sub() {
        return std::numeric_limits<T>::max() / 2 - 1000;
    }

    template<typename T>
    constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
    inf_sub() {
        return std::min(std::numeric_limits<T>::max() / 2 - 1000, T(1e50));
    }
}  // namespace sub

template<typename T>
constexpr T inf() {
    static_assert(std::is_arithmetic<T>::value, "T must be arithmetic value");
    return sub::inf_sub<T>();
}

template<typename T>
constexpr T zero() {
    static_assert(std::is_arithmetic<T>::value, "T must be arithmetic value");
    return T(0);
}


char c[1010][1010];
ll bad[1010][1010];
ll dst[1010][1010];
int H, W;
int A, B;

struct NODE {
    int r, c;
    ll cst;

    bool operator<(const NODE &rhs) const {
        return cst > rhs.cst;
    }
};

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


ll dijkstra(int sy, int sx, int gy, int gx) {
    priority_queue<NODE> Q;
    for(int i = 0 ; i < 1010 ; i++)
        for(int j = 0 ; j < 1010 ; j++)
            dst[i][j] = inf<ll>();

    auto add = [&](int sy, int sx, ll cst) {
        if (cst >= dst[sy][sx]) return;
        Q.push({sy, sx, cst});
        dst[sy][sx] = cst;
    };

    add(sy, sx, 0);


    while (Q.size()) {
        auto q = Q.top();
        Q.pop();
        if (q.r == gy && q.c == gx) {
            return q.cst;
        }

        for (int d = 0; d < 4; d++) {
            int y = q.r + dy[d];
            int x = q.c + dx[d];
            if (x < 0 || y < 0 || x >= W || y >= H || c[y][x] == '#') continue;
            add(y, x, q.cst + A);
        }
        if( bad[q.r][q.c] ) continue;
        for (int x = -1; x <= 1; x++) {
            for (int y = -1; y <= 1; y++) {
                int I = q.r + y;
                int J = q.c + x;
                if (I < 0 || J < 0 || I >= H || J >= W)
                    continue;
                add(I, J, q.cst + B + A * (abs(x) + abs(y)));
            }
        }
    }
    return inf<ll>();
}

int main() {
    cin >> H >> W >> A >> B;

    int sx, sy, gx, gy;
    for (int i = 0; i < H; i++) {
        for (int j = 0; j < W; j++) {
            cin >> c[i][j];
            if (c[i][j] == '*') {
                for (int x = -1; x <= 1; x++) {
                    for (int y = -1; y <= 1; y++) {
                        int I = i + y;
                        int J = j + x;
                        if (I < 0 || J < 0 || I >= H || J >= W)
                            continue;
                        bad[I][J] = true;
                    }
                }
            } else if (c[i][j] == 's') {
                sx = j;
                sy = i;
            } else if (c[i][j] == 'g') {
                gx = j;
                gy = i;
            }
        }
    }
    auto ans = dijkstra(sy, sx, gy, gx);
    if (ans >= inf<ll>()) {
        cout << "INF" << endl;
    } else {
        cout << ans << endl;
    }


}