Today on Informatics class Nastya learned about GCD and LCM (see links below). Nastya is very intelligent, so she solved all the tasks momentarily and now suggests you to solve one of them as well.

We define a pair of integers (a, b) good, if GCD(a, b) = x and LCM(a, b) = y, where GCD(a, b) denotes the greatest common divisor of a and b, and LCM(a, b) denotes the least common multiple of a and b.

You are given two integers x and y. You are to find the number of good pairs of integers (a, b) such that l ≤ a, b ≤ r. Note that pairs (a, b) and (b, a) are considered different if a ≠ b.


-----Input-----

The only line contains four integers l, r, x, y (1 ≤ l ≤ r ≤ 10^9, 1 ≤ x ≤ y ≤ 10^9).


-----Output-----

In the only line print the only integer — the answer for the problem.


-----Examples-----
Input
1 2 1 2

Output
2

Input
1 12 1 12

Output
4

Input
50 100 3 30

Output
0



-----Note-----

In the first example there are two suitable good pairs of integers (a, b): (1, 2) and (2, 1).

In the second example there are four suitable good pairs of integers (a, b): (1, 12), (12, 1), (3, 4) and (4, 3).

In the third example there are good pairs of integers, for example, (3, 30), but none of them fits the condition l ≤ a, b ≤ r.

Difficulty: MEDIUM_HARD
Tags: Number theory

Mathematics

Starter code:

Solutions:
import math
import os
import random
import re
from sys import stdin, stdout
from collections import Counter
from itertools import permutations

def si():
	return str(stdin.readline())

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())

def debug(x):
	return stdout.write(str(x))

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r, x, y) = mi()
if y % x != 0:
	debug(0)
else:
	res = 0
	p = y // x
	t = 1
	while t * t <= p:
		if p % t == 0:
			a = x * t
			b = x * y / a
			if l <= a <= r and l <= b <= r and (gcd(a, b) == x):
				if b != a:
					res += 2
				else:
					res += 1
		t += 1
	debug(res)


def gg(a, b):
	while a * b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return a + b
from math import *
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
else:
	k = 0
	y //= x
	i = 1
	while i <= sqrt(y) and i <= r:
		if y % i == 0:
			a = i
			b = y // i
			if l <= a * x <= r and l <= b * x <= r:
				if gg(a, b) == 1:
					if a == b:
						k += 1
					else:
						k += 2
		i += 1
	print(k)


from fractions import gcd

def valid(x):
	if l <= x <= r:
		return True
	return False
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	exit(0)
p = y // x
i = 1
ans = 0
while i * i <= p:
	if p % i == 0:
		f1 = i
		f2 = p // i
		if f1 != f2:
			if gcd(f1, f2) == 1 and valid(x * f1) and valid(x * f2):
				ans += 2
		elif gcd(f1, f2) == 1 and valid(x * f1) and valid(x * f2):
			ans += 1
	i += 1
print(ans)


import math

