Buggy python submission (verdict: Time Limit Exceeded):
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq

def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)


used = [[[False] * Z for i in range(Y)] for j in range(X)]
l = []

heapq.heappush(l, make(0, 0, 0))
used[0][0][0] = True

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    
    if i < X - 1 and not used[i+1][j][k]:
        heapq.heappush(l, make(i+1, j, k))
        used[i+1][j][k] = True
    
    if j < Y - 1 and not used[i][j+1][k]:
        heapq.heappush(l, make(i, j+1, k))
        used[i][j+1][k] = True
    
    if k < Z - 1 and not used[i][j][k+1]:
        heapq.heappush(l, make(i, j, k+1))
        used[i][j][k+1] = True
    
    print(-V)




Fixed submission:
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq

def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)


used = set()
l = []

heapq.heappush(l, make(0, 0, 0))
used.add((0, 0, 0))

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    
    if i < X - 1 and (i+1, j, k) not in used:
        heapq.heappush(l, make(i+1, j, k))
        used.add((i+1, j, k))
    
    if j < Y - 1 and (i, j+1, k) not in used:
        heapq.heappush(l, make(i, j+1, k))
        used.add((i, j+1, k))
    
    if k < Z - 1 and (i, j, k+1) not in used:
        heapq.heappush(l, make(i, j, k+1))
        used.add((i, j, k+1))
    
    print(-V)

Buggy python submission (verdict: Time Limit Exceeded):
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq



def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)

# class flags:
#     def __init__(self, X, Y, Z):
#         self.ar = []
#         for k in range(X):
#             l = []
#             for j in range(Y):
#                 ll = []
#                 for i in range(Z):
#                     ll.append(False)
#                 l.append(ll)
#             self.ar.append(l)
        
#     def __getitem__(self, item):
#         return self.ar[item[0]][item[1]][item[2]]
    
#     def __setitem__(self, item, value):
#         self.ar[item[0]][item[1]][item[2]] = value
        

used = [[[False] * Z for i in range(Y)] for j in range(X)]

def push_next(l, i, j, k):
    if i < X - 1 and not used[i+1][j][k]:
        heapq.heappush(l, make(i+1, j, k))
        used[i+1][j][k] = True
    
    if j < Y - 1 and not used[i][j+1][k]:
        heapq.heappush(l, make(i, j+1, k))
        used[i][j+1][k] = True
    
    if k < Z - 1 and not used[i][j][k+1]:
        heapq.heappush(l, make(i, j, k+1))
        used[i][j][k+1] = True



l = []

heapq.heappush(l, make(0, 0, 0))
used[0][0][0] = True

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    push_next(l, i, j, k)
    
    print(-V)




Fixed submission:
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq

def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)


used = set()
l = []

heapq.heappush(l, make(0, 0, 0))
used.add((0, 0, 0))

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    
    if i < X - 1 and (i+1, j, k) not in used:
        heapq.heappush(l, make(i+1, j, k))
        used.add((i+1, j, k))
    
    if j < Y - 1 and (i, j+1, k) not in used:
        heapq.heappush(l, make(i, j+1, k))
        used.add((i, j+1, k))
    
    if k < Z - 1 and (i, j, k+1) not in used:
        heapq.heappush(l, make(i, j, k+1))
        used.add((i, j, k+1))
    
    print(-V)

Buggy python submission (verdict: Time Limit Exceeded):
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq



def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)

# class flags:
#     def __init__(self, X, Y, Z):
#         self.ar = []
#         for k in range(X):
#             l = []
#             for j in range(Y):
#                 ll = []
#                 for i in range(Z):
#                     ll.append(False)
#                 l.append(ll)
#             self.ar.append(l)
        
#     def __getitem__(self, item):
#         return self.ar[item[0]][item[1]][item[2]]
    
#     def __setitem__(self, item, value):
#         self.ar[item[0]][item[1]][item[2]] = value
        

