Problem:
Score : 600 points

Problem Statement

We have an integer sequence A of length N, where A_1 = X, A_{i+1} = A_i + D (1 \leq i < N ) holds.

Takahashi will take some (possibly all or none) of the elements in this sequence, and Aoki will take all of the others.

Let S and T be the sum of the numbers taken by Takahashi and Aoki, respectively. How many possible values of S - T are there?

Constraints

-10^8 \leq X, D \leq 10^8

1 \leq N \leq 2 \times 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N X D

Output

Print the number of possible values of S - T.

Sample Input 1

3 4 2

Sample Output 1

8

A is (4, 6, 8).

There are eight ways for (Takahashi, Aoki) to take the elements: ((), (4, 6, 8)), ((4), (6, 8)), ((6), (4, 8)), ((8), (4, 6))), ((4, 6), (8))), ((4, 8), (6))), ((6, 8), (4))), and ((4, 6, 8), ()).

The values of S - T in these ways are -18, -10, -6, -2, 2, 6, 10, and 18, respectively, so there are eight possible values of S - T.

Sample Input 2

2 3 -3

Sample Output 2

2

A is (3, 0). There are two possible values of S - T: -3 and 3.

Sample Input 3

100 14 20

Sample Output 3

49805

Solution in Rust (1.15.1) (judge verdict: Runtime Error)

fn run() {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    let mut it = s.trim().split_whitespace();
    let n: i64 = it.next().unwrap().parse().unwrap();
    let x: i64 = it.next().unwrap().parse::<i64>().unwrap();
    let d: i64 = it.next().unwrap().parse::<i64>().unwrap();
    let mut map = std::collections::BTreeMap::<i64, Vec<(i64, i64)>>::new();
    for i in 0..(n + 1) {
        let m = x * i - x * (n - i);
        let v = (m % (2 * d).abs() + 2 * d.abs()) % (2 * d.abs());
        let po = map.entry(v).or_insert(vec![]);
        let (l, r) = if d >= 0 {
            let l = i * (i - 1) / 2 * d;
            let r = n * (n - 1) / 2 * d - (n - i) * (n - 1 - i) / 2 * d;
            (l, r)
        } else {
            let l = i * (i - 1) / 2 * d;
            let r = n * (n - 1) / 2 * d - (n - i) * (n - 1 - i) / 2 * d;
            (r, l)
        };
        let s = n * (n - 1) / 2 * d;
//        println!("{}: {} {}", i, m + 2 * l - s, m + 2 * r - s);
        po.push((m + 2 * l - s, m + 2 * r - s));
    }
    let mut ans = 0;
    for (_, a) in map {
        let mut a = a;
        a.sort();
        a.reverse();
        let mut now = a.pop().unwrap();
        while let Some((l, r)) = a.pop() {
            if l <= now.1 {
                now.1 = std::cmp::max(now.1, r);
            } else {
                ans += (now.1 - now.0) / (2 * d.abs()) + 1;
                now = (l, r);
            }
        }
        ans += (now.1 - now.0) / (2 * d.abs()) + 1;
    }
    println!("{}", ans);
}

fn main() {
    run();
}