import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


# inputna
n,m,X = list(map(int, input().split()))
M = 10**9+7
xyz = [list(map(int, input().split())) for _ in range(m)]
for i in range(m):
    xyz[i] = (xyz[i][0]-1, xyz[i][1]-1, xyz[i][2])
xyz.sort(key=lambda x: x[2])

class UnionFindTree:
    def __init__(self, n):
        self.n = n
        self.parent = list(range(n))
        self.size = [1] * n

    def root(self, i):
        inter = set()
        while self.parent[i]!=i:
            inter.add(i)
            i = self.parent[i]
        r = i
        for i in inter:
            self.parent[i] = r
        return r

    def connect(self, i, j):
        ri = self.root(i)
        rj = self.root(j)
        if ri==rj:
            return
        if self.size[ri]<self.size[rj]:
            self.parent[ri] = rj
            self.size[rj] += self.size[ri]
        else:
            self.parent[rj] = ri
            self.size[ri] += self.size[rj]
ans = 0
uf = UnionFindTree(n)
ss = [0] * n
es = [[] for _ in range(n)]
for x,y,z in xyz:
    rx = uf.root(x)
    ry = uf.root(y)
    if rx==ry:
        continue
    uf.connect(x,y)
    es[x].append((y,z))
    es[y].append((x,z))
ans = 0
size = [None]*n
start = 0
def sub(u, p):
    global ans
    res = 0
    for v,z in es[u]:
        if v==p:
            continue
        size = sub(v,u)
        res += size
        ans = ans + size * (n-size) * pow(X,z,M)
        ans %= M
    return res+1
sub(0,-1)
print(ans%M)