#include "bits/stdc++.h"
using namespace std;

#define say(obj) (cout << (obj) << endl)
#define endline (cout << endl)
#define all(container) container.begin(), container.end()
#define sortall(container) (sort(container.begin(), container.end()))
#define yn(cond) ((cond) ? (cout << "yes" << endl) : (cout << "no" << endl))
#define Yn(cond) ((cond) ? (cout << "Yes" << endl) : (cout << "No" << endl))
#define YN(cond) ((cond) ? (cout << "YES" << endl) : (cout << "NO" << endl))

typedef long long       ll;

typedef vector<int>     vi;
typedef vector<ll>      vll;
typedef vector<double>  vd;
typedef vector<bool>    vb;
typedef vector<char>    vc;
typedef vector<string>  vs;
typedef pair<int, int>  pii;
typedef pair<ll, ll>    pll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvll;
typedef vector<vd>		vvd;
typedef vector<vb>		vvb;
typedef vector<vc>		vvc;
typedef vector<vs>		vvs;
typedef vector<pii>     vpii;
typedef vector<pll>     vpll;

typedef struct edge_ {
	ll to, cost;
	edge_(ll to, ll cost) : to(to), cost(cost) {}
} edge;

typedef struct point_ {
	ll x, y;
	point_(ll x = 0, ll y = 0) : x(x), y(y) {}
} point;

template <typename T>
using mat2d = vector<vector<T>>;

constexpr double	PI = 3.14159265358979323846;
constexpr int		INF = (int)1e7;
constexpr ll		MOD = (ll)1e9 + 7;
constexpr double	EPS = 1e-7;
constexpr int		dy4[4] = { 0, 1, 0, -1 };
constexpr int		dx4[4] = { 1, 0, -1, 0 };
constexpr int		dy8[8] = { 0, 1, 1, 1, 0, -1, -1, -1 };
constexpr int		dx8[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };

template <typename T>
T getSum(std::vector<T>& v) {
	T ret = 0;
	for (T& x : v) ret += x;
	return ret;
}

template <typename T>
istream& operator >> (istream& is, vector<T>& vec) {
	for (T& x : vec) is >> x;
	return is;
}

template <typename T>
ostream& operator << (ostream& os, const vector<T>& vec) {
	for (const T& x : vec) os << x << " ";
	return os;
}

template <typename T>
ostream& operator << (ostream& os, const vector<vector<T>>& mat) {
	for (const vector<T>& m : mat) os << m << endl;
	return os;
}

template <typename S, typename T>
istream& operator >> (istream& is, pair<S, T>& p) {
	is >> p.first >> p.second;
	return is;
}

istream& operator >> (istream& is, point& p) {
	is >> p.x >> p.y;
	return is;
}

template <typename S, typename T>
ostream& operator << (ostream& os, const pair<S, T>& p) {
	os << "{" << p.first << " : " << p.second << "}";
	return os;
}

template <typename T>
ostream& operator << (ostream& os, const set<T>& s) {
	for (const T& x : s) os << x << " ";
	return os;
}

ostream& operator << (ostream& os, const edge e) {
	os << "{to: " << e.to << ", cost: " << e.cost << "}";
	return os;
}

ostream& operator << (ostream& os, const point& p) {
	os << "(" << p.x << " " << p.y << ")";
	return os;
}

/******************************************************************************/
/**********************         Don't make WA !!         **********************/
/******************************************************************************/

struct int3 {
	int i, j, k;
	int3(int _i, int _j, int _k) : i(_i), j(_j), k(_k) {}
};

int main()
{
	ll X, Y, Z, K;
	cin >> X >> Y >> Z >> K;
	vll A(X), B(Y), C(Z);
	cin >> A >> B >> C;

	sort(all(A), greater<ll>());
	sort(all(B), greater<ll>());
	sort(all(C), greater<ll>());

	vector<vvb> isUsed(X, vvb(Y, vb(Z, false)));
	vll ans;
	vector<int3> idx;
	int i, j, k;
	i = j = k = 0;
	for (int KK = 0; KK < K; KK++) {
		if (!isUsed[i][j][k]) {
			isUsed[i][j][k] = true;
			ans.push_back(A[i] + B[j] + C[k]);
			idx.push_back(int3(i, j, k));
		}
		else {
			ll ans_tmp = -1;
			int3 ansidx(0, 0, 0);
			for (int l = 0; l < ans.size(); l++) {
				ll tmp1, tmp2, tmp3;
				tmp1 = idx[l].i + 1 < X ? ans[l] - A[idx[l].i] + A[idx[l].i + 1] : LLONG_MIN;
				tmp2 = idx[l].j + 1 < Y ? ans[l] - B[idx[l].j] + B[idx[l].j + 1] : LLONG_MIN;
				tmp3 = idx[l].k + 1 < Z ? ans[l] - C[idx[l].k] + C[idx[l].k + 1] : LLONG_MIN;
				if (ans_tmp < tmp1 && !isUsed[idx[l].i + 1][idx[l].j][idx[l].k]) {
					ans_tmp = tmp1;
					ansidx.i = idx[l].i + 1;
					ansidx.j = idx[l].j;
					ansidx.k = idx[l].k;
				}
				if (ans_tmp < tmp2 && !isUsed[idx[l].i][idx[l].j + 1][idx[l].k]) {
					ans_tmp = tmp2;
					ansidx.i = idx[l].i;
					ansidx.j = idx[l].j + 1;
					ansidx.k = idx[l].k;
				}
				if (ans_tmp < tmp3 && !isUsed[idx[l].i][idx[l].j][idx[l].k + 1]) {
					ans_tmp = tmp3;
					ansidx.i = idx[l].i;
					ansidx.j = idx[l].j;
					ansidx.k = idx[l].k + 1;
				}
			}
			ans.push_back(ans_tmp);
			idx.push_back(ansidx);
			isUsed[ansidx.i][ansidx.j][ansidx.k] = true;
		}
	}

	for (int i = 0; i < K; i++)
		say(ans[i]);

	return 0;
}

Measured memory_bytes: 180224