void main()
{
    long x, y, z, k;
    rdVals(x, y, z, k);
    long[] a = rdRow;
    long[] b = rdRow;
    long[] c = rdRow;

    a.sort!"a > b";
    b.sort!"a > b";
    c.sort!"a > b";

    auto que = new BinaryHeap!(Array!Cake, "a.t > b.t")();
    foreach (i; 0 .. k)
    {
        que.insert(Cake(0, 0, 0));
    }

    foreach (u; 0 .. x)
    {
        foreach (v; 0 .. y)
        {
            if (u * v > k) break;
            foreach (w; 0 .. z)
            {
                if (u * v * w > k) break;
                Cake cake = Cake(a[u], b[v], c[w]);
                if (que.front.t < cake.t)
                {
                    que.popFront;
                    que.insert(cake);
                }
            }
        }
    }

    long[] results = new long[k];
    while (!que.empty)
    {
        results[que.length-1] = que.front.t;
        que.popFront;
    }

    foreach (r; results)
    {
        r.writeln;
    }
}

struct Cake
{
    long a, b, c, t;

    this(long a, long b, long c)
    {
        this.a = a, this.b = b, this.c = c;
        t = a + b + c;
    }
}

enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;

T rdElem(T = long)()
if (!is(T == struct))
{
    return readln.chomp.to!T;
}

alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);

T rdElem(T)()
if (is(T == struct))
{
    T result;
    string[] input = rdRow!string;
    assert(T.tupleof.length == input.length);
    foreach (i, ref x; result.tupleof)
    {
        x = input[i].to!(typeof(x));
    }
    return result;
}

T[] rdRow(T = long)()
{
    return readln.split.to!(T[]);
}

T[] rdCol(T = long)(long col)
{
    return iota(col).map!(x => rdElem!T).array;
}

T[][] rdMat(T = long)(long col)
{
    return iota(col).map!(x => rdRow!T).array;
}

void rdVals(T...)(ref T data)
{
    string[] input = rdRow!string;
    assert(data.length == input.length);
    foreach (i, ref x; data)
    {
        x = input[i].to!(typeof(x));
    }
}

void wrMat(T = long)(T[][] mat)
{
    foreach (row; mat)
    {
        foreach (j, compo; row)
        {
            compo.write;
            if (j == row.length - 1) writeln;
            else " ".write;
        }
    }
}

import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.traits;
import std.container;
import std.functional;
import std.typecons;
import std.ascii;
import std.uni;