#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vpdd = vector<pdd>;
template <typename T>
void ckmin(T& a, const T& b) {
  a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
  a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
  cin >> x;
}
void re(double& x) {
  string t;
  re(t);
  x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
  re(first);
  re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
  re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
  for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
  for (int i = 0; i < (SZ); i++) re(a[i]);
}
}  // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
  cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
  pr(first);
  pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
  pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
  if (pretty) pr("{");
  bool fst = 1;
  for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
  if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
  prContain<T, false>(x);
  pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
  prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
  prContain(x);
}
template <class T>
void pr(const set<T>& x) {
  prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
  prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
  pr(first);
  ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
  pr(first, " ");
  ps(rest...);
}
}  // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
  sort((v).begin(), (v).end());
  v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::const_iterator find(const vector<T>& v, const T& x) {
  auto it = lower_bound((v).begin(), (v).end(), x);
  return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(const vector<T>& v, const T& x) {
  auto it = find(v, x);
  assert(it != v.end() && *it == x);
  return it - v.begin();
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator lower_bound(
    const vector<pair<T1, T2>>& v, const T1& x) {
  return lower_bound(
      (v).begin(), (v).end(), x,
      [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator upper_bound(
    const vector<pair<T1, T2>>& v, const T1& x) {
  return upper_bound(
      (v).begin(), (v).end(), x,
      [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
}  // namespace __algorithm
using namespace __algorithm;
struct __monostate {
  friend istream& operator>>(istream& is,
                             const __attribute__((unused)) __monostate& ms) {
    return is;
  }
  friend ostream& operator<<(ostream& os,
                             const __attribute__((unused)) __monostate& ms) {
    return os;
  }
} ms;
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << setprecision(15);
  if (int((second).size())) {
    setIn(second + ".in"), setOut(second + ".out");
  }
}
}  // namespace __io
using namespace __io;
map<ll, int> factor(ll N) {
  map<ll, int> res;
  for (ll p = 2; p * p <= N; p++) {
    while (N % p == 0) {
      res[p]++;
      N /= p;
    }
  }
  if (N > 1) res[N]++;
  return res;
}
ll crt(const vi& MODS, const vi& n) {
  auto inverse = [](int M, int n) {
    int g = M, x = 0, y = 1;
    for (int r = n; r != 0;) {
      int q = g / r;
      g %= r;
      swap(g, r);
      x -= q * y;
      swap(x, y);
    }
    assert(g == 1);
    assert(y == M || y == -M);
    return x < 0 ? x + M : x;
  };
  const int M = int((MODS).size());
  vi x(M);
  for (int i = 0; i < M; i++) {
    x[i] = n[i];
    for (int j = 0; j < i; j++) {
      x[i] = ll(x[i] - x[j]) * inverse(MODS[i], MODS[j] % MODS[i]) % MODS[i];
      if (x[i] < 0) x[i] += MODS[i];
    }
  }
  ll v = 0;
  for (int i = M - 1; i >= 0; i--) v = MODS[i] * v + x[i];
  return v;
}
int main() {
  setIO();
  ll a1, b1, a2, b2, L, R;
  re(a1, b1, a2, b2, L, R);
  auto f1 = factor(a1), f2 = factor(a2);
  vi primes;
  for (auto& p : f1) primes.push_back(p.first);
  for (auto& p : f2) primes.push_back(p.first);
  dedup(primes);
  ll mod = 1;
  for (auto& p : primes)
    for (int i = 0; i < (max(f1[p], f2[p])); i++) mod *= p;
  {
    ll add = 0;
    if (b1 < 0) ckmax(add, (-b1 + mod - 1) / mod);
    if (b2 < 0) ckmax(add, (-b2 + mod - 1) / mod);
    if (L < 0) ckmax(add, (-L + mod - 1) / mod);
    b1 += add * mod;
    b2 += add * mod;
    L += add * mod;
    R += add * mod;
  }
  vi MODS;
  vi RESIDUES;
  for (auto& p : primes) {
    int ppow = 1;
    for (int i = 0; i < (max(f1[p], f2[p])); i++) ppow *= p;
    int spow = 1;
    for (int i = 0; i < (min(f1[p], f2[p])); i++) spow *= p;
    if (b1 % spow != b2 % spow) {
      ps(0);
      return 0;
    }
    MODS.push_back(ppow);
    RESIDUES.push_back((f1[p] > f2[p] ? b1 : b2) % ppow);
  }
  ll res = crt(MODS, RESIDUES);
  auto first = [&](ll V) { return V / mod + int(V % mod > res); };
  ckmax(L, max(b1, b2));
  if (L <= R)
    ps(first(R + 1) - first(L));
  else
    ps(0);
  return 0;
}
