# by the authority of GOD     author: manhar singh sachdev #

import os,sys
from io import BytesIO,IOBase

def find(parent,x):
    if x == parent[x]:
        return x
    parent[x] = find(parent,parent[x])
    return parent[x]

def union(parent,a,b,rank):
    a,b = find(parent,a),find(parent,b)
    if a != b:
        if rank[a] < rank[b]:
            a,b = b,a
        parent[b] = a
        if rank[a] == rank[b]:
            rank[a] += 1
        return 1
    return 0

def main():
    for x in range(int(input())):
        n,m,k = map(int,input().split())
        ed = [tuple(map(int,input().split())) for _ in range(m)]
        if x == 308:
            print(n,m,k)
            print(ed)
            exit()
        ed1 = sorted(filter(lambda xx:xx[2] <= k,ed),key=lambda xx:xx[2],reverse=1)
        ed = sorted(filter(lambda xx:xx[2] > k,ed),key=lambda xx:xx[2])
        parent = list(range(n))
        rank = [0]*n
        conn = n
        ans = 0
        for i in ed1:
            a,b = i[0]-1,i[1]-1
            if union(parent,a,b,rank):
                conn -= 1
            if conn == 1:
                break
        if conn != 1:
            for i in ed:
                a,b = i[0]-1,i[1]-1
                if union(parent,a,b,rank):
                    conn -= 1
                    ans += i[2]-k
                if conn == 1:
                    break
        else:
            if not len(ed1):
                ans = abs(ed[0][2]-k)
            elif not len(ed):
                ans = abs(ed1[0][2]-k)
            else:
                ans = min(abs(ed1[0][2]-k),abs(ed[0][2]-k))
        print(ans)

# Fast IO Region
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self,file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
            self.newlines = b.count(b"\n")+(not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd,self.buffer.getvalue())
            self.buffer.truncate(0),self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self,file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s:self.buffer.write(s.encode("ascii"))
        self.read = lambda:self.buffer.read().decode("ascii")
        self.readline = lambda:self.buffer.readline().decode("ascii")

sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
    main()