#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize 03
#pragma GCC optimize("unroll-loops")

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <iterator>
#include <cmath>
#include <ctime>
#include <vector>
#include <deque>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <random>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef std::pair<int, int> pii;
typedef std::pair<char, char> pcc;
typedef std::pair<short, char> psc;
typedef unsigned long long ull;
typedef long long ll;
typedef long double lb;
typedef tree<int,
             null_type,
             less<int>,
             rb_tree_tag,
             tree_order_statistics_node_update> ordered_set;

#define fast ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define file_in freopen("input.txt", "r", stdin);
#define file_in_out freopen("commander.in", "r", stdin); freopen("commander.out", "w", stdout);
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second

template<typename T>
istream& operator>>(istream &in, vector<T> &v) {
    for (auto &it : v) {
        in >> it;
    }
    return in;
}

template<typename T>
ostream& operator<<(ostream &out, const vector<T> &v) {
    for (auto &it : v) {
        out << it << " ";
    }
    return out;
}

template<typename T1, typename T2>
istream& operator>>(istream &in, pair<T1, T2> &v) {
    in >> v.fi >> v.se;
    return in;
}

template<typename T1, typename T2>
ostream& operator<<(ostream &out, const pair<T1, T2> &v) {
    out << v.fi << " " << v.se;
    return out;
}

int ans = 0;
ll l, r, x, y;
bool not_overflow(lb a, lb b) {
    return a <= (1ll << 62) / b;
}
map<pair<ll, ll>, char> used;
void rec(int i, ll p, vector<vector<ll>> pp) {
    if (i == pp.size()) {
        if (l <= p && p <= r && l <= x * y / p && x * y / p <= r && gcd(p, x * y / p) == x && lcm(p, x * y / p) == y && !used[{p, x * y / p}]) {
            used[{p, x * y / p}] = 1;
            ++ans;
        }
        return;
    }
    for (auto el : pp[i]) {
        if (not_overflow(p, el)) rec(i + 1, p * el, pp);
    }
}

int main() {
    fast
    // file_in
    // file_in_out

    cin >> l >> r >> x >> y;
    ll xx = x, yy = y;
    map<int, int> divs1, divs2;
    for (int i = 2; i * i <= xx; ++i) {
        int c = 0;
        while (xx % i == 0) { ++c; xx /= i; }
        divs1[i] = c;
    }
    for (int i = 2; i * i <= yy; ++i) {
        int c = 0;
        while (yy % i == 0) { ++c; yy /= i; }
        divs2[i] = c;
    }
    divs1[xx] = (xx != 1); divs2[yy] = (yy != 1);
    for (auto [d, c] : divs1) {
        divs1[d] += divs2[d];
        divs2[d] = 0;
    }
    vector<pii> div;
    for (auto el : divs1) if (el.se != 0) div.push_back(el);
    for (auto el : divs2) if (el.se != 0) div.push_back(el);
    int n = div.size();

    for (int i = 0; i < (1 << n); ++i) {
        int j = i, k = 0;
        vector<vector<ll>> pp;
        while (j) {
            if (j & 1) {
                vector<ll> now;
                ll st = div[k].fi;
                for (int s = 0; s < div[k].se; ++s) { now.push_back(st); st *= div[k].fi; }
                pp.push_back(now);
            }
            j >>= 1;
            ++k;
        }
        rec(0, 1, pp);
    }
    cout << ans << '\n';
    return 0;
}