#include <iostream>
#include <fstream>
#include <vector>

#define NMax 17
#define Infinit 1000000000

using namespace std;

ifstream fin ("zebughil.in");
ofstream fout ("zebughil.out");

int N, GMax, G[NMax], Best[1<<NMax][NMax];
vector <int> Stare[1<<NMax];

void Initialize ()
{
    int n=(1<<NMax);
    for (int i=0; i<n; ++i)
    {
        for (int j=0; j<NMax; ++j)
        {
            if (!(i&(1<<j)))
            {
                Stare[i].push_back (j);
            }
        }
    }
}

int main()
{
    Initialize ();
    for (int T=0; T<3; ++T)
    {
        fin >> N >> GMax;
        for (int i=0; i<N; ++i)
        {
            fin >> G[i];
        }
        int n=(1<<N);
        /*for (int i=1; i<n; ++i)
        {
            Best[i]=Infinit;
            int MaxSubM=(1<<Stare[i].size ());
            for (int SubM=0; SubM<MaxSubM; ++SubM)
            {
                int NBlocuri=Stare[SubM].size ();
                int GCurent=0, SubM2=i;
                for (int j=0; j<NBlocuri; ++j)
                {
                    int Bloc=Stare[i][Stare[SubM][j]];
                    GCurent+=G[Bloc];
                    SubM2^=(1<<Bloc);
                }
                if (GCurent<=GMax)
                {
                    Best[i]=min (Best[i], Best[SubM2]+1);
                }
            }
        }
        fout << Best[n-1] << "\n";*/
        for (int i=0; i<n; ++i)
        {
            for (int j=1; j<=N; ++j)
            {
                Best[i][j]=-1;
            }
        }
        Best[0][1]=GMax;
        for (int i=0; i<n; ++i)
        {
            for (int j=1; j<=N; ++j)
            {
                if (Best[i][j]==-1)
                {
                    continue;
                }
                int NBlocuri=Stare[i].size ();
                for (int k=0; k<NBlocuri; ++k)
                {
                    int Bloc=Stare[i][k];
                    int ii=(i|(1<<Bloc));
                    if (G[Bloc]>Best[i][j])
                    {
                        Best[ii][j+1]=max (Best[ii][j+1], GMax-G[k]);
                    }
                    else
                    {
                        Best[ii][j]=max (Best[ii][j], Best[i][j]-G[k]);
                    }
                }
            }
        }
        --n;
        for (int i=1; i<=N; ++i)
        {
            if (Best[n][i]!=-1)
            {
                fout << i << "\n";
                break;
            }
        }
    }
    fin.close ();
    fout.close ();
    return 0;
}