#include <bits/stdc++.h>
#define SYN ios_base::sync_with_stdio(0);cin.tie(0);
using namespace std;
/***************************************************************************************************************************************/
typedef long long int LLI;
typedef unsigned long long int ULLI;
#define IMAX ((unsigned)1<<31)-1
#define eps 1e-11
#define LIMAX (1LL<<63)-1
#define ULIMAX (1LL<<64)-1
#define UIMAX ((LLI)1<<32)-1
#define MP(X,Y) make_pair(X,Y)

#define REP(i,n) for(int i=0;i<n;i++)
#define DREP(i,n) for(int i=n;i>=0;i--)
#define LREP(i,a,b) for(int i=a;i<=b;i++)
#define DLREP(i,a,b) for(int i=a;i>=b;i--)
#define FOR(i,a,b,c) for(int i=a;i<=b;i+=c)

#define fill(a,v) memset(a,v,sizeof(a))
#define DEBUG(x) cout << #x << ": " << x << endl;
#define SZ(X) ((int)X.size())
#define all(x) (x).begin(),(x).end()
#define SORT(x) sort(all(x))
#define VI vector<int>
#define VS vector<string>
#define PB push_back
#define REV(a) reverse(all(a))
typedef pair<int, int>PII;
typedef pair<LLI, LLI>PLL;
typedef pair<char, int>PCI;
typedef pair<int, char>PIC;
typedef pair<double, double>PDD;
#define MSI map<string,int>
#define MSLI map<string,LLI>
#define MCI map<char,int>
template<class T> inline T MIN_3(T a, T b, T c)
{
    return min(min(a, b), c);
}
template<class T> inline T MAX_3(T a, T b, T c)
{
    return max(max(a, b), c);
}
#define ACM(x) accumulate(all(x),0);
#define CAP(x,y,z) set_intersection (all(x), all(y), z.begin())
#define CUP(x,y,z) set_union(all(x),all(y),z.begin())
#define DIF(x,y,z) set_difference (all(x),all(y),z.begin());
#define BRPS(n,bit) bitset<bit>(n)
#define DSORT(X)  sort(X.rbegin(), X.rend());
#define read(x) freopen(#x".txt","r",stdin)
#define write(x) freopen(#x".txt","w",stdout)
#define LB(A, x) (lower_bound(all(A), x) - A.begin())//exactly where it starts
#define UB(A, x) (upper_bound(all(A), x) - A.begin())
#define UNQ(x) SORT(x),(x).erase(unique(all(x)),x.end())

template<class T> inline T BIGMOD(T n, T m, T mod)
{
    LLI ans = 1;
    LLI k = n;
    while(m)
    {
        if(m & 1)
        {
            ans *= k;
            if(ans>mod) ans %= mod;
        }
        k *= k;
        if(k>mod) k %= mod;
        m >>= 1;
    }
    return ans;
}


inline int DBLCMP(double a, double b)
{
    if(fabs(a - b) <= eps) return 0;
    if(a < b) return -1;
    return 1;
}
template<class T> inline T sqr(T x)
{
    return x*x;
}
template<class T> inline int countbit(T n)
{
    return (n == 0) ? 0 : (1 + countbit(n&(n - 1)));
}
template<class T> inline T euclide(T a, T b, T &x, T &y)
{
    if (a < 0)
    {
        T d = euclide(-a, b, x, y);
        x = -x;
        return d;
    }
    if (b < 0)
    {
        T d = euclide(a, -b, x, y);
        y = -y;
        return d;
    }
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    else
    {
        T d = euclide(b, a % b, x, y);
        T t = x;
        x = y;
        y = t - (a / b) * y;
        return d;
    }
}
template<class T> string toString(T n)
{
    ostringstream ost;
    ost << n;
    ost.flush();
    return ost.str();
}
template<class T> string toBinary(T n)
{
    string ret="";
    while(n)
    {
        if(n%2==1)ret+='1';
        else ret+='0';
        n>>=1;
    }
    reverse(ret.begin(),ret.end());
    return ret;
}
void combination(int n,vector< vector<int> > &ret)
{
    ret.resize(n+1, vector<int>(n+1, 0));
    for(int i=1; i<=n; i++)
    {
        ret[i][0]=ret[i][i]=1;
        for(int j=1; j<i; j++)
        {
            ret[i][j]=ret[i-1][j]+ret[i-1][j-1];
        }
    }
}
int toInt(string s)
{
    int r = 0;
    istringstream sin(s);
    sin >> r;
    return r;
}
LLI toLInt(string s)
{
    LLI r = 0;
    istringstream sin(s);
    sin >> r;
    return r;
}
double toDouble(string s)
{
    double r = 0;
    istringstream sin(s);
    sin >> r;
    return r;
}
vector<string> parse(string temp)
{
    vector<string> ans;
    ans.clear();
    string s;
    istringstream iss(temp);
    while (iss >> s)ans.PB(s);
    return ans;
}
template<class T> inline T gcd(T a, T b)
{
    if (a < 0)return gcd(-a, b);
    if (b < 0)return gcd(a, -b);
    return (b == 0) ? a : gcd(b, a % b);
}
template<class T> inline T lcm(T a, T b)
{
    if (a < 0)return lcm(-a, b);
    if (b < 0)return lcm(a, -b);
    return a*(b / gcd(a, b));
}
template<class T> inline T power(T b, T p)
{
    if (p < 0)return -1;
    if (b <= 0)return -2;
    if (!p)return 1;
    return b*power(b, p - 1);
}
#define fst first
#define snd second
//istringstream(temp) >> data >> value >> stamp;
//mod1 = 1000000007, mod2 = 1000000009;
//.016-.040-.900-2.48
/***************************************************************************************************************************************/

