static int beautifulPath(int[][] edges, int A, int B) {
        // count the number of vertices
        Set<Integer> vertexSet = new HashSet<Integer>();
        for (int i = 0; i < edges.length; i++) {
            int v1 = edges[i][0];
            int v2 = edges[i][1];
            vertexSet.add(v1);
            vertexSet.add(v2);
        }
        int N = vertexSet.size() + 1;
        int[][] graph = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (i == j) graph[i][j] = 0;
                else graph[i][j] = Integer.MAX_VALUE;
            }
        }
        for (int i = 0; i < edges.length; i++) {
           int v1 = edges[i][0];
           int v2 = edges[i][1];
           graph[v1][v2] = Math.min(graph[v1][v2], edges[i][2]);
           graph[v2][v1] = Math.min(graph[v2][v1], edges[i][2]);
        }

        // Now do Dijkstra
        boolean[] visited = new boolean[N];
        int[] distances = new int[N];

        Arrays.fill(visited, false);
        Arrays.fill(distances, Integer.MAX_VALUE);

        PriorityQueue<Integer> q = new PriorityQueue<Integer>((v1, v2) -> distances[v1]- distances[v2]);
        distances[A] = 0;
        q.offer(A);

        while (!q.isEmpty()) {
            int v = q.poll();
            if (v == B) return distances[v];

            for (int i = 1; i < N; i++) {
                if (i != v && graph[v][i] != Integer.MAX_VALUE && !visited[i]) {
                    int newDist = distances[v] | graph[v][i];
                    if (newDist < distances[i]) {
                        q.remove(i);
                        distances[i] = newDist;
                        q.offer(i);
                    }
                }
            }
            visited[v] = true;
        }
        return -1;
    }