n=int(input()) # 读入一个整数

a,b,c=map(int,input().split()) # 读入三个整数, 以空格分开

l=list(map(int,input().split())) # 读入一行长度不定的以空格分开的整数

# 筛[2,n]上的素数, 并将最大素因子存入mpf数组中,素数存入数组prime中
maxn=1000005
mpf=[0]*maxn
prime=[0]*maxn
isv=[0]*maxn
cnt=0
for i in range(2,n+1):
    if isv[i]==0:
        prime[cnt]=i
        cnt+=1
        mpf[i]=i
    j=0
    while j<cnt and i*prime[j]<=n:
        num=i*prime[j]
        isv[i*prime[j]]=1
        mpf[num]=max(mpf[i],prime[j])
        if i%prime[j]==0:
            break
        j+=1

#返回[d,x,y],其中d为a和b的最大公约数,(x,y)为ax+by=d中的(x,y)
def exgcd(a,b): 
    x,y=-1,-1
    if a==0 and b==0:
        return [-1,x,y] #无最大公约数
    if b==0:
        return [a,1,0]
    d,y,x=map(int,exgcd(b,a%b))
    y-=a//b*x
    return [d,x,y]
#求逆元
def mod_inverse(a,n){
    x,y=0,0
    d,x,y=map(int,exgcd(a,n))
    if d==1:
    	return (x%n+n)%n
    else:
    	return -1
}

def pow_m(a,n,M):
    ret=1
    tmp=a%M
    while n!=0:
        if n&1:
            ret=(ret*tmp)%M
        tmp=tmp*tmp%M
        n>>=1
    return ret

# 顶点个数最多为 maxn
e=[[]for i in range(maxn)]
# 每次append一个二元组[wgt,nxt]， 表示边权和该边的终点

def dij(e,s): #e为邻接表
    dis=defaultdict(lambda:float("inf"))
    dis[s]=0
    q=[(0,s)]
    isv=set()
    while q:
        _,u=heapq.heappop(q) #弹出元素后第一个值丢弃，第二个值(顶点)赋值给u
        if u in isv:
            continue
    isv.add(u)
    for v,w in e[u]:
        if dis[v]>dis[u]+w:
            dis[v]=dis[u]+w
            heapq.heappush(q,(dis[v],v))
    return dis

def prim():
    q=[(0,1)] #以1作为起点,与dij不同的是,这里的第一个分量表示边权
    isv=set()
    tot=0 #总边权
    while q:
        w,u=heapq.heappop(q)
        if u in isv:
            continue
        tot+=w
        isv.add(u)
        if len(isv)==n:
            break
        for s,t in e[u]:
            if s not in isv:
                heapq.heappush(q,(t,s))
     return tot

e=[[0,0,0]for i in range(maxn)] #前两个元素为边的端点，后两个元素为边权
def find(x):
    if fa[x]==x:
        return x
    else:
        fa[x]=find(fa[x])
        return fa[x]
def union(x,y):
    fa[find(x)]=find(y)
def kruskal():
    cnt=0
    tot=0
    e.sort(key=lambda x:x[2]) #根据边权排序
    for i in e:
        v=find(i[0])
        u=find(i[1])
        if u!=v:
            cnt+=1
            tot+=i[2]
            fa[u]=v
            if cnt>=n-1:
                break
    return tot

# 队列
from collections import deque # 双向队列，可以做到O(1)地在队首和队尾插入和弹出元素

def find(x): #x所在集合的代表元
    if fa[x]==x:
        return x
    else:
        fa[x]=find(fa[x])
        return fa[x]
def union(x,y): #合并x,y
    fa[find(x)]=find(y) #令x所在集合的代表元的fa等于y所在集合的代表元