Problem: The fearless Ikta has finally hunted down the infamous Count Big Bridge! Count Bigbridge is now trapped in a rectangular room w meters wide and h meters deep, waiting for his end.

If you select a corner of the room and take the coordinate system so that the width direction is the x-axis and the depth direction is the y-axis, and the inside of the room is in the positive direction, Count Big Bridge is at the point (p, q). .. At point (x, y), there is a shock wave launcher, which is Ikta's ultimate weapon, from which a shock wave of v meters per second is emitted in all directions. This shock wave is valid for t seconds and is reflected off the walls of the room.

Ikta, who is outside the room, wants to know how much Count Big Bridge will suffer, so let's write a program that asks Count Big Bridge how many shock waves he will hit. At this time, if the shock wave hits the enemy from the n direction at the same time, it is considered to have hit the enemy n times, and it is also effective if the shock wave hits the enemy exactly t seconds later. The shock wave does not disappear due to obstacles such as the launcher itself and Count Big Bridge, and the shock waves do not interfere with each other.



Input

The input is given in the following format.

> w h v t x y p q
>

* Each is a positive integer as explained in the problem statement.



Constraints

* v × t ≤ 106
* 2 ≤ w, h ≤ 108
* 0 <x, p <w
* 0 <y, q <h
* (x, y) ≠ (p, q)

Output

Output the number of times the shock wave hits Count Big Bridge on one line.

Examples

Input

10 10 1 10 3 3 7 7


Output

1


Input

10 10 1 11 3 3 7 7


Output

5


Input

2 3 1000 1000 1 1 1 2


Output

523598775681

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = __int128_t;
using Int = long long int;

const ll INF = 1LL << 60;
Int W, H, V, T, x, y, p, q;

ll find_upper(ll X, ll cy, ll ty, ll piv) {
    ll ub = T*V, lb = piv-1;
    while(ub - lb > 1) {
        ll mid = (ub + lb) / 2;
        ll Y = cy*mid + ty;

        ll dx = X - x, dy = Y - y;
        if(dx*dx + dy*dy > T*T*V*V) {
            ub = mid;
        }
        else {
            lb = mid;
        }
    }
    return ub;
}

ll find_lower(ll X, ll cy, ll ty, ll piv) {
    ll ub = piv, lb = -T*V;
    while(ub - lb > 1) {
        ll mid = (ub + lb) / 2;
        ll Y = cy*mid + ty;

        ll dx = X - x, dy = Y - y;
        if(dx*dx + dy*dy <= T*T*V*V) {
            ub = mid;
        }
        else {
            lb = mid;
        }
    }
    return ub;
}

bool is_valid(ll X, ll cy, ll ty, ll k) {
    ll Y = cy*k + ty;
    ll dx = X - x, dy = Y - y;
    return dx*dx + dy*dy <= T*T*V*V;
}

Int solve(ll cx, ll tx, ll cy, ll ty) {
    Int ret = 0;
    for(ll k=-T*V; k<=T*V; k++) {
        ll X = cx*k + tx, dx = X - x;
        if(dx*dx > T*T*V*V) continue;
        
        ll piv = INF;
        for(int k=-2; k<=2; k++) {
            if(is_valid(X, cy, ty, k)) {
                piv = k;
                break;
            }
        }
        if(piv == INF) continue;
        ll ub = find_upper(X, cy, ty, piv);
        ll lb = find_lower(X, cy, ty, piv);
        ret += ub - lb;
    }
    return ret;
}

int main() {
    cin >> W >> H >> V >> T >> x >> y >> p >> q;

    Int ans = 0;
    ans += solve(2*W,     p, 2*H,     q);
    ans += solve(2*W,     p, 2*H, 2*H-q);
    ans += solve(2*W, 2*W-p, 2*H,     q);
    ans += solve(2*W, 2*W-p, 2*H, 2*H-q);

    cout << ans << endl;
    return 0;
}