Problem:
How many ways?

Write a program which identifies the number of combinations of three integers which satisfy the following conditions:

You should select three distinct integers from 1 to n.

A total sum of the three integers is x.

For example, there are two combinations for n = 5 and x = 9.

1 + 3 + 5 = 9

2 + 3 + 4 = 9

Input

The input consists of multiple datasets. For each dataset, two integers n and x are given in a line.

The input ends with two zeros for n and x respectively. Your program should not process for these terminal symbols.

Constraints

3 ≤ n ≤ 100

0 ≤ x ≤ 300

Output

For each dataset, print the number of combinations in a line.

Sample Input

5 9
0 0

Sample Output

2

Note

      解説

Solution in Rust (judge verdict: Accepted)

pub fn read_parameters<T>() -> Result<Vec<T>, String>
where
    T: std::str::FromStr,
{
    let mut line = String::new();

    std::io::stdin()
        .read_line(&mut line)
        .map_err(|err| format!("{:?}", err))?;

    line.trim()
        .split_whitespace()
        .map(|x| x.parse::<T>())
        .collect::<Result<Vec<T>, _>>()
        .map_err(|_| format!("{}", "parse error"))
}

fn sort(i: i32, j: i32, k: i32) -> (i32, i32, i32) {
    if i <= j {
        if j <= k {
            (i, j, k)
        } else {
            if i <= k {
                (i, k, j)
            } else {
                (k, i, j)
            }
        }
    } else {
        if i <= k {
            (j, i, k)
        } else {
            if j <= k {
                (j, k, i)
            } else {
                (k, j, i)
            }
        }
    }
}

fn is_member(a: (i32, i32, i32), v: &Vec<(i32, i32, i32)>) -> bool {
    for x in v {
        if a.0 == x.0 && a.1 == x.1 && a.2 == x.2 {
            return true;
        }
    }
    false
}

fn main() {
    loop {
        let z = read_parameters::<i32>().unwrap();
        let (n, x) = (z[0], z[1]);

        if n == 0 && x == 0 {
            return;
        }

        let mut ans = Vec::new();
        for i in 1..n + 1 {
            for j in i + 1..n + 1 {
                let k = x - (i + j);
                if k >= 1 && k <= n && k != i && k != j {
                    let a = sort(i, j, k);
                    if !is_member(a, &ans) {
                        ans.push(a)
                    }
                }
            }
        }
        println!("{}", ans.len());
    }
}