using System;
using System.Collections.Generic;
using System.Text;
using System.Numerics;
using System.IO;

namespace SolutionCS
{
    class Program
    {
        public class TestElem : IComparable
        {
            public int indA;
            public int indB;
            public int indC;
            public long value;

            public TestElem(int a, int b, int c, long v)
            {
                indA = a;
                indB = b;
                indC = c;

                value = v;
            }


            public int CompareTo(object obj)
            {
                TestElem other = (TestElem)obj;

                return -value.CompareTo(other.value);
            }
        }


        // 昇順のPriorityQueue
        // 降順にしたい場合はTのCompareToの符号を反転させる
        public class PriorityQueue<T> where T : IComparable
        {
            T[] heap;
            int count = 0;
            bool ascend = true;
            T tail;

            public PriorityQueue(int maxSize, bool ascend = true)
            {
                heap = new T[maxSize];
                count = 0;
                this.ascend = ascend;
            }

            private int Compare(T e0, T e1)
            {
                if (!ascend)
                {
                    return e0.CompareTo(e1);
                }

                return e1.CompareTo(e0);
            }

            public void Push(T elem)
            {
                // 要素をPushするインデックス(枝の末尾部分)
                int i = count;

                // 要素数を増やす
                count++;

                // 親(i=0)に向かってたどる
                while (i > 0)
                {
                    // 親のインデックス
                    int p = (i - 1) / 2;

                    // elemのほうが大きいか同一の場合、Pushするインデックス確定
                    if (Compare(heap[p],elem) <= 0)
                    {
                        break;
                    }

                    // 親→子にコピーして再度親との比較を行う
                    heap[i] = heap[p];
                    i = p;
                }

                // 要素を決まったインデックスに入れる
                heap[i] = elem;
            }

            public T Pop()
            {
                // 要素なしの場合、Exception
                if (count == 0)
                {
                    throw new InvalidOperationException();
                }

                // 要素数減らす
                count--;

                // 返す要素を保存
                T result = heap[0];

                // 一番末端の要素(これを親から比較して配列に配置する)
                T x = heap[count];

                // 親から末尾に向かって子→親入れ替えを行う
                int i = 0;
                while (i * 2 + 1 < count)
                {
                    int l = i * 2 + 1;      // 子の左枝のインデックス
                    int r = i * 2 + 2;      // 子の右枝のインデックス

                    // 右が範囲外ではない、右のほうが小さいか検証
                    if (r < count && Compare(heap[r],heap[l]) < 0)
                    {
                        // 右のほうが小さい場合、上に上がっていくのは右のインデックス
                        l = r;
                    }

                    // x(配列の一番最後の要素)と比べて、大きければおわり
                    if (Compare(heap[l],x) >= 0)
                    {
                        break;
                    }

                    // 一個親側に繰り上げ
                    heap[i] = heap[l];

                    // 処理した枝のインデックスを与え、再度入れ替え
                    i = l;
                }

                // 一番末尾の要素を新たに保存
                heap[i] = x;

                // 最初に保存していた結果を返す
                return result;
            }

            public int Count { get { return count; } }
            public T Peek { get { return heap[0]; } }
        }

        class Done : IComparable<Done>
        {
            int a;
            int b;
            int c;

            public Done(int a,int b, int c)
            {
                this.a = a;
                this.b = b;
                this.c = c;
            }

            public int CompareTo(Done e)
            {
                int ret = a.CompareTo(e.a);

                if(0 == ret)
                {
                    ret = b.CompareTo(e.b);

                    if(0==ret)
                    {
                        ret = c.CompareTo(e.c);
                    }
                }

                return ret;
            }
        }



        static void Main(string[] args)
        {
            string[] s = Console.ReadLine().Split(' ');

            int X = int.Parse(s[0]);
            int Y = int.Parse(s[1]);
            int Z = int.Parse(s[2]);
            int K = int.Parse(s[3]);

            long[] a = new long[X];
            long[] b = new long[Y];
            long[] c = new long[Z];

            s = Console.ReadLine().Split(' ');
            for (int i = 0; i < X; i++)
            {
                a[i] = long.Parse(s[i]);
            }
            s = Console.ReadLine().Split(' ');
            for (int i = 0; i < Y; i++)
            {
                b[i] = long.Parse(s[i]);
            }
            s = Console.ReadLine().Split(' ');
            for (int i = 0; i < Z; i++)
            {
                c[i] = long.Parse(s[i]);
            }
            Array.Sort(a);
            Array.Sort(b);
            Array.Sort(c);
            Array.Reverse(a);
            Array.Reverse(b);
            Array.Reverse(c);

            int indA = 0;
            int indB = 0;
            int indC = 0;
            PriorityQueue<TestElem> pq = new PriorityQueue<TestElem>(6000, false);

            pq.Push(new TestElem(indA, indB, indC, a[indA] + b[indB] + c[indC]));

            List<Done> dList = new List<Done>();

            int count = 0;
            while (pq.Count > 0)
            {
                TestElem e = pq.Pop();
                Console.WriteLine(e.value);

                count++;
                if(count >= K)
                {
                    break;
                }

                indA = e.indA;
                indB = e.indB;
                indC = e.indC;

                Done d;
                if (indA + 1 < X)
                {
                    d = new Done(indA + 1, indB, indC);

                    int ret = dList.BinarySearch(d);
                    if(ret < 0)
                    {
                        pq.Push(new TestElem(indA + 1, indB, indC, a[indA + 1] + b[indB] + c[indC]));
                        dList.Insert(-ret -1, d);
                    }
                }
                if (indB + 1 < Y)
                {
                    d = new Done(indA, indB + 1, indC);

                    int ret = dList.BinarySearch(d);
                    if (ret < 0)
                    {
                        pq.Push(new TestElem(indA, indB + 1, indC, a[indA] + b[indB + 1] + c[indC]));
                        dList.Insert(-ret -1, d);
                    }
                }
                if (indC + 1 < Y)
                {
                    d = new Done(indA, indB, indC + 1);

                    int ret = dList.BinarySearch(d);
                    if (ret < 0)
                    {
                        pq.Push(new TestElem(indA, indB, indC + 1, a[indA] + b[indB] + c[indC + 1]));
                        dList.Insert(-ret-1, d);
                    }
                }
            }
        }
    }
}



Measured memory_bytes: 13792