#include <bits/stdc++.h>

using ull = unsigned long long;

using namespace std;

const int P = 1000000007;

int quo2(int x) { return ((x & 1) ? x + P : x) >> 1; }
int norm(int x) { return x >= P ? x - P : x; }
int reduce(int x) { return x < 0 ? x + P : x; }
int neg(int x) { return x ? P - x : 0; }
void add(int& x, int y) { if ((x += y - P) < 0) x += P; }
void sub(int& x, int y) { if ((x -= y) < 0) x += P; }
void fam(int& x, int y, int z) { x = (x + y * (ull)z) % P; }
int mpow(int x, unsigned k) {
	if (k == 0) return 1;
	int ret = mpow(x * (ull)x % P, k >> 1);
	if (k & 1) ret = ret * (ull)x % P;
	return ret;
}

const int N = 2010;

namespace BM {

int _u[N * 2], _v[N * 2], _x[N * 2], _y[N * 2];
int *u = _u, *v = _v, *x = _x, *y = _y;

int euclid(int n, int* vec) {
	memset(u, 0, sizeof(int) * n * 2);
	memset(x, 0, sizeof(int) * n * 2);
	memset(y, 0, sizeof(int) * n * 2);
	u[n * 2] = 1;
	std::copy(vec, vec + n * 2, v);
	y[0] = 1;
	int du = n * 2, dv = n * 2 - 1, dx = -1, dy = 0;
	while (true) {
		while (dv >= 0 && !v[dv]) --dv;
		if (dv < n && dy <= n) break;
		dx = std::max(dx, du - dv + dy);
		int nv = mpow(v[dv], P - 2);
		for (int i = du - dv; i >= 0; --i) {
			int c = (P - nv) * (ull)u[i + dv] % P;
			for (int j = 0; j <= dy; ++j) fam(x[i + j], c, y[j]);
			for (int j = 0; j <= dv; ++j) fam(u[i + j], c, v[j]);
		}
		std::swap(u, v); std::swap(du, dv);
		std::swap(x, y); std::swap(dx, dy);
	}
	int n0 = mpow(y[0], P - 2);
	for (int i = 0; i <= dy; ++i) y[i] = y[i] * (ull)n0 % P;
	return dy;
}

}

const int THRES = 2000;

int seq[THRES];

int f[THRES], g[THRES], h[THRES], tf[THRES], tg[THRES];

int A, B;

int dp[26][60], tmp[26][60];

void gen(int* arr, int s) {
	memset(dp, 0, sizeof(dp));
	arr[0] = 1;
	for (int i = 0; i < s; ++i) dp[i][1] = 1;
	for (int n = 1; n < THRES; ++n) {
		for (int i = 0; i < s; ++i) add(arr[n], accumulate(dp[i], dp[i] + 60, 0ULL) % P);
		memset(tmp, 0, sizeof(tmp));
		int sum = 0;
		for (int i = 0; i < s; ++i) {
			for (int j = 1; j < A; ++j) {
				add(sum, dp[i][j]);

				add(tmp[i][j + 1], dp[i][j]); sub(tmp[i][1], dp[i][j]);
				if (i) {
					add(tmp[i - 1][A + 2], dp[i][j]); sub(tmp[i - 1][1], dp[i][j]);
				}
				if (i + 1 < s) {
					add(tmp[i + 1][A + B + 2], dp[i][j]); sub(tmp[i + 1][1], dp[i][j]);
				}
			}
			for (int j = 2; j < B; ++j) {
				add(sum, dp[i][A + j]);

				add(tmp[i][2], dp[i][A + j]); sub(tmp[i][1], dp[i][A + j]);
				if (i) {
					add(tmp[i - 1][A + j + 1], dp[i][A + j]); sub(tmp[i - 1][1], dp[i][A + j]);
				}
				if (i + 1 < s) {
					add(tmp[i + 1][A + B + 2], dp[i][A + j]); sub(tmp[i + 1][1], dp[i][A + j]);
				}
			}
			for (int j = 2; j < B; ++j) {
				add(sum, dp[i][A + B + j]);

				add(tmp[i][2], dp[i][A + B + j]); sub(tmp[i][1], dp[i][A + B + j]);
				if (i) {
					add(tmp[i - 1][A + 2], dp[i][A + B + j]); sub(tmp[i - 1][1], dp[i][A + B + j]);
				}
				if (i + 1 < s) {
					add(tmp[i + 1][A + B + j + 1], dp[i][A + B + j]); sub(tmp[i + 1][1], dp[i][A + B + j]);
				}
			}
		}
		for (int i = 0; i < s; ++i) {
			add(tmp[i][1], sum);
			tmp[i][A] = tmp[i][A + B] = tmp[i][A + B + B] = 0;
		}
		memcpy(dp, tmp, sizeof(dp));
	}
}

void mix(int* f, int* g, int* h) {
	memset(tf, 0, sizeof(tf));
	memset(tg, 0, sizeof(tg));
	tf[0] = tg[0] = 1;
	for (int n = 1; n < THRES; ++n) {
		for (int k = 1; k <= n; ++k) {
			fam(tf[n], tg[n - k], f[k]);
			fam(tg[n], tf[n - k], g[k]);
		}
	}
	h[0] = 1;
	for (int n = 1; n < THRES; ++n) h[n] = norm(tf[n] + tg[n]);
}

int d;
int rec[THRES];

vector<int> mul(vector<int> a, vector<int> b) {
	static int tmp[THRES];
	memset(tmp, 0, sizeof(tmp));
	for (int i = 0; i < d; ++i) for (int j = 0; j < d; ++j)
		fam(tmp[i + j], a[i], b[j]);
	for (int i = d * 2 - 2; i >= d; --i) {
		for (int j = 1; j <= d; ++j)
			fam(tmp[i - j], tmp[i], rec[j]);
	}
	return vector<int>(tmp, tmp + d);
}
vector<int> ini, id;
vector<int> pw(vector<int> v, int n) {
	if (n == 0) return id;
	auto ret = pw(mul(v, v), n / 2);
	if (n & 1) ret = mul(ret, v);
	return ret;
}

int main() {
	int L, R; cin >> L >> R >> A >> B;

	gen(f, 10); gen(g, 26);
	mix(g, g, g);
	mix(f, g, h);
	for (int n = 0; n < THRES; ++n) {
		sub(h[n], f[n]); sub(h[n], g[n]);
	}
	for (int n = 1; n < THRES; ++n) add(h[n], h[n - 1]);

	d = BM::euclid(THRES / 2, h);
	for (int i = 1; i <= d; ++i) rec[i] = neg(BM::y[i]);
	assert(d <= 500); cerr << "deg = " << d << '\n';
	d = 500;
	ini.resize(d); ini[1] = 1;
	id.resize(d); id[0] = 1;
	vector<int> X = pw(ini, R), Y = pw(ini, L - 1);
	int ans = 0;
	for (int i = 0; i < d; ++i) {
		sub(X[i], Y[i]);
		fam(ans, X[i], h[i]);
	}
	cout << ans << '\n';

	return 0;
}