//#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <vector>

namespace n91 {

	using i8 = std::int_least8_t;
	using i32 = std::int_least32_t;
	using i64 = std::int_least64_t;
	using u8 = std::uint_least8_t;
	using u32 = std::uint_least32_t;
	using u64 = std::uint_least64_t;
	using isize = std::ptrdiff_t;
	using usize = std::size_t;

	class rep {
		const usize f, l;

	public:
		class itr {
			friend rep;
			usize i;
			constexpr itr(const usize x) noexcept : i(x) {}

		public:
			void operator++() noexcept { ++i; }
			constexpr usize operator*() const noexcept { return i; }
			constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
		};
		constexpr rep(const usize first, const usize last) noexcept
			: f(first), l(last) {}
		constexpr itr begin() const noexcept { return itr(f); }
		constexpr itr end() const noexcept { return itr(l); }
	};
	class revrep {
		const usize f, l;

	public:
		class itr {
			friend revrep;
			usize i;
			constexpr itr(usize x) noexcept : i(x) {}

		public:
			void operator++() noexcept { --i; }
			constexpr usize operator*() const noexcept { return i; }
			constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
		};
		constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
		constexpr itr begin() const noexcept { return itr(l); }
		constexpr itr end() const noexcept { return itr(f); }
	};
	template <class T> using vec_alias = std::vector<T>;
	template <class T> auto md_vec(const usize n, const T &value) {
		return std::vector<T>(n, value);
	}
	template <class... Args> auto md_vec(const usize n, Args... args) {
		return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
	}
	template <class T> constexpr T difference(const T &a, const T &b) {
		return a < b ? b - a : a - b;
	}

} // namespace n91

#include <algorithm>
#include <array>
#include <iostream>
#include <set>
#include <utility>

namespace n91 {

	void main_() {
		usize x, y, z, k;
		std::cin >> x >> y >> z >> k;
		std::vector<u64> a(x), b(y), c(z);
		for (auto &e : a) {
			std::cin >> e;
		}
		for (auto &e : b) {
			std::cin >> e;
		}
		for (auto &e : c) {
			std::cin >> e;
		}

		std::sort(a.rbegin(), a.rend());
		std::sort(b.rbegin(), b.rend());
		std::sort(c.rbegin(), c.rend());

		struct prog {
			usize i, j, k;
		};
		const auto eval = [&](const prog &e) noexcept {
			return a[e.i] + b[e.j] + c[e.k];
		};
		const auto comp = [&](const prog &l, const prog &r) noexcept {
			if (eval(l) != eval(r)) {
				return eval(r) < eval(l);
			}
			else if (l.i != r.i) {
				return l.i < r.i;
			}
			else if (l.j != r.j) {
				return l.j < r.j;
			}
			else {
				return l.k < r.k;
			}
		};

		std::set<prog, decltype(comp)> set(comp);
		set.insert({ 0, 0, 0 });
		while (k--) {
			const auto itr = set.begin();
			std::cout << eval(*itr) << std::endl;
			if (itr->i + 1 != x) {
				set.insert({ itr->i + 1, itr->j, itr->k });
			}
			if (itr->j + 1 != y) {
				set.insert({ itr->i, itr->j + 1, itr->k });
			}
			if (itr->k + 1 != z) {
				set.insert({ itr->i, itr->j, itr->k + 1 });
			}
			set.erase(itr);
		}
	}

} // namespace n91

int main() {
	n91::main_();
	return 0;
}


Measured memory_bytes: 512