// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <algorithm>

#include <cmath>

#include <vector>

#include <list>

#include <set>

#include <map>

#include <queue>

#include <stack>

#include <cctype>

#include <cassert>

#include <climits>

#include <string>

#include <bitset>

#include <cfloat>

#include <random>

#include <iomanip>

#include <unordered_set>

#pragma GCC optimize("Ofast")

using namespace std;

typedef long double ld;

typedef long long int ll;

typedef unsigned long long int ull;

typedef vector<int> vi;

typedef vector<char> vc;

typedef vector<bool> vb;

typedef vector<double> vd;

typedef vector<string> vs;

typedef vector<ll> vll;

typedef vector<pair<int,int> > vpii;

typedef vector<pair<ll,ll> > vpll;

typedef vector<vector<int> > vvi;

typedef vector<vector<char> > vvc;

typedef vector<vector<string> > vvs;

typedef vector<vector<ll> > vvll;

typedef map<int, int> mii;

typedef set<int> si;

#define rep(i,n) for(int i = 0; i < (n); ++i)

#define rrep(i,n) for(int i = 1; i <= (n); ++i)

#define irep(it, stl) for(auto it = stl.begin(); it != stl.end(); it++)

#define drep(i,n) for(int i = (n) - 1; i >= 0; --i)

#define fin(ans) cout << (ans) << '\n'

#define STLL(s) strtoll(s.c_str(), NULL, 10)

#define mp(p,q) make_pair(p, q)

#define pb(n) push_back(n)

#define all(a) a.begin(), a.end()

#define rall(a) a.rbegin(), a.rend()

#define Sort(a) sort(a.begin(), a.end())

#define Rort(a) sort(a.rbegin(), a.rend())

#define MATHPI acos(-1)

#define itn int

// #define endl '\n';

#define fi first

#define se second

#define NONVOID [[nodiscard]]

const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};

const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};

template <class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;} return 0;}

template <class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;} return 0;}

template <class T> inline void dump(T &v){irep(i, v){cout<<*i<<((i==--v.end())?'\n':' ');}}

inline string getline(){string s; getline(cin,s); return s;}

inline void yn(const bool b){b?fin("yes"):fin("no");}

inline void Yn(const bool b){b?fin("Yes"):fin("No");}

inline void YN(const bool b){b?fin("YES"):fin("NO");}

struct io{io(){ios::sync_with_stdio(false);cin.tie(0);}};

const int INF = INT_MAX;

const ll LLINF = 1LL<<60;

const ll MOD = 1000000007;

const double EPS = 1e-9;



template <typename T>

class Sum {

public:

    // 単位元

    T unit;

    

    Sum(void) {

        // 単位元

        unit = 0;

    }



    // 演算関数

    T calc(T a, T b) {

        return a + b;

    }

};





template <typename T, class MONOID>

class SegmentTree {

public:

    // セグメント木の葉の要素数

    int n;



    // セグメント木

    vector<T> tree;



    // モノイド

    MONOID mono;



    SegmentTree(vector<T> &v) : n(1 << (int)ceil(log2(v.size()))), tree(vector<T>(n << 1)) {

        for(int i = 0; i < v.size(); ++i) {

            update(i, v[i]);

        }

        for(int i = v.size(); i < n; ++i) {

            update(i, mono.unit);

        }

    }



    // k番目の値(0-indexed)をxに変更

    void update(int k, T x) {

        k += n;

        tree[k] = x;

        for(k = k >> 1; k > 0; k >>= 1){

            tree[k] = mono.calc(tree[k << 1 | 0], tree[k << 1 | 1]);

        }

    }



    // [l, r)の最小値(0-indexed)を求める．

    T query(int l, int r) {

        T res = mono.unit;

        l += n;

        r += n;

        while(l < r) {

            if(l & 1) {

                res = mono.calc(res, tree[l++]);

            }

            if(r & 1) {

                res = mono.calc(res, tree[--r]);

            }

            l >>= 1;

            r >>= 1;

        }

        return res;

    }



