using System;
using System.Collections.Generic;
using System.Linq;

namespace abc123
{
    class ProgramD
    {
        public int K;
        public long[] A;
        public long[] B;
        public long[] C;

        static void Main(string[] args)
        {
            var program = new ProgramD();
            program.InitializeByConsole();
            // program.InitializeSample3();

            var outputs = program.GetOutput();

            foreach (var output in outputs)
            {
                Console.WriteLine(output);
            }
        }

        public void InitializeByConsole()
        {
            var nums = Console.ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();

            this.K = nums[3];
            this.A = Console.ReadLine().Split(' ').Select(s => long.Parse(s)).ToArray();
            this.B = Console.ReadLine().Split(' ').Select(s => long.Parse(s)).ToArray();
            this.C = Console.ReadLine().Split(' ').Select(s => long.Parse(s)).ToArray();
        }

        private static int GenIndexHash(int indexA, int indexB, int indexC)
        {
            return (indexA << 20) + (indexB << 10) + indexC;
        }

        private IEnumerable<long> GetOutput()
        {
            Array.Sort(this.A);
            Array.Sort(this.B);
            Array.Sort(this.C);

            Array.Reverse(this.A);
            Array.Reverse(this.B);
            Array.Reverse(this.C);

            var numa = Math.Min(this.K, this.A.Length);
            var numb = Math.Min(this.K, this.B.Length);
            var numc = Math.Min(this.K, this.C.Length);

            var abcIndexSet = new HashSet<int>();
            var abcQueue = new PriorityQueue<AbcSet>(new AbcTotalComparer());

            abcQueue.Enqueue(new AbcSet(0, 0, 0, this.A[0] + this.B[0] + this.C[0]));
            abcIndexSet.Add(GenIndexHash(0, 0, 0));
            var answers = new List<long>();

            while (true)
            {
                if (abcQueue.Count == 0)
                {
                    break;
                }

                var abc = abcQueue.Dequeue();
                if (answers.Count >= this.K)
                {
                    break;
                }

                answers.Add(abc.Result);

                if (abc.IndexA != numa - 1)
                {
                    Do(abc.IndexA + 1, abc.IndexB, abc.IndexC, abcQueue, abcIndexSet);
                }
                if (abc.IndexB != numb - 1)
                {
                    Do(abc.IndexA, abc.IndexB + 1, abc.IndexC, abcQueue, abcIndexSet);
                }
                if (abc.IndexC != numc - 1)
                {
                    Do(abc.IndexA, abc.IndexB, abc.IndexC + 1, abcQueue, abcIndexSet);
                }
            }

            return answers;
        }

        void Do(int ai, int bi, int ci, PriorityQueue<AbcSet> abcQueue, HashSet<int> abcIndexSet)
        {
            var hash = GenIndexHash(ai, bi, ci);
            if (abcIndexSet.Contains(hash))
            {
                return;
            }

            abcIndexSet.Add(hash);
            var total = this.A[ai] + this.B[bi] + this.C[ci];
            abcQueue.Enqueue(new AbcSet(ai, bi, ci, total));
        }

        public void InitializeSample1()
        {
            this.K = 8;
            this.A = new long[] {4, 6};
            this.B = new long[] {1, 5};
            this.C = new long[] {3, 8};
        }

        public void InitializeSample2()
        {
            this.K = 5;
            this.A = new long[] {1, 10, 100};
            this.B = new long[] {2, 20, 200};
            this.C = new long[] {1, 10, 100};
        }

        public void InitializeSample3()
        {
            this.K = 20;
            this.A = new[] {7467038376, 5724769290, 292794712, 2843504496, 3381970101, 8402252870, 249131806, 6310293640, 6690322794, 6082257488};
            this.B = new[] {1873977926, 2576529623, 1144842195, 1379118507, 6003234687, 4925540914, 3902539811, 3326692703, 484657758, 2877436338};
            this.C = new[] {4975681328, 8974383988, 2882263257, 7690203955, 514305523, 6679823484, 4263279310, 585966808, 3752282379, 620585736};
        }
    }

    public class AbcTotalComparer : IComparer<AbcSet>
    {
        public int Compare(AbcSet x, AbcSet y)
        {
            return y.Result.CompareTo(x.Result);
            var a = x.IndexA.CompareTo(y.IndexA);
            if (a != 0) return a;

            var b = x.IndexB.CompareTo(y.IndexB);
            if (b != 0) return b;

            return x.IndexC.CompareTo(y.IndexC);
        }
    }
    public struct AbcSet : IComparable<AbcSet>
    {
        public AbcSet(int indexA, int indexB, int indexC, long result)
        {
            IndexA = indexA;
            IndexB = indexB;
            IndexC = indexC;
            Result = result;
        }

