贪心，模拟

思路：贪心的想：对于左右排列来说，如果他们落在相同的y上越多，我们越倾向于划分；对于上下排列来说，如果他们落在相同的x上越多，我们越倾向于划分。那就用两个hash表来模拟这个贪心过程即可

代码：

import sys
from collections import defaultdict

input = lambda: sys.stdin.readline().strip()

import math
inf = 10 ** 18

def I():
    return input()

def II():
    return int(input())

def MII():
    return map(int, input().split())

def GMI():
    return map(lambda x: int(x) - 1, input().split())

def LI():
    return input().split()

def LII():
    return list(map(int, input().split()))

def LFI():
    return list(map(float, input().split()))

fmax = lambda x, y: x if x > y else y
fmin = lambda x, y: x if x < y else y
isqrt = lambda x: int(math.sqrt(x))

'''

'''

def solve():
    n, m, k, l, d = LII()

    hash_x = defaultdict(list) # 统计左右排列
    hash_y = defaultdict(list) # 统计上下排列
    for _ in range(d):
        x, y, p, q = LII()
        if x == p:
            if y > q: # 把y小的作为头
                x, p = p, x
                y, q = q, y
            hash_x[y].append([x, y, p, q]) # 把y相同的左右排列放一块，方便贪心
        elif y == q:
            if x > p: # 把x小的作为头
                x, p = p, x
                y, q = q, y
            hash_y[x].append([x, y, p, q]) # 把x相同的上下排列放一块，方便贪心

    res_k = []
    for x, row in sorted(hash_y.items(), key=lambda y:-len(y[1])): # x相同的上下排列，从大到小排序
        for i in range(len(row)):
            res_k.append(row[i][0])
            break # 每个x只处理一次

    res_l = []
    for y, row in sorted(hash_x.items(), key=lambda x:-len(x[1])): # y相同的左右排列，从大到小排序
        for i in range(len(row)):
            res_l.append(row[i][1])
            break # 每个y只处理一次

    # 最终先切片，再排序
    print(*sorted(res_k[:k]))
    print(*sorted(res_l[:l]))

t = 1
# t = II()
for _ in range(t):
    solve()