    T operator[](int k) {

        // st[i]で添字iの要素の値を返す

        if(k - n >= 0 || k < 0) {

            return -INF;

        }

        return tree[tree.size() - n + k];

    }



    void show(void) {

        int ret = 2;

        for(int i = 1; i < 2*n; ++i) {

            if(tree[i] == mono.unit) cout << "UNIT ";

            else cout << tree[i] << " ";

            if(i == ret - 1) {

                cout << endl;

                ret <<= 1;

            }

        }

        cout << endl;

    }

};



int main() {



    int n,k;

    cin>>n>>k;

    ll ans=0;

    vll v(n+1);

    for(int i=0;i<n+1;i++)v[i]=i;



    SegmentTree<ll,Sum<ll>> st(v);



    for(int i=k;i<=n+1;i++){

        ans+=(st.query(n+1-i,n+1)%MOD-st.query(0,i)%MOD+1+MOD)%MOD;

        ans%=MOD;

        // fin(ans);

    }

    fin(ans);

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <cstdio>

#include <algorithm>

#include <cmath>

#include <vector>

#include <list>

#include <set>

#include <map>

#include <queue>

#include <stack>

#include <cctype>

#include <cassert>

#include <climits>

#include <string>

#include <bitset>

#include <cfloat>

#include <random>

#include <iomanip>

#include <unordered_set>

using namespace std;

typedef long double ld;

typedef long long int ll;

typedef unsigned long long int ull;

typedef vector<int> vi;

typedef vector<char> vc;

typedef vector<bool> vb;

typedef vector<double> vd;

typedef vector<string> vs;

typedef vector<ll> vll;

typedef vector<pair<int,int> > vpii;

typedef vector<pair<ll,ll> > vpll;

typedef vector<vi> vvi;

typedef vector<vvi> vvvi;

typedef vector<vc> vvc;

typedef vector<vs> vvs;

typedef vector<vll> vvll;

typedef map<int,int> mii;

typedef set<int> si;

#define rep(i,n) for(int i = 0; i < (n); ++i)

#define rrep(i,n) for(int i = 1; i <= (n); ++i)

#define arep(i,v) for(auto i : v)

#define irep(it, stl) for(auto it = stl.begin(); it != stl.end(); it++)

#define drep(i,n) for(int i = (n) - 1; i >= 0; --i)

#define fin(ans) cout << (ans) << '\n'

#define STLL(s) strtoll(s.c_str(), NULL, 10)

#define mp(p,q) make_pair(p, q)

#define pb(n) push_back(n)

#define all(a) a.begin(), a.end()

#define rall(a) a.rbegin(), a.rend()

#define Sort(a) sort(a.begin(), a.end())

#define Rort(a) sort(a.rbegin(), a.rend())

#define MATHPI acos(-1)

#define fi first

#define se second

constexpr int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};

constexpr int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};

template <class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;} return 0;}

template <class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;} return 0;}

template <class T> inline void dump(T &v){irep(i, v){cout<<*i<<((i==--v.end())?'\n':' ');}}

inline string getline(){string s; getline(cin,s); return s;}

inline void yn(const bool b){b?fin("yes"):fin("no");}

inline void Yn(const bool b){b?fin("Yes"):fin("No");}

inline void YN(const bool b){b?fin("YES"):fin("NO");}

struct io{io(){ios::sync_with_stdio(false);cin.tie(0);}};

const int INF = INT_MAX;

constexpr ll LLINF = 1LL<<60;

constexpr ll MOD = 1000000007;

constexpr double EPS = 1e-9;



struct mint {

    ll x;

    mint(ll _x = 0):x((_x % MOD + MOD) % MOD) {}



    /* 初期化子 */

    mint operator+() const {

    return mint(x);

    }

    mint operator-() const {

    return mint(-x);

    }