def divisors(n):
	divs = [1, n]
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			divs.extend([i, n // i])
	return set(divs)
(l, r, x, y) = map(int, input().split())
cnt = 0
if y % x != 0:
	print(0)
	exit(0)
vv = y // x
for d in divisors(vv):
	c = vv // d
	if l <= c * x <= r and l <= d * x <= r and (math.gcd(c, d) == 1):
		cnt += 1
print(cnt)


def gcd(a, b):
	while b != 0:
		t = int(a)
		a = int(b)
		b = t % a
	return int(a)

def lcm(a, b):
	return int(a * b / gcd(a, b))
global ct, lo, l1, x, y
ct = 0
import math

def can(n):
	if n >= lo and n <= l1:
		return True
	return False
(lo, l1, x, y) = map(int, input().split())

def divisors(n):
	global ct
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				if can(x * y / i) and can(i) and (lcm(i, x * y / i) == y) and (gcd(x * y / i, i) == x):
					ct += 1
			else:
				f = n / i
				if can(x * y / i) and can(i) and (lcm(i, x * y / i) == y) and (gcd(x * y / i, i) == x):
					ct += 1
				if can(x * y / f) and can(f) and (lcm(f, x * y / f) == y) and (gcd(x * y / f, f) == x):
					ct += 1
		i = i + 1
divisors(y)
print(ct)


(l, r, x, y) = map(int, input().split())
h = ()
a = 0
if y % x < 1:
	y //= x
	s = y
	l = (l - 1) // x + 1
	r //= x
	i = 2
	while i * i <= y:
		j = 1
		while y % i < 1:
			j *= i
			y //= i
		if j > 1:
			h += (j,)
		i += 1
	if y > 1:
		h += (y,)
	for i in range(1 << len(h)):
		p = 1
		for (j, u) in enumerate(h):
			if i >> j & 1:
				p *= u
		a += l <= p <= r and l <= s // p <= r
print(a)


from math import gcd
(l, r, x, y) = map(int, input().split())
new = (l // x, r // x + 1)
if y % x != 0:
	print(0)
else:
	out = 0
	n = y // x
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			c = n // i
			if c * x >= l and c * x <= r and (i * x >= l) and (i * x <= r) and (gcd(i, c) == 1):
				if i * i == n:
					out += 1
				else:
					out += 2
	print(out)


import math

def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a

def lcm(a, b):
	return a * b // gcd(a, b)

def f(d):
	d = str(d)
	if d[len(d) - 2:] == '.0':
		return True
	return False
(l, r, x, y) = [int(i) for i in input().split()]
count = 0
for c in range(1, int(math.sqrt(y / x)) + 1):
	d = y / x / c
	if f(d):
		if l <= c * x and r >= d * x and (gcd(c * x, d * x) == x) and (lcm(c * x, d * x) == y):
			if c != d:
				count += 2
			else:
				count += 1
print(count)


from __future__ import print_function
from collections import *
from sys import stdin
from heapq import *
from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x: reversed(range(x))
mod = int(1000000000.0) + 7
inf = float('inf')
(l, r, gc, lc) = gil()
if lc % gc:
	print(0)
	exit()
k = lc // gc
ans = 0
for k1 in range(1, int(sqrt(k)) + 1):
	if k % k1:
		continue
	k2 = k // k1
	if gcd(k1, k2) > 1:
		continue
	if l <= gc * k1 <= r and l <= gc * k2 <= r:
		ans += 1 if k1 == k2 else 2
print(ans)


from math import gcd
(l, r, x, y) = list(map(int, input().split()))
if y % x != 0:
	print(0)
	exit(0)
prod = y // x
num = int((prod + 0.5) ** 0.5)
lis = []
for i in range(1, num + 1):
	if prod % i == 0 and i != prod // i:
		lis.append((i, prod // i))
		lis.append((prod // i, i))
	if prod % i == 0 and i == prod // i:
		lis.append((i, i))
ans = 0
for pp in lis:
	gc = gcd(pp[0], pp[1])
	if gc == 1 and l / x <= pp[0] and (pp[0] <= r / x) and (l / x <= pp[1]) and (pp[1] <= r / x):
		ans += 1
print(ans)


(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
else:
	z = y // x
	primes = []
	i = 2
	while i <= z ** 0.5:
		if z % i == 0:
			primes.append(i)
			z //= i
		else:
			i += 1
	if z > 1:
		primes.append(z)
	prim = set(primes)
	prime = [guy ** primes.count(guy) for guy in prim]
	z = y // x
	tot = 0
	for i in range(2 ** len(prime)):
		prod = 1
		strin = bin(i)[::-1] + '0' * 20
		for j in range(len(strin)):
			if strin[j] == '1':
				prod *= prime[j]
		if l <= x * prod <= r and l <= x * (z // prod) <= r:
			tot += 1
	print(tot)


def f(k):
	res = []
	d = 2
	while d * d <= k:
		if k % d == 0:
			res.append(d)
			k //= d
		else:
			d += 1
	if k != 1:
		res.append(k)
	return res

def main():
	(l, r, x, y) = list(map(int, input().split()))
	if y % x != 0:
		return 0
	if y == x:
		if l <= x <= r:
			return 1
		else:
			return 0
	a = f(x)
	b = f(y)
	for i in range(len(a)):
		b = b[:b.index(a[i])] + b[b.index(a[i]) + 1:]
	ans = 0
	a = [b[0]]
	for i in range(1, len(b)):
		if b[i] == b[i - 1]:
			a[-1] *= b[i]
		else:
			a.append(b[i])
	for i in range(2 ** len(a)):
		c1 = 1
		c2 = 1
		for j in range(len(a)):
			if 2 ** j & i:
				c1 *= a[j]
			else:
				c2 *= a[j]
		if l <= x * c1 <= r and l <= x * c2 <= r:
			ans += 1
	return ans
print(main())


def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)
(l, r, x, y) = map(int, input().split())
from math import sqrt
if y % x != 0:
	print(0)
	exit(0)
y = y // x
if l % x != 0:
	l = l // x + 1
else:
	l //= x
if r % x != 0:
	r = r // x
else:
	r //= x
ans = 0
bound = int(sqrt(y)) + 1
for i in range(1, bound + 1):
	if i > y // i:
		break
	if gcd(i, y // i) != 1:
		continue
	if y % i == 0:
		if l <= i <= r and l <= y // i <= r:
			if i == y // i:
				ans += 1
			else:
				ans += 2
print(ans)


import math
from fractions import gcd
(l, r, x, y) = list(map(int, input().strip().split()))
b = math.ceil(l / x)
e = r // x
if y % x != 0:
	print(0)
	return
y = y / x
if y == 1 and b == 1 and (e >= 1):
	print(1)
	return
ans = 0
for i in range(1, math.ceil(math.sqrt(y))):
	if y % i == 0:
		d = y // i
		if gcd(i, d) == 1 and i >= b and (i <= e) and (d >= b) and (d <= e):
			if i == d:
				ans = ans + 1
			else:
				ans = ans + 2
print(ans)


import math

def gcd(a, b):
	while b > 0:
		(a, b) = (b, a % b)
	return a

def lcm(a, b):
	return a * b / gcd(a, b)

def divisors(n):
	divs = list()
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			divs.append(tuple([i, n // i]))
			divs.append(tuple([n // i, i]))
		divs.append(tuple([1, n]))
		divs.append(tuple([n, 1]))
	return sorted(list(set(divs)))

def two_range(l, r, x, y):
	z = divisors(y // x)
	count = 0
	for elem in z:
		if l <= x * elem[0] <= r and l <= x * elem[1] <= r and (lcm(x * elem[0], x * elem[1]) == y):
			count += 1
	return count
(m, n, c, d) = [int(j) for j in input().split()]
print(two_range(m, n, c, d))


import math
(l, r, x, y) = map(int, input().split())
m = x * y
if l % x == 0:
	low = l
else:
	low = (l // x + 1) * x
cnt = 0
b = min(int(math.sqrt(m)), r)
while low <= b:
	if m % low == 0 and m // low <= r and (math.gcd(low, m // low) == x):
		cnt += 2
	low += x
b = int(math.sqrt(m))
if b >= l and b <= r and (b * b == m) and (math.gcd(b, b) == x):
	cnt -= 1
print(cnt)


from math import sqrt, gcd

def solve1():
	yo1 = set()
	yo2 = set()
	bo = x
	for i in range(1, int(sqrt(x)) + 1):
		if bo % i == 0:
			yo1.add((bo // i, i))
	bo = y
	for i in range(1, int(sqrt(y)) + 1):
		if bo % i == 0:
			yo2.add((bo // i, i))
	return (yo1, yo2)
(l, r, x, y) = map(int, input().split())
ba = set()
(s1, s2) = solve1()
la = set()
for i in s1:
	(a, b) = i
	for j in s2:
		(c, d) = j
		la = la | {(a * c, b * d), (a * b, c * d), (a * d, b * c), (a * b * c, d), (a * c * d, b), (b * c * d, a)}
count = 0
for (a, b) in la:
	if gcd(a, b) == x and a * b // gcd(a, b) == y and (l <= a <= r) and (l <= b <= r):
		count += 1
print(count)


from math import gcd, ceil
(l, r, x, y) = map(int, input().split())
t = x * y
k = int(t ** 0.5)
if y % x != 0:
	print(0)
elif k > r:
	print(0)
elif x == y and l <= x <= y:
	print(1)
else:
	ans = 0
	for i in range(k - k % x, x * ceil(l / x) - 1, -x):
		if t // i <= r:
			if t % i == 0 and gcd(i, t // i) == x:
				ans += 2
		else:
			break
	print(ans)


import math

def binarySearch(arr, x):
	l = 0
	r = len(arr) - 1
	while l <= r:
		mid = l + (r - l) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] < x:
			l = mid + 1
		else:
			r = mid - 1
	return -1
(l, r, x, y) = map(int, input().split())
prod = x * y
count = 0
for i in range(x, math.floor(math.sqrt(prod)) + 1, x):
	cond1 = False
	cond2 = False
	if prod % i == 0 and i >= l and (i <= r) and (prod // i >= l) and (prod // i <= r):
		cond1 = True
	if cond1 and math.gcd(i, prod // i) == x:
		cond2 = True
	if cond1 and cond2:
		if i != prod // i:
			count = count + 2
		else:
			count = count + 1
print(count)


from sys import stdin, stdout
from math import gcd
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, stdin.readline().split()))
for _ in range(1):
	(l, r, hcf, lcm) = lst()
	a = 1
	ans = 0
	s = set()
	factor = lcm * hcf
	while a * a <= lcm:
		if lcm % a == 0:
			a1 = lcm // a
			b = factor // a
			b1 = factor // a1
			if l <= a <= r and l <= b <= r and (gcd(a, b) == hcf):
				ans += 1
			if a == a1:
				a += 1
				continue
			if l <= a1 <= r and l <= b1 <= r and (gcd(a1, b1) == hcf):
				ans += 1
		a += 1
	print(ans)


from math import sqrt

def p_divs(n):
	_a = []
	for _i in range(2, int(sqrt(n)) + 10):
		while n % _i == 0:
			_a.append(_i)
			n //= _i
	if n > 1:
		_a.append(n)
	return _a
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
else:
	m = y // x
	divs = p_divs(m)
	d = dict()
	for p in divs:
		if p in d:
			d[p] += 1
		else:
			d[p] = 1
	p = []
	for k in d:
		p.append((k, d[k]))
	ans = 0
	for i in range(2 ** len(p)):
		(a, b) = (x, x)
		for k in range(len(p)):
			if i // 2 ** k % 2 == 1:
				a *= p[k][0] ** p[k][1]
			else:
				b *= p[k][0] ** p[k][1]
		if a >= l and a <= r and (b >= l) and (b <= r):
			ans += 1
	print(ans)


import sys

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
else:
	res = 0
	p = y // x
	t = 1
	while t * t <= p:
		if p % t == 0:
			a = x * t
			b = x * y / a
			if l <= a <= r and l <= b <= r and (gcd(a, b) == x):
				if b != a:
					res += 2
				else:
					res += 1
		t += 1
	print(res)


(l, r, x, y) = map(int, input().split())

def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a
divisor = [1, y]
i = 2
count = 0
while i * i <= y:
	if y % i == 0:
		divisor.append(i)
		if i * i != y:
			divisor.append(y // i)
	i += 1
for j in divisor:
	if j >= l and j <= r and (j % x == 0):
		a = x * y // j
		if a >= l and a <= r and (gcd(a, j) == x):
			count += 1
print(count)


from math import gcd
(l, r, hcf, lcm) = map(int, input().split())
div = lcm // hcf
if lcm % hcf != 0:
	print(0)
	exit()
i = 1
count = 0
while i * i <= div:
	if div % i == 0:
		if i * hcf >= l and i * hcf <= r and (div // i * hcf >= l) and (div // i * hcf <= r) and (gcd(i, div // i) == 1):
			if i == div // i:
				count += 1
			else:
				count += 2
	i += 1
print(count)


(l, r, x, y) = map(int, input().split())
z = int(y / x)

def gcd(a, b):
	if a % b == 0:
		return b
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a * b / gcd(a, b)

def check(a, b):
	if gcd(a, b) == x and lcm(a, b) == y and (a >= l and a <= r) and (b >= l and b <= r):
		return True
	else:
		return False
count = 0
for i in range(1, z + 1):
	if i * i > z:
		break
	elif z % i == 0:
		a = x * i
		b = x * int(z / i)
		if check(a, b):
			count += 1
			if a != b:
				count += 1
print(count)


from sys import exit
from math import sqrt
from fractions import gcd
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	exit(0)
lo = (l + x - 1) // x
hi = r // x
p = y // x
s = 0
k1 = 1
while k1 * k1 <= p:
	k2 = p // k1
	if lo <= k1 <= hi and lo <= k2 <= hi and (gcd(k1, k2) == 1) and (k1 * k2 == p):
		s += 1 + (k1 != k2)
	k1 += 1
print(s)


(l, r, x, y) = list(map(int, input().split()))
if y % x != 0:
	print(0)
else:
	cd = y // x

	def dels(n):
		i = 2
		p = []
		while i * i <= n:
			while n % i == 0:
				p.append(i)
				n = n // i
			i += 1
		if n > 1:
			p.append(n)
		return p
	d = dels(cd)
	s = dict()
	for i in d:
		if i not in s:
			s[i] = 1
		else:
			s[i] += 1
	unique = list(s.keys())
	kol = len(unique)
	k = 0
	for i in range(2 ** kol):
		c = 1
		d = 1
		dv = ''
		while i != 0:
			dv += str(i % 2)
			i //= 2
		dv = dv[::-1]
		if len(dv) < kol:
			dv = '0' * (kol - len(dv)) + dv
		for j in range(kol):
			if dv[j] == '1':
				c *= unique[j] ** s[unique[j]]
			else:
				d *= unique[j] ** s[unique[j]]
		if l <= c * x <= r and l <= d * x <= r:
			k += 1
	print(k)


import os
import sys
from io import BytesIO, IOBase
import math
from queue import Queue
import collections
import itertools
import bisect
import heapq
import random

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

def primeFactorsCount(n):
	cnt = 0
	while n % 2 == 0:
		cnt += 1
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			cnt += 1
			n = n // i
	if n > 2:
		cnt += 1
	return cnt

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)

def countcon(s, i):
	c = 0
	ch = s[i]
	for i in range(i, len(s)):
		if s[i] == ch:
			c += 1
		else:
			break
	return c

def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(1, n):
		for j in range(0, i):
			if arr[i] > arr[j] and lis[i] < lis[j] + 1:
				lis[i] = lis[j] + 1
	maximum = 0
	for i in range(n):
		maximum = max(maximum, lis[i])
	return maximum

def isSubSequence(str1, str2):
	m = len(str1)
	n = len(str2)
	j = 0
	i = 0
	while j < m and i < n:
		if str1[j] == str2[i]:
			j = j + 1
		i = i + 1
	return j == m

def maxfac(n):
	root = int(n ** 0.5)
	for i in range(2, root + 1):
		if n % i == 0:
			return n // i
	return n

def p2(n):
	c = 0
	while n % 2 == 0:
		n //= 2
		c += 1
	return c

def seive(n):
	primes = [True] * (n + 1)
	primes[1] = primes[0] = False
	i = 2
	while i * i <= n:
		if primes[i] == True:
			for j in range(i * i, n + 1, i):
				primes[j] = False
		i += 1
	pr = []
	for i in range(0, n + 1):
		if primes[i]:
			pr.append(i)
	return pr

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def denofactinverse(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return pow(fac, m - 2, m)

def numofact(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return fac

def sod(n):
	s = 0
	while n > 0:
		s += n % 10
		n //= 10
	return s
(l, r, x, y) = map(int, input().split())
if y % x:
	print(0)
else:
	val = y // x
	root = int(val ** 0.5)
	ans = 0
	for i in range(1, root + 1):
		if val % i == 0:
			j = val // i
			(val1, val2) = (i * x, j * x)
			if l <= val1 <= r and l <= val2 <= r and (math.gcd(val1, val2) == x):
				if val1 == val2:
					ans += 1
				else:
					ans += 2
	print(ans)


from math import gcd
(l, r, x, y) = map(int, input().split())
a = []
if y % x != 0:
	print(0)
else:
	y = y // x
	for i in range(1, int(y ** 0.5) + 1):
		if y % i == 0 and i != y // i:
			a.append([i, y // i])
			a.append([y // i, i])
		elif y % i == 0:
			a.append([i, i])
	ans = 0
	for i in range(len(a)):
		if gcd(a[i][0], a[i][1]) == 1 and l <= x * a[i][0] <= r and (l <= x * a[i][1] <= r):
			ans += 1
	print(ans)


import sys, os, io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
import math
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def si():
	return input()

def prefix_sum(arr):
	r = [0] * (len(arr) + 1)
	for (i, el) in enumerate(arr):
		r[i + 1] = r[i] + el
	return r

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
t = 1
for _ in range(t):
	(l, r, x, y) = li()
	z = y // x
	ans = 0
	if y % x == 0:
		for i in range(1, z + 1):
			if i * i > z:
				break
			if z % i == 0:
				if gcd(z // i, i) == 1:
					if l / x <= i <= r / x and l / x <= z // i <= r / x:
						if z // i != i:
							ans += 2
						else:
							ans += 1
	print(ans)


import sys
input = sys.stdin.buffer.readline
import math

def solution():
	(l, r, x, y) = map(int, input().split())
	if y % x != 0:
		print(0)
		return
	p = y // x
	cnt = 0
	for i in range(1, int(p ** 0.5) + 1):
		if p % i == 0:
			a = i
			b = p // i
			if a * x >= l and b * x >= l and (a * x <= r) and (b * x <= r):
				if math.gcd(a, b) == 1:
					if a == b:
						cnt += 1
					else:
						cnt += 2
	print(cnt)
solution()


from math import gcd

def main():
	(l, r, x, y) = map(int, input().split())
	if y % x:
		print(0)
		return 0
	y //= x
	i = 1
	ans = 0
	while i * i <= y:
		if y % i == 0 and gcd(i, y // i) == 1:
			if i * x <= r and l <= i * x and (y // i * x <= r) and (l <= y // i * x):
				ans += 1 + (i * i != y)
		i += 1
	print(ans)
	return 0
main()


def main():
	(l, r, x, y) = map(int, input().split())
	if y % x:
		print(0)
		return
	(divisors, res) = ([], 0)
	y //= x
	for p in (2, 3, 5):
		q = 1
		while not y % p:
			y //= p
			q *= p
		if q != 1:
			divisors.append(q)
	p = 7
	while y >= p * p:
		for s in (4, 2, 4, 2, 4, 6, 2, 6):
			if not y % p:
				q = 1
				while not y % p:
					y //= p
					q *= p
				divisors.append(q)
			p += s
	if y != 1:
		divisors.append(y)
	for i in range(2 ** len(divisors)):
		ab = [x, x]
		for (j, p) in enumerate(divisors):
			ab[i & 1] *= p
			i >>= 1
		res += l <= ab[0] <= r >= ab[1] >= l
	print(res)
main()


from math import sqrt
(l, r, x, y) = map(int, input().split())
c = 0
t = y // x
for i in range(1, int(sqrt(t)) + 1):
	a = i * x
	b = int(t / i) * x
	v = a
	u = b
	while v != 0 and u != 0:
		if v > u:
			v = v % u
		else:
			u = u % v
	if v + u == x and a * b // (v + u) == y and (a * b == x * y) and (b >= l) and (b <= r) and (a >= l) and (a <= r):
		c += 2
		if a == b:
			c -= 1
print(c)


(l, r, x, y) = map(int, input().split())
f = lambda ka, kb: int(gcd(ka * x, kb * x) == x and l <= ka * x <= r and (l <= kb * x <= r))
gcd = lambda a, b: a if b == 0 else gcd(b, a % b)
cnt = 0
k = y // x
d = 1
while d * d <= k:
	if k % d == 0:
		cnt += f(d, k // d)
		if d * d != k:
			cnt += f(k // d, d)
	d += 1
if y % x:
	cnt = 0
print(cnt)


from itertools import product

def factorize(n):
	res = []
	if n % 2 == 0:
		power = 0
		while n % 2 == 0:
			power += 1
			n //= 2
		res.append((2, power))
	i = 3
	while i * i <= n:
		if n % i == 0:
			power = 0
			while n % i == 0:
				power += 1
				n //= i
			res.append((i, power))
		i += 2
	if n > 1:
		res.append((n, 1))
	return res
(l, r, x, y) = [int(x) for x in input().split()]
if y % x:
	print(0)
	exit()
diff = y // x
facs = [p ** power for (p, power) in factorize(diff)]
res = 0
for i in range(2 ** len(facs)):
	fac1 = x
	for j in range(len(facs)):
		if 1 << j & i:
			fac1 *= facs[j]
	fac2 = x * y // fac1
	if l <= fac1 <= r and l <= fac2 <= r:
		res += 1
print(res)


import sys
from math import sqrt, ceil, gcd

def sieve(N):
	b = [True] * (N + 1)
	b[0] = False
	b[1] = False
	lim = ceil(sqrt(N))
	i = 2
	while i <= lim:
		if b[i]:
			for n in range(i ** 2, N + 1, i):
				b[n] = False
		i += 1
	return [i for (i, b) in enumerate(b) if b]
P = sieve(10 ** 5)

def factor(n, P):
	if n in P:
		return [n]
	f = []
	for p in P:
		while n % p == 0:
			n //= p
			f.append(p)
		if n in P:
			f.append(n)
			return f
	if n != 1:
		f.append(n)
	return f

def divisors(n):
	F = factor(n, P)
	D = {1}
	for f in F:
		D |= {f * d for d in D}
	return D
(l, r, x, y) = map(int, input().split())
a = x
if y % a != 0:
	print(0)
	sys.exit()
x //= a
y //= a
cnt = 0
for d in divisors(y):
	n = d * a
	m = y // d * a
	if l <= n <= r and l <= m <= r and (gcd(d, y // d) == 1):
		cnt += 1
print(cnt)


def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	return divisors
import math
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	exit()
z = y // x
d = make_divisors(z)
ans = 0
for i in d:
	j = z // i
	if math.gcd(i, j) == 1:
		if l <= i * x <= r and l <= j * x <= r:
			ans += 1
print(ans)


(l, r, x, y) = map(int, input().split())
num = 0
i = x
R = x * y

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
while i * i <= R:
	if R % i == 0:
		if l <= i <= r and l <= R // i <= r and (gcd(i, R // i) == x):
			num += 1
			if i != R // i:
				num += 1
	i += x
print(num)


import math
(l, r, gcd, lcm) = (int(x) for x in input().split())
if lcm % gcd != 0:
	print(0)
	quit()
divisors = set()
for div in range(1, int(lcm ** 0.5 + 2)):
	if lcm % div == 0:
		divisors.add(div)
		divisors.add(lcm // div)
prod = lcm * gcd
answers = set()
for div in divisors:
	if div < l or div > r:
		continue
	dop = prod // div
	if dop < l or dop > r:
		continue
	if math.gcd(div, dop) != gcd:
		continue
	answers.add((div, dop))
	answers.add((dop, div))
print(len(answers))


from math import *

def log_finder(x, base):
	for i in range(int(log(x, base)), -1, -1):
		if x % base ** i == 0:
			return i

def function():
	(l, r, x, y) = [int(x) for x in input().split()]
	s = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343, 10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487, 10499, 10501, 10513, 10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627, 10631, 10639, 10651, 10657, 10663, 10667, 10687, 10691, 10709, 10711, 10723, 10729, 10733, 10739, 10753, 10771, 10781, 10789, 10799, 10831, 10837, 10847, 10853, 10859, 10861, 10867, 10883, 10889, 10891, 10903, 10909, 10937, 10939, 10949, 10957, 10973, 10979, 10987, 10993, 11003, 11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 11093, 11113, 11117, 11119, 11131, 11149, 11159, 11161, 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257, 11261, 11273, 11279, 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383, 11393, 11399, 11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, 11497, 11503, 11519, 11527, 11549, 11551, 11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657, 11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 11743, 11777, 11779, 11783, 11789, 11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839, 11863, 11867, 11887, 11897, 11903, 11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, 11969, 11971, 11981, 11987, 12007, 12011, 12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 12107, 12109, 12113, 12119, 12143, 12149, 12157, 12161, 12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 12253, 12263, 12269, 12277, 12281, 12289, 12301, 12323, 12329, 12343, 12347, 12373, 12377, 12379, 12391, 12401, 12409, 12413, 12421, 12433, 12437, 12451, 12457, 12473, 12479, 12487, 12491, 12497, 12503, 12511, 12517, 12527, 12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589, 12601, 12611, 12613, 12619, 12637, 12641, 12647, 12653, 12659, 12671, 12689, 12697, 12703, 12713, 12721, 12739, 12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 12823, 12829, 12841, 12853, 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941, 12953, 12959, 12967, 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, 13049, 13063, 13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 13183, 13187, 13217, 13219, 13229, 13241, 13249, 13259, 13267, 13291, 13297, 13309, 13313, 13327, 13331, 13337, 13339, 13367, 13381, 13397, 13399, 13411, 13417, 13421, 13441, 13451, 13457, 13463, 13469, 13477, 13487, 13499, 13513, 13523, 13537, 13553, 13567, 13577, 13591, 13597, 13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681, 13687, 13691, 13693, 13697, 13709, 13711, 13721, 13723, 13729, 13751, 13757, 13759, 13763, 13781, 13789, 13799, 13807, 13829, 13831, 13841, 13859, 13873, 13877, 13879, 13883, 13901, 13903, 13907, 13913, 13921, 13931, 13933, 13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081, 14083, 14087, 14107, 14143, 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243, 14249, 14251, 14281, 14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389, 14401, 14407, 14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 14479, 14489, 14503, 14519, 14533, 14537, 14543, 14549, 14551, 14557, 14561, 14563, 14591, 14593, 14621, 14627, 14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713, 14717, 14723, 14731, 14737, 14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821, 14827, 14831, 14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, 14923, 14929, 14939, 14947, 14951, 14957, 14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 15077, 15083, 15091, 15101, 15107, 15121, 15131, 15137, 15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 15227, 15233, 15241, 15259, 15263, 15269, 15271, 15277, 15287, 15289, 15299, 15307, 15313, 15319, 15329, 15331, 15349, 15359, 15361, 15373, 15377, 15383, 15391, 15401, 15413, 15427, 15439, 15443, 15451, 15461, 15467, 15473, 15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569, 15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 15647, 15649, 15661, 15667, 15671, 15679, 15683, 15727, 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787, 15791, 15797, 15803, 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, 15913, 15919, 15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, 16061, 16063, 16067, 16069, 16073, 16087, 16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 16187, 16189, 16193, 16217, 16223, 16229, 16231, 16249, 16253, 16267, 16273, 16301, 16319, 16333, 16339, 16349, 16361, 16363, 16369, 16381, 16411, 16417, 16421, 16427, 16433, 16447, 16451, 16453, 16477, 16481, 16487, 16493, 16519, 16529, 16547, 16553, 16561, 16567, 16573, 16603, 16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 16673, 16691, 16693, 16699, 16703, 16729, 16741, 16747, 16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 16871, 16879, 16883, 16889, 16901, 16903, 16921, 16927, 16931, 16937, 16943, 16963, 16979, 16981, 16987, 16993, 17011, 17021, 17027, 17029, 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107, 17117, 17123, 17137, 17159, 17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239, 17257, 17291, 17293, 17299, 17317, 17321, 17327, 17333, 17341, 17351, 17359, 17377, 17383, 17387, 17389, 17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 17471, 17477, 17483, 17489, 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579, 17581, 17597, 17599, 17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, 17729, 17737, 17747, 17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863, 17881, 17891, 17903, 17909, 17911, 17921, 17923, 17929, 17939, 17957, 17959, 17971, 17977, 17981, 17987, 17989, 18013, 18041, 18043, 18047, 18049, 18059, 18061, 18077, 18089, 18097, 18119, 18121, 18127, 18131, 18133, 18143, 18149, 18169, 18181, 18191, 18199, 18211, 18217, 18223, 18229, 18233, 18251, 18253, 18257, 18269, 18287, 18289, 18301, 18307, 18311, 18313, 18329, 18341, 18353, 18367, 18371, 18379, 18397, 18401, 18413, 18427, 18433, 18439, 18443, 18451, 18457, 18461, 18481, 18493, 18503, 18517, 18521, 18523, 18539, 18541, 18553, 18583, 18587, 18593, 18617, 18637, 18661, 18671, 18679, 18691, 18701, 18713, 18719, 18731, 18743, 18749, 18757, 18773, 18787, 18793, 18797, 18803, 18839, 18859, 18869, 18899, 18911, 18913, 18917, 18919, 18947, 18959, 18973, 18979, 19001, 19009, 19013, 19031, 19037, 19051, 19069, 19073, 19079, 19081, 19087, 19121, 19139, 19141, 19157, 19163, 19181, 19183, 19207, 19211, 19213, 19219, 19231, 19237, 19249, 19259, 19267, 19273, 19289, 19301, 19309, 19319, 19333, 19373, 19379, 19381, 19387, 19391, 19403, 19417, 19421, 19423, 19427, 19429, 19433, 19441, 19447, 19457, 19463, 19469, 19471, 19477, 19483, 19489, 19501, 19507, 19531, 19541, 19543, 19553, 19559, 19571, 19577, 19583, 19597, 19603, 19609, 19661, 19681, 19687, 19697, 19699, 19709, 19717, 19727, 19739, 19751, 19753, 19759, 19763, 19777, 19793, 19801, 19813, 19819, 19841, 19843, 19853, 19861, 19867, 19889, 19891, 19913, 19919, 19927, 19937, 19949, 19961, 19963, 19973, 19979, 19991, 19993, 19997, 20011, 20021, 20023, 20029, 20047, 20051, 20063, 20071, 20089, 20101, 20107, 20113, 20117, 20123, 20129, 20143, 20147, 20149, 20161, 20173, 20177, 20183, 20201, 20219, 20231, 20233, 20249, 20261, 20269, 20287, 20297, 20323, 20327, 20333, 20341, 20347, 20353, 20357, 20359, 20369, 20389, 20393, 20399, 20407, 20411, 20431, 20441, 20443, 20477, 20479, 20483, 20507, 20509, 20521, 20533, 20543, 20549, 20551, 20563, 20593, 20599, 20611, 20627, 20639, 20641, 20663, 20681, 20693, 20707, 20717, 20719, 20731, 20743, 20747, 20749, 20753, 20759, 20771, 20773, 20789, 20807, 20809, 20849, 20857, 20873, 20879, 20887, 20897, 20899, 20903, 20921, 20929, 20939, 20947, 20959, 20963, 20981, 20983, 21001, 21011, 21013, 21017, 21019, 21023, 21031, 21059, 21061, 21067, 21089, 21101, 21107, 21121, 21139, 21143, 21149, 21157, 21163, 21169, 21179, 21187, 21191, 21193, 21211, 21221, 21227, 21247, 21269, 21277, 21283, 21313, 21317, 21319, 21323, 21341, 21347, 21377, 21379, 21383, 21391, 21397, 21401, 21407, 21419, 21433, 21467, 21481, 21487, 21491, 21493, 21499, 21503, 21517, 21521, 21523, 21529, 21557, 21559, 21563, 21569, 21577, 21587, 21589, 21599, 21601, 21611, 21613, 21617, 21647, 21649, 21661, 21673, 21683, 21701, 21713, 21727, 21737, 21739, 21751, 21757, 21767, 21773, 21787, 21799, 21803, 21817, 21821, 21839, 21841, 21851, 21859, 21863, 21871, 21881, 21893, 21911, 21929, 21937, 21943, 21961, 21977, 21991, 21997, 22003, 22013, 22027, 22031, 22037, 22039, 22051, 22063, 22067, 22073, 22079, 22091, 22093, 22109, 22111, 22123, 22129, 22133, 22147, 22153, 22157, 22159, 22171, 22189, 22193, 22229, 22247, 22259, 22271, 22273, 22277, 22279, 22283, 22291, 22303, 22307, 22343, 22349, 22367, 22369, 22381, 22391, 22397, 22409, 22433, 22441, 22447, 22453, 22469, 22481, 22483, 22501, 22511, 22531, 22541, 22543, 22549, 22567, 22571, 22573, 22613, 22619, 22621, 22637, 22639, 22643, 22651, 22669, 22679, 22691, 22697, 22699, 22709, 22717, 22721, 22727, 22739, 22741, 22751, 22769, 22777, 22783, 22787, 22807, 22811, 22817, 22853, 22859, 22861, 22871, 22877, 22901, 22907, 22921, 22937, 22943, 22961, 22963, 22973, 22993, 23003, 23011, 23017, 23021, 23027, 23029, 23039, 23041, 23053, 23057, 23059, 23063, 23071, 23081, 23087, 23099, 23117, 23131, 23143, 23159, 23167, 23173, 23189, 23197, 23201, 23203, 23209, 23227, 23251, 23269, 23279, 23291, 23293, 23297, 23311, 23321, 23327, 23333, 23339, 23357, 23369, 23371, 23399, 23417, 23431, 23447, 23459, 23473, 23497, 23509, 23531, 23537, 23539, 23549, 23557, 23561, 23563, 23567, 23581, 23593, 23599, 23603, 23609, 23623, 23627, 23629, 23633, 23663, 23669, 23671, 23677, 23687, 23689, 23719, 23741, 23743, 23747, 23753, 23761, 23767, 23773, 23789, 23801, 23813, 23819, 23827, 23831, 23833, 23857, 23869, 23873, 23879, 23887, 23893, 23899, 23909, 23911, 23917, 23929, 23957, 23971, 23977, 23981, 23993, 24001, 24007, 24019, 24023, 24029, 24043, 24049, 24061, 24071, 24077, 24083, 24091, 24097, 24103, 24107, 24109, 24113, 24121, 24133, 24137, 24151, 24169, 24179, 24181, 24197, 24203, 24223, 24229, 24239, 24247, 24251, 24281, 24317, 24329, 24337, 24359, 24371, 24373, 24379, 24391, 24407, 24413, 24419, 24421, 24439, 24443, 24469, 24473, 24481, 24499, 24509, 24517, 24527, 24533, 24547, 24551, 24571, 24593, 24611, 24623, 24631, 24659, 24671, 24677, 24683, 24691, 24697, 24709, 24733, 24749, 24763, 24767, 24781, 24793, 24799, 24809, 24821, 24841, 24847, 24851, 24859, 24877, 24889, 24907, 24917, 24919, 24923, 24943, 24953, 24967, 24971, 24977, 24979, 24989, 25013, 25031, 25033, 25037, 25057, 25073, 25087, 25097, 25111, 25117, 25121, 25127, 25147, 25153, 25163, 25169, 25171, 25183, 25189, 25219, 25229, 25237, 25243, 25247, 25253, 25261, 25301, 25303, 25307, 25309, 25321, 25339, 25343, 25349, 25357, 25367, 25373, 25391, 25409, 25411, 25423, 25439, 25447, 25453, 25457, 25463, 25469, 25471, 25523, 25537, 25541, 25561, 25577, 25579, 25583, 25589, 25601, 25603, 25609, 25621, 25633, 25639, 25643, 25657, 25667, 25673, 25679, 25693, 25703, 25717, 25733, 25741, 25747, 25759, 25763, 25771, 25793, 25799, 25801, 25819, 25841, 25847, 25849, 25867, 25873, 25889, 25903, 25913, 25919, 25931, 25933, 25939, 25943, 25951, 25969, 25981, 25997, 25999, 26003, 26017, 26021, 26029, 26041, 26053, 26083, 26099, 26107, 26111, 26113, 26119, 26141, 26153, 26161, 26171, 26177, 26183, 26189, 26203, 26209, 26227, 26237, 26249, 26251, 26261, 26263, 26267, 26293, 26297, 26309, 26317, 26321, 26339, 26347, 26357, 26371, 26387, 26393, 26399, 26407, 26417, 26423, 26431, 26437, 26449, 26459, 26479, 26489, 26497, 26501, 26513, 26539, 26557, 26561, 26573, 26591, 26597, 26627, 26633, 26641, 26647, 26669, 26681, 26683, 26687, 26693, 26699, 26701, 26711, 26713, 26717, 26723, 26729, 26731, 26737, 26759, 26777, 26783, 26801, 26813, 26821, 26833, 26839, 26849, 26861, 26863, 26879, 26881, 26891, 26893, 26903, 26921, 26927, 26947, 26951, 26953, 26959, 26981, 26987, 26993, 27011, 27017, 27031, 27043, 27059, 27061, 27067, 27073, 27077, 27091, 27103, 27107, 27109, 27127, 27143, 27179, 27191, 27197, 27211, 27239, 27241, 27253, 27259, 27271, 27277, 27281, 27283, 27299, 27329, 27337, 27361, 27367, 27397, 27407, 27409, 27427, 27431, 27437, 27449, 27457, 27479, 27481, 27487, 27509, 27527, 27529, 27539, 27541, 27551, 27581, 27583, 27611, 27617, 27631, 27647, 27653, 27673, 27689, 27691, 27697, 27701, 27733, 27737, 27739, 27743, 27749, 27751, 27763, 27767, 27773, 27779, 27791, 27793, 27799, 27803, 27809, 27817, 27823, 27827, 27847, 27851, 27883, 27893, 27901, 27917, 27919, 27941, 27943, 27947, 27953, 27961, 27967, 27983, 27997, 28001, 28019, 28027, 28031, 28051, 28057, 28069, 28081, 28087, 28097, 28099, 28109, 28111, 28123, 28151, 28163, 28181, 28183, 28201, 28211, 28219, 28229, 28277, 28279, 28283, 28289, 28297, 28307, 28309, 28319, 28349, 28351, 28387, 28393, 28403, 28409, 28411, 28429, 28433, 28439, 28447, 28463, 28477, 28493, 28499, 28513, 28517, 28537, 28541, 28547, 28549, 28559, 28571, 28573, 28579, 28591, 28597, 28603, 28607, 28619, 28621, 28627, 28631, 28643, 28649, 28657, 28661, 28663, 28669, 28687, 28697, 28703, 28711, 28723, 28729, 28751, 28753, 28759, 28771, 28789, 28793, 28807, 28813, 28817, 28837, 28843, 28859, 28867, 28871, 28879, 28901, 28909, 28921, 28927, 28933, 28949, 28961, 28979, 29009, 29017, 29021, 29023, 29027, 29033, 29059, 29063, 29077, 29101, 29123, 29129, 29131, 29137, 29147, 29153, 29167, 29173, 29179, 29191, 29201, 29207, 29209, 29221, 29231, 29243, 29251, 29269, 29287, 29297, 29303, 29311, 29327, 29333, 29339, 29347, 29363, 29383, 29387, 29389, 29399, 29401, 29411, 29423, 29429, 29437, 29443, 29453, 29473, 29483, 29501, 29527, 29531, 29537, 29567, 29569, 29573, 29581, 29587, 29599, 29611, 29629, 29633, 29641, 29663, 29669, 29671, 29683, 29717, 29723, 29741, 29753, 29759, 29761, 29789, 29803, 29819, 29833, 29837, 29851, 29863, 29867, 29873, 29879, 29881, 29917, 29921, 29927, 29947, 29959, 29983, 29989, 30011, 30013, 30029, 30047, 30059, 30071, 30089, 30091, 30097, 30103, 30109, 30113, 30119, 30133, 30137, 30139, 30161, 30169, 30181, 30187, 30197, 30203, 30211, 30223, 30241, 30253, 30259, 30269, 30271, 30293, 30307, 30313, 30319, 30323, 30341, 30347, 30367, 30389, 30391, 30403, 30427, 30431, 30449, 30467, 30469, 30491, 30493, 30497, 30509, 30517, 30529, 30539, 30553, 30557, 30559, 30577, 30593, 30631, 30637, 30643, 30649, 30661, 30671, 30677, 30689, 30697, 30703, 30707, 30713, 30727, 30757, 30763, 30773, 30781, 30803, 30809, 30817, 30829, 30839, 30841, 30851, 30853, 30859, 30869, 30871, 30881, 30893, 30911, 30931, 30937, 30941, 30949, 30971, 30977, 30983, 31013, 31019, 31033, 31039, 31051, 31063, 31069, 31079, 31081, 31091, 31121, 31123, 31139, 31147, 31151, 31153, 31159, 31177, 31181, 31183, 31189, 31193, 31219, 31223, 31231, 31237, 31247, 31249, 31253, 31259, 31267, 31271, 31277, 31307, 31319, 31321, 31327, 31333, 31337, 31357, 31379, 31387, 31391, 31393, 31397, 31469, 31477, 31481, 31489, 31511, 31513, 31517, 31531, 31541, 31543, 31547, 31567, 31573, 31583, 31601, 31607]
	p = []
	mn = []
	mj = []
	yy = y
	xx = x
	if y in s:
		if y != x and x != 1:
			print(0)
			return
		p.append(int(y))
		mn.append(int(log(x, y)))
		mj.append(1)
	else:
		sq = int(sqrt(y))
		for i in s:
			if i > sq:
				break
			if y % i == 0:
				p.append(int(i))
				mn.append(log_finder(x, i))
				mj.append(log_finder(y, i))
				yy /= i ** mj[-1]
				xx /= i ** mn[-1]
		if yy != 1:
			p.append(int(yy))
			mj.append(1)
			mn.append(log_finder(x, yy))
			xx /= yy ** mn[-1]
		if xx != 1:
			print(0)
			return
	n = 0
	results = set()
	xy = x * y
	for i in range(1 << len(p)):
		mmm = 1
		for j in range(len(p)):
			if i & 1 << j > 0:
				mmm *= p[j] ** mn[j]
			else:
				mmm *= p[j] ** mj[j]
		nnn = xy / mmm
		if not (mmm > r or mmm < l or nnn > r or (nnn < l)):
			results.add((min(mmm, nnn), max(mmm, nnn)))
			results.add((max(mmm, nnn), min(mmm, nnn)))
	print(len(results))
function()


def gcd(a, b):
	while b:
		a %= b
		(a, b) = (b, a)
	return a
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	exit()
ans = 0
n = y // x
i = 1
while i * i <= n:
	if n % i == 0:
		c = n // i
		if l <= c * x <= r and l <= i * x <= r and (gcd(i, c) == 1):
			if i * i == n:
				ans += 1
			else:
				ans += 2
	i += 1
print(ans)


import os, sys
from io import BytesIO, IOBase
from math import sqrt, ceil, gcd, log2
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def dtb(n):
	return bin(n).replace('0b', '')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def lcm(a, b):
	return a * b // gcd(a, b)
(l, r, x, y) = map(int, input().split())
a = [1]
z = y // x
if y % x:
	print(0)
else:
	i = 1
	t = sqrt(z)
	ct = 0
	while i <= t:
		if z % i == 0:
			if l <= x * i <= r and l <= x * z // i <= r and (gcd(i, z // i) == 1):
				ct += 2
				if i == z // i:
					ct -= 1
		i += 1
	print(ct)


import collections
from functools import cmp_to_key
import sys

def getIntList():
	return list(map(int, input().split()))
import bisect

def getfactor(t):
	r = {}
	for x in range(2, 100000):
		while t % x == 0:
			t = t // x
			if x not in r:
				r[x] = 1
			else:
				r[x] += 1
	if t > 1:
		r[t] = 1
	return r
(L, R, X, Y) = getIntList()
af = getfactor(X)
bf = getfactor(Y)
base = X
res = set()
if X == Y:
	res.add((X, Y))
for x in af:
	if x not in bf or af[x] > bf[x]:
		print(0)
		sys.exit()
	bf[x] -= af[x]
z = [x for x in bf if bf[x] > 0]
n = len(z)

def search(a, b, d):
	if d == n:
		res.add((a, b))
		return
	nt = z[d] ** bf[z[d]]
	search(a * nt, b, d + 1)
	search(a, b * nt, d + 1)
search(base, base, 0)
r = 0
for x in res:
	if x[0] >= L and x[0] <= R and (x[1] >= L) and (x[1] <= R):
		r += 1
print(r)


import math
(l, r, x, y) = map(int, input().split())
i = 1
di = []
while i * i <= y:
	if y % i == 0:
		if l <= i and i <= r:
			di.append(i)
		if i * i != y:
			if l <= y // i and y // i <= r:
				di.append(y // i)
	i += 1
ans = 0
for a in di:
	for b in di:
		g = math.gcd(a, b)
		if g == x and a * b // g == y:
			ans += 1
print(ans)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import sqrt, gcd

def main():
	(l, r, x, y) = RL()
	res = 0
	sq = int(sqrt(x * y))
	for i in range(x, sq + 1, x):
		if x * y % i != 0:
			continue
		rr = x * y // i
		if l <= i <= r and l <= rr <= r and (gcd(i, rr) == x):
			res += 1
			if i != rr:
				res += 1
	print(res)
main()


import math
[l, r, x, y] = map(int, input().split())
numpair = 0
for i in range(x, int(math.sqrt(x * y)) + 1, x):
	if x * y % i == 0:
		a = i
		b = x * y // i
		if l <= a <= r and l <= b <= r and (math.gcd(a, b) == x):
			numpair += 1
			if a != b:
				numpair += 1
print(numpair)


from math import gcd
(l, r, x, y) = map(int, input().split())
if y % x:
	print(0)
else:
	m = y // x
	d = 1
	ans = 0
	while d ** 2 < m:
		if m % d == 0:
			if gcd(d, m // d) == 1 and l <= d * x <= r and (l <= m // d * x <= r):
				ans += 2
		d += 1
	if m == 1 and l <= x <= r:
		ans = 1
	print(ans)


def gcd(x, y):
	if x < y:
		(x, y) = (y, x)
	if y == 0:
		return x
	return gcd(y, x % y)
(l, r, x, y) = map(int, input().strip().split())
if y % x != 0:
	print('0')
	exit(0)
k = y // x
d = 1
res = 0
while d * d <= k:
	if k % d == 0:
		k1 = d
		k2 = k // d
		if gcd(k1, k2) == 1:
			a = k1 * x
			b = k2 * x
			if l <= a and a <= r and (l <= b) and (b <= r):
				res += 1
				res += 1 if k1 != k2 else 0
	d += 1
print(res)


from math import gcd, sqrt
(left, right, x, y) = [int(x) for x in input().split(' ')]
total = 0
prod = x * y
s = int(sqrt(prod))
for i in range(x, s + 1, x):
	g = gcd(i, prod // i)
	if prod % i == 0 and left <= i and (right >= i) and (prod // i >= left) and (prod // i <= right) and (g == x) and (prod // g == y):
		total += 1
		if i * i != prod:
			total += 1
print(total)


from collections import Counter
from math import gcd, sqrt

def perebor(k, a, b):
	if k < total_n_divs:
		return perebor(k + 1, a * powers[k], b) + perebor(k + 1, a, b * powers[k])
	elif left <= min(a, b) and right >= max(a, b):
		return 1
	return 0

def divs(n):
	d = 2
	lst = []
	maxn = int(sqrt(n)) + 2
	while d <= maxn:
		while n % d == 0:
			lst.append(d)
			n //= d
		d += 1
	if n > 1:
		lst.append(n)
	return lst
(left, right, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	exit()
remproduct = y // x
ds = Counter(divs(remproduct))
powers = [d ** ds[d] for d in ds.keys()]
total_n_divs = len(powers)
print(perebor(0, x, x))


import math, sys
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	sys.exit()
pro = y // x
ans = 0
for i in range(1, int(pro ** 0.5) + 1):
	if pro % i == 0:
		if l <= x * i and pro // i * x <= r and (math.gcd(i, pro // i) == 1):
			if i == pro // i:
				ans += 1
			else:
				ans += 2
print(ans)


from math import sqrt
[l, r, x, y] = list(map(int, input().strip().split()))
if y % x != 0:
	print(0)
	return
y = y // x
l = -(-l // x)
r = r // x
pr = []
i = 2
yx = y
mx = sqrt(yx)
while i <= mx:
	d = 1
	while yx % i == 0:
		d *= i
		yx //= i
	if d > 1:
		pr.append(d)
		mx = sqrt(yx)
	i += 1
if yx > 1:
	pr.append(yx)

def count(a, ar):
	if len(ar) == 0:
		if l <= a <= r and l <= y // a <= r:
			return 1
		else:
			return 0
	res = 0
	res += count(a, ar[1:])
	aa = a * ar[0]
	if aa <= r and y // aa >= l:
		res += count(aa, ar[1:])
	return res
res = count(1, pr)
print(res)


from math import gcd, sqrt
(l, r, x, y) = list(map(int, input().split()))
product = x * y
div = int(sqrt(product))
div = div // x * x
ans = 0
while div >= 1:
	if product % div == 0:
		div2 = product // div
		hcf = gcd(div, div2)
		lcm = div * div2 // hcf
		if hcf == x and lcm == y:
			if div >= l and div <= r and (div2 >= l) and (div2 <= r):
				ans += 2
				if div2 == div:
					ans -= 1
			else:
				break
	div -= x
print(ans)


import math

def function(l, r, x, y):
	if y % x != 0:
		print(0)
	if y % x == 0:
		total = 0
		n = int(y / x)
		for i in range(1, math.floor(math.sqrt(n)) + 1):
			if n % i == 0:
				d1 = i
				d2 = int(n / i)
				if d1 * x >= l and d2 * x <= r:
					if math.gcd(d1, d2) == 1:
						if d1 == d2:
							total += 1
						if d1 != d2:
							total += 2
		print(total)
(l, r, x, y) = map(int, input().rstrip().split())
function(l, r, x, y)


import math

def gcd(x, y):
	while x and y:
		x %= y
		if x:
			y %= x
	return x + y

def lcm(x, y):
	return x * y // gcd(x, y)
(tl, tr, tx, ty) = input().split()
l = int(tl)
r = int(tr)
x = int(tx)
y = int(ty)
t = []
cnt = 0
for i in range(1, int(math.sqrt(y)) + 1):
	if y % i == 0 and i >= l and (i <= r):
		t.append(i)
		cnt += 1
	if y % i == 0 and i * i != y and (y // i >= l) and (y // i <= r):
		t.append(y // i)
		cnt += 1
ans = 0
for i in range(cnt):
	for j in range(cnt):
		if gcd(t[i], t[j]) == x and t[i] * t[j] == x * y:
			ans += 1
print(ans)


from collections import defaultdict
(l, r, x, y) = list(map(int, input().split()))
if x == y == 1:
	if l == 1:
		print(1)
		return
	print(0)
	return
if y % x != 0:
	print(0)
	return
c = x * y
c_ = y // x
i = 2
del_ = defaultdict(int)
while c_ > 1:
	while c_ % i == 0:
		c_ //= i
		del_[i] += 1
	i += 1
mas = tuple((k ** v for (k, v) in list(del_.items())))
ln = len(mas)
ans = 0
for i in range(2 ** ln):
	b = bin(i)[2:].zfill(ln)
	a = x
	for j in range(ln):
		if b[j] == '1':
			a *= mas[j]
	b = c // a
	if l <= a <= r and l <= b <= r:
		ans += 1
print(ans)


def GCD(a, b):
	return a if b == 0 else GCD(b, a % b)
(l, r, x, y) = map(int, input().split())
tmp = x * y
ans = 0
for (i, j) in zip(range(x, r + 1, x), range(100000)):
	if i < l:
		continue
	if tmp % i != 0:
		continue
	t = tmp // i
	if i > t:
		continue
	if t > r:
		continue
	if GCD(t, i) != x:
		continue
	ans += 1
	if t != i:
		ans += 1
print(ans)


import math
I = input().split()
l = int(I[0])
r = int(I[1])
x = int(I[2])
y = int(I[3])
pie = int(math.sqrt(y)) + 5
res = 0

def spr(p):
	q = int(x * y / p)
	if math.gcd(p, q) != x:
		return 0
	if max(p, q) <= r and min(p, q) >= l:
		return 1
	else:
		return 0
for i in range(1, pie):
	if y % i == 0:
		if y / i > i:
			res += spr(i)
			res += spr(int(y / i))
		elif y / i == i:
			res += spr(i)
print(res)


import math
(l, r, x, y) = [int(x) for x in input().split()]
D = []
for i in range(1, int(math.sqrt(y)) + 1):
	if y % i == 0:
		if i != y // i:
			D.append(i)
			D.append(y // i)
		else:
			D.append(i)
P = []
for d in D:
	if d % x == 0:
		P.append((d, x * y // d))
s = 0
for p in P:
	if l <= p[0] and p[0] <= r:
		if l <= p[1] and p[1] <= r:
			if math.gcd(p[0], p[1]) == x:
				s += 1
print(s)


s = list(map(int, input().split()))
l = s[0]
r = s[1]
x = s[2]
y = s[3]

def findgcd(a, b):
	M = max(a, b)
	m = min(a, b)
	while m != 0:
		t = M % m
		M = m
		m = t
	return M
count = 0
if x != y:
	if True:
		prod = x * y
		a = []
		for i in range(1, int(y ** 0.5) + 1):
			if y / i == int(y / i):
				a.append(i)
				a.append(int(y / i))
		a = list(set(a))
		for i in a:
			b_i = prod / i
			if int(b_i) == b_i:
				if findgcd(b_i, i) == x and l <= i <= r and (l <= b_i <= r):
					count += 1
				else:
					continue
if x == y and l <= x <= r and (l <= y <= r):
	count = 1
print(count)


import math

def kk(n):
	list = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				list.append(i)
			else:
				list.append(i)
				list.append(int(n / i))
	return list
(l, r, x, y) = map(int, input().split())
s = kk(y)
c = 0
for i in range(0, len(s)):
	a = s[i]
	b = x * y // a
	if a >= l and a <= r and (b >= l) and (b <= r):
		if math.gcd(a, b) == x:
			h = a * b // math.gcd(a, b)
			if h == y:
				c += 1
print(c)


from math import *
(l, r, x, y) = map(int, input().split())
m = int(sqrt(y) - 0.1) + 1
s = list((i for i in range(1, m) if y % i == 0))
s += list((y // i for i in s))
if m * m == y:
	s += [m]
print(sum((sum((int(l <= i <= r and l <= j <= r and (i * j == x * y) and (gcd(i, j) == x)) for i in s)) for j in s)))


import math
R = lambda : map(int, input().split())
(l, r, a, b) = R()
if b % a:
	print(0)
	quit()
i = 1
res = 0
b //= a
while i <= int(math.sqrt(b)):
	if b % i == 0 and math.gcd(b // i, i) == 1:
		if l <= b // i * a <= r and l <= i * a <= r:
			res += 1
			if b // i != i:
				res += 1
	i += 1
print(res)


import math
(L, R, x, y) = input().split()
L = int(L)
R = int(R)
x = int(x)
y = int(y)

def NOD(a, b):
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return a + b

def simple(x):
	d = 2
	while d * d <= x and x % d != 0:
		d += 1
	return d * d > x
if L * L > x * y or R * R < x * y or y % x != 0:
	print(0)
elif simple(y) and x == 1 and (L == 1) and (y != 1):
	print(2)
else:
	d = set()
	new_x = 1
	new_y = y // x
	pr = new_x * new_y
	tek = 1
	while tek * tek <= pr:
		if pr % tek == 0:
			d.add(tek)
		tek += 1
	count = 0
	for first in d:
		second = pr // first
		a = x * first
		b = x * second
		if L <= a <= R and L <= b <= R:
			if NOD(a, b) == x:
				if a == b:
					count += 1
				else:
					count += 2
	print(count)


import math

def HOK(a, b):
	while b:
		t = a % b
		a = b
		b = t
	return a
(l, r, x, y) = map(int, input().split())
k = 0
if y % x != 0:
	k = 0
else:
	k1 = 1
	S = y // x
	while k1 * k1 <= S:
		if S % k1 == 0:
			k2 = S // k1
			if l <= k2 * x and k2 * x <= r and (k1 * x <= r) and (l <= k1 * x) and (HOK(k2, k1) == 1):
				if k1 * k1 != S:
					k += 2
				else:
					k += 1
		k1 += 1
print(k)


import math
(l, r, gcd, lcm) = (int(x) for x in input().split())
if lcm % gcd != 0:
	print(0)
	quit()
lcm_divisors = set()
for num in range(1, int(lcm ** 0.5) + 2):
	if lcm % num == 0:
		lcm_divisors.add(num)
		lcm_divisors.add(lcm // num)
product = gcd * lcm
answers = set()
for divisor in lcm_divisors:
	if divisor < l or divisor > r:
		continue
	dop = product // divisor
	if dop < l or dop > r:
		continue
	if math.gcd(divisor, dop) != gcd:
		continue
	answers.add((divisor, dop))
	answers.add((dop, divisor))
print(len(answers))


(l, r, x, y) = list(map(int, input().split()))
if y % x != 0:
	print(0)
else:
	k = y // x
	l /= x
	r /= x
	i = 1
	s = 0
	import math
	while i * i <= k:
		if k % i == 0:
			if l <= i and i <= r:
				if l <= k // i and k // i <= r and (math.gcd(i, k // i) == 1):
					if i == k // i:
						s += 1
					else:
						s += 2
		i += 1
	print(s)


f = lambda : map(int, input().split())

def nod(a, b):
	while True:
		if a % b == 0:
			return b
		if b % a == 0:
			return a
		if a > b:
			(a, b) = (b, a % b)
		else:
			(a, b) = (b % a, a)
(l, r, x, y) = f()
if y % x != 0:
	print(0)
else:
	k = 0
	z = int(y / x)
	for c in range(1, int(z ** 0.5) + 1):
		if z % c == 0:
			d = int(z / c)
			if l <= c * x and c * x <= r and (l <= d * x) and (d * x <= r) and (nod(c, d) == 1):
				k += 1
				if c * c != z:
					k += 1
	print(k)


import configparser
import math
import sys
input = sys.stdin.readline
pairs = set()

def gen(a, b, place, keys):
	if place == len(keys):
		pairs.add((min(a, b), max(a, b)))
	else:
		new_a = a * keys[place][0] ** keys[place][1]
		new_b = b * keys[place][0] ** keys[place][2]
		gen(new_a, new_b, place + 1, keys)
		new_a = a * keys[place][0] ** keys[place][2]
		new_b = b * keys[place][0] ** keys[place][1]
		gen(new_a, new_b, place + 1, keys)

def main():
	(l, r, x, y) = [int(x) for x in input().split(' ')]
	max_sqrt = int(math.sqrt(int(1000000000.0) + 7) + 5)
	prime = [True for i in range(max_sqrt)]
	for i in range(2, max_sqrt):
		if prime[i]:
			for j in range(i + i, max_sqrt, i):
				prime[j] = False
	prime_x = {}
	prime_y = {}
	for j in range(2, max_sqrt):
		if j * j > max(x, y):
			break
		if prime[j] and x % j == 0 or y % j == 0:
			prime_y[j] = 0
			prime_x[j] = 0
			if x % j == 0:
				while x % j == 0:
					prime_x[j] = 1 if j not in prime_x else prime_x[j] + 1
					x //= j
			if y % j == 0:
				while y % j == 0:
					prime_y[j] = 1 if j not in prime_y else prime_y[j] + 1
					y //= j
	if x != 1:
		prime_x[x] = 1
		if x == y:
			prime_y[x] = 1
		else:
			prime_y[x] = 0
	if y != 1:
		prime_y[y] = 1
		if x == y:
			prime_x[y] = 1
		else:
			prime_x[y] = 0
	for (small, big) in zip(prime_x.values(), prime_y.values()):
		if big < small:
			print(0)
			return
	keys = []
	for k in prime_x.keys():
		keys.append((k, prime_x[k], prime_y[k]))
	gen(1, 1, 0, keys)
	cnt = 0
	for (left, right) in pairs:
		if left >= l and right <= r:
			if left == right:
				cnt += 1
			else:
				cnt += 2
	print(cnt)
main()


from math import gcd
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	exit()
z = y // x
p = []
use = set()
for i in range(1, int(z ** 0.5) + 1):
	if z % i == 0 and i not in use:
		p.append(i)
		use.add(i)
		if z // i not in use:
			p.append(z // i)
			use.add(z // i)
cnt = 0
for c in p:
	d = z // c
	if l <= c * x <= r and l <= d * x <= r and (gcd(c, d) == 1):
		cnt += 1
print(cnt)


from math import sqrt, gcd
(l, r, x, y) = map(int, input().split())
m = x * y
p = int(sqrt(m))
start = l // x * x
while start < l:
	start += x
ans = 0
for a in range(start, p + 1, x):
	if m % a > 0:
		continue
	b = m // a
	if b > r:
		continue
	if gcd(a, b) == x:
		ans += 1
		if a != b:
			ans += 1
print(ans)


from math import sqrt
from fractions import gcd
(l, r, x, y) = map(int, input().split())
now = sqrt(y)
now = int(now)
ans = int(0)
for i in range(now):
	cur = i + 1
	if cur > now:
		break
	if y % cur == 0:
		a = int(cur * x)
		b = int(y / cur)
		if gcd(a, b) == x and a * b / x == y and (a >= l) and (a <= r) and (b <= r) and (b >= l) and (a <= b):
			if a == b:
				ans = ans + 1
			else:
				ans = ans + 2
print(ans)


from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def digits(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def ceil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def mapin():
	return map(int, input().split())
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(l, r, x, y) = mapin()
c = y // x
ll = set()
if y % x == 0:
	for i in range(1, int(math.sqrt(c)) + 3):
		j = c // i
		if c % i == 0 and math.gcd(i, j) == 1 and (l <= i * x) and (i * x <= r) and (l <= j * x) and (j * x <= r):
			ll.add((i * x, j * x))
			ll.add((j * x, i * x))
	print(len(ll))
else:
	print(0)


from math import gcd

def lcm(a, b):
	p = a * b
	return p // gcd(a, b)
s = set()
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
else:
	ans = 0
	n = y // x
	d = 1
	while d * d <= n:
		if n % d == 0:
			c = n // d
			if l <= c * x <= r and l <= d * x <= r and (gcd(c, d) == 1):
				if d * d == n:
					ans += 1
				else:
					ans += 2
		d += 1
	print(ans)


import math

def solve():
	(l, r, x, y) = map(int, input().split())
	if y % x != 0:
		print(0)
		return
	y //= x
	l = (l + x - 1) // x
	r = r // x
	ans = 0
	di = []
	a = 1
	while a * a <= y:
		if y % a == 0:
			b = y // a
			if l <= a and a <= r and (l <= b) and (b <= r):
				if math.gcd(a, b) == 1:
					ans += 1
					ans += a != b
		a += 1
	print(ans)
for tt in range(1):
	solve()


import math
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	quit()
aa = y // x
ans = 0
l = l / x
r = r / x
for i in range(1, int(math.sqrt(y / x)) + 1, 1):
	if aa % i == 0:
		(a, b) = (i, aa // i)
		if l <= a <= r and l <= b <= r:
			if math.gcd(a, b) == 1:
				ans += 2
				if a == b:
					ans -= 1
print(ans)


import math

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(l, r, x, y) = map(int, input().split())
lwall = math.ceil(l / x)
rwall = math.floor(r / x)
n = y // x
ans = 0
if y % x != 0:
	print(0)
else:
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0 and lwall <= i and (i <= rwall) and (gcd(i, n / i) == 1) and (n / i <= rwall):
			ans += 2
			if i == math.sqrt(n):
				ans -= 1
	print(ans)


import math
(l, r, x, y) = map(int, input().split())

def gc(a, b):
	if a == 0:
		return b
	elif b == 0:
		return a
	elif a == b:
		return b
	else:
		return gc(b % a, a)
if y % x != 0:
	print(0)
else:
	n = y / x
	ans = 0
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			c = n / i
			if c * x >= l and c * x <= r and (i * x <= r) and (i * x >= l) and (gc(c, i) == 1):
				if i * i == n:
					ans += 1
				else:
					ans += 2
	print(ans)


(l, r, x, y) = map(int, input().split())
import math

def it(a):
	if a < l or a > r:
		return False
	return True
ans = 0
div = set()
for i in range(1, int(y ** 0.5) + 1):
	if y % i == 0 and y // i % x == 0 and it(i * x) and it(y // i) and (math.gcd(i, y // i // x) == 1):
		c = 1 if i == y // i // x else 0
		ans += 2 - c
		div.add(y // i)
		div.add(i * x)
print(len(div))


def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	exit()
z = y // x
ans = 0
for i in range(1, int(z ** 0.5) + 1):
	if z % i == 0:
		if gcd(i, z // i) == 1 and l <= i * x <= r and (l <= z // i * x <= r):
			ans += 1
			if i != z // i:
				ans += 1
print(ans)


from math import sqrt, gcd
(l, r, x, y) = (int(x) for x in input().split())
(v, s, j, pairs) = (y // x, sqrt(y // x), 1, set())
if y % x:
	print(0)
else:
	while j * j <= v:
		if v % j == 0 and gcd(j, v // j) == 1 and (l <= j * x <= r) and (l <= v // j * x <= r):
			pairs.add((j, v // j))
			pairs.add((v // j, j))
		j += 1
	print(len(pairs))


from math import *
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
else:
	(ans, t) = (0, y // x)
	for q in range(1, int(sqrt(t)) + 1):
		ans += 2 * (t % q == 0 and r >= q * x >= l and (r >= t // q * x >= l) and (gcd(q, t // q) == 1))
	ans -= int(sqrt(t)) ** 2 == t and l <= int(sqrt(t)) * x <= r and (t == 1)
	print(ans)


import math

def get_div(n):
	a = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			a.append([i, n // i])
	return a
tmp = [int(i) for i in input().split()]
(l, r, x, y) = (tmp[0], tmp[1], tmp[2], tmp[3])
if y % x != 0:
	print(0)
else:
	c = 0
	a = get_div(y // x)
	for p in a:
		pl = min(p)
		pr = max(p)
		if math.gcd(pl, pr) == 1:
			if l <= x * pl and x * pr <= r:
				c += 1
				if p[0] != p[1]:
					c += 1
	print(c)


from sys import stdin, stdout
from math import gcd
input = stdin.buffer.readline

def add(a, b):
	if l <= a <= r and l <= b <= r and (gcd(a, b) == x):
		s.add((a, b))
(l, r, x, y) = map(int, input().split())
s = set()
a = []
b = []
i = 1
while i * i <= x:
	if not x % i:
		a.append(i)
		a.append(x // i)
		add(i, x * y // i)
		add(x * y // i, i)
	i += 1
i = 1
while i * i <= y:
	if not y % i:
		b.append(i)
		b.append(y // i)
		add(i, x * y // i)
		add(x * y // i, i)
	i += 1
for i in a:
	for j in b:
		add(i * j, x * y // i // j)
		add(x * y // i // j, i * j)
print(len(s))


import math
(l, r, x, y) = map(int, input().split())
ans = 0
if y % x != 0:
	print(0)
else:
	l = (l + x - 1) // x
	r = r // x
	y //= x
	i = 1
	while i * i <= y:
		if y % i == 0:
			j = y // i
			if l <= i and i <= r and (j >= l) and (j <= r) and (math.gcd(i, j) == 1):
				if i == j:
					ans += 1
				else:
					ans += 2
		i += 1
	print(ans)


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
else:
	c = 0
	k = y // x
	i = 1
	while i * i <= k:
		if k % i == 0:
			j = k // i
			if (l <= j * x and j * x <= r) and (l <= i * x and i * x <= r) and (gcd(i, j) == 1):
				if i * i == k:
					c += 1
				else:
					c += 2
		i += 1
	print(c)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 998244353
dd = [(0, -1), (1, 0), (0, 1), (-1, 0)]
ddn = [(0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, -1), (-1, 0), (-1, 1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def divisions(n):
	sq = int(math.sqrt(n) + 1)
	d = collections.defaultdict(int)
	while n % 2 == 0:
		n //= 2
		d[2] += 1
	i = 3
	while n > 1 and sq >= i:
		if n % i == 0:
			n //= i
			d[i] += 1
		else:
			i += 2
	if n > 1:
		d[n] += 1
	r = [1]
	for (k, v) in d.items():
		for c in r[:]:
			for i in range(1, v + 1):
				r.append(c * k ** i)
	return sorted(r)

def main():
	(l, r, x, y) = LI()
	if y % x != 0:
		return 0
	a = divisions(y // x)
	t = 0
	l /= x
	r /= x
	y //= x
	for c in a:
		d = y // c
		g = fractions.gcd(c, d)
		if g == 1 and l <= c <= r and (l <= d <= r):
			t += 1
	return t
print(main())


import itertools
import operator
import functools

def factorize(n):
	factors = []
	for i in itertools.chain([2], itertools.count(3, 2)):
		factor = 1
		while n % i == 0:
			n //= i
			factor *= i
		if factor > 1:
			factors.append(factor)
		if n == 1:
			break
	return factors

def powerset(A):
	if A == []:
		yield []
	else:
		a = A[0]
		for tail in powerset(A[1:]):
			yield tail
			yield ([a] + tail)
(l, r, gcd, lcm) = map(int, input().split())
result = 0
if lcm % gcd == 0:
	quotient = lcm // gcd
	factors = factorize(quotient)
	l = (l - 1) // gcd + 1
	r = r // gcd
	for a_factors in powerset(factors):
		a = functools.reduce(operator.mul, a_factors, 1)
		if not l <= a <= r:
			continue
		b = quotient // a
		if not l <= b <= r:
			continue
		result += 1
print(result)


from math import gcd
from math import sqrt
(l, r, x, y) = map(int, input().split())
if x == y:
	if l <= x <= r:
		print('1')
	else:
		print('0')
else:
	rl = min(r, int(sqrt(y)))
	i = 1
	prod = x * y
	count = 0
	while i <= rl:
		if y % i == 0:
			g = gcd(i, int(prod / i))
			if g == x and i >= l and (prod / i >= l) and (prod / i <= r):
				if i * i == prod:
					count += 1
				else:
					count += 2
			k = y // i
			j = x * i
			g = gcd(k, j)
			if gcd(k, j) == x and k >= l and (k <= r) and (j >= l) and (j <= r) and (k > sqrt(y)) and (j > sqrt(y) or y % j != 0) and (j <= k):
				if k == j:
					count += 1
				else:
					count += 2
		i += 1
	print(count)


import math
(l, r, x, y) = map(int, input().split())
prod = x * y
count = 0
for i in range(x, math.floor(math.sqrt(prod)) + 1, x):
	cond1 = False
	cond2 = False
	if prod % i == 0 and i >= l and (i <= r) and (prod // i >= l) and (prod // i <= r):
		cond1 = True
	if cond1 and math.gcd(i, prod // i) == x:
		cond2 = True
	if cond1 and cond2:
		if i != prod // i:
			count = count + 2
		else:
			count = count + 1
print(count)


n = input()
arr = n.split(' ')
arr = list(map(lambda x: int(x), arr))
(l, r, x, y) = arr
gcd = x
lcm = y
from math import sqrt
from fractions import gcd

def lcm(a, b):
	return int(a * b / gcd(a, b))
ab = x * y
ans = 0
a = x
while a <= sqrt(ab):
	b = int(ab / a)
	if a > b:
		break
	if ab % a == 0:
		if l <= b and b <= r and (lcm(a, b) == y) and (l <= a) and (a <= r):
			if b == a:
				ans += 1
			else:
				ans += 2
	a += x
print(ans)


from math import gcd
(l, r, x, y) = map(int, input().split())
if y % x != 0:
	print(0)
	quit()
o = 0
(yx, lx, rx) = (y // x, l / x, r / x)
for c in range(1, 1 + int((y / x) ** 0.5)):
	if yx % c != 0:
		continue
	d = yx // c
	if gcd(c, d) == 1 and lx <= c <= rx and (lx <= d <= rx):
		o += 2
		if c == d:
			o -= 1
			break
print(max(0, o))


def nod(a, b):
	while b != 0:
		t = a % b
		a = b
		b = t
	return a

def nok(a, b):
	return int(a * b / nod(a, b))
(l, r, x, y) = map(int, input().split())
from math import sqrt
if y % x != 0:
	print(0)
else:
	f = y // x
	par = 0
	d = 1
	while d * d <= f:
		if f % d == 0:
			c = f // d
			if l <= c * x <= r and l <= d * x <= r and (nod(c, d) == 1):
				if d * d == f:
					par = par + 1
				else:
					par = par + 2
		d += 1
	print(par)


(l, r, x, y) = [int(i) for i in input().split()]
from math import gcd, sqrt
c = 0
k = y // x
for i in range(1, int(sqrt(k)) + 1):
	j = k // i
	if j * x >= l and j * x <= r and (i * x >= l) and (i * x <= r) and (y // x == y / x):
		g = gcd(i, j)
		if g == 1 and i * j == k:
			if i == j:
				c += 1
			else:
				c += 2
print(c)


def myprod(mylist):
	result = 1
	for i in range(len(mylist)):
		result *= mylist[i]
	return result
from itertools import combinations
from itertools import compress

def rwh_primes1v1(n):
	sieve = bytearray([True]) * (n // 2)
	for i in range(3, int(n ** 0.5) + 1, 2):
		if sieve[i // 2]:
			sieve[i * i // 2::i] = bytearray((n - i * i - 1) // (2 * i) + 1)
	return [2, *compress(range(3, n, 2), sieve[1:])]
mylist = list(map(int, input().split(' ')))
[l, r, x, y] = mylist
if y % x == 0:
	myvalue = int(y / x)
	result = []
	primes_list = rwh_primes1v1(10000)
	myidx = 0
	value = primes_list[myidx]
	current = 1
	while value <= myvalue:
		if myvalue % value == 0:
			myvalue = int(myvalue / value)
			current *= value
		else:
			if current != 1:
				result.append(current)
			myidx += 1
			if myidx == len(primes_list):
				value = myvalue
			else:
				value = primes_list[myidx]
			current = 1
	result.append(current)
	mylist = []
	for myr in range(1, len(result) + 1):
		mylist += list(combinations(result, myr))
	lb = l / x
	ub = r / x
	count = 0
	if lb <= 1 <= ub and lb <= myprod(result) <= ub:
		count += 1
	if x != y:
		for i in range(len(mylist)):
			if lb <= myprod(mylist[i]) <= ub and lb <= int(myprod(result) / myprod(mylist[i])) <= ub:
				count += 1
	print(count)
else:
	print(0)


from math import sqrt

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(l, r, x, y) = [int(i) for i in input().split()]
z = x * y
p = 0
for i in range(x, int(sqrt(z)) + 1, x):
	g = gcd(i, z // i)
	if z % i == 0 and l <= i and (i <= r) and (z // i >= l) and (z // i <= r) and (g == x) and (z // g == y):
		if i * i == z:
			p += 1
		else:
			p += 2
print(p)


from fractions import gcd
(l, r, x, y) = map(int, input().split())
coun = 0
li = [1, y]
i = 2
while i * i <= y:
	if y % i == 0 and i * i != y:
		li.append(i)
		li.append(y / i)
	elif i * i == y:
		li.append(i)
	i += 1
for j in li:
	if j >= l and j <= r and (j % x == 0):
		a = x * y // j
		if a >= l and a <= r and (gcd(a, j) == x):
			coun += 1
print(coun)


def gcd(a, b):
	if a % b == 0:
		return b
	return gcd(b, a % b)
import math
(l, r, x, y) = [int(e) for e in input().split()]
count = 0
if y % x == 0:
	for i in range(1, int(math.sqrt(y / x)) + 1):
		if y // x % i == 0:
			if l / x <= i <= r / x and l / x <= y / x / i <= r / x:
				if gcd(i, y // x / i) == 1:
					if i == y // x / i:
						count += 1
					else:
						count += 2
	print(count)
else:
	print('0')


import math

def gcd(a, b):
	if a < b:
		(a, b) = (b, a)
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(l, r, x, y) = [int(t) for t in input().split()]
n = y / x
ans = 0
for i in range(1, int(math.sqrt(n)) + 1):
	a = i * x
	b = int(y / i)
	if y % i == 0 and a >= l and (b <= r) and (gcd(a, b) == x):
		ans += (1, 2)[a != b]
print(ans)