Problem:
勇猛果敢なイクタ君はついに悪名高きビッグブリッジ伯爵を追い詰めた！　今やビッグブリッジ伯爵は幅 w メートル、奥行き h メートルの長方形の部屋に閉じ込められており、最期を待つばかりとなっている。

部屋のある角を選び、幅方向を x 軸、奥行き方向を y 軸に、それぞれ部屋の内部が正の方向になるように座標系をとると、ビッグブリッジ伯爵は点 (p, q) にいる。点 (x, y) にイクタ君の最終兵器である衝撃波発射装置があり、ここから秒速 v メートルの衝撃波を全方向に出す。この衝撃波は t 秒間有効であり、部屋の壁面で反射する。

部屋の外にいるイクタ君はビッグブリッジ伯爵がどれだけ苦しむか知りたがっているので、ビッグブリッジ伯爵に衝撃波が何回当たるかを求めるプログラムを書いてあげよう。このとき、衝撃波が同時に n 方向から敵に当たる場合は n 回当たったとみなし、また衝撃波がちょうど t 秒後に敵に当たる場合も有効であるとする。衝撃波は発射装置自身やビッグブリッジ伯爵などの障害物により消滅せず、衝撃波同士は干渉しない。

Input

入力は以下の形式で与えられる。

w h v t x y p q

それぞれは問題文の説明の通りの正の整数である。

Constraints

v × t ≤ 106

2 ≤ w, h ≤ 108

0 < x, p < w

0 < y, q < h

(x, y) ≠ (p, q)

Output

衝撃波がビッグブリッジ伯爵に当たる回数を1行に出力せよ。

Sample Input 1

10 10 1 10 3 3 7 7

Output for the Sample Input 1

1

Sample Input 2

10 10 1 11 3 3 7 7

Output for the Sample Input 2

5

入力例 1, 2 において部屋の大きさと発射装置とビッグブリッジ伯爵の位置が同じであることに注意しながら、それぞれに付随する図（黒い点が発射装置、白い点がビッグブリッジ伯爵を表す）を見よ。

Sample Input 3

2 3 1000 1000 1 1 1 2

Output for the Sample Input 3

523598775681

Solution in Rust (judge verdict: Accepted)

extern crate core;

use std::fmt;
use std::cmp::Ordering;
use std::fmt::{Display, Error, Formatter};
macro_rules! read_line{
    () => {{
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).ok();
        line
    }};
    (delimiter: ' ') => {
        read_line!().split_whitespace().map(|x|x.to_string()).collect::<Vec<_>>()
    };
    (delimiter: $p:expr) => {
        read_line!().split($p).map(|x|x.to_string()).collect::<Vec<_>>()
    };
    (' ') => {
        read_line!(delimiter: ' ')
    };
    ($delimiter:expr) => {
        read_line!(delimiter: $delimiter)
    };
    (' '; $ty:ty) => {
        read_line!().split_whitespace().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
    };
    ($delimiter:expr; $ty:ty) => {
        read_line!($delimiter).into_iter().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
    };
}
macro_rules! let_all {
    ($($n:ident:$t:ty),*) => {
        let line = read_line!(delimiter: ' ');
        let mut iter = line.iter();
        $(let $n:$t = iter.next().unwrap().parse().ok().unwrap();)*
    };
}
fn main(){
    let_all!(w: f64, h: f64, v: f64, t: f64, x: f64, y: f64, p: f64, q: f64);
    let start = Point{x: x, y: y};
    let mut n = 0;
    let mut result = 0;
    while let Some(RangeF64{lower, upper}) = cal_y_range(&start, if n % 2 == 0 {
        p + n as f64 * w
    }else {
        n as f64 * w + w - p
    }, v * t) {
        //println!("n = {}, lower = {}, upper = {}", n, lower, upper);
        let le = ((lower - q) / 2_f64 / h);
        let ue = ((upper - q) / 2_f64 / h);
        if le < ue {
            //println!("n = {}, lower = {}, upper = {}", n, le, ue);
            result += (ue.floor() - le.ceil() + 1_f64) as i64;
        }
        let lo = ((lower + q - 2_f64 * h) / 2_f64 / h);
        let uo = ((upper + q - 2_f64 * h) / 2_f64 / h);
        if lo < uo {
            //println!("n = {}, lower = {}, upper = {}", n, lo, uo);
            result += (uo.floor() - lo.ceil() + 1_f64) as i64;
        }
        n += 1;
    }
    n = -1;
    while let Some(RangeF64{lower, upper}) = cal_y_range(&start, if n % 2 == 0 {
        p + n as f64 * w
    }else {
        n as f64 * w + w - p
    }, v * t) {
        //println!("n = {}, lower = {}, upper = {}", n, lower, upper);
        let le = ((lower - q) / 2_f64 / h);
        let ue = ((upper - q) / 2_f64 / h);
        if le < ue {
            //println!("n = {}, lower = {}, upper = {}", n, le, ue);
            result += (ue.floor() - le.ceil() + 1_f64) as i64;
        }
        let lo = ((lower + q - 2_f64 * h) / 2_f64 / h);
        let uo = ((upper + q - 2_f64 * h) / 2_f64 / h);
        if lo < uo {
            //println!("n = {}, lower = {}, upper = {}", n, lo, uo);
            result += (uo.floor() - lo.ceil() + 1_f64) as i64;
        }
        n -= 1;
    }
    println!("{}", result);
}
struct Point {
    x: f64, y: f64
}
struct RangeF64 {
    lower: f64, upper: f64,
}
trait Math {
    fn absolute(&self) -> Self;
}
impl Math for f64 {
    fn absolute(&self) -> Self {
        if self < &0_f64 {
            -*self
        }else {
            *self
        }
    }
}
fn cal_y_range(from: &Point, x: f64, distance: f64) -> Option<RangeF64> {
    let dx = (x - from.x).abs();
    if dx <= distance {
        let dy = (distance * distance - dx * dx).sqrt();
        Some(RangeF64 { lower: from.y - dy, upper: from.y + dy})
    }else {
        None
    }
}