package hackercup2022.

round2;

import java.util.*;

public class C {

static Scanner sc;

static Map<Integer, TreeMap<Integer, long []>> truth;
static TreeMap<Integer, long []> truthTree, nTree;

public static void main(String[] args) {

// TODO Auto-generated method stub
sc = IoHandler.initialiseIO();

int t = sc.nextInt();

for (int i = 1; i <= t; ++i) {

solve(i);
}

IoHandler.closeIO();
}

private static void solve(int t) {

int n = sc.nextInt();
int k = sc.nextInt();

int [][] arr = new int [n][5];

for (int i = 0; i < n; ++i) {

for (int j = 0; j < 4; ++j) {
arr[i][j] = sc.nextInt();
}

int swap = arr[i][2];

arr[i][2] = arr[i][1];
arr[i][1] = swap;
}

Map<Integer, List<int []>> map = new HashMap<>();

for (int [] a : arr) {

if (!map.containsKey(a[0]))
map.put(a[0], new ArrayList<>());

map.get(a[0]).add(a);
}

List<Integer> keys = new ArrayList<>(map.keySet());

List <int []> list;

Collections.sort(keys, (a, b) -> b - a);

long [] kVals = new long [k];

long [] next;

long [] def = new long [k];

 //Map<Integer, TreeMap<Integer, PriorityQueue<Long>>> truth = new
HashMap<>();
//TreeMap<Integer, PriorityQueue<Long>> truthTree;
truth = new HashMap<>();
Integer tKey;
PriorityQueue<Long> result = new PriorityQueue<>();

for (int key : keys) {

list = map.get(key);

for (int [] a : list) {

//kVals = getBestK(a);
//System.out.println(truth + " " + a[2]);
truthTree = truth.getOrDefault(a[2], null);

//System.out.println(key + Arrays.toString(a));
//System.out.println(truthTree);

if (truthTree == null) {
next = null;
}else {
tKey = truthTree.floorKey(a[3]+1);

if (tKey == null) {
next = null;
}else {
next = truthTree.get(tKey);
}
}

kVals = new long [k];

Arrays.fill(kVals, -1);

long [] test = new long [k];

if (next != null) {
//System.out.println(" " + Arrays.toString(next));

for (int i = 0; i < next.length; ++i) {

if (next[i] == -1) continue;

kVals[i] = next[i];

result.add(kVals[i] - a[3]);
test[i] = kVals[i] - a[3];
kVals[i] -= a[3];

if (result.size() > k)
result.poll();
}
}

/*
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(test));
System.out.println(Arrays.toString(kVals));
*/
 boolean use = true;
for (int i = 0; i < kVals.length; ++i) {
if (kVals[i] == -1) {
if (use) {
use = false;
kVals[i] = a[1];
}
continue;
}

kVals[i] += a[1];
}

if (truth.containsKey(a[0])) {
nTree = truth.get(a[0]);
}else {
nTree = new TreeMap<>((x , y) -> y - x);
}

nTree.put(a[1], merge(kVals, nTree.getOrDefault(a[0],

null)));
truth.put(a[0], nTree);
//System.out.println(nTree);
}

nTree = truth.get(key);
kVals = null;

for (int kTree : nTree.keySet()) {

kVals = merge(nTree.get(kTree), kVals);
nTree.put(kTree, kVals);
}

long fR = 0;

for (long val : result) {

fR += val;
}

fR %= 1_000_000_007;

print(t , fR);
}

private static long [] merge(long [] a, long [] b ) {

if (b == null) return a;

PriorityQueue<Long> queue = new PriorityQueue<>((x, y) ->

Long.compare(y, x));

for (long num : a) {

queue.add(num);
}

for (long num : b) {

 queue.add(num);
}

long [] res = new long [a.length];

for (int i = 0; i < a.length; ++i) {

res[i] = queue.poll();
}

return res;
}

private static long [] getBestK(int [] arr) {

return null;
}

private static void print (int test, long result) {

IoHandler.println("Case #" + test + ": " + result);
}