used = []
for i in range(X):
    l = []
    for j in range(Y):
        ll = []
        for k in range(Z):
            ll.append(False)
        l.append(ll)
    used.append(l)

def push_next(l, i, j, k):
    if i < X - 1 and not used[i+1][j][k]:
        heapq.heappush(l, make(i+1, j, k))
        used[i+1][j][k] = True
    
    if j < Y - 1 and not used[i][j+1][k]:
        heapq.heappush(l, make(i, j+1, k))
        used[i][j+1][k] = True
    
    if k < Z - 1 and not used[i][j][k+1]:
        heapq.heappush(l, make(i, j, k+1))
        used[i][j][k+1] = True



l = []

heapq.heappush(l, make(0, 0, 0))
used[0][0][0] = True

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    push_next(l, i, j, k)
    
    print(-V)




Fixed submission:
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq

def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)


used = set()
l = []

heapq.heappush(l, make(0, 0, 0))
used.add((0, 0, 0))

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    
    if i < X - 1 and (i+1, j, k) not in used:
        heapq.heappush(l, make(i+1, j, k))
        used.add((i+1, j, k))
    
    if j < Y - 1 and (i, j+1, k) not in used:
        heapq.heappush(l, make(i, j+1, k))
        used.add((i, j+1, k))
    
    if k < Z - 1 and (i, j, k+1) not in used:
        heapq.heappush(l, make(i, j, k+1))
        used.add((i, j, k+1))
    
    print(-V)

Buggy python submission (verdict: Time Limit Exceeded):
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq



def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)

class flags:
    def __init__(self, X, Y, Z):
        self.ar = []
        for k in range(X):
            l = []
            for j in range(Y):
                ll = []
                for i in range(Z):
                    ll.append(False)
                l.append(ll)
            self.ar.append(l)
        
    def __getitem__(self, item):
        return self.ar[item[0]][item[1]][item[2]]
    
    def __setitem__(self, item, value):
        self.ar[item[0]][item[1]][item[2]] = value
        

used = flags(X,Y,Z)
def push_next(l, i, j, k):
    if i < X - 1 and not used[i+1, j, k]:
        heapq.heappush(l, make(i+1, j, k))
        used[i+1, j, k] = True
    
    if j < Y - 1 and not used[i, j+1, k]:
        heapq.heappush(l, make(i, j+1, k))
        used[i, j+1, k] = True
    
    if k < Z - 1 and not used[i, k, k+1]:
        heapq.heappush(l, make(i, j, k+1))
        used[i, j, k+1] = True



l = []

heapq.heappush(l, make(0, 0, 0))
used[0, 0, 0] = True

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    push_next(l, i, j, k)
    
    print(-V)




Fixed submission:
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)


# Priority QueueとしてHeapを使う
# Pythonのheapqは小さい順に取り出すので、-1を掛けて負数としてpushしていく
#   (-Ai-Bj-Ck, i, j, k)
# 取り出したi, j, kについて、(i+1, j, k), (i, j+1, k), (i, j, k+1)に対応するタプルをpushする
# ただし、すでにpushした値は入れないようにする

import heapq

def make(i, j, k):
    return (-A[i]-B[j]-C[k], i, j, k)


used = set()
l = []

heapq.heappush(l, make(0, 0, 0))
used.add((0, 0, 0))

for cnt in range(K):
    V, i, j, k = heapq.heappop(l)
    
    if i < X - 1 and (i+1, j, k) not in used:
        heapq.heappush(l, make(i+1, j, k))
        used.add((i+1, j, k))
    
    if j < Y - 1 and (i, j+1, k) not in used:
        heapq.heappush(l, make(i, j+1, k))
        used.add((i, j+1, k))
    
    if k < Z - 1 and (i, j, k+1) not in used:
        heapq.heappush(l, make(i, j, k+1))
        used.add((i, j, k+1))
    
    print(-V)