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 Kotlin (1.3.71) (judge verdict: Accepted)

fun main(args: Array<String>) = ABC163D.main()

object ABC163D {
    fun log(message: Any?) {
        //println(message)// TODO: ←消す
    }

    fun main() {
        val (N, K) = readLongs()

        val sizes = (K..N + 1).asSequence().map { k ->
            val min = (0..k - 1).sum()
            val max = (N - k + 1..N).sum()
            max - min + 1
        }
        val ans = sizes.fold(0L.toModLong(1000000007)) { acc, it -> acc + it }
        println(ans)
    }

    /*####################################################################################*/
    fun readLongs() = readLine()!!.split(" ").map { it.toLong() }

    fun LongRange.sum(): Long {
        val length = this.last - this.first + 1
        return length * (this.first + this.last) / 2
    }

    fun Number.toModLong(base: Long): ModLong = ModLong(this.toLong() % base, base)
    class ModLong(
        private val value: Long,
        private val base: Long
    ) : Number(), Comparable<ModLong> {
        override fun toString(): String = value.toString()
        override fun equals(other: Any?): Boolean = value == other
        override fun hashCode(): Int = value.hashCode()
        operator fun plus(other: Long): ModLong = (this.value + other % base).toModLong(base)
        override fun compareTo(other: ModLong): Int = value.compareTo(other.value)
        override fun toByte(): Byte = value.toByte()
        override fun toChar(): Char = value.toChar()
        override fun toDouble(): Double = value.toDouble()
        override fun toFloat(): Float = value.toFloat()
        override fun toInt(): Int = value.toInt()
        override fun toLong(): Long = value
        override fun toShort(): Short = value.toShort()
    }
}