def modify_graph_edge_weights_brute_force(
    graph,
    edges_to_modify,
    weight_range,
    condition_function
):
    best_weight_assignments = None
    best_optimization_score = float('inf')

    def explore_weight_assignments(index, current_weights):
        nonlocal best_weight_assignments, best_optimization_score

        # Base case: all edges have been assigned weights
        if index == len(edges_to_modify):
            
            # Create a modified graph with the new weights
            modified_graph = graph.copy()
            for i, edge in enumerate(edges_to_modify):
                modified_graph[edge[0]][edge[1]] = current_weights[i]
            
            # Check if the condition is satisfied
            if condition_function(modified_graph):

                # Calculate optimization score (sum of weights)
                optimization_score = sum(current_weights)
                
                # Update if this assignment is better
                if optimization_score < best_optimization_score:
                    best_optimization_score = optimization_score
                    best_weight_assignments = current_weights[:]
            return

        # Recursive step: try all possible weights for the current edge
        for weight in weight_range:
            # Assign the current weight to the edge and explore
            current_weights.append(weight)
            explore_weight_assignments(index + 1, current_weights)

            # Backtrack: remove the last assigned weight
            current_weights.pop()

    explore_weight_assignments(0, [])
    return best_weight_assignments

import heapq

def modify_graph_edge_weights(number_of_nodes, edges, source, destination, target_distance, edge_to_modify):

    def calculate_shortest_distance(graph, start_node, end_node):
        distances = {node: float('inf') for node in range(number_of_nodes)}
        distances[start_node] = 0
        priority_queue = [(0, start_node)]

        while priority_queue:
            current_distance, current_node = heapq.heappop(priority_queue)

            if current_distance > distances[current_node]:
                continue

            for neighbor, weight in graph[current_node]:
                distance = current_distance + weight
                if distance < distances[neighbor]:
                    distances[neighbor] = distance
                    heapq.heappush(priority_queue, (distance, neighbor))

        return distances[end_node]

    # Build the graph using the provided edges.
    graph = {node: [] for node in range(number_of_nodes)}
    for u, v, weight in edges:
        graph[u].append((v, weight))
        graph[v].append((u, weight))

    # Find the initial shortest distance.
    initial_shortest_distance = calculate_shortest_distance(graph, source, destination)

    # It's impossible if target is less than the initial shortest distance.
    if target_distance < initial_shortest_distance:
        return None

    u, v, original_weight = edge_to_modify

    # Restore original weights for modification purposes.
    graph = {node: [] for node in range(number_of_nodes)}
    for u_node, v_node, weight in edges:
        graph[u_node].append((v_node, weight))
        graph[v_node].append((u_node, weight))

    graph[u] = [(neighbor, weight) for neighbor, weight in graph[u] if neighbor != v]
    graph[v] = [(neighbor, weight) for neighbor, weight in graph[v] if neighbor != u]

    graph[u].append((v, original_weight))
    graph[v].append((u, original_weight))

    low = original_weight
    high = float('inf')
    modified_weight = -1

    while low <= high:
        mid = (low + high) // 2

        graph[u] = [(neighbor, weight) for neighbor, weight in graph[u] if neighbor != v]
        graph[v] = [(neighbor, weight) for neighbor, weight in graph[v] if neighbor != u]

        graph[u].append((v, mid))
        graph[v].append((u, mid))
        
        shortest_distance_with_modified_weight = calculate_shortest_distance(graph, source, destination)

        if shortest_distance_with_modified_weight == target_distance:
            modified_weight = mid
            break
        elif shortest_distance_with_modified_weight < target_distance:
            high = mid - 1
        else:
            low = mid + 1

    # If target distance isn't achievable by increasing the weight
    if modified_weight == -1:
        graph[u] = [(neighbor, weight) for neighbor, weight in graph[u] if neighbor != v]
        graph[v] = [(neighbor, weight) for neighbor, weight in graph[v] if neighbor != u]
        graph[u].append((v, original_weight))
        graph[v].append((u, original_weight))

        graph[u].sort()
        graph[v].sort()

        graph[u] = [(neighbor, weight) for neighbor, weight in graph[u] if neighbor != v]
        graph[v] = [(neighbor, weight) for neighbor, weight in graph[v] if neighbor != u]

        graph[u].append((v, float('inf')))
        graph[v].append((u, float('inf')))

        shortest_distance_with_modified_weight = calculate_shortest_distance(graph, source, destination)

        if shortest_distance_with_modified_weight != target_distance:

            return None
        else:
            modified_weight = float('inf')

    modified_edges = []
    for u_node, connections in graph.items():
        for v_node, weight in connections:
            if u_node < v_node:
                modified_edges.append((u_node, v_node, weight))

    for i in range(len(modified_edges)):
        if (modified_edges[i][0] == u and modified_edges[i][1] == v) or (modified_edges[i][1] == u and modified_edges[i][0] == v):
            modified_edges[i] = (u, v, modified_weight)

    return modified_edges