    /* 代入演算子 */

    mint& operator+=(const mint a) {

        if ((x += a.x) >= MOD) x -= MOD;

        return *this;

    }

    mint& operator-=(const mint a) {

        if ((x += MOD - a.x) >= MOD) x -= MOD;

        return *this;

    }

    mint& operator*=(const mint a) {

        (x *= a.x) %= MOD;

        return *this;

    }

    mint& operator/=(const mint a) {

        x *= modinv(a).x;

        return (*this);

    }

    mint& operator%=(const mint a) {

        x %= a.x;

        return (*this);

    }

    mint& operator++() {

        ++x;

        if(x >= MOD) x -= MOD;

        return *this;

    }

    mint& operator--() {

        if(!x) x += MOD;

        --x;

        return *this;

    }

    mint& operator&=(const mint a) {

        x &= a.x;

        return (*this);

    }

    mint& operator|=(const mint a) {

        x |= a.x;

        return (*this);

    }

    mint& operator^=(const mint a) {

        x ^= a.x;

        return (*this);

    }

    mint& operator<<=(const mint a) {

        x *= pow(2, a).x;

        return (*this);

    }

    mint& operator>>=(const mint a) {

        x /= pow(2, a).x;

        return (*this);

    }



    /* 算術演算子 */

    mint operator+(const mint a) const {

        mint res(*this);

        return res+=a;

    }

    mint operator-(const mint a) const {

        mint res(*this);

        return res-=a;

    }

    mint operator*(const mint a) const {

        mint res(*this);

        return res*=a;

    }

    mint operator/(const mint a) const {

        mint res(*this);

        return res/=a;

    }

    mint operator%(const mint a) const {

        mint res(*this);

        return res%=a;

    }

    mint operator&(const mint a) const {

        mint res(*this);

        return res&=a;

    }

    mint operator|(const mint a) const {

        mint res(*this);

        return res|=a;

    }

    mint operator^(const mint a) const {

        mint res(*this);

        return res^=a;

    }

    mint operator<<(const mint a) const {

        mint res(*this);

        return res<<=a;

    }

    mint operator>>(const mint a) const {

        mint res(*this);

        return res>>=a;

    }



    /* 条件演算子 */

    bool operator==(const mint a) const noexcept {

        return x == a.x;

    }

    bool operator!=(const mint a) const noexcept {

        return x != a.x;

    }

    bool operator<(const mint a) const noexcept {

        return x < a.x;

    }

    bool operator>(const mint a) const noexcept {

        return x > a.x;

    }

    bool operator<=(const mint a) const noexcept {

        return x <= a.x;

    }

    bool operator>=(const mint a) const noexcept {

        return x >= a.x;

    }



    /* ストリーム挿入演算子 */

    friend istream& operator>>(istream& is, mint& m) {

        is >> m.x;

        m.x = (m.x % MOD + MOD) % MOD;

        return is;

    }

    friend ostream& operator<<(ostream& os, const mint& m) {

        os << m.x;

        return os;

    }



    /* その他の関数 */

    mint modinv(mint a) {

        return pow(a, MOD - 2);

    }

    mint pow(mint x, mint n){

        mint res = 1;

        while(n.x > 0){

            if((n%2).x) res *= x;

            x *= x;

            n.x /= 2;

        }

        return res;

    }

};







int main() {

    

    mint ans=0;

    mint n,k;

    int N,K;

    cin>>N>>K;

    n.x=N;k.x=K;

    ++n;

    for(mint i=k;i.x<=n.x;++i){

        mint a=(n.x)*(n.x-1)/2;

        mint b=(n.x-i.x)*(n.x-i.x-1)/2;

        mint c=(i.x)*(i.x-1)/2;

        // cout<<i<<" "<<a<<" "<<b<<" "<<c<<endl;

        ans+=a+1-b-c;

    }

    fin(ans);

}














// Fastest known solution for this problem: