#include <iostream>

using namespace std;

struct Tile
{
    int hodnota;
    int cetnost;
};

void swapIt(Tile * pole,int left,int right)
{
    int hodnotaTmp = pole[right].hodnota;
    int cetnostTmp = pole[right].cetnost;
    pole[right].hodnota=pole[left].hodnota;
    pole[right].cetnost=pole[left].cetnost;
    pole[left].hodnota=hodnotaTmp;
    pole[left].cetnost=cetnostTmp;
}

void quicksortTile(Tile * pole,int left,int right)
{
    if(left<right)
    {
        int bound=left;
        for(int i=left+1;i<right;i++)
        {
            if(pole[i].hodnota<pole[left].hodnota)
            {
                swapIt(pole,i,++bound);
            }
        }
        swapIt(pole,left,bound);
        quicksortTile(pole,left,bound);
        quicksortTile(pole,bound+1,right);
    }
}

Tile* phase(int pocetVstupu,Tile* predchoziPole,int * delkaPredchozihoPole,int limit)
{
    Tile *resultPole=new Tile[pocetVstupu*(*delkaPredchozihoPole)];
    int index=0;
    for(int i=0;i<pocetVstupu;i++)
    {
        int vstup;
        cin>>vstup;
        for(int j=0;j<(*delkaPredchozihoPole);j++)
        {
            if(vstup+predchoziPole[j].hodnota>limit)
            {
                break;
            }
            else
            {
                resultPole[index].hodnota=vstup+predchoziPole[j].hodnota;
                resultPole[index].cetnost=predchoziPole[j].cetnost;
                index++;
            }
        }
    }
    quicksortTile(resultPole,0,index);
    //Ykondenyovanipole
    Tile *condenPole=new Tile[index];
    int indexCond=0;
    condenPole[indexCond].hodnota=resultPole[0].hodnota;
    condenPole[indexCond].cetnost=resultPole[0].cetnost;
    indexCond++;
    for(int i=1;i<index;i++)
    {
        if(resultPole[i].hodnota==condenPole[indexCond-1].hodnota)
        {
            //Duplicita
            condenPole[indexCond-1].cetnost+=resultPole[i].cetnost;
        }
        else
        {
            //Vytvarime novy zaznam
            condenPole[indexCond].hodnota=resultPole[i].hodnota;
            condenPole[indexCond].cetnost=resultPole[i].cetnost;
            indexCond++;
        }
    }
    //Navrat
    //delete []resultPole;
    *delkaPredchozihoPole=indexCond;
    return condenPole;
}


int main(void)
{
    while(true)
    {
        int L,S,M,D,B;
        cin>>L>>S>>M>>D>>B;
        if(L==0)
        {
            return 0;
        }
        Tile * prvniPole=new Tile[1];
        prvniPole[0].hodnota=0;
        prvniPole[0].cetnost=1;
        int delkaPredchozihoPole=1;

        long long result=0;
        prvniPole=phase(S,prvniPole,&delkaPredchozihoPole,L);
        /*cout<<"nacitame cetnost delka je: "<<delkaPredchozihoPole<<endl;*/
                if (delkaPredchozihoPole==0)
                {
                    cout<<0<<endl;
                    continue;
                }
        //cout<<result<<endl;
        prvniPole=phase(M,prvniPole,&delkaPredchozihoPole,L);
                if (delkaPredchozihoPole==0)
                {
                    cout<<0<<endl;
                    continue;
                }
        //cout<<result<<endl;
        prvniPole=phase(D,prvniPole,&delkaPredchozihoPole,L);
                                if (delkaPredchozihoPole==0)
                {
                    cout<<0<<endl;
                    continue;
                }
        //cout<<result<<endl;
        prvniPole=phase(B,prvniPole,&delkaPredchozihoPole,L);


        for (int i=0;i<delkaPredchozihoPole;i++)
        {
            result+=prvniPole[i].cetnost;
        }
        cout<<result<<endl;

    }


    return 0;
}