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 C# (Mono-mcs 6.8.0.105) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        var inputs = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        var n = inputs[0];
        var k = inputs[1];

        Modint result = 0;

        for (long i = k; i <= n + 1; i++)
        {
            result += i * (n - i + 1) + 1;
        }

        Console.WriteLine(result);
    }

    /// <summary>
    /// モジュラス数学 割り算をしたときの余りのみ注目
    /// </summary>
    public struct Modint
    {
        private const int M = 1000000007;

        public long Value { get; }

        private static readonly List<int> _factorialCache = new List<int> { 1 };

        public Modint(long value) { Value = value; }

        public static implicit operator Modint(long a)
        {
            var m = a % M;
            return new Modint((m < 0) ? m + M : m);
        }

        public static Modint operator +(Modint a, Modint b)
            => a.Value + b.Value;

        public static Modint operator -(Modint a, Modint b)
            => a.Value - b.Value;

        public static Modint operator *(Modint a, Modint b)
            => a.Value * b.Value;

        // フェルマーの小定理
        public static Modint operator /(Modint a, Modint b)
            => a * Pow(b, M - 2);

        /// <summary>
        /// a^n (繰り返し２累乗法)
        /// </summary>
        public static Modint Pow(Modint a, int n)
        {
            if (n == 0) return 1;
            if (n == 1) return a;

            var p = Pow(a, n / 2);
            return p * p * Pow(a, n % 2);
        }

        /// <summary>
        /// 階乗 n!
        /// </summary>
        public static Modint Fac(int n)
        {
            for (int i = _factorialCache.Count; i <= n; i++)
            {
                _factorialCache.Add((int)(Math.BigMul(_factorialCache.Last(), i) % M));
            }
            return _factorialCache[n];
        }

        public static Modint nCr(int n, int r)
            => (n < r) ? 0 :
               (n == r) ? 1 : Fac(n) / (Fac(r) * Fac(n - r));
    }
}