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 Ruby (2.7.1) (judge verdict: Accepted)

class Mint < Numeric
  
  attr_reader :value, :mod
  @@mod = 10 ** 9 + 7
  
  def initialize(value)
    @value = value
  end
  
  def +(other)
    if other.kind_of?(Mint)
      Mint.new((value + other.value) % @@mod)
    elsif other.kind_of?(Integer)
      Mint.new((value + other) % @@mod)
    else
      x, y = other.coerce(self)
      x + y
    end
  end
  
  def -(other)
    if other.kind_of?(Mint)
      Mint.new((value - other.value) % @@mod)
    elsif other.kind_of?(Integer)
      Mint.new((value - other) % @@mod)
    else
      x, y = other.coerce(self)
      x - y
    end
  end
  
  def *(other)
    if other.kind_of?(Mint)
      Mint.new((value * other.value) % @@mod)
    elsif other.kind_of?(Integer)
      Mint.new((value * other) % @@mod)
    else
      x, y = other.coerce(self)
      x * y
    end
  end
  
  def /(other)
    if other.kind_of?(Mint)
      Mint.new((value * other.value.pow(@@mod-2, @@mod) % @@mod ))
    elsif other.kind_of?(Integer)
      Mint.new((value * other.pow(@@mod-2, @@mod) % @@mod ))
    else
      x, y = other.coerce(self)
      x / y
    end
  end
  
  # def %(other)
  #   if other.kind_of?(Mint)
  #     raise MintDivisionError
  #   elsif other.kind_of?(Integer)
  #     Mint.new(value % @@mod)
  #   else
  #     x, y = other.coerce(self)
  #     x % y
  #   end
  # end
  
  def coerce(other)
    if other.kind_of?(Integer)
      return [Mint.new(other), self]
    elsif other.kind_of?(Mint)
      return [other, self]
    else
      super
    end
  end
  
  def inspect
    "#{value} (mod #{@@mod})"
  end
  
  def to_s
    "#{value % @@mod}"
  end
end

class Integer
  
  def coerce(other)
    if other.kind_of?(Mint)
      return [other, Mint.new(self)]
    elsif other.kind_of?(Integer)
      return [other, self]
    else
      super
    end
  end
  
end

class MintDivisionError < StandardError
  def initialize(msg="divided by Mint")
    super
  end
end

class Range
  alias_method :primitive_initialize, :initialize
  def initialize(s,t)
    s = s.value if s.kind_of?(Mint)
    t = t.value if s.kind_of?(Mint)
    primitive_initialize(s,t)
  end
end

n, k = gets.to_s.split.map{|e|e.to_i}
 
ans = (k..n+1).map{|i| Mint.new(i) * (n + n - i + 1) / 2 - i * ( i - 1 ) / 2 + 1 }.sum
 
puts ans