// 献丑了，开始2次的思路都不对，还是按视频思路来写
// java 集合开固定长度会快一些； 集合虽然操作方便，但是没有哨兵，记得要特判边界

import java.util.*;
import java.util.stream.*;

public class Main{


    class Node{
        int x,y,z;
        Node(int x, int y ) {this.x = x; this.y = y; }
    }

    void run(){
        int c = jin.nextInt();

        while(c -- != 0){
            int m = jin.nextInt();
            int n = jin.nextInt();

            for (int i = 0 ; i < m ; i ++){
                if (i >= seq.size()) seq.add(new ArrayList<Integer>());
                else seq.get(i).clear();

                for (int j = 0 ; j < n ; j++){
                    seq.get(i).add(jin.nextInt());        
                }
                seq.get(i).sort((a, b) -> ( a - b));
            }
            var res = String.join(" ", solve(n, m).stream().map(x -> String.valueOf(x)).collect(Collectors.toList()));
            System.out.println(res);
        }
    }


    List<Integer> calc(List<Integer> a, List<Integer> b){
        heap.clear();
        List<Integer> buffer = new ArrayList<>();
        for (int i = 0 ; i < a.size(); i++) heap.add(new Node(a.get(0) + b.get(i), 0));

        for (int i = 0; i < a.size(); i++){
            Node top = heap.poll();
            buffer.add(top.x);
            if (top.y + 1 >= a.size() ) continue; //  java用集合就不像数据可以多开一个哨兵那么方便了
            heap.add(new Node(top.x - a.get(top.y) + a.get(top.y+1), top.y+1));
        }
        return buffer;
    }
    List<Integer> solve(int n, int m){

        var res = seq.get(0);
        for (int i = 1 ; i < seq.size() ; i++){
            res = calc(res, seq.get(i));
        }

        return res;

        // for (int i = 0 ; i < m ; i ++){

        //         for (int j = 0 ; j < n ; j++){
        //             System.out.printf("%d ", seq.get(i).get(j));     
        //         }
        //         System.out.println();
        // }

        // int k = Math.max(2 * n /m +1, 2);
        // for (int i = 0 ;i < m ; i++){
        //     for (int j = 0 ; j <= k ; j++){
        //         if (seq.get(i).size() > j) heap.add(seq.get(i).get(j));
        //     }
        // }  这个不能这么搞，因为可能同一列选了2个

        // System.out.println(heap.size());



        // List<Integer> answer = new ArrayList<>();
        // int res = 0;
        // for (int i = 0 ; i < m ; i++){
        //     int v = seq.get(i).get(0);
        //     res += v;
        //     heap.add(new Node(v, i, 0));
        // }


        // for (int i = 0 ; i < n; i++){
        //     answer.add(res);

        //     Node node = heap.poll();
        //     res -= node.x;
        //     int v = seq.get(node.y).get(node.z+1);
        //     res += v;
        //     heap.add(new Node(v , node.y, node.z+1));
        // }  这个也不对, 因为 a[i],b[j] 确定为当前最小的时候， a[i+1],b[j] 和 a[i],b[j+1] 都是最小的备选

    }

    List<List<Integer>> seq = new ArrayList<>();
    Queue<Integer> queue = new LinkedList<>();
    Queue<Node> heap = new PriorityQueue<>(2000000, (a,b) -> (a.x-b.x));
    private Scanner jin = new Scanner(System.in);
    public static void main(String[] args) throws Exception {new Main().run();}
}