char c, d;

bool read() {
	return !!(cin >> c >> d);
}

void solve() {
	int cnt = 0;
	if (c == 'a' || c == 'h') cnt++;
	if (d == '1' || d == '8') cnt++;
	if (cnt == 0) puts("8");
	else if (cnt == 1) puts("5");
	else if (cnt == 2) puts("3");
	else throw;
}

const int N = 300300;

int n, a[N];

bool read() {
	if (!(cin >> n)) return false;
	forn(i, n) assert(scanf("%d", &a[i]) == 1);
	return true;
}

void solve() {
	sort(a, a + n);

	li suml = 0, sumr = accumulate(a, a + n, 0ll);
	li ansv = LLONG_MAX, ansp = LLONG_MIN;
	forn(i, n) {
		li curv = li(i) * a[i] - suml;
		curv += sumr - li(n - i) * a[i];
		if (ansv > curv) {
			ansv = curv;
			ansp = a[i];
		}
		suml += a[i];
		sumr -= a[i];
	}
	assert(sumr == 0);

	assert(ansv != LLONG_MAX);
	cerr << "ansv: " << ansv << endl;
	cout << ansp << endl;
}

int n;

bool read() {
	return !!(cin >> n);
}

const int N = 101;

int a[N][N];

void solve() {
	memset(a, 0, sizeof(a));

	forn(i, n / 2) {
		int len = n / 2 - i;
		forn(j, len) {
			int x1 = i, x2 = n - 1 - i;
			int y1 = j, y2 = n - 1 - j;
			a[x1][y1] = 1;
			a[x1][y2] = 1;
			a[x2][y1] = 1;
			a[x2][y2] = 1;
		}
	}

	int odd = 1, even = 2;
	forn(i, n)
		forn(j, n)
			if (a[i][j]) a[i][j] = even, even += 2;
			else a[i][j] = odd, odd += 2;

	forn(i, n) {
		forn(j, n) {
			if (j) putchar(' ');
			printf("%d", a[i][j]);
		}
		puts("");
	}
}

li a1, b1, a2, b2, l, r;

bool read() {
	return !!(cin >> a1 >> b1 >> a2 >> b2 >> l >> r);
}

li _ceil(li, li);
li _floor(li a, li b) { return b < 0 ? _floor(-a, -b) : a < 0 ? -_ceil(-a, b) : a / b; }
li _ceil(li a, li b) { return b < 0 ? _ceil(-a, -b) : a < 0 ? -_floor(-a, b) : (a + b - 1) / b; }

li gcd(li a, li b, li& x, li& y) {
	if (!a) {
		x = 0, y = 1;
		return b;
	}
	li xx, yy, g = gcd(b % a, a, xx, yy);
	x = yy - b / a * xx;
	y = xx;
	return g;
}

void solve() {
	l = max(0ll, _ceil(l - b1, a1));
	r = _floor(r - b1, a1);
	if (l > r) {
		puts("0");
		return;
	}

	li A = a1, B = -a2, C = b2 - b1;
	li x0, y0;
	li g = gcd(A, B, x0, y0);
	if (C % g) {
		puts("0");
		return;
	}

	if (g < 0) {
		g = -g;
		x0 = -x0;
		y0 = -y0;
	}

	li L = _ceil(r * g - x0 * C, B);
	li R = _floor(l * g - x0 * C, B);
	R = min(R, _floor(y0 * C, A));

	li ans = max(0ll, R - L + 1);
	cout << ans << endl;
}