int m,n,t,l;
int I[30], A[30], L[30],O[30];
int T[30], Z[30] , V[30] ,C[30];

struct Z
{
    int can,eij,tij;
} info[30][30];

vector<PII>team[30];
bool ok(int mask)
{
    if(t==1)return true;
    REP(i,30)team[i].clear();
    for(int i=0; i<m; i++)
    {
        if(mask&(1<<i))
        {
            for(int j=0; j<t; j++)
            {
                if(info[i][j].can)
                {
                    team[j].PB(MP(info[i][j].eij,info[i][j].tij));
                }
            }
        }
    }
    int f=0;
    for(int i=0; i<t; i++)
    {
        if(!team[i].empty())
        {
            SORT(team[i]);
            f=1;
        }
    }
    if(!f)return true;
    int cc,csum,xc,xsum;
    cc=csum=xc=xsum=0;
    f=0;
    for(int i=0; i<t; i++)
    {

        cc=0,csum=0;
        for(int j=0; j<team[i].size(); j++)
        {
            cc++;
            csum+=team[i][j].fst;
        }
        //cout << i << " ->" << cc << " " << csum << " " << team[i].size() << endl;
        if(i==0)
        {
            xc=cc;
            xsum=csum;
        }
        else
        {
            if(cc>xc || (cc==xc && xsum>csum)){f=1;}
        }
    }
    if(f==1)return false;
    return true;
}
void show(int mask)
{
    bool f=true;
    for(int i=0; i<m; i++)
    {
        if(mask&(1<<i))
        {
            if(f)printf("%d",i+1);
            else printf(" %d",i+1);
            f=false;
        }
    }
    puts("");
}
int main()
{
    while(scanf("%d %d %d %d",&m,&n,&t,&l)==4)
    {
        fill(info,0);
        fill(I,0);
        fill(A,0);
        fill(L,0);
        fill(O,0);
        fill(T,0);
        fill(Z,0);
        fill(V,0);
        fill(C,0);

        //cout << "#" << endl;
        REP(i,m)scanf("%d %d %d %d",&I[i],&A[i],&L[i],&O[i]);
        REP(i,t)scanf("%d %d %d %d",&T[i],&Z[i],&V[i],&C[i]);
        for(int i=0; i<m; i++)
        {
            for(int j=0; j<t; j++)
            {

                info[i][j].eij= ceil((I[i]*1.0)/O[i]) + max((int)ceil((A[i]*1.0)/C[j]),5);
                info[i][j].tij=max(I[i]-T[j],0)+ceil((A[i]*1.0)/(Z[j]+C[j])) + ceil(L[i]*1.0/V[j]);
                info[i][j].can=((T[j]+C[j])>I[i]-O[i]) && (info[i][j].eij<=l);
            }
        }
        for(int i=1; i<(1<<m); i++)
        {
            if(__builtin_popcount(i)==n && ok(i))
            {
                show(i);
                break;
            }
            //cout << endl;
        }
    }
}