# compatibility
# Dog <-> Mice
# Cat <-> Elephant

# Hypothesis:
#   Bind (Dog, Mice) -> DM
#   Bing (Cat, Elephent) -> CE

import sys

def compable(a, b):
    atype = a[0]
    btype = b[0]
    return atype == btype

def latestNonConflict(ana, i, z2a, cur):
    for j in range(i-1, -1, -1):
        if j in z2a.keys():
            options = z2a[j]
            for e in options:
                if compable(e, cur):
                    return j
                elif e[2] <= cur[1]:
                    return j
    else:
        return -1

def anazip(ana):
    dm = dict()
    ce = dict()

    for e in ana:
        anatype = e[0]
        index = (e[1], e[2])
        if anatype == 'D' or anatype == 'M':
            if index in dm.keys():
                dm[index] += 1
            else:
                dm[index] = 1
        else:
            if index in ce.keys():
                ce[index] += 1
            else:
                ce[index] = 1

    newdm = [('DM', key[0], key[1], dm[key]) for key in dm.keys()]
    newce = [('CE', key[0], key[1], ce[key]) for key in ce.keys()]
    ana = newce + newdm

    z2a = dict()
    for e in ana:
        if e[2] in z2a.keys():
            z2a[e[2]].append(e)
        else:
            z2a[e[2]] = [e]
    
    return ana, z2a

def processTable(table, m, n):
    res = dict()

    for i in range(m, 0, -1):
        res[table[i]] = i
    
    final = [-1] * (n+1)
    if n in res.keys():
        final[n] = res[n]
    for i in range(n-1, 0, -1):
        if i in res.keys():
            final[i] = res[i]
        else:
            final[i] = final[i+1]
    return final[1:]

def minimumZooNumbers(m, n, t, s, d):
    table = [0] * (m + 1)

    ana = list(zip(t,s,d))
    ana, z2a = anazip(ana)
    ana = sorted(ana, key=lambda x: x[2])
    # type, source, des, weight

    table[0] = 0
    table[1] = 0

    for i in range(2, m+1):
        if i in z2a.keys():
            options = z2a[i]
            pros = []
            for e in options:
                inclProf = e[3]
                l = latestNonConflict(ana, i, z2a, e)
                if l != -1:
                    inclProf += table[l]
                pros.append(max(inclProf, table[i-1]))
            table[i] = max(pros)
        else:
            table[i] = table[i-1]
    
    result = processTable(table,m,n)

    return result

if __name__ == "__main__":
    cases = int(input().strip())
    for a0 in range(cases):
        m, n = input().strip().split(' ')
        m, n = [int(m), int(n)]
        t = input().strip().split(' ')
        s = list(map(int, input().strip().split(' ')))
        d = list(map(int, input().strip().split(' ')))
        result = minimumZooNumbers(m, n, t, s, d)
        print (" ".join(map(str, result)))