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)

// ---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std::str::FromStr;
    use std::str::SplitWhitespace;
    use std::io::Read;
    use std;
    pub struct Scanner<'a> {
        it: SplitWhitespace<'a>
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace()
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            match self.it.next().unwrap().parse::<T>() {
                Ok(v) => v,
                _ => panic!("Scanner error")
            }
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.next::<String>().chars().collect()
        }
    }
    pub fn read_string() -> String {
        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).unwrap();
        s
    }
}
// ---------- end scannner ----------
use std::io::Write;
use std::cmp::*;
fn main() {
    let sc = scanner::read_string();
    let mut sc = scanner::Scanner::new(&sc);
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    // run(&mut sc, &mut out);
    // solvea(&mut sc,&mut out);
    // solveb(&mut sc,&mut out);
    // solvec(&mut sc,&mut out);
    solved(&mut sc,&mut out);
}

#[allow(dead_code)]
fn solvea(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<std::io::StdoutLock>){
    let t = sc.next::<usize>();
    for _ in 0..t{
        let n = sc.next::<i32>();
        for i in 2..=32{
            let cnt = 2i64.pow(i);
            if (n as i64)%(cnt-1) == 0{
                writeln!(out,"{}",(n as i64)/(cnt-1)).ok();
                break;
            }
        }
    }
}


#[allow(dead_code)]
fn solved(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<std::io::StdoutLock>){
    let n = sc.next::<usize>();
    let k = sc.next::<usize>();
    let mut res = 0i64;
    const MOD:i64 = (1e9+7.0) as i64;
    for i in k..=(n+1){
        let l = (i as i64)*((i-1) as i64)/2i64;
        let r = (i as i64)*((2*n-i+1) as i64)/2i64;
        res = (res+r-l+1)%MOD;
    }
    writeln!(out,"{}",res).ok();
}