def parse_input(input_str):
    lines = input_str.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")
    best_x = None

    for x1 in range(10):
        for x2 in range(10):
            for x3 in range(10):
                modified_edges = []
                total_penalty = 0

                for idx, (a, b, c, d) in enumerate(edges):
                    x = [x1, x2, x3][idx]
                    modified_edges.append((a, b, c + x))
                    total_penalty += d * x

                mst_weight = kruskal(N, modified_edges)
                score = K * mst_weight - total_penalty
                if score > max_score:
                    max_score = score
                    best_x = (x1, x2, x3)

    return int(max_score) if max_score != float("-inf") else -1


def main():
    import sys

    input = sys.stdin.read
    input_str = input()
    N, M, K, edges = parse_input(input_str)
    result = calculate_maximum_score(N, M, K, edges)
    print(result)


if __name__ == "__main__":
    main()