laal

import heapq as hq
import math

class Bin:
    def __init__(self):
        self.list = []

    def AñadirPlaca(self, item):
        self.list.append(item)

    def suma(self):
        total = 0
        for elem in self.list:
            total += elem
        return total

    def Mostrar(self):
        return self.list

def BinPacking(arreglo, areaPlancha):
    """ Returns list of bins with input items inside. """
    a = []
    a.append(Bin())

    for item in arreglo:

        añadir = False

        for bin in a:
            if bin.suma() + item <= areaPlancha:
                bin.AñadirPlaca(item)
                añadir = True
                break


        if añadir == False:
            nuevo = Bin()
            nuevo.AñadirPlaca(item)
            a.append(nuevo)

    arreglo = []
    for bin in a:
        arreglo.append(bin.Mostrar())

    return(arreglo)


def sumarareas(G):
    n = len(G)
    suma = 0
    for i in range(n):
        suma += G[i]
    return suma

def ordenamientoBurbuja(unaLista):
    for numPasada in range(len(unaLista)-1,0,-1):
        for i in range(numPasada):
            if unaLista[i]>unaLista[i+1]:
                temp = unaLista[i]
                unaLista[i] = unaLista[i+1]
                unaLista[i+1] = temp
    return unaLista

def Position(G):
    n = len(G)
    print(G[1])
    print(G)

def Ordenar(G):
    ordenado = sorted(G , key=lambda k: [k[0], k[1]],reverse=True)
    return ordenado

def SepararArea(arreglo):
	n=len(arreglo)
	a=[]

	for i in range(n):
		a.append(arreglo[i][0])

	return a
def SepararTipo(arreglo):
	n=len(arreglo)
	a=[]

	for i in range(n):
		a.append((arreglo[i][1],arreglo[i][2],arreglo[i][3]))

	return a

def Unificar(G):
    ordenado=SepararArea(Ordenar(TC))
    n=len(ordenado)
    a=[]
    resultado=[]
    for i in range(n):
        a.append(ordenado[i])
    for i in range(n):
        for j in range(3):
            resultado.append(a[i][j])
    return resultado

#print(ordenado)
#print(resultado)
'''def Posicionar(G):
    u=Unificar(SepararArea(Ordenar(TC)))
    n=len(u)
    b = []
    cordenadas = []
    arrx = []
    arry = []
    arrz = []
    x = 0
    y = 0
    z = 0
    u3 = []
    #del(u[0])
    #arrx.append(x)
    for i in range(n):
        arrx.append(u[i])
    u.pop(0)
        #u2 = u.pop(0)
        #arry.append(u[i])
        #arrz.append(u[i])
    return u '''
def posicionar(largo,ancho,alto,arreglo):
    n=len(arreglo)
    resultado=[]
    resultado.append([0,0,0])
    x=arreglo[2]
    y=arreglo[1]
    z=arreglo[2]
    q=30
    z2 = 0
    x2 = 0
    #while x<largo and y<ancho and z<alto:# Para que no sobrepase las dimensiones de la caja




   # while q < 5

    for i in range(q):
        if z <= alto:
            resultado.append([0,0,z])
            z+=arreglo[2]
        else:
            if y <= ancho and z2 <= alto:
                resultado.append([0,y,z2])
                z2+=arreglo[2]
                a = len(resultado)
                d = resultado[a-1]


        #if z <= alto and  d >= largo:
       #     resultado.append([0,arreglo[1],z2])
        #    z2+=arreglo[2]






       # if z >= alto and
    a = len(resultado)
    d = resultado[a-1]
    d2 = d[2]




    print(d2)



    return resultado


#print(posicionar(20,30,8,resultado))

with open('cortes.in') as f:
    contenedor = f.readline().strip()
    contenedor1, contenedor2,contenedor3 = [int(x) for x in contenedor.split(' ')]
    volume = contenedor1*contenedor2*contenedor3
    Medidas = []
    TC = []
    Areas = []
    OrdenarTC = []
    OrdenarS = []
    CantidadxTipo = []
    TipoxCaja = []
    xyz = []
    line = int(f.readline())
    for i in range(line):
        D = f.readline().strip()
        Q, T, X, Y, Z = [x for x in D.split(' ')]
        cantidad = int(Q)
        CantidadxTipo.append((cantidad))
        tipo = T
        xyz.append((int(X),int(Y),int(Z)))
        TipoxCaja.append((tipo))
        G = [[] for _ in range(cantidad)]
        OrdenarTC.append((int(X)*int(Y)*int(Z)))
        for j in range(cantidad):
            G[j].append(((tipo),(int(X),int(Y),int(Z))))
            TC.append(((int(X),int(Y),int(Z)),(int(X)*int(Y)*int(Z))))
            Medidas.append((int(X),int(Y),int(Z)))
            Areas.append((int(X)*int(Y)*int(Z)))

        #print(G)
    #print(TC)
    #print(Areas)
    for k in range(line):
        OrdenarS.append((OrdenarTC[k],CantidadxTipo[k],TipoxCaja[k],xyz[k]))
    AreaTotal = sumarareas(Areas)
    Desperdicio = 100 -((AreaTotal/volume)*100)
    Usado = 100-Desperdicio
    #print(AreaTotal)
    #print(Usado)

    hola =  BinPacking(Areas, volume)
    #print(Posicionar(Unificar(SepararArea(Ordenar(TC)))))

    #print(posicionar(20,30,3,Unificar(SepararArea(Ordenar(TC)))))
    #print(Medidas)
    #print(ordenamientoBurbuja(Areas))

    #print(Position(Areas))
    #SepararArea(Ordenar(TC))
    #print(Unificar(SepararArea(Ordenar(TC))))

### funciones para la cantidad y tipos

    QTOrdenado = Ordenar(OrdenarS)
    #print(QTOrdenado)
    #for l in range(len(QTOrdenado)):
        #del(QTOrdenado[i][0])
    print(QTOrdenado)
    print(SepararTipo(QTOrdenado))