//以下为使用Java的大数类实现
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
  public static void main(String[] args)
  {
    BigInteger inc = new BigInteger("1");
    BigInteger n = null;
    Scanner sc = new Scanner(System.in);
    while(sc.hasNext())
    {
      n = sc.nextBigInteger();
      BigInteger ans = new BigInteger("1");
      BigInteger i = new BigInteger("1");
      for(; i.compareTo(n) != 1; i = i.add(inc))
      {
        ans = ans.multiply(i);
      }
      System.out.println(ans);
    }
  }
}

//快速求解N!末尾第一个非0数字，时间复杂度为O(n^2)，n为 N的位数
//输入的N为字符串读入
int lastdigit(char*buf)
{
    int mod[20]={1,1,2,6,4,2,2,4,2,8,4,4,8,4,6,8,8,6,8,2};
    int len=strlen(buf),a[maxn],i,c,ret=1;
    if(len==1)
        return mod[buf[0]-'0'];
    for(i=0;i<len;i++)
        a[i]=buf[len-1-i]-'0';
    for(;len;len-=!a[len-1])
    {
        ret=ret*mod[a[1]%2*10+a[0]]%5;
        for(c=0,i=len-1;i>=0;i--)
            c=c*10+a[i],a[i]=c/5,c%=5;
    }
    return ret+ret%2*5;
}

//快速求解N！的位数，输入的n即为N！中的最大的那个N
int strilingToDigit (int n)
{
    double ans;
    ans = 0.5*log10(2*pi)+(0.5+n)*log10(n)-n/log(10.0)+1.0;
    return int(ans);
}

int factorNum(int i, int n)
{
    int cnt = 0;
    while(n)
    {
        n /= i;
        cnt += n;
    }
    return cnt;
}

search(n) {
       for(i = n; i <= 9; i++) {
             sum += A[i];        //求和
             如果sum在ans数组中不存在，则将sum插入到ans[]数组中
             search(n+1);
             sum -= A[i];         //回溯
     }
}

#include<stdio.h>
#include<string.h>

//zju只能够使用long long
typedef long long int64;
int64 INF;
int64 nbln, nbun, left, right, bln[20], bun[510], sum;

//a b的最大公约数
int64 gcd(int64 a, int64 b)
{
        if(b == 0) return a;
        else return gcd(b, a%b);
}

//a b的最小公倍数数，如果两个数的最小公倍数超过了表达范围则返回0
int64 lcm(int64 a, int64 b)
{
        int64 t;
        if(a == 0 || b == 0) return 0;
        t = gcd(a, b);
        t = a/t;
        if(INF/t < b) return 0;
        return t*b;
}

//容斥原理求解因子个数的数，递归的求解
void rong(int64 a, int s, int l)
{
        int i;
        int64 t;
        for(i=s; i<nbln; i++)
        {
                t = lcm(a, bln[i]);
                if(t==0 || a > right) return;
                if(l%2 == 1) sum -= (right/t-left/t);
                else sum += (right/t-left/t);
                rong(t, i+1, l+1);
        }
}

int  main()
{
        int i, j, k;
        int64 t, ans;
        INF = (1<<31);
        INF = (INF<<31);
        INF = (INF<<1)-1;
        while(scanf("%lld%lld%lld%lld", &nbln, &nbun, &left, &right) && nbln+nbun+left+right)
        {
                left--;
                for(i=0; i<nbln; i++) scanf("%lld", &bln[i]);
                for(i=0; i<nbun; i++) scanf("%lld", &bun[i]);
                //容斥原理的预处理
                for(i=0; i<nbln-1; i++)
                {
                        for(j=i+1; j<nbln; j++)
                        {
                                if(bln[i] > bln[j])
                                {
                                t = bln[i];
                                bln[i] = bln[j];
                                bln[j] = t;
                                }
                        }
                }
                sum = 0;
                //满足条件1的数
                rong(1, 0, 0);
                t = 1;
                for(i=0; i<nbun; i++)
                {
                        t = lcm(t, bun[i]);
                        if(t == 0) break;
                }
                ans = sum;
                sum = 0;
                //满足条件2的数
                rong(t, 0, 0);
                ans -= sum;
                printf("%lld\n", ans);
        }
        return 0;
}