Problem:
Score : 400 points

Problem Statement

We have N+1 integers: 10^{100}, 10^{100}+1, ..., 10^{100}+N.

We will choose K or more of these integers. Find the number of possible values of the sum of the chosen numbers, modulo (10^9+7).

Constraints

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

1 \leq K \leq N+1

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the number of possible values of the sum, modulo (10^9+7).

Sample Input 1

3 2

Sample Output 1

10

The sum can take 10 values, as follows:

(10^{100})+(10^{100}+1)=2\times 10^{100}+1

(10^{100})+(10^{100}+2)=2\times 10^{100}+2

(10^{100})+(10^{100}+3)=(10^{100}+1)+(10^{100}+2)=2\times 10^{100}+3

(10^{100}+1)+(10^{100}+3)=2\times 10^{100}+4

(10^{100}+2)+(10^{100}+3)=2\times 10^{100}+5

(10^{100})+(10^{100}+1)+(10^{100}+2)=3\times 10^{100}+3

(10^{100})+(10^{100}+1)+(10^{100}+3)=3\times 10^{100}+4

(10^{100})+(10^{100}+2)+(10^{100}+3)=3\times 10^{100}+5

(10^{100}+1)+(10^{100}+2)+(10^{100}+3)=3\times 10^{100}+6

(10^{100})+(10^{100}+1)+(10^{100}+2)+(10^{100}+3)=4\times 10^{100}+6

Sample Input 2

200000 200001

Sample Output 2

1

We must choose all of the integers, so the sum can take just 1 value.

Sample Input 3

141421 35623

Sample Output 3

220280457

Solution in Rust (1.42.0) (judge verdict: Accepted)

const MOD: u64 = 1_000_000_007;

fn main() {
    let mut input = Input::new();

    let n: u64 = input.parse();
    let k: u64 = input.parse();

    let mut ans: u64 = 1;
    for i in k..=n {
        let u = (n + (n - i + 1)) * i / 2;
        let l = (i - 1) * i / 2;
        ans += u - l + 1;
        ans %= MOD;
    }

    println!("{}", ans);
}

struct Input(Vec<String>);

#[allow(dead_code)]
impl Input {
    fn new() -> Self {
        Self(Vec::new())
    }
    fn read(&self) -> String {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).expect("read() failed.");
        s
    }
    fn fill(&mut self) {
        let s = self.read();
        self.0 = s.split_whitespace().map(String::from).rev().collect();
    }
    fn parse<T: std::str::FromStr>(&mut self) -> T {
        if self.0.len() == 0 {
            self.fill();
        }
        self.0.pop().unwrap().parse().ok().unwrap()
    }
}