        public int IndexA { get; }
        public int IndexB { get; }
        public int IndexC { get; }
        public long Result { get; }

        public int CompareTo(AbcSet other)
        {
            return this.Result.CompareTo(other.Result);
        }
    }

    #region PriorityQueue
    /// <summary>
    /// 指定した型のインスタンスを最も価値が低い順に取り出すことが可能な可変サイズのコレクションを表します．
    /// </summary>
    /// <typeparam name="T">優先度付きキュー内の要素の型を指定します．</typeparam>
    /// <remarks>内部的にはバイナリヒープによって実装されています．</remarks>
    public class PriorityQueue<T>
    {
        readonly List<T> heap = new List<T>();
        readonly Comparison<T> cmp;

        /// <summary>
        /// デフォルトの比較子を使用してインスタンスを初期化します．
        /// </summary>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public PriorityQueue() { cmp = Comparer<T>.Default.Compare; }

        /// <summary>
        /// デリゲートで表されるような比較関数を使用してインスタンスを初期化します．
        /// </summary>
        /// <param name="comparison"></param>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public PriorityQueue(Comparison<T> comparison) { cmp = comparison; }

        /// <summary>
        /// 指定された比較子を使用してインスタンスを初期化します．
        /// </summary>
        /// <param name="comparer"></param>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public PriorityQueue(IComparer<T> comparer) { cmp = comparer.Compare; }

        /// <summary>
        /// 優先度付きキューに要素を追加します．
        /// </summary>
        /// <param name="item">優先度付きキューに追加される要素</param>
        /// <remarks>最悪計算量 O(log N) で実行されます．</remarks>
        public void Enqueue(T item)
        {
            var pos = heap.Count;
            heap.Add(item);
            while (pos > 0)
            {
                var par = (pos - 1) / 2;
                if (cmp(heap[par], item) <= 0)
                    break;
                heap[pos] = heap[par];
                pos = par;
            }
            heap[pos] = item;

        }

        /// <summary>
        /// 優先度付きキューから最も価値が低い要素を削除し，返します．
        /// </summary>
        /// <returns>優先度付きキューから削除された要素．</returns>
        /// <remarks>最悪計算量 O(log N) で実行されます．</remarks>
        public T Dequeue()
        {
            var ret = heap[0];
            var pos = 0;
            var x = heap[heap.Count - 1];

            while (pos * 2 + 1 < heap.Count - 1)
            {
                var lch = pos * 2 + 1;
                var rch = pos * 2 + 2;
                if (rch < heap.Count - 1 && cmp(heap[rch], heap[lch]) < 0) lch = rch;
                if (cmp(heap[lch], x) >= 0)
                    break;
                heap[pos] = heap[lch];
                pos = lch;
            }
            heap[pos] = x;
            heap.RemoveAt(heap.Count - 1);
            return ret;

        }
        /// <summary>
        ///  優先度付きキューに含まれる最も価値が低い要素を削除せずに返します．
        /// </summary>
        /// <returns>優先度付きキューに含まれる最も価値が低い要素．</returns>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public T Peek() { return heap[0]; }

        /// <summary>
        /// 優先度付きキュー内の要素の数を取得します．
        /// </summary>
        /// <returns>優先度付キュー内にある要素の数</returns>
        /// <remarks>最悪計算量 O(1) で実行されます．</remarks>
        public int Count { get { return heap.Count; } }
        /// <summary>
        /// 優先度付きキュー内に要素が存在するかどうかを O(1) で判定します．
        /// </summary>
        /// <returns>優先度付キュー内にある要素が存在するならば true，そうでなければ　false．</returns>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public bool Any() { return heap.Count > 0; }

        /// <summary>
        /// 優先度付きキューに含まれる要素を昇順に並べて返します．
        /// </summary>
        /// <remarks>この操作は計算量 O(N log N)で実行されます．</remarks>
        public T[] Items
        {
            get
            {
                var ret = heap.ToArray();
                Array.Sort(ret, cmp);
                return ret;
            }
        }
    }
    #endregion
}


Measured memory_bytes: 14560