Problem:
Score: 1000 points

Problem Statement

Find the number of sequences of N non-negative integers A_1, A_2, ..., A_N that satisfy the following conditions:

L \leq A_1 + A_2 + ... + A_N \leq R

When the N elements are sorted in non-increasing order, the M-th and (M+1)-th elements are equal.

Since the answer can be enormous, print it modulo 10^9+7.

Constraints

All values in input are integers.

1 \leq M < N \leq 3 \times 10^5

1 \leq L \leq R \leq 3 \times 10^5

Input

Input is given from Standard Input in the following format:

N M L R

Output

Print the number of sequences of N non-negative integers, modulo 10^9+7.

Sample Input 1

4 2 3 7

Sample Output 1

105

The sequences of non-negative integers that satisfy the conditions are:

\begin{eqnarray} &(1, 1, 1, 0), (1, 1, 1, 1), (2, 1, 1, 0), (2, 1, 1, 1), (2, 2, 2, 0), (2, 2, 2, 1), \\ &(3, 0, 0, 0), (3, 1, 1, 0), (3, 1, 1, 1), (3, 2, 2, 0), (4, 0, 0, 0), (4, 1, 1, 0), \\ &(4, 1, 1, 1), (5, 0, 0, 0), (5, 1, 1, 0), (6, 0, 0, 0), (7, 0, 0, 0)\end{eqnarray}

and their permutations, for a total of 105 sequences.

Sample Input 2

2 1 4 8

Sample Output 2

3

The three sequences that satisfy the conditions are (2, 2), (3, 3), and (4, 4).

Sample Input 3

141592 6535 89793 238462

Sample Output 3

933832916

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll M=1000000007;
int n,m,l,r,i;
ll p[600005],inv[600005],ans;
ll C(int n,int m)
{
	if(n<0|m<0||n<m)
		return 0;
	return p[n]*inv[m]%M*inv[n-m]%M;
}
ll Ans(int y)
{
	int i,j;
	ll ans=0;
	for(i=0;i*m<=y;i++)
	{
		int u=y-i*m;
		ll s=0;
		for(j=0;j<=n-m&&u+n-m-j*i>=n;j++)
			if(j%2==0)
				s=(s+C(n-m,j)*C(u+n-m-j-j*i,n))%M;
			else
				s=(s-C(n-m,j)*C(u+n-m-j-j*i,n))%M;
		ans=(ans+s)%M;
		s=0;
		for(j=0;j<=n-m&&u+n-m-j*(i-1)>=n;j++)
			if(j%2==0)
				s=(s+C(n-m,j)*C(u+n-m-j-j*(i-1),n))%M;
			else
				s=(s-C(n-m,j)*C(u+n-m-j-j*(i-1),n))%M;
		ans=(ans-s)%M;
	}
	return ans*C(n,m)%M;
}
int main()
{
	scanf("%d %d %d %d",&n,&m,&l,&r);
	p[0]=inv[0]=inv[1]=1;
	for(i=2;i<=600000;i++)
		inv[i]=inv[M%i]*(M-M/i)%M;
	for(i=1;i<=600000;i++)
	{
		p[i]=p[i-1]*i%M;
		inv[i]=inv[i-1]*inv[i]%M;
	}
	ans=Ans(r)-Ans(l-1);
	cout<<((C(r+n,n)-C(l+n-1,n)-ans)%M+M)%M;
}