def parse_input():
    import sys
    input = sys.stdin.read
    lines = input().strip().split('\n')
    N, M, K = map(int, lines[0].split())
    edges = []
    for i in range(1, M + 1):
        a, b, c, d = map(int, lines[i].split())
        edges.append((a, b, c, d))
    return N, M, K, edges

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

def union(parent, rank, x, y):
    root_x = find(parent, x)
    root_y = find(parent, y)
    if root_x != root_y:
        if rank[root_x] > rank[root_y]:
            parent[root_y] = root_x
        elif rank[root_x] < rank[root_y]:
            parent[root_x] = root_y
        else:
            parent[root_y] = root_x
            rank[root_x] += 1

def kruskal(N, edges):
    parent = [i for i in range(N + 1)]
    rank = [0] * (N + 1)
    mst_weight = 0
    edge_count = 0
    for a, b, weight in sorted(edges, key=lambda x: x[2]):
        if find(parent, a) != find(parent, b):
            union(parent, rank, a, b)
            mst_weight += weight
            edge_count += 1
            if edge_count == N - 1:
                break
    if edge_count == N - 1:
        return mst_weight
    else:
        return float('inf')

def calculate_maximum_score(N, M, K, edges):
    max_score = float('-inf')
    for edge in edges:
        a, b, c, d = edge
        x_opt = c / (K + d)
        adjusted_edges = [(a, b, c + x_opt) for (a, b, c, d) in edges]
        mst_weight = kruskal(N, adjusted_edges)
        score = K * mst_weight - sum(d * x_opt for _, _, _, d in edges)
        max_score = max(max_score, score)
    return int(max_score) if max_score != float('-inf') else -1

def main():
    N, M, K, edges = parse_input()
    result = calculate_maximum_score(N, M, K, edges)
    print(result)

if __name__ == "__main__